From f1bf39d6fecf35a820a686f754a3d66860a0ca29 Mon Sep 17 00:00:00 2001 From: Joel16 Date: Thu, 27 May 2021 02:26:39 -0400 Subject: [PATCH] cmfilemanager-psp: Inital reimplementation in c++ --- .gitattributes | 2 + .gitignore | 61 + .travis.yml | 17 + .travis/.build.sh | 12 + ICON0.PNG | Bin 0 -> 8000 bytes Makefile.psp | 7 + README.MD | 55 + app/Makefile | 44 + app/config.json | 6 + app/data/battery_20.png | Bin 0 -> 230 bytes app/data/battery_20_charging.png | Bin 0 -> 327 bytes app/data/battery_30.png | Bin 0 -> 230 bytes app/data/battery_30_charging.png | Bin 0 -> 332 bytes app/data/battery_50.png | Bin 0 -> 231 bytes app/data/battery_50_charging.png | Bin 0 -> 332 bytes app/data/battery_60.png | Bin 0 -> 231 bytes app/data/battery_60_charging.png | Bin 0 -> 331 bytes app/data/battery_80.png | Bin 0 -> 227 bytes app/data/battery_80_charging.png | Bin 0 -> 328 bytes app/data/battery_full.png | Bin 0 -> 178 bytes app/data/battery_full_charging.png | Bin 0 -> 305 bytes app/data/bg_header.png | Bin 0 -> 4451 bytes .../btn_material_light_check_off_normal.png | Bin 0 -> 152 bytes ...n_material_light_check_off_normal_dark.png | Bin 0 -> 152 bytes .../btn_material_light_check_on_normal.png | Bin 0 -> 247 bytes ...tn_material_light_check_on_normal_dark.png | Bin 0 -> 247 bytes .../btn_material_light_radio_off_normal.png | Bin 0 -> 405 bytes ...n_material_light_radio_off_normal_dark.png | Bin 0 -> 364 bytes .../btn_material_light_radio_on_normal.png | Bin 0 -> 488 bytes ...tn_material_light_radio_on_normal_dark.png | Bin 0 -> 425 bytes .../btn_material_light_toggle_off_normal.png | Bin 0 -> 1036 bytes .../btn_material_light_toggle_on_normal.png | Bin 0 -> 1060 bytes ...n_material_light_toggle_on_normal_dark.png | Bin 0 -> 1059 bytes app/data/btn_playback_forward.png | Bin 0 -> 812 bytes app/data/btn_playback_pause.png | Bin 0 -> 157 bytes app/data/btn_playback_play.png | Bin 0 -> 424 bytes app/data/btn_playback_repeat.png | Bin 0 -> 1020 bytes app/data/btn_playback_repeat_overlay.png | Bin 0 -> 1020 bytes app/data/btn_playback_rewind.png | Bin 0 -> 802 bytes app/data/btn_playback_shuffle.png | Bin 0 -> 1356 bytes app/data/btn_playback_shuffle_overlay.png | Bin 0 -> 1356 bytes app/data/default_artwork.png | Bin 0 -> 1549 bytes app/data/default_artwork_blur.png | Bin 0 -> 169333 bytes app/data/ic_arrow_back_normal.png | Bin 0 -> 339 bytes app/data/ic_fso_default.png | Bin 0 -> 1288 bytes app/data/ic_fso_folder.png | Bin 0 -> 469 bytes app/data/ic_fso_folder_dark.png | Bin 0 -> 523 bytes app/data/ic_fso_type_app.png | Bin 0 -> 802 bytes app/data/ic_fso_type_audio.png | Bin 0 -> 829 bytes app/data/ic_fso_type_compress.png | Bin 0 -> 540 bytes app/data/ic_fso_type_image.png | Bin 0 -> 832 bytes app/data/ic_fso_type_text.png | Bin 0 -> 388 bytes app/data/ic_material_dialog.png | Bin 0 -> 701 bytes app/data/ic_material_dialog_dark.png | Bin 0 -> 649 bytes .../ic_material_light_navigation_drawer.png | Bin 0 -> 182 bytes app/data/ic_material_light_sdcard.png | Bin 0 -> 314 bytes app/data/ic_material_light_sdcard_dark.png | Bin 0 -> 305 bytes app/data/ic_material_light_secure.png | Bin 0 -> 606 bytes app/data/ic_material_light_secure_dark.png | Bin 0 -> 564 bytes app/data/ic_material_light_usb.png | Bin 0 -> 333 bytes app/data/ic_material_options_dialog.png | Bin 0 -> 1028 bytes app/data/ic_material_options_dialog_dark.png | Bin 0 -> 1125 bytes app/data/ic_material_properties_dialog.png | Bin 0 -> 768 bytes .../ic_material_properties_dialog_dark.png | Bin 0 -> 946 bytes app/data/ic_play_btn.png | Bin 0 -> 1633 bytes app/debug.log | 6 + app/drivers/mutex-imports.S | 140 + app/include/colours.h | 24 + app/include/config.h | 20 + app/include/fs.h | 36 + app/include/ftppsp.h | 71 + app/include/g2d.h | 19 + app/include/gui.h | 54 + app/include/kernel_functions.h | 43 + app/include/log.h | 10 + app/include/mutex.h | 23 + app/include/textures.h | 23 + app/include/utils.h | 48 + app/source/colours.cpp | 15 + app/source/config.cpp | 86 + app/source/fs.cpp | 512 + app/source/ftppsp.cpp | 1095 ++ app/source/g2d.cpp | 147 + app/source/gui.cpp | 122 + app/source/gui/delete.cpp | 87 + app/source/gui/filebrowser.cpp | 148 + app/source/gui/imageviewer.cpp | 125 + app/source/gui/options.cpp | 258 + app/source/gui/settings.cpp | 156 + app/source/kernel_functions.cpp | 27 + app/source/log.cpp | 47 + app/source/main.cpp | 64 + app/source/textures.cpp | 156 + app/source/utils.cpp | 435 + audio_driver/Makefile | 26 + audio_driver/audio_driver.c | 20 + audio_driver/exports.exp | 16 + display_driver/Makefile | 26 + display_driver/display_driver.c | 59 + display_driver/exports.exp | 19 + display_driver/sceDisplay_driver.S | 14 + fs_driver/Makefile | 26 + fs_driver/exports.exp | 18 + fs_driver/fs_driver.c | 41 + impose_driver/Makefile | 26 + impose_driver/exports.exp | 22 + impose_driver/impose_driver.c | 62 + input_driver/Makefile | 26 + input_driver/exports.exp | 16 + input_driver/input_driver.c | 21 + launcher/Makefile | 31 + launcher/source/main.c | 31 + libs/include/FLAC/all.h | 371 + libs/include/FLAC/assert.h | 46 + libs/include/FLAC/callback.h | 185 + libs/include/FLAC/export.h | 97 + libs/include/FLAC/format.h | 1025 ++ libs/include/FLAC/metadata.h | 2182 +++ libs/include/FLAC/ordinals.h | 85 + libs/include/FLAC/stream_decoder.h | 1559 ++ libs/include/FLAC/stream_encoder.h | 1790 +++ libs/include/dr_flac.h | 12120 ++++++++++++++++ libs/include/dr_pcx.h | 793 + libs/include/dr_wav.h | 6279 ++++++++ libs/include/fmt123.h | 135 + libs/include/glib2d.h | 804 + libs/include/intraFont.h | 369 + libs/include/kubridge.h | 182 + libs/include/libccc.h | 108 + libs/include/mpg123.h | 1441 ++ libs/include/ogg/config_types.h | 26 + libs/include/ogg/ogg.h | 209 + libs/include/ogg/os_types.h | 158 + libs/include/opus/opus.h | 981 ++ libs/include/opus/opus_defines.h | 799 + libs/include/opus/opus_multistream.h | 660 + libs/include/opus/opus_projection.h | 568 + libs/include/opus/opus_types.h | 166 + libs/include/opus/opusfile.h | 2164 +++ libs/include/pspusbdevice.h | 51 + libs/include/rapidjson/allocators.h | 692 + libs/include/rapidjson/cursorstreamwrapper.h | 78 + libs/include/rapidjson/document.h | 3027 ++++ libs/include/rapidjson/encodedstream.h | 299 + libs/include/rapidjson/encodings.h | 716 + libs/include/rapidjson/error/en.h | 122 + libs/include/rapidjson/error/error.h | 216 + libs/include/rapidjson/filereadstream.h | 99 + libs/include/rapidjson/filewritestream.h | 104 + libs/include/rapidjson/fwd.h | 151 + libs/include/rapidjson/internal/biginteger.h | 290 + libs/include/rapidjson/internal/clzll.h | 71 + libs/include/rapidjson/internal/diyfp.h | 257 + libs/include/rapidjson/internal/dtoa.h | 245 + libs/include/rapidjson/internal/ieee754.h | 78 + libs/include/rapidjson/internal/itoa.h | 308 + libs/include/rapidjson/internal/meta.h | 186 + libs/include/rapidjson/internal/pow10.h | 55 + libs/include/rapidjson/internal/regex.h | 739 + libs/include/rapidjson/internal/stack.h | 232 + libs/include/rapidjson/internal/strfunc.h | 69 + libs/include/rapidjson/internal/strtod.h | 290 + libs/include/rapidjson/internal/swap.h | 46 + libs/include/rapidjson/istreamwrapper.h | 128 + libs/include/rapidjson/memorybuffer.h | 70 + libs/include/rapidjson/memorystream.h | 71 + libs/include/rapidjson/msinttypes/inttypes.h | 316 + libs/include/rapidjson/msinttypes/stdint.h | 300 + libs/include/rapidjson/ostreamwrapper.h | 81 + libs/include/rapidjson/pointer.h | 1415 ++ libs/include/rapidjson/prettywriter.h | 277 + libs/include/rapidjson/rapidjson.h | 741 + libs/include/rapidjson/reader.h | 2244 +++ libs/include/rapidjson/schema.h | 2648 ++++ libs/include/rapidjson/stream.h | 223 + libs/include/rapidjson/stringbuffer.h | 121 + libs/include/rapidjson/writer.h | 710 + libs/include/stb_image.h | 7559 ++++++++++ libs/include/systemctrl.h | 401 + libs/include/systemctrl_se.h | 233 + libs/include/vorbis/codec.h | 240 + libs/include/vorbis/vorbisenc.h | 112 + libs/include/vorbis/vorbisfile.h | 143 + libs/include/xmp.h | 358 + libs/lib/libFLAC.a | Bin 0 -> 445416 bytes libs/lib/libglib2d.a | Bin 0 -> 405782 bytes libs/lib/libintrafont.a | Bin 0 -> 38914 bytes libs/lib/libmpg123.a | Bin 0 -> 335788 bytes libs/lib/libogg.a | Bin 0 -> 79842 bytes libs/lib/libopus.a | Bin 0 -> 2942040 bytes libs/lib/libopusfile.a | Bin 0 -> 244268 bytes libs/lib/libpspkubridge.a | Bin 0 -> 17186 bytes libs/lib/libpspsystemctrl_kernel.a | Bin 0 -> 57410 bytes libs/lib/libpspsystemctrl_user.a | Bin 0 -> 46494 bytes libs/lib/libpspumd_kernel.a | Bin 0 -> 35244 bytes libs/lib/libpspusbdevice.a | Bin 0 -> 3250 bytes libs/lib/libpspusbdevice_driver.a | Bin 0 -> 3338 bytes libs/lib/libvorbis.a | Bin 0 -> 235816 bytes libs/lib/libvorbisfile.a | Bin 0 -> 33716 bytes libs/lib/libxmp-lite.a | Bin 0 -> 187010 bytes 200 files changed, 66815 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 .travis.yml create mode 100644 .travis/.build.sh create mode 100644 ICON0.PNG create mode 100644 Makefile.psp create mode 100644 README.MD create mode 100644 app/Makefile create mode 100644 app/config.json create mode 100644 app/data/battery_20.png create mode 100644 app/data/battery_20_charging.png create mode 100644 app/data/battery_30.png create mode 100644 app/data/battery_30_charging.png create mode 100644 app/data/battery_50.png create mode 100644 app/data/battery_50_charging.png create mode 100644 app/data/battery_60.png create mode 100644 app/data/battery_60_charging.png create mode 100644 app/data/battery_80.png create mode 100644 app/data/battery_80_charging.png create mode 100644 app/data/battery_full.png create mode 100644 app/data/battery_full_charging.png create mode 100644 app/data/bg_header.png create mode 100644 app/data/btn_material_light_check_off_normal.png create mode 100644 app/data/btn_material_light_check_off_normal_dark.png create mode 100644 app/data/btn_material_light_check_on_normal.png create mode 100644 app/data/btn_material_light_check_on_normal_dark.png create mode 100644 app/data/btn_material_light_radio_off_normal.png create mode 100644 app/data/btn_material_light_radio_off_normal_dark.png create mode 100644 app/data/btn_material_light_radio_on_normal.png create mode 100644 app/data/btn_material_light_radio_on_normal_dark.png create mode 100644 app/data/btn_material_light_toggle_off_normal.png create mode 100644 app/data/btn_material_light_toggle_on_normal.png create mode 100644 app/data/btn_material_light_toggle_on_normal_dark.png create mode 100644 app/data/btn_playback_forward.png create mode 100644 app/data/btn_playback_pause.png create mode 100644 app/data/btn_playback_play.png create mode 100644 app/data/btn_playback_repeat.png create mode 100644 app/data/btn_playback_repeat_overlay.png create mode 100644 app/data/btn_playback_rewind.png create mode 100644 app/data/btn_playback_shuffle.png create mode 100644 app/data/btn_playback_shuffle_overlay.png create mode 100644 app/data/default_artwork.png create mode 100644 app/data/default_artwork_blur.png create mode 100644 app/data/ic_arrow_back_normal.png create mode 100644 app/data/ic_fso_default.png create mode 100644 app/data/ic_fso_folder.png create mode 100644 app/data/ic_fso_folder_dark.png create mode 100644 app/data/ic_fso_type_app.png create mode 100644 app/data/ic_fso_type_audio.png create mode 100644 app/data/ic_fso_type_compress.png create mode 100644 app/data/ic_fso_type_image.png create mode 100644 app/data/ic_fso_type_text.png create mode 100644 app/data/ic_material_dialog.png create mode 100644 app/data/ic_material_dialog_dark.png create mode 100644 app/data/ic_material_light_navigation_drawer.png create mode 100644 app/data/ic_material_light_sdcard.png create mode 100644 app/data/ic_material_light_sdcard_dark.png create mode 100644 app/data/ic_material_light_secure.png create mode 100644 app/data/ic_material_light_secure_dark.png create mode 100644 app/data/ic_material_light_usb.png create mode 100644 app/data/ic_material_options_dialog.png create mode 100644 app/data/ic_material_options_dialog_dark.png create mode 100644 app/data/ic_material_properties_dialog.png create mode 100644 app/data/ic_material_properties_dialog_dark.png create mode 100644 app/data/ic_play_btn.png create mode 100644 app/debug.log create mode 100644 app/drivers/mutex-imports.S create mode 100644 app/include/colours.h create mode 100644 app/include/config.h create mode 100644 app/include/fs.h create mode 100644 app/include/ftppsp.h create mode 100644 app/include/g2d.h create mode 100644 app/include/gui.h create mode 100644 app/include/kernel_functions.h create mode 100644 app/include/log.h create mode 100644 app/include/mutex.h create mode 100644 app/include/textures.h create mode 100644 app/include/utils.h create mode 100644 app/source/colours.cpp create mode 100644 app/source/config.cpp create mode 100644 app/source/fs.cpp create mode 100644 app/source/ftppsp.cpp create mode 100644 app/source/g2d.cpp create mode 100644 app/source/gui.cpp create mode 100644 app/source/gui/delete.cpp create mode 100644 app/source/gui/filebrowser.cpp create mode 100644 app/source/gui/imageviewer.cpp create mode 100644 app/source/gui/options.cpp create mode 100644 app/source/gui/settings.cpp create mode 100644 app/source/kernel_functions.cpp create mode 100644 app/source/log.cpp create mode 100644 app/source/main.cpp create mode 100644 app/source/textures.cpp create mode 100644 app/source/utils.cpp create mode 100644 audio_driver/Makefile create mode 100644 audio_driver/audio_driver.c create mode 100644 audio_driver/exports.exp create mode 100644 display_driver/Makefile create mode 100644 display_driver/display_driver.c create mode 100644 display_driver/exports.exp create mode 100644 display_driver/sceDisplay_driver.S create mode 100644 fs_driver/Makefile create mode 100644 fs_driver/exports.exp create mode 100644 fs_driver/fs_driver.c create mode 100644 impose_driver/Makefile create mode 100644 impose_driver/exports.exp create mode 100644 impose_driver/impose_driver.c create mode 100644 input_driver/Makefile create mode 100644 input_driver/exports.exp create mode 100644 input_driver/input_driver.c create mode 100644 launcher/Makefile create mode 100644 launcher/source/main.c create mode 100644 libs/include/FLAC/all.h create mode 100644 libs/include/FLAC/assert.h create mode 100644 libs/include/FLAC/callback.h create mode 100644 libs/include/FLAC/export.h create mode 100644 libs/include/FLAC/format.h create mode 100644 libs/include/FLAC/metadata.h create mode 100644 libs/include/FLAC/ordinals.h create mode 100644 libs/include/FLAC/stream_decoder.h create mode 100644 libs/include/FLAC/stream_encoder.h create mode 100644 libs/include/dr_flac.h create mode 100644 libs/include/dr_pcx.h create mode 100644 libs/include/dr_wav.h create mode 100644 libs/include/fmt123.h create mode 100644 libs/include/glib2d.h create mode 100644 libs/include/intraFont.h create mode 100644 libs/include/kubridge.h create mode 100644 libs/include/libccc.h create mode 100644 libs/include/mpg123.h create mode 100644 libs/include/ogg/config_types.h create mode 100644 libs/include/ogg/ogg.h create mode 100644 libs/include/ogg/os_types.h create mode 100644 libs/include/opus/opus.h create mode 100644 libs/include/opus/opus_defines.h create mode 100644 libs/include/opus/opus_multistream.h create mode 100644 libs/include/opus/opus_projection.h create mode 100644 libs/include/opus/opus_types.h create mode 100644 libs/include/opus/opusfile.h create mode 100644 libs/include/pspusbdevice.h create mode 100644 libs/include/rapidjson/allocators.h create mode 100644 libs/include/rapidjson/cursorstreamwrapper.h create mode 100644 libs/include/rapidjson/document.h create mode 100644 libs/include/rapidjson/encodedstream.h create mode 100644 libs/include/rapidjson/encodings.h create mode 100644 libs/include/rapidjson/error/en.h create mode 100644 libs/include/rapidjson/error/error.h create mode 100644 libs/include/rapidjson/filereadstream.h create mode 100644 libs/include/rapidjson/filewritestream.h create mode 100644 libs/include/rapidjson/fwd.h create mode 100644 libs/include/rapidjson/internal/biginteger.h create mode 100644 libs/include/rapidjson/internal/clzll.h create mode 100644 libs/include/rapidjson/internal/diyfp.h create mode 100644 libs/include/rapidjson/internal/dtoa.h create mode 100644 libs/include/rapidjson/internal/ieee754.h create mode 100644 libs/include/rapidjson/internal/itoa.h create mode 100644 libs/include/rapidjson/internal/meta.h create mode 100644 libs/include/rapidjson/internal/pow10.h create mode 100644 libs/include/rapidjson/internal/regex.h create mode 100644 libs/include/rapidjson/internal/stack.h create mode 100644 libs/include/rapidjson/internal/strfunc.h create mode 100644 libs/include/rapidjson/internal/strtod.h create mode 100644 libs/include/rapidjson/internal/swap.h create mode 100644 libs/include/rapidjson/istreamwrapper.h create mode 100644 libs/include/rapidjson/memorybuffer.h create mode 100644 libs/include/rapidjson/memorystream.h create mode 100644 libs/include/rapidjson/msinttypes/inttypes.h create mode 100644 libs/include/rapidjson/msinttypes/stdint.h create mode 100644 libs/include/rapidjson/ostreamwrapper.h create mode 100644 libs/include/rapidjson/pointer.h create mode 100644 libs/include/rapidjson/prettywriter.h create mode 100644 libs/include/rapidjson/rapidjson.h create mode 100644 libs/include/rapidjson/reader.h create mode 100644 libs/include/rapidjson/schema.h create mode 100644 libs/include/rapidjson/stream.h create mode 100644 libs/include/rapidjson/stringbuffer.h create mode 100644 libs/include/rapidjson/writer.h create mode 100644 libs/include/stb_image.h create mode 100644 libs/include/systemctrl.h create mode 100644 libs/include/systemctrl_se.h create mode 100644 libs/include/vorbis/codec.h create mode 100644 libs/include/vorbis/vorbisenc.h create mode 100644 libs/include/vorbis/vorbisfile.h create mode 100644 libs/include/xmp.h create mode 100644 libs/lib/libFLAC.a create mode 100644 libs/lib/libglib2d.a create mode 100644 libs/lib/libintrafont.a create mode 100644 libs/lib/libmpg123.a create mode 100644 libs/lib/libogg.a create mode 100644 libs/lib/libopus.a create mode 100644 libs/lib/libopusfile.a create mode 100644 libs/lib/libpspkubridge.a create mode 100644 libs/lib/libpspsystemctrl_kernel.a create mode 100644 libs/lib/libpspsystemctrl_user.a create mode 100644 libs/lib/libpspumd_kernel.a create mode 100644 libs/lib/libpspusbdevice.a create mode 100644 libs/lib/libpspusbdevice_driver.a create mode 100644 libs/lib/libvorbis.a create mode 100644 libs/lib/libvorbisfile.a create mode 100644 libs/lib/libxmp-lite.a diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..dfe0770 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +# Auto detect text files and perform LF normalization +* text=auto diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b62f72e --- /dev/null +++ b/.gitignore @@ -0,0 +1,61 @@ +# Prerequisites +*.d +.vscode/ + +# Object files +*.o +*.ko +*.obj +*.elf +*.SFO + +# Linker output +*.ilk +*.map + +# Precompiled Headers +*.gch +*.pch + +# Libraries +*.lib +*.la +*.lo + +# Shared objects (inc. Windows DLLs) +*.dll +*.so +*.so.* +*.dylib + +# Executables +*.exe +*.out +*.app +*.i*86 +*.x86_64 +*.hex +*.PBP +*.prx + +# Debug files +*.dSYM/ +*.su +*.idb +*.pdb + +# Kernel Module Compile Results +*.mod* +*.cmd +.tmp_versions/ +modules.order +Module.symvers +Mkfile.old +dkms.conf + +# CMFileManager PSP Specific objects +app/drivers/audio_driver.S +app/drivers/display_driver.S +app/drivers/fs_driver.S +app/drivers/impose_driver.S +app/drivers/input_driver.S diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..efd9834 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,17 @@ +language: c + +dist: bionic + +services: + - docker + +script: + - docker run -it --rm -v "$PWD:/src" haydenkow/nu-pspdev make -f Makefile.psp + - sh .travis/.build.sh + +deploy: + provider: pages + skip_cleanup: true + github_token: $GITHUB_TOKEN # Set in travis-ci.org dashboard + on: + branch: master diff --git a/.travis/.build.sh b/.travis/.build.sh new file mode 100644 index 0000000..efe77a2 --- /dev/null +++ b/.travis/.build.sh @@ -0,0 +1,12 @@ +#!/bin/sh -e + +rm -rf .git .travis common libs .gitattributes .gitignore .travis.yml ICON0.PNG LICENSE Makefile.psp README.md +mkdir -p PSP/GAME/CMFileManager +mv app/EBOOT.PBP PSP/GAME/CMFileManager/APP.PBP && mv launcher/EBOOT.PBP PSP/GAME/CMFileManager/EBOOT.PBP +mv audio_driver/audio_driver.prx PSP/GAME/CMFileManager/audio_driver.prx +mv display_driver/display_driver.prx PSP/GAME/CMFileManager/display_driver.prx +mv fs_driver/fs_driver.prx PSP/GAME/CMFileManager/fs_driver.prx +mv impose_driver/impose_driver.prx PSP/GAME/CMFileManager/impose_driver.prx +mv input_driver/input_driver.prx PSP/GAME/CMFileManager/input_driver.prx +zip -r CMFileManager-PSP.zip PSP/ +rm -rf app audio_driver display_driver fs_driver impose_driver, input_driver launcher PSP diff --git a/ICON0.PNG b/ICON0.PNG new file mode 100644 index 0000000000000000000000000000000000000000..4b31f1952b1b35068ada1c784bee39afcef4a060 GIT binary patch literal 8000 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 literal 0 HcmV?d00001 diff --git a/Makefile.psp b/Makefile.psp new file mode 100644 index 0000000..7ea7cae --- /dev/null +++ b/Makefile.psp @@ -0,0 +1,7 @@ +SUBDIRS = audio_driver display_driver fs_driver impose_driver input_driver app launcher + +all: + @for dir in $(SUBDIRS); do $(MAKE) -C $$dir; done + +clean: + @for dir in $(SUBDIRS); do $(MAKE) clean -C $$dir; done diff --git a/README.MD b/README.MD new file mode 100644 index 0000000..6b0f917 --- /dev/null +++ b/README.MD @@ -0,0 +1,55 @@ +# CMFileManager PSP [![Build Status](https://travis-ci.org/joel16/CMFileManager-PSP.svg?branch=master)](https://travis-ci.org/joel16/CMFileManager-PSP) ![Github latest downloads](https://img.shields.io/github/downloads/joel16/CMFileManager-PSP/total.svg) + +CMFileManager PSP is a PSP application built using the unofficial PSPSDK and [glib2d (modded)](https://github.com/joel16/gLib2D). The user interface in this homebrew is heavily inspired and based on the LineageOS/CM file manager. The aim of this project is to provide a stable and up to date file manager that makes use of updated tools, whilst offering a modernized and user friendly interace. CMFileManager PSP is the **only** homebrew that properly uses the 'move' function correctly for moving files/folder from one place to another. Unlike other file managers for PSP which copies a file from one place to another and then deletes it, which can take a while depending on the file size. + +**Features:** + +- Copy files/folders. +- Move files/folders. +- Delete files/folders. +- Multi file handling functions for copy/move/delete. +- File properties. (File size, creation time, modification time, access times, permissions) +- Creating directories. +- Renaming files/folders. +- Image viewer (BMP, GIF - non animated, JPG, PCX, PNG, PGM, PPM and TGA). +- Auto USB mount (with ef0:/ and ms0:/ support for PSP Go). +- Dark theme mode. +- EBOOT (homebrew/game) launcher - Also allows you to rip icon0/pic1 from eboot if it exists. +- Browse other drives like flah0, flash1 and UMD (if not using PSP Go). +- Support for both ef0:/ (internal) and ms0:/ (external) drives on PSP Go. +- Screenshots in .BMP format. Use L + R to capture a screenshot. +- Audio Player 16-Bit short 41K - 48K Hz. (FLAC, IT, MOD, MP3, OGG, OPUS, S3M, WAV and XM) +- FTP connection + + +**FTP Mode Instructions:** +1. Press *START* to open settings menu and select `FTP connection`. +3. Select a network connection when the Network dialog pops up. +4. After it is connected successfully, a message will appear saying `FTP Connection established IP:Port`. Use an FTP client like WinSCP and enter the IP and port (1337) and make sure to use anonymous login. +6. Once an FTP connection is established from your server, you won't see any folders or files. You have to manually search for the path `/ms0:` or `/ef0:`. You can also search for other devices like `/flash0:` or UMD - `/disc0:` (**Please use caution when browsing any flash0-flash3**) + + +**Buttons:** + +- Press *DPAD Up* to move the cursor up. +- Press *DPAD Right* to move the cursor down. +- Press *DPAD Left* to position the cursor to the start of the directory. +- Press *DPAD Right* to position the cursor to the end of the directory. +- Press *Start* to open settings. +- Press *Select* to open menubar. +- Press *Triangle* to bring up file options. +- Press *enter button (depending on your region)* to enter directory/open file. +- Press *cancel button (depending on your region)* to go back to previous directory/menu. +- Press *L + R* to caputre screenshot. +- Press *Select + Start* to exit. +- Press *Start* on FTP mode or Audio player to disable/enable screen to save battery. + + +**Image Viewer controls:** +- L/R - Rotate anti-clockwise/clockwise +- Up/Down - Zoom in/out +- Select - Help menu +- Left/Right - Previous/Next image +- Analog stick - Position image after zoom +- Triangle - Flip vertically +- Square - Flip horizantally diff --git a/app/Makefile b/app/Makefile new file mode 100644 index 0000000..17e6414 --- /dev/null +++ b/app/Makefile @@ -0,0 +1,44 @@ +TARGET = CMFileManager + +SOURCES := data drivers source source/audio source/gui +CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c)) +SFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.S)) +CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp)) +GFXFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.png)) +FONTFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.pgf)) + +OBJS := $(addsuffix .o,$(BINFILES)) \ + $(CFILES:.c=.o) $(SFILES:.S=.o) $(CPPFILES:.cpp=.o) $(GFXFILES:.png=.o) $(FONTFILES:.pgf=.o) + +VERSION_MAJOR := 4 +VERSION_MINOR := 0 +VERSION_MICRO := 0 + +INCDIR = ../libs/include ../libs/include/ogg ../libs/include/opus include +CFLAGS = -Os -G0 -Wall -ffast-math -fno-rtti -fno-exceptions \ + -DVERSION_MAJOR=$(VERSION_MAJOR) -DVERSION_MINOR=$(VERSION_MINOR) -DVERSION_MICRO=$(VERSION_MICRO) +CXXFLAGS = $(CFLAGS) -std=gnu++17 +ASFLAGS := $(CFLAGS) + +BUILD_PRX = 1 +PSP_LARGE_MEMORY = 1 + +LIBDIR = ../libs/lib +LDFLAGS = +LIBS = -lpsputility -lintrafont -lglib2d -lpspgu -lpsprtc -lpspvram \ + -lxmp-lite -lmpg123 -lvorbisfile -lvorbis -lopusfile -lopus -lFLAC -logg -lpspaudio \ + -lpspctrl -lpsppower -lpspreg -lpspusb -lpspusbstor -lpspusbdevice -lpspumd \ + -lpspkubridge -lpspsystemctrl_user -lstdc++ -lm -lz + +EXTRA_TARGETS = EBOOT.PBP +PSP_EBOOT_TITLE = CM File Manager PSP v$(VERSION_MAJOR).$(VERSION_MINOR)$(VERSION_MICRO) +PSP_EBOOT_ICON = ../ICON0.PNG + +PSPSDK=$(shell psp-config --pspsdk-path) +include $(PSPSDK)/lib/build.mak + +%.o: %.png + bin2o -i $< $@ $(addsuffix _png, $(basename $(notdir $<) )) + +%.o: %.pgf + bin2o -i $< $@ $(addsuffix _pgf, $(basename $(notdir $<) )) diff --git a/app/config.json b/app/config.json new file mode 100644 index 0000000..b90da8e --- /dev/null +++ b/app/config.json @@ -0,0 +1,6 @@ +{ + "config_ver": 4, + "sort": 0, + "dark_theme": 1, + "dev_options": 1 +} diff --git a/app/data/battery_20.png b/app/data/battery_20.png new file mode 100644 index 0000000000000000000000000000000000000000..056b94c39951f6b1bef04d2a0728aac564f14cc5 GIT binary patch literal 230 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbL!O@L2`E0F$AF1X>DAq>p7s9krvc?%JzX3_D(37xZ!W~3D8TIa=F#8(|G9D& z>}vR7bvZ@ok*}7jeXz85O0QeNJihk=OdCHGcXYb8#6-BQc>C^};IWwFGUxA0S3h8$ U*(QGI8_+-oPgg&ebxsLQ0H6YK&Hw-a literal 0 HcmV?d00001 diff --git a/app/data/battery_20_charging.png b/app/data/battery_20_charging.png new file mode 100644 index 0000000000000000000000000000000000000000..15b973b47728851a0352b24357872e63f85823e5 GIT binary patch literal 327 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbK}W`IwKE0F$A7w|`VZ5hxq<&q%3 zU*l8$C;h)r`bWskbJ4NZ6rl1fPZ!6KiaELG zPx3VwaIjoh)v@;XzC~gG|0_RrxnRNBUfJ$x@XX#(f^C(XfbuZ`P8BgrGr@v8K`zS` zi}N>pXxyW*I?9px*p|6XcJjww+P+#4Y@mO7&nM0t7i+;>rsF54o^w7BZ~pw#{(5`O XnQWq0QWL^}wla9S`njxgN@xNAYk{$N literal 0 HcmV?d00001 diff --git a/app/data/battery_30.png b/app/data/battery_30.png new file mode 100644 index 0000000000000000000000000000000000000000..e3269ee4592b91c6a65ddac13dcdad94baf6f1f3 GIT binary patch literal 230 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbL!O@L2`E0F$AF1X>DAq>o{M{Z`hfDTo-U3d6?3+pR~KVY;Bj%xdhz#PIjhnq z0R_qJ_jQxYV>s%3R+=<~O={Y>A;S3}V^MuG|B2uZ&ZFfgQr`z@Zn2woZ{2?No(SfX UHcPI>0u5yFboFyt=akR{0Pt0A@Bjb+ literal 0 HcmV?d00001 diff --git a/app/data/battery_30_charging.png b/app/data/battery_30_charging.png new file mode 100644 index 0000000000000000000000000000000000000000..0b6948a7f77047c5b84ecf1baee2d739366c3dd4 GIT binary patch literal 332 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbK}et=JiE0F$AN1%V1=_1fd)si5; zUDAq>o;$X)$^hlvJY5_^D&{ObuP(-*z~kbW^`fQd|86G1 zN)DOF-*$^W^3_sZzp|HggIjTdoY{K|7KMlEM_iQJV?6$Gik?4qY+?V--hY4gGHkoS VqS?Ofw;a$!22WQ%mvv4FO#mb-Z&v^S literal 0 HcmV?d00001 diff --git a/app/data/battery_50_charging.png b/app/data/battery_50_charging.png new file mode 100644 index 0000000000000000000000000000000000000000..062631e71ba20d52b5275f50fdb7331dd511f5f8 GIT binary patch literal 332 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbK}et=JiE0F$AN1%V1=_1fd)si5; zUK+>=z2BX|ee}Qcuk)pUgxoysVh%+CHKcpGIEGZr z$vy8b)}SEZ;us)vP{y#g>*2rjDWVGf`(NKOReYEs5}1BWhtVSRlTzl-VjCz9BW?@}4!)Ufdl;_BJy<@~iJ!plACri0$3;tG4AIzOzqU W$gcYRhs;Nyl?$$%G literal 0 HcmV?d00001 diff --git a/app/data/battery_60.png b/app/data/battery_60.png new file mode 100644 index 0000000000000000000000000000000000000000..355b8ce981b282b6730b0cf49dd336a30ec5781d GIT binary patch literal 231 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbL!O@L2`E0F$AF1X>DAq>p7u%~Qh@Sqo-U3d6?4{}H|Jwe;9+rGbn@r_de)c- z5fcxe^4qe>kg=afZovQm literal 0 HcmV?d00001 diff --git a/app/data/battery_60_charging.png b/app/data/battery_60_charging.png new file mode 100644 index 0000000000000000000000000000000000000000..b44820183e74c44761299ed7f8522339318e8419 GIT binary patch literal 331 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbK}et=JiE0F$AN1%V1=_1fd)si5; zUJtUeMlWIZt}wO* z7EeyKJ5>dQm0m8Zed)lj{BnupjLOJ~jEnAl6A;^QE4rZl?g1G9-AqIEGZr$vy8b zbU=ZFH9))T<<*el|Ix>CWJ*4j?_vEQ`I}$7X>yS#BYYIUrD3up6C53Vse-FoO`x=Zd_uPQzQCk zI@jLpNWUAD*c0iDq}8p)1AaURL2Tg>Ndo8Q=>q-3`2U)ule{ zIK8VdCeQWTJk?R*i+2NSD!rzdkz(^4zTJhEYjaI!|4c{k zA_ocgmRcwu8Dc>HcTH7CLbNwn1@V~LB zwV@Hy=j*GyYbrfFzQ5Vde1jHM8AS}va{hY9kNB~zrXxj|9LE}cNQze8XxAl0+Q=~^ z$9b|j{LE>@yXu5yPSW#J1Jss#Zgo9#S%bEWB4(GmFM`>fz2jdYvP2c09km@u#h$t2 zAD*jiw0g)vR9##F?W2>;zU9I)vC8g2Su^fKC7Z|VG zCeuKUSMprw9Hr064mIn+6E;`3L*>!zAAKdZ-P*Bvt&C+Vhi!Fw+*h6CpcC$wrtnfu z*jwM3Y{o~H9bb<1>4nFk%m zrf{gyM;l?qAmzzHYJ+uOg}ini^bN=fqTl_j)D!hRRsp%S2OA;##qn{8+ae_@PmU3} zt-oT2o7{0lW`wYR_^9e?zBP4>run zVsrnD&C+jgcEq$#8{$WNrb7jmu7Er_Xkzaaww;Hm5dYd6GEQuFn`7h6_6vX+XIuPZ zV%(wa{ZRE*HdaHmPqu2Z`7(t+4Gz2KG%z^Gj+pe zVG!*g?5XcGRmQT+$gOY@jJQMa=m9Uf{(( zJM?iu4><;9Id|7{WeVbMZIaD>3Z!HS%PP5)?9lAUNbJSN%Cp(dQMs)nS&YbSeQcJv zwo0%G1+EJqCKjp@6tqK`sMpD6Upz=Wk_qx@i96NqNv+^Orp%N=SMRh}NWk{o>iX~h z0{>w_=Kti!WpZgF2iXB6)@WZ(1&hJRv*oeU4&&u?Y)vnAqhB9$rByUqZ}U9YE0Z!G zmB0$Z9yr$Id)}I4idEzw(1?#W!GQYDw|xg1x_F>8o^dweOdE;O=hxfBZJO!VdY$qh zjrcR3dk>Ir_+_~zX;=%%LBst5XYds<9e}a}SC(Cmw>%M6)-+h)HX!I|k@3 z{j!!Egb#}8?9^EUcdFSx5=aTDjY)+r@zVD0m~geVHykdcHa6fC1cOU=1EVZf9{R~K zFw2>yuYi`mXQ2&VlpUVqlrBSDRPKH@+LkG?^KG2GjEEm^by*q@)K3n==qs%#XJ!^B zn*C`0^!XFhe-%#baNCj}f6Mg)ZqSSg1LcmMckiN`+?$wiyRxsTv$1 zd{E>g=O$q9HOjTLz?4LY<9eq7mNVO4&D-S&{(Hm)39^PS(|ZKj#II~ zJ=x|)HV0|GPj!%wFtNZj0Ibr~Yi){_*}>aB=8DFg>q_#epBxFnd)4aI#Uar455ZA$ zl6w{Ay^#-f{!8M?n#dINi~?;DNNKH?3UY)%#_YtxHZ+9^`K@vhAPdPcILo=ve8`f) z>=I~sJeTcUB71m|J&V)^eZD}4wfhis0;1&_n0RWO^);6h7aSPuNo>DMHe#X@qB zg`cFuiRgg^Wl+i!rA}5xlm|&AYa(J^sT)Z-8Qtk76Al+y4|aHt9{JRqm7P`ujkpv8 z?nr?YfBDNq>W;K==^X8NF4|mM)foGXlpzP6pz@G3~*?w$g(tTmv}_fAT7HoS3_72*2W%Kr4bSs1`!^n8MqdWG;l`O z6vH!-xeCPSKMmv{BMZ5&WZdn;ch?Y%d~7|u>Oy{|_MSe&bGRv(leq^|*i{Fou-Jk+ zBRZ{^Gx4}o5=X;b*;&|ASc5zJ^Elh$UsVYu@7)5OMLP6VALC5WdZ`Fiy3xcfuo_H( zc5zaH&bE-W3+kq{esYY=<&3x!`0iRn{0l1&#;ui;Ip#L+5rxi7!M8G?Lef=dMC7J( zikSjx>S{ST=3&PvO~7&Du@2vpV?vy!K<4dSEOT3MJ5&+y#`O$rnVJHVU?Rrs#@&~! zB?sreR(Q@Rw^BTT%{uyAOJ|=qaO%>O`-*TBcd$uj-C99}e0a1A-!knwEhPupp8i~s@Tw(3>TP2v3ZzYb*8YR7CtAk+V1_O$#+}< zhi-SF^&uP;zGA7F9DHg!)$Tcm8&L{^wE7A=JXXdj2RvvBlMC^&QsGh2$swF<;@$-~ zs-q9-R{V;Ow5z2`jvyTKu|fI+Zt5inMj_9=4pSti5TEH_67)ON4#x~ORJu{t!|Z`m zxF2w`RFFm&Ih-%D<#Z|r9VtvELoq_%dqgkiab~r&ADAA=8r600DPNoSr32#pzi&FjLr6EvuPZpdTAbkZNIu$Zu_v)qfho=VaEQl_j}hT5d2P zGaHG**X5p}x?|5{*otWM+8%?9;1tjol9eN#rWOP#TBM~?Y;LpZEp6mTG_qFEtXos* zHG5H*%s_Nh(XYI7RsRK7(tk`L`|3*5#`S4z2M`M-@=XzO(dhaL?VC+EP3u28Pw$gM zaJkW+4Z`Kxp@4z-m`LWBdawm$Zj0`f^PaicI3wdh&=xXI5dBjG;2%BFJz`S95yx*#;lUrrZLTqAY7xg* zRlzpGWY%fvjL-v1%H626SUZNYsVr%%vU7!csUS-LB`v7N(6=2{d(7k^;!H6kgiCh= zWAnlnG8x5~xSmuRbl~= z`)UJqUnl(hy0vy_*eNX5I)(LBUgUzFX@<$gh+u4F;*HtIDzuS3BJr4sHgb?cTWW_7tv!$3TJdE~vUwg)2Y56Eb>*=N z*R}A;MRD+Mt%~xHCr5fPgMd14huqplWo~IKE_X9G>mQ5qa86U30@+@S`x@Li4a(^| z#;rB3M|i)I9lsJecGbgHkfFuxuZF01kX4*Qzst@g?4#Z4nu&j*=6I8TNRBgJcKq_> zAba?o!oG+2B4B8a^C-S;Cg;RCrWoZy5wH(eavZ=9 ztV-a1_4&x$*6GFWX^{}cOve)grn>4xv+t)!HGGF|ccC(lb1nYYwcgwK^WKW$yF+~t z#A{bw(l7q;AoZ`-5D{knyLfsv|-P7Z~c1IsMq5yLDOnHbAK~!7J zzVs%CK5|3>3BjkCFXg>+E;i9WhLffmzO}g|5j8Fy3v9YD|y(izIuy z3ce`wSa)wDR>={1PFJzaZbgM>e6+Ix3Bd@pJggjBtdc{$y8S^COMj30Ck8P|js$%# z0u!cR3x7MS4>3uO@minu)Y4}9iA3y?V-WkKk{p< literal 0 HcmV?d00001 diff --git a/app/data/btn_material_light_check_off_normal.png b/app/data/btn_material_light_check_off_normal.png new file mode 100644 index 0000000000000000000000000000000000000000..657f84bdbb51e16be7a0264de0aeeaae0d81161c GIT binary patch literal 152 zcmeAS@N?(olHy`uVBq!ia0vp^5+KaN3?zjj6;6Yw0G|+7AZ>&S>hotz1B$Yh1o;Is zNM#pK$T_Xtc>yS*@9E+gQZXkvVS$W+mNawYM1~oMpYS}Iq0wM@hK-{r!D5ZTa~1~~ gDWDKnz`^qjn^`$0e&_NQ25M#SboFyt=akR{0LqXji~s-t literal 0 HcmV?d00001 diff --git a/app/data/btn_material_light_check_off_normal_dark.png b/app/data/btn_material_light_check_off_normal_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..8c5f43aaa348788a53bc4b39cec784ca63fb83c0 GIT binary patch literal 152 zcmeAS@N?(olHy`uVBq!ia0vp^5+KaN3?zjj6;6Yw0G|+7ApIW|*afY%0*bPg1o;Is zNM#pK$T_Xtc>yS*@9E+gQZXkvVS$W+mNawYM1~oMpYS}Iq0wM@hK-{r!D5ZTa~1~~ gDWDKnz`^qjn^`$0e&_NQ25M#SboFyt=akR{08Jn=>Hq)$ literal 0 HcmV?d00001 diff --git a/app/data/btn_material_light_check_on_normal.png b/app/data/btn_material_light_check_on_normal.png new file mode 100644 index 0000000000000000000000000000000000000000..4f8a1735a7b36462ee48d38de7ec3d4259cfd55f GIT binary patch literal 247 zcmeAS@N?(olHy`uVBq!ia0vp^5+KaM3?#3wJbMaA83*`;xB_V-Y{1yq7$~fwqGDoV z0+BZa10Xw>N$~_wn_x+hUoeAIc5%+EnaP?{nKY(M)3f*8^;7O8P%_EW#WAE}&d~|p zd<_abtP4fDI9~kqU+pOxb;LB^a`KnYJ&|(U>sZ$ayl{2kxL)`nPfH^&*fH~bRLili zD`Z|ijhZs+#lyp&Zp)lGzS_(5jQ#UzlYgFD**C9aL O7(8A5T-G@yGywpy&QVDK literal 0 HcmV?d00001 diff --git a/app/data/btn_material_light_check_on_normal_dark.png b/app/data/btn_material_light_check_on_normal_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..0f2b334f2c99ffa5adbe43408b7fd7ff353866b7 GIT binary patch literal 247 zcmeAS@N?(olHy`uVBq!ia0vp^5+KaM3?#3wJbMaA83*`;xB}__B!cZzA2k8B36=!; z1v5xx7w62HnXEaLNn^@1J$v6>KjmHmC6hc|978JR9G&3J*Py_|x=^HxxCckv^4U99W&2IwH*7pLgwYus425vJUsmAw#=F1 xtG!Im*gu~(`R950=76aSbOftAHN0b{aR2IL@pjXF9RjqC!PC{xWt~$(69AA`c{l(7 literal 0 HcmV?d00001 diff --git a/app/data/btn_material_light_radio_off_normal.png b/app/data/btn_material_light_radio_off_normal.png new file mode 100644 index 0000000000000000000000000000000000000000..b77dcef9fe5afaa89471ab250ccb684358a61501 GIT binary patch literal 405 zcmeAS@N?(olHy`uVBq!ia0vp^G9b*s3?yAI>n{URMFBn`u0Yz*(9qb}*a!@OY<+!w z2pgFMio>};HZm6|ZU6?z8i5LcWVuRxkSZUw_&$3GpN!`MJyI%1p~ivw6Ss6LX6p*CB3^qnr!fRL&|*f7&CS z8hSlc)8h18+iNGvrzT@8mz zS~e{E5nu89?OVr0tzDN(m9{dODf%3@Ia|gtkL}~xvx{_hun{UR2?0JKu0Z-fEkTW{%r2lE3MD~) z!3=`NAz6Iv-rX~1b$SVv&1~|JXK9@t&c(~x>?x-ZQ5rGz$w{Ev*`6+rAr*7ZPQ1<6 ztiaPI7+|TX(xaJ&eJAJy zCKhL~{uK|~zgF*x*YtH$=CCw1w#a%h{3@##d3FDhdG_|JFBc2M+e@yJ`>j{Xv@MB4 V``T(Q7oam4JYD@<);T3K0RYf1#iIZK literal 0 HcmV?d00001 diff --git a/app/data/btn_material_light_radio_on_normal.png b/app/data/btn_material_light_radio_on_normal.png new file mode 100644 index 0000000000000000000000000000000000000000..f4dbca6b117c0e4f7a6449b583805d5fcff76ba9 GIT binary patch literal 488 zcmeAS@N?(olHy`uVBq!ia0vp^G9b*s3?yAI>n{URlLLH0T!FNqp`o#{u@M*m+4}nW z5H>Oi6o+$xY-BD_+yD%K8qLkkA6(k z__%F>CCFJNL4Lsug2o|PeC*!cGiG&q36;%k@{ng~ogU7`%gQKfA;QQsjj`F-Q%-cM z0t+K+1be9hOTwbl3P8=5JzX3_D(0M>c$2TmfycGGfjL!DKq5?(#oX-g|MkTV!jg-Q zxxWjZJo&cCa)#5rTPBIR#;ugUFe}6A(~Gv9^Ndd~>)ZWtPw(sC+q1sDX=pufnAE6S z#+hoUk~uB6T);SsYkP(tNA)!2XKNZhEbtVLc%>)O!^a*t$zkbqVU5RvewKZf%L^PU znMC(EwXIKiu<(<<%(Z3rul=*}F#W@kRrJg@$oYwMQ-an{URr2#%6u0Z-f-NDoDGzXx?>Lo#b z!3=`NAz6Iv-rX~1b$SVv&1~|JXK9@t&c(~hC~6_XG_BcFZmL2=>6?kM&Oj}DJY5_^ zD(0M>c$=?TLBJ*apw??vQ5V;!?7e^ft6#gdOz`pqJ1c(`b!WA7#&go=)u#yA|7g@p zJW{~hJ^A#+rIP2ngE}@%u<_>KyC&%C@0%;MHt$vp*L`tr#_G1Pk4J6^JvF@((tksn z_p9xvvJ2^~8As!rD^?^X{Nod1ATTEffOtDi2Y6Sn6xPYO%_+ zeEIUVYuBz^xpL^xp@|bG+S=OY<>ehdeE8|pr|;gq`v3#)-@kwP^5wa6=i=kzwY9a4 zz`)qp*ucO*OG`^eMuwG@)ym51=FOWxT^~Pw1ggJ!_3DfnGp0_RItvD-PoLh`*O#50 zt*@_dXJ>c*{CS|tyLa!dTD5B3x^?TH=wJ4x}H6I2GlZV&K#icfW80* z$g*Y2fR+M{1=_W9=T2Zq0D}wYfC&>OXliQ4#>U>dbqi=XP}kC>OB)&*3=Iu|p$GI1 zP&?2}pfaG}r%agwA%Tp}&d&7obfDf#mo5R_1N0Xppn$dmqoA^~QbR)nD66in4vZb3 z%jM`1cDJ3%{(gTrMOT!cmxqUkid!jBv~cktxVvxiR~Ki}f6I=NxN zgbf`lX6$HLGG$ATj=+f%C$%-SHZGjCbj_kwY>cm@W<}j{Sg?5U>gD+fCz?{s7Ej#R zDJ3&w*34*!#-&rY@*Z-Cwyti`GG%vHpJBwEE*@^aqw<}cN88Gkl~o6)Mppd(vFXs8 zFQ47RmWl~v^aY5E$S?(qNwqD~xnsk0a>ogc6>D=Y8fu(Mnm9G`$WiC1hH5H{G`zbU zf~L)x#P!`ts%z619+mB>X*Ul|NqxRTY2~T2&OfeL?q47vr_kei)I(7yfNA^YEo=5L zY3`e$wc2Gtm&@wxtkjhL%3MVK3(&~-@qtm@O1TaS?83{ F1OW1~2TT9} literal 0 HcmV?d00001 diff --git a/app/data/btn_material_light_toggle_on_normal.png b/app/data/btn_material_light_toggle_on_normal.png new file mode 100644 index 0000000000000000000000000000000000000000..4072b1f2f6678a388793a1c5f506849a84a2eb8a GIT binary patch literal 1060 zcmeAS@N?(olHy`uVBq!ia0vp^Y9P$P3?%12mYl=D!1y)5C&U%V#RTlib^?CgqRH#U zv-XN-?-xtoE*w6a+cch$4P+n-8@q(On!JXgvYv$s5b0Y2NhKXq2}Ladk9x7pJrc!d zB}*?zmR$s)(u0VhdVMF1hO&~N8LT=1xU*=RW zPqN^+WZ5O42|x$1E8FW>x@EL2u32!nY55r-YFKhIx_7U9#d)9tk+|hR_vqPp@6HINKSHJiKP%3%CKDqMqqRAV8>Rlsqs^;#mTYM~} zYoAovCGor?K*7kOp1MWHY8M{$Z9gDUbP6aEUD{u___$9SkbA}@EDI~YfeZMofZt5Xyo9Z*0QjA-XWlyf#w8t z?gRNKX&umHEi=cE+}7-_mHB<^3i{XQ!%%AL68rr55#GIj~aF5`75WD!;dI$-nDlPW-Jc}b98Far}S2PYe&ka_-;*^OQ@?96Q3d;)?3 z0z#5*^B#Wt^Y_=Q?Xf~U%HGwT6DCiZIBEKlhyOp93d%Ly`S%|PzNB)=c7Fge&Y1BR zz5&t|EJmk+)NbyeXaE0S=MQ=Q|Bm7R|9klJUjF}IqA>mA|Nl1}V7jg7UfWp-B9FfcQ8HS#}j=FXu@TwH5%b9x^fICqb6 z;i-!!CD)xgdi5*^=Z@+Fy`R5)+SbG@A8((My6GRIK|3p(Vn`%wdyA5`F&B6HO-aGd zB|2JCu2TbjbbKOXY&LCT2}$iVNX_v)F->jxf~Z+so2Mx1+A^Qyo*AhTccQJb(NRI& zoL^2M>?iAqQ(WBw52XWQf}+@h!{Qo6l%|GW)tDF>936iD0tbulS>3g{Zv|Xs=f>XE zn0Q|8!sXl7?HM`L{ASstzS{DV%h>8k+PPV_?hNrxv#j&~HMMq&=|^_iA2l@4OHNGW hQ&^B8azUJd;b%$ymR(yTCIe%g!PC{xWt~$(69Cq7qVoU% literal 0 HcmV?d00001 diff --git a/app/data/btn_material_light_toggle_on_normal_dark.png b/app/data/btn_material_light_toggle_on_normal_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..eda59be17fd3928be436e07610f698a7fd488bb0 GIT binary patch literal 1059 zcmeAS@N?(olHy`uVBq!ia0vp^Y9P$P3?%12mYl=D!1y)5C&U%V#RR-ss}+Bx%Ch>pil)YjW+qDJra)5B)I{FcP+VPAI?PAC zK3}`5N~gC*r>_=-dTX?Msx@0nmGYDL^fVcnm^7Uo{TpkN7tKjuu_$xZ5(HYgIAQ(_ zm)08X_HvNMo*I?144`8)ogEV9OfTNOrQ+}&ASyesGivD^gZ_G;$;yQ(KqqOtI;SmL z02Hq{v?qW228U^#S{)TK(Sck70rxb4ASh{z6=%N{# zEu}z_pw`Bcz1vInYzvq_MXR#{C=$}qQo3)uKZsjtmzq?vcU$nn=|C@V3kk(colv@O zN7CxWh7%f8OVbVfyfarX1zMfEZJqU$Hto(z`J^yCAJ4d%Q;K$O0=gDxPRPRP`e4@r zy#q8{&CbTJzAAa)Y@nOdmoJ2)xY<*knya;deuo5IPqkWQHlMBr3oEOrlA^e(vZRJO zFoY%4Ri(5vW%P99^!3Cw)TE>QHJXaFyQ@Kg++Gg!Bfp*|FtQXfqJa^oUSFV5U!Y!_ zuT+pM;p@UKAqsTBB&*3wfYkDmAirP+CRPqkHbx=y{3){=y=2&#*|_-x1O)^Hge2YO zJ^c3P@2^+eV}*E>y{kJXOrA7x()1+{|9>tOlxw*2?>`WHN#&C5{s3g0G2<_M^Z$PZ zi_z)-|95i-J^TOvI)BLX|91@k|KG!(_wxV$5{2m>|Npe;&zoD~&^dOv^qwy}*l-rhPTwdfzCK|3p(Vn`%=yTsy#3kEahJ{0sgrL;I; zs_XFsQ;r@})b4fOyuV091pxbil3j2-%xPzk*fE{zopr09fs*HUIzs literal 0 HcmV?d00001 diff --git a/app/data/btn_playback_forward.png b/app/data/btn_playback_forward.png new file mode 100644 index 0000000000000000000000000000000000000000..f2e4fd66a5fa955eb774611673046be9944b6c8e GIT binary patch literal 812 zcmeAS@N?(olHy`uVBq!ia0vp^N+8U^3=*07`vU_5qji8!h%1o$YZQgoR4Gv_qJZ_^N-0o ztcL6(brS7UQM&x({M%g+dr;!* zZih7y9I0(m-26h4n_L=!acA!7;uumfCpkfa)q+7;*qFQN_^D&(8W*-q?w;K~o&VTl zaRCt_F~?vfEj2wwO;+Kj)2B_GIypSRC0t2w^^!GA;Y#aPEnC-^HF24RKt|^47flsX zOhyj#*38@2sI*I{P|{ghY(unz*OAa(U!SuVrgqGZj)>AU%7{4au)}PUm4sKrvD>#c zHr!!iT=k9bPt6OjBWGpj&Uxr{FV8AR=v5j~@&p;92& zNtHR^k%xf9mPEG;ER063rZ!5Kcp^D3OwkDUU~!ysLds2g!4akAiObS?Y<4m{)-XFa zg^~A&x{8`&#hR0vVO=l0c!DlZIP&9?@tF&uJmw4xiP6UQ1ay`x1jZYKr>mdKI;Vst E0G_`3kN^Mx literal 0 HcmV?d00001 diff --git a/app/data/btn_playback_pause.png b/app/data/btn_playback_pause.png new file mode 100644 index 0000000000000000000000000000000000000000..31355d5fc5d597185c467472a9e8d34c5d06dfe7 GIT binary patch literal 157 zcmeAS@N?(olHy`uVBq!ia0vp^N+8U_3?xrvihTr95&=FTu0Z-fHlSQLHy$X*Q4-`A z%%IV;AjRSS|GjgzE(40`c)B=-RLn_EP!KoJl9skM*dQS-&FSD8aryLVUWpl}PoHLT hb8YM7NYk0j$52-m-o7w?({!Ld22WQ%mvv4FO#qFrI@JIG literal 0 HcmV?d00001 diff --git a/app/data/btn_playback_play.png b/app/data/btn_playback_play.png new file mode 100644 index 0000000000000000000000000000000000000000..2943df982ddc482f9430c629cc6425d459ca34ad GIT binary patch literal 424 zcmeAS@N?(olHy`uVBq!ia0vp^N+8U^3=*07`vZ`g7T^=&3Z(xJK5#(w=nA0Aj7oz1 zf*Hgm7-Ls^b0++KGF9OJ{Y&{hlt4Ar*7>UcM=G&_ST};e;E96diM#Pn<~Ve)>1Qk9+&8`C6{=^`Vz- zYj1u27u&ncUnOI!wZpEx8|)dBGA+6~H01o3IV?#r`+wuxY>)1zrx+$)o2@&sWO}5+ z`diOg1*cwp$l+o&SKnpHuPk1HyYKqnbK14M{dD0=DIfO%(83Ek;lZs(#ovmX{WUKs!tz2zMHNs zw&6wj`aj1LM89rav+mm-|F`Bs!XlNwx4qXt7sSo5w(NUo)j=PJnRjlT*D~dkm-_KD z&5-wBa_^~BxkYbM)Vg$%`komH3MkD#edgq4+4e7Ns+X=@^PcNz%%!_n@9wP~SJQ#% zrrXoSF{EP7+(|#pnF2)`(m5iJE$yAD7_GY7C1uM35zd91+%>Xqey{zzy|?(8sqwL% z;+pr%f8Q&AxA*zJ?!^7g&!4VNnJ2*7>Y5c387Mk^$}~-F7t4^4tSw$$e*6h5R-L=5 zq&aI@cFPs1*9;5xEfm!BRolGurp}?HG|>&)wiJ0qTc5aav2%)^b!BsqEGf8Sd)9=LSopI_J~BqUF6Iw znRV54;-Xh99&5P6gZEDS;yKmVj(gwMTo2c!URKjt@88_Yv{^m$Td~*IgNhDX!sq2u z1=p>Ko6u@uw{gR6!A+`vm#1_5|9P~0cZ~k@@UWS4y_Zn-;0cXR~-M{5y zY-|>l6}~!oVB7CGCsX2X9CqIO>2ROxw1dCCy>?gFV*Q@y^THJgQIAh9FB02!O-yt` b^>3yN!O36F-tpQ7OezeXu6{1-oD!M<&<^5b literal 0 HcmV?d00001 diff --git a/app/data/btn_playback_repeat_overlay.png b/app/data/btn_playback_repeat_overlay.png new file mode 100644 index 0000000000000000000000000000000000000000..21e17fb8a7e31d98f3935136d256531cc063fd0d GIT binary patch literal 1020 zcmeAS@N?(olHy`uVBq!ia0vp^N+8U^3=*07`vU_5 zFUr^dIi4W;b>o_K-}d;wH5U>VsrH&dXu8orIXb6%t%l`Y5wUmCojvke_>O-bmf}&Tu);z-Nkx$Z|%664oo-Q zo-U3d6?5iJ`f1J-DAJJ55qWHB?@YyL)!i;BTNa3LF5Kj!Qpr)_d=A}1v4ke|DZrHY^$Sd0V#D$BUQ}iSk-@bNOvn=f8+hPlu zzZ{bfACqD}=jasBAz8HZu3XFMcdQa}k}8Id3j^m@l*CDV>t}7!_}1e+wR1x8qzB2n zLlh4MUshSRVntTki3JMZT+*IDJ9^5WYtdHcjXM^7vj4!E+!GfP!=|)HBr5JAXI{yy ztELkdy<+iL!yO*Hcj6b%slImH`?ltKxGwdwn$CLv=2oW7>Y?9?y}lk)bkGt$FPAE~ zZcW^TRtvk08+HqBQvJI;o#X${qvg9}^rwf1&7AAK#L`uE=RfbAJ9`Z{8X0s*V`y`pfYhV3m;7L34i_K>7=lXxWac4OK4)(L^PX5U#TlgqQ zk^Q3#Xc1z%OX3N9hl%`IT$`Flq+^M(d&4i+-(qa2KkN%$V zrR{C(wLkosQ5%Im^jtm)j5}RV7srr_Id3mr4?E-_!1jQ(w@cuROKgBLlUSI5pvGTY{(YY7X(Zh8@3pun*Y>U3t(GnhX7LJNVl9SG^&_EzesnV!|CmvZ_E{}q0vCpyei=85P7V~fGl)z4*}Q$iB}C%*!H literal 0 HcmV?d00001 diff --git a/app/data/btn_playback_shuffle.png b/app/data/btn_playback_shuffle.png new file mode 100644 index 0000000000000000000000000000000000000000..2540308ba0174379f923948c6eafed8d1520bad6 GIT binary patch literal 1356 zcmeAS@N?(olHy`uVBq!ia0vp^N+8U^3=*07`vU_56K{Y|h%1m=-_SIQMneD?0vS&i z{{<$9^(8@m!3+#6Lc&ap>WL|732~{(;+!VkYHa?OU%z?z;=GR4q7O?gr+oQ;RXhFh zzdsx8c~z%s^=@$IV?Fa%w(-Y$KW3v9TwO=p_+5Vg`YO}*Jizhe(PhsrN%#HKo!#^4 zqUJ+qyZN!)DyusrLzjz)%5x}|)G7t-ymkEGmiW1EE6i8EYhia-P$kE+$CoYKK6xrC zGI7cY4b9aJjjNIJckz_A z^?T=cbuFuRSl~5*(TOv=z+**MSNk>tX6E3C9eb8_Et6=^aY+d=Df;m;$}2PL*pW>; zj~rzdZMRZY*`!*j`g&o@#`LZwEdi@MqjuSx5PQe7;Nr~4n;Kpb#YLY#ZRX~3e5di~ zL_+cbt{X92U0Xv!)_7TL+Nhn7V6aj1D$~uNV@=+y!7-Jr0j@r&eA;}X+d{9JI@~{Y zCF;t|j)YLffcp$QmjnJETlQ?zw6HLpb6ayKPYwt)%-26H`0!mpb^uG8akR0q@FcEf z=ho#d(3MTqS+mPFN=xqA-eoy6YyVoF*mlI9;no(*zCW~P`GWi z!P~9x*?y&FMay=G&tdYif2nynXFhs|C)!}T?rO0a25X<34NW^V#pHZY z0sF7iS2;UY?kaxPB)qIdJ>kKR<=giNpAm6uTw}V- uJaT^k literal 0 HcmV?d00001 diff --git a/app/data/btn_playback_shuffle_overlay.png b/app/data/btn_playback_shuffle_overlay.png new file mode 100644 index 0000000000000000000000000000000000000000..6e684af3c583958d712d46b23a2b9f9b7dcbb896 GIT binary patch literal 1356 zcmeAS@N?(olHy`uVBq!ia0vp^N+8U^3=*07`vU_56K{Y|h%1o$e-w;{05}AsyZIx4 z31WRokY6wZ1B;L_6Qg=!N?Jl(YO*+|Nw*rC|K-sam}o-1%6~{FQC|vEGl_Xa!f-5jTF9-@m@fv^@`S{CITPvrE!_KXqsKe7dOl z(AjQ&EVs()4$08vBBJsfiY2v5K|609Ke#1+?%N9UmG4^E9Trr{@oX}*J$yxD&im7z zHS@mj4{JKK``#LZvrcCHuPnCLeKr=WKjpn^N5eTU<)q9oMyF6FSy`aU6Va?k!fVhwzS;c@K&fGv>-UJ@cRXqutN`CKIPrwecN3;rEUG* z`CVPh>Kzt%O<;85%r5X)(bd(y&48IXIAX`1WnIf8+H+h|LQIN&yo~b7%sO^t)6OGD znMK>JR8=;qR;s>U*s?LbYe`GMD$l50HYdd1@hrGFGxDZ}S445q=TDotxg6hVJUWq( ze1Pjl3|H6IkdQTA7MnI|CnOkb)V#`cGw4{8H*0WAC2N4IPb!}_pXj#GtELY3k6nqn zGP5HgR59Q_1JC7v|Hqa++cYgKOy}Iz+{u#z0uA%^PYXVLSCAdR(qGTW#=m z>wC6esaeso9pZDCyzF0UUJf~P^*j+MKLpEU_DD^U+Qa8*h|KWgb`fph6=X1!+%Vlq!X=%nDEGf_8&_4XrGsf6HZ zhvw|g+1Y-zOOoUL#;0r6G^R`nH3;_UVcsG-k*PCxYh-!3Z+ZFlJ;G;1+#1)IF7r5e sV%hWqCwESpJ~@AGhH;w71wIA_|C;J;?JP<^fw_Re)78&qol`;+08JBe_5c6? literal 0 HcmV?d00001 diff --git a/app/data/default_artwork.png b/app/data/default_artwork.png new file mode 100644 index 0000000000000000000000000000000000000000..bb6330e3445812b425e1644c835f9a4aa761dfce GIT binary patch literal 1549 zcmeAS@N?(olHy`uVBq!ia0vp^CqS5k8A#4*i(A9M!1y)5C&U%V{Z9(`_wV2L@83z$ zfm7|@zkhMc;gtZo0a^ax!-v0r|3(&}g#Gj9Pq_9kU%tTE#5071gdmE4{rZKh3yoV+ zQetjy4p#tVpFVy1>({Rk5uhL6y?Zx%_H4KU2m@#cPzng(;t(#-sXu=FfD1wxK+`^c z{D>w9!rjtHtGdN!3Dm=b7g)QO7{xAl{&*w83 z7&+}HSg|v7ojTHDz$5S9cc9Ztnu%4adUb^t3!_nZ`@=SU)43PdGcYhKc)B=-RLpsM z`(?OLpv*N%ZOrC2yUrdrtQ0 zEZ?Zpex_Q5TeW)K%$(Nm9%8F5n;cpBN$w<*;uVD!sg{6dfh+;1v+orxUplqeWIx?? zXXWzyIfj1wH5J!YerDY(=gC=EeaXhHMf=DV0mFYAE<19Vax7#+*39d)0!i?6OT|&% ziJv}k*K7(8O`X3yK*-ePvv%X6M+u&pH=6=7D-tVHCVC&4aP(r=sZ|N3Yt;TFm*ysU z-n~>M=qx2QdsgrMEMcW3sgc>ydu-os&sJ*Hi5Gn7aYZ_eLvWGiTr?`8?Uw^K;d4H=}p4J1~@cGN9|1D1WJk1U$ocihH zzS3y>_d9=m+O~QA)>mb3o&Xi(ivNCD{(auwJq=zLIhJq~Yf3{a+6^2Jb1KB_;b-e!jsz>HDR>&P3ibj=XWTSlI3S$)DVl zPj*kQSf8?R<>TaE%O9K$U#GTprRF{5nK8TT9xppr-ceZoaqaE$3jUPm{CD<-|31Eb zm!-4vcX^wdBh@i!a`u%`kNh}a&a3HK=`70=#UKmE&o z@37JGpHuti+kJ0K-n{VUjW1`WpIo0c|5){v_)UNRluii$R{3f16Mj{UWD68X2))nn W#o*Aa|DET+DcjT4&t;ucLK6TxwZj7d literal 0 HcmV?d00001 diff --git a/app/data/default_artwork_blur.png b/app/data/default_artwork_blur.png new file mode 100644 index 0000000000000000000000000000000000000000..e61ff52d0f65b7769371beb27e6878e342ade934 GIT binary patch literal 169333 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 qnAcpl(*8qXH7GI!V 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¥L}kF`o^m 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

A$T)8P8CwREaagoHlxdgj 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⁢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 Y`7P@%O}?eCfi^ODy85}Sb4q9e0O}>f!vFvP literal 0 HcmV?d00001 diff --git a/app/data/ic_fso_default.png b/app/data/ic_fso_default.png new file mode 100644 index 0000000000000000000000000000000000000000..03c1edd5c889e27254e37cdf900c04e6a339060b GIT binary patch literal 1288 zcmaKqX;f2J5P*Xlf+AWs1f&91IjwRy#fojE0u2Zr_F|8%SV0R?j))X0g6z1^3PdDC z2reKcR*_Ah2!c{k5D=?jX%NXmNJ#SbmM#SEVSdyd8qG);=o{h*!kc&M|6dubt96Ynjm-}lX0@&1ej9Lp zzg<(vF3&A2;k|x?U<8C<5Q4)fj$%p_S7L+;SE?{vIVn>->+7$oYhsp`=Uy%riYKHp zXhJHVm{dq)(4-ueDG(WiC}0#pF_Kij8XV@_tp}A-IV_n}$RR`yq4L=*uG8sAl6?N+ z<&Da!>zunH@q_}w;912{oS2l!B@(GXAQX*{Kk4peuu4G_kr?zq5R^bMLMDgajPZFR zqhov_C}I?`r7{>NR4{^EVwDmqQmIm_NDZl`Pz;|XN>W9tNwr3;p)f+J1Rgb|fH7)H zi(xp1 zOgte`sz{YuGd%+UAh=i})#>z%qEfI-uh-`@+2?XE4-E6<5G+@~3J53|7Xra3grJ}v z!wDQGz*sKi6-LL#-{e$vcJ+V>Jbv0!z$)eL9%6z!E=vgZ|Aw~EbcNXhqs8VQtXi}z zq72Bn?Z!Js4DUquJh@cWLBAAp3@!nrmZ6!`555#Gqv(!HfYp%xjJL^5Q9& ze!p<#*-*#k(Z!5g7e|NM&zNT?C%2!W5NcYNx9GHQmhlRkBY}r8k^SJ=vw?0a7p=Mw zhUX*keo+Yfp%Y?_YJc^lcT8Np)JW=XLhZ%{|^q zSwaNw)()RM?Qy2N^<~Rretwlr zg@?cG93SU$y94UOoGfaFqHkQe@+c+7L-5d0ryO7%ezeh$_?Ct@3@VR)9J>|#?ld1y Ke|n8aSk}K8DL`NV literal 0 HcmV?d00001 diff --git a/app/data/ic_fso_folder.png b/app/data/ic_fso_folder.png new file mode 100644 index 0000000000000000000000000000000000000000..60e41a626674a601d38d84cb611c624e5cd48212 GIT binary patch literal 469 zcmeAS@N?(olHy`uVBq!ia0vp^Dj>|k3?#4J%UA`ZmInBQxB_W7u&z5`*>=&i?W$SZ zbs%Y3y+eK(+d!RqJ`{)(h5c z7aZEoSe32^ii>6Mlc~6*U3*?9Yq?a}CH2BRQh5i&a}J8<><5w{1sS_Uq83P&p69d8 z6-inrQGABaHU}uqWgNxlUN7L=CE(Wsxk8l4y*nQR|k3?#4J%UA`ZP6qgdxB_ViP!I61Ypb-M&}2WQ z)nQ7j{iGI~j%pceGqZ+blioVLzB--0THU@{qrN)p)=EVeJD@JTmQv%sdYjftAX^j2 z?ytA$Z?u`v1VncIjrPsua`xsxDUFsA{r-BR3H27eb>`K1Ktl{$%d}ccHCswR8i9<~ zQjMl!^~NHVk~Hn^Dj+Et;HFfVtl3tk-CeESQ!N?j&ceqlY;P_d?kf`;BoiA5L@fNg zK<#iKImajs$Z;+S@(X5QWMVd&vSs_)K&GG@|Nj4f=)=r>^hGe+{WlxduW8m~Vt?@e z*Jka%a}OQkc=Y(;(UbqS#NGoci{x=za^T=09#%eKk%QS8pMb`#^K@|xshE?TAhD!j zA}5=KWT8f4T4HK)I}@Lu-kW0upFey$$gsa*fqOu_~Lem`rkEm;^ z_A(f4D*B}0%GI@^>&KJ{jhni(!dzE4_|EOzpk&8es3el9C9v2d+e7=3n$yH-=Q_fd zEa;A(D5tTq3~AT)78&qol`;+07!$p#Q*>R literal 0 HcmV?d00001 diff --git a/app/data/ic_fso_type_app.png b/app/data/ic_fso_type_app.png new file mode 100644 index 0000000000000000000000000000000000000000..9918e5c6757a083adc511bd5a623645a97526b65 GIT binary patch literal 802 zcmV+-1Ks?IP)JsJo&fh>D!^Yg+l4CaD-$ScFI@ktADgPWN?cGv=IM z+c`V?a^GW3SAI-oW@crHyGdNllJ%UqQ-T+Hu|p8&4-f2pp9kLG-t&K+m%*S#ixw?f z|B=u)a|guMiT&HHSGcE{z1~1NWk7ejZI4SthL#>rAoXvxDsNzCnZ!_EEw{X&45;p< z?M#Ktgf*xfhjnA`7;0}IQQ?|S77mZ6beP9d5Qjf`(DydURN@RwNhqoE|VBVC1Qi}Mwh;ih+>hx2lk}55c3nLX@*+#UXSAtB`}C% zYWGd4iJLFLzOuNQNES~MVL#JGBRdx4n#d6~xqK`HH;T03K4#p3TD0D?aL`Zorh~T= znE>}d?c&58s6uA$h~36|p%7mx5bBn)+qGK&iF`qaE?6kkeTLuB{Pj*;6?dRgiBXx; zj)sfH23d{Va`Lu(_!Ri4F^`X}k}!~8tCX3z)$-xfH3~~cxx~oL;iDmrK&PPu2o4{S z*e27-J?JbZ7#YbTd;?J=(rX_LdD6%{K0eRn2rw&UKwxN_GqAXq+%rtPPX&lJb_@tQ zPA;?i_mTPW56ipY^J3K9kN{g~P`S=ceF`Rw&Mzf4_PLKhyL-q_cC8bixvR7v?H`>@ zTKN`cG!1w%;7`m@1_UNu1B03#s$F^adz~C&24%OSA+qhky?h8#(p;oZf^kg zzEc8J_1w(+-OAjdXvEg*MP2%7hzT(DkBz)0a`jI>0+5Qh1HqI&0j6Hg;%#knc;Bq0 zVgsJbN5h+QL@hwBG^m^x;|}Ei7~D~-uwH?u0gX;;VjA-{CN^;}xh4brwhFbDTDc`( z`+6=p?m(mvyFbA<|7Fip+;l>!MW)y`nMfH3 gEn2i_(fUXF1tm%znF3K2oB#j-07*qoM6N<$f-V$$tpET3 literal 0 HcmV?d00001 diff --git a/app/data/ic_fso_type_audio.png b/app/data/ic_fso_type_audio.png new file mode 100644 index 0000000000000000000000000000000000000000..1376ac7a8fc9d08deefb39aab54884b097d83616 GIT binary patch literal 829 zcmV-D1H$}?P);J(9Wr_HWbSk4&Uv3de}3|< zTeofi@kbE82?Q4}UYvU7%o*Q#^XBo=#WBm5FP8#Z+Hm{!?Uz7{A8p^hee;?%Yo-A4 zWFULf>C>kl0^Ri*sHSDrs#P*Hb@ zUtg()h6aZjGiLPOxN+k>Q0+vZ9wC}JXv2mL370Qle%jyPp9kc!;8Dul)6C&Yq z8#iuBqnU&H`zKD=xN+mE%*;%JQIV38A_-Kxbkd~BGkJJ;sP7mdAtAPq(1^VOk#Wh1 zsaZ*C>KZt0QB+joN=(U04v0!j2n~riC?+PxL3Ia7OUp=yhew_9YnnMJI3@p$w@*M2 zF16m?{$9b!d2a(+=S+?Wk3J11W)-rjcP)QjMjS^qUAubaZ^fE}|9!&ZpZfU) z7jkfLzzaea78XWdzrZZt(AdYtEBF7ue(l=dva-sr3JQvPRCkbofS_1@e({$J7cTtY zclzRg>)e(vI61lIcXoDvIdS6T?>XBK|FTW%eS(xuYby{73+?=SN30U@bH^pV{0#FZEYvw z=%E=8Cn)CQO_-)yK!L8mLE}W)1=ZMj+te=H}*$h)-0r369lM&@+(|6%}I! zrW0mG9b-w$pjf?#_#`zxAONWa>7k{AM!_f;1*2dTjCcS5WZ^u|*y8y(00000NkvXX Hu0mjf`;wR0 literal 0 HcmV?d00001 diff --git a/app/data/ic_fso_type_compress.png b/app/data/ic_fso_type_compress.png new file mode 100644 index 0000000000000000000000000000000000000000..6ae7bc4aa0e1a60d5f3c55522bf75c5dea2f1dd9 GIT binary patch literal 540 zcmeAS@N?(olHy`uVBq!ia0vp^Dj>|k3?#4J%UA`ZE(Q36xB}_^zP{mvPVR5K5A>B= zNswPK10xG7vq*A5uC-LQn#PQo(=&BTyfvHM9DLc>nbNiM!lDi9ojjvz%dNuGDtg3a zJGpr~j3#(YjTB7Cw{78&%c-8mAIhNDz40p0#Lb>Ajv*Cu-d;K`)MOygkeD=K0Y`W2 z#-#8!tRZin{*6CrP!U_u_VHN#jmzfNGgX=dzEAgP3epm?g<`j9gQ8R@SYwQ0M2%uJh>vI%i54LXqoN{4B_ci& z>m%_MQA4d7AJK@4x{*>5jWMx-uX7G0C@pl6TcPxRFkJ4rKNHIUWS z)jKOID+yYy_PxnuGPbm|d~IuM`_b3ehq19SbaZr}xw-jsNlD4;;^N{Yy7JKL^+`=l zO-}^_85kIlEG{l4PEAeeDY-j6J^i~i6SgPEC`hZILF zGBPrb^7Hc#Yiep#F@ubbjy@qPKHBYeD_O(rz}ngx;C33JH+1}m;>!(Olhe9E&udgF5 zEe*-Z$vje0Qa~fmdrol6m}sgb4u?bC-`@|a6goRQp-?EmYz&9P9E`>q1qB6s^wnxL zDl02NI}2A=SJ>Lx;y^U^!T>QXEG)dRTCK2HEa>X$0_`D|0IjX9FdB`#e^`{4mxGoj zDk>__*w_eKoT#s_=X**}AX?PAy81$#!7b2T(Hd=M09cz8Imr>Do;+uIu;uut?2dskOi_lzuy zza9pIfyebTv)LR^zkMVq5RLMEx7+=a#`>P1FBT(1ByejvYGiQ}k`IWl^$h|6)&4kl00&0tJ*VJmB_+93!7j8jVJy z`Fos~9_2}dy#yACECG#?L!3FzDYt(ns6z=L0*C-2fCwN0h=9rMo(2NM0Ac~D4bcK( zV@wthJEvq*=~B9^TkdBw5D@*HnHU%bqIOvskPo!&e86;fW+H$HnA&9}U|!L-^PLB0 z&ZD!#IN8DFdh486H=$naggFnBVospjO$JB@2mwMP3Jm2VuZMm)^4l+Hnn8A;9v}vY z0b+nSKLhnCxI6>58+&gLa^8%OW(s+x!#}Sr3Xl$v-Ard((q*K%+79iCX;1l8sq}@?LP*BjGJ$tTS zzkcJ!jceDg0ofBKOnCkJ_5c6>fn;cC=-an%fjSNyIs{PzWM95~`O1|mK*s#}^Z)(( z2UNLW!2%%H!^7j^#fyLc{spoV5)uv`Jox3y7oY+l1IPsmB7=UrN>QL|^h$#Kf*BZ? z*f_bAQ`)*(lig4KKdo|(J+q^OqppF~=ifgcM)AqNSd?oX{;5@A=9kydDs&Uv5A@&` zPZ!6KiaBpDaRwc7kYIgS@6@zNW45$jVqk#S`+D2vau5HjA@%ANSHCJLg*NXB^nc|z zbpRh>(PtLdov>Y0(_d<` z_>S@^^Q<#G2F8cZa2P9}=^4q47e@BB&*cL5O}Co1K7VKUly`rVCEsT4J-K&r&g`$N zdbj-jbL(xfzvlJ2?|(P@3Km+-JGcMU$)6=QNA_RYHnr-~w&~jc88=;c(=qGvZBt;( OGkCiCxvXd((q*K%+79dp`;1lAS0tQJ*NpW#;;o;$7 zVPOdg2_YdNPEJl{W@e_Qra;mF41gj)8pw@|jI^+@04nqJ^fWXyOioS)ia0np7#kY{ z6#&fxip0dk1O^5=Iy&0h+eb%7!)=L=j|W<$SCab$=m7PSAirP+4kgFPXoJMgLq~Ui z{onQNaPTJMvL|8zlP>*bmhnjI?e}2fQ?<1A7ZzLr^u!!b7srr_Id3nt`^p3|FkGzf zY-XNpEMai)@AM4wjhipM+RNo;d@O74&37}-lx>dd-Dq`7e!k3%Gbca(%P_t6`|{>^ zpBHaR_RG!w+`ZF!+Pg2v%xa4 z_|S+E__6=ztEzV$Pj~N=GT&Yf441oi-=5u3Ur|#v&pPGgy!mqS?~b2-{eJs*eznj4 szCHh%+H-#W`}zBQo<0Bly7&+C&%g00Q7?J?flFVdQ&MBb@0C3J4)c^nh literal 0 HcmV?d00001 diff --git a/app/data/ic_material_light_navigation_drawer.png b/app/data/ic_material_light_navigation_drawer.png new file mode 100644 index 0000000000000000000000000000000000000000..9bc6f829ee58e1ec293fa8a34b28b3ad0cfef887 GIT binary patch literal 182 zcmeAS@N?(olHy`uVBq!ia0vp^av;pY3?xs=ZJr3E)B}7%T!Hj|BEULZFH4|O-jX1{ zUs8}u@xGh8+WGaKFtDnm{r-UW|8Cgy| literal 0 HcmV?d00001 diff --git a/app/data/ic_material_light_sdcard.png b/app/data/ic_material_light_sdcard.png new file mode 100644 index 0000000000000000000000000000000000000000..02292e2d812c65cc531aecf1f3cc0f7fb8d0c937 GIT binary patch literal 314 zcmeAS@N?(olHy`uVBq!ia0vp^QXtI13?%1G+4BcTB?tI~xB_V-FfcSU)X~u~Fff2{ zfh14_2;f{~2C_1UIHpRV8X(Zt)-Jo!kO8ztu_VYZm_a~{mqER6R;!d*Z-!Gzw7pm2pEHZi0G{?z8sqRe5&R$}X vT&5LIEd-2YK4}DTo$)C+u;ze6IRnG;N{-o2CfM!;TFBt(>gTe~DWM4f9Yk7q literal 0 HcmV?d00001 diff --git a/app/data/ic_material_light_sdcard_dark.png b/app/data/ic_material_light_sdcard_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..8d47d31b6f2e772db7c2ae4c437160acdf89d5b3 GIT binary patch literal 305 zcmeAS@N?(olHy`uVBq!ia0vp^QXtI13?%1G+4BcT#Rm934sGA zj_|PQ^hg-3$$67-;9#fT(W7S%pFVr~xc&jX4mD+!Gv`h#98%Ca#)tyP%*-I>v%e3ODg@94U#6u?z@vzSb^sHuJm@dr`vr2kLKhQn~ MPgg&ebxsLQ06)tE;I!YmFnv15C)tCG9UnABSa%aFI)tu z0Pc7o8zK&2K%56RVUqKl5}^M>N`m}?85p>YlXBwBxK-+A)+;G=%;;&G+AYsklp(}w zQpP%ck~~AUs>ei`OmDwLc8w_^Rt@%|6BtALrMdFd*uDFdd9+Qma$Dq>1Rd0LTUoLr zd0hSd6vKYb76+QY*VDx@q+-tA^H=!}8HhAIZ1%p$JN?nSb%*ah{d>Pv?9imVy{-S3 zdG4RHh5f<%%q>=X4`vt@pGa~wnH{UjxBRqj#}S*j)*pW~1bA9kx-RNcl<8(xnbdMb z#5;4!$w|uY^G|OMaaa-2RMZ+Yb*a?OqU#@jPv)IAOZN-!?1-%Lm`$bCYre7@DJGt{ zm7$Z+vh@5NmyO>_%;HU^=SQz~yqmUrvD#Zpw)W(nhz9rNFK13@bY~EEvb2lM|9*V3 c|Nhskem{g;*B4mD0X@Rt>FVdQ&MBb@08A;ov;Y7A literal 0 HcmV?d00001 diff --git a/app/data/ic_material_light_secure_dark.png b/app/data/ic_material_light_secure_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..d21e9b624970cf553cf68b257cc1cbb64fb3bb47 GIT binary patch literal 564 zcmeAS@N?(olHy`uVBq!ia0vp^QXtI13?%1G+4BcT-45^xaRt)1d(jDu zq5aZad1`&iJla~hEpkkP4!W%@k*@xV4?LzF02;dA)5S5QV$R+R*M*u41XwRDP?F+4 z+LW+iVbW2)r1!u6$EP$Y8#nHGReN*hoHuXO82;GC=*)XC*{R2IrHRVP6y-^$yCp&W}_~f4K%U2pVWH-jmztFHu(QcC4iTEO) z$+nI66&jbl^x?_bw;*>X7sn~S+^}djft~aBmA<%n&+Yy#>-*o>1;rm*!PC{xWt~$(69CG9U-bY0 literal 0 HcmV?d00001 diff --git a/app/data/ic_material_light_usb.png b/app/data/ic_material_light_usb.png new file mode 100644 index 0000000000000000000000000000000000000000..264e8a826936029f0a0190755b5f3ac38186b82d GIT binary patch literal 333 zcmeAS@N?(olHy`uVBq!ia0vp^A|TAc3?z4jzqJQanE^f_u0Z-fUBDmdwPirdluLsA zf*BY!MQTkO*;S>PW7y<*ET?oT%(8QsK0zg*v_rBYx!j_+cJ11yPoLhrd9!!#-Y;Li0386d<>kwlK!@GAa|dWCQ1PKdhk&*`c<|ug zzkfh8|Ns9FH00Q^V~-v^0y0jVI01A9P%+S*Kv|#_K<@hW>w#K;HWn5ZE?Ke!Xctf= zQ1}Qdo&`>Zdk_D%XLUNiq15#EnO|`a=9q@tzw2@H(i9E8JU3yN@m{0QUw3Oa|9+li zX;5FVaD`v)#|xJpDj$@wE&Fq1flsjd^jr6q2rl>getG82g5_b+cDKFf7U$+)?D;It zw$k|eH?gxjDmu;Fw^S}VE1WwoVIPVYpXJN7(mq_XdB^k@#2VoDWZT2HHJdB` zKU!@uPdylecb-uUQKgp(udF2-_MOG r`~PR|l+b9c-+LVmswXev`pvGlknIa&s?RN8I%V*5^>bP0l+XkKIz#swwU?7Brg*iGp0=*0j6Cj9>pGh+S8B`43(Fh{GFFe$9GYiC~)vZ~#bpHOj|1){h3oF0AuljZU?$`QNqQ1qcxqH)@+t`0i UpB0|Y2u#upp00i_>zopr0LgaXfB*mh literal 0 HcmV?d00001 diff --git a/app/data/ic_material_properties_dialog.png b/app/data/ic_material_properties_dialog.png new file mode 100644 index 0000000000000000000000000000000000000000..4844b3b72e8e1db58ecc43874d32d2e85b9c343e GIT binary patch literal 768 zcmeAS@N?(olHy`uVBq!ia0vp^w}JQq2Q!e|IqS(rAhkEZC&U#B&z9Xoam zNFF_U^v|C^M~)nM@ZiC}fB$~|{0UU>|NnoW7NCMhj~)R%^zQ%svk{$w%LM z_S`r;M*hl+AXx?m#?78Cjv*Cu-dg?Bl|K#NGow_pXyy4pW_iw#h zHuvtb@Q~#E{gczGeb=uzcJQIX?QM&bZ+GM*Z|Xg1rgnSAfH1Q1rLUEr+UBsWb%XAN zT*VyjlxU9IOgF_2;S@S&@OYcm&0|waZ+jlgwfuk9OaB)M9OI4HR^8asrwL^fC|tJrx!f=IH1M^a9Y2KoA=nyLQeOA7I!emjw9*Gx2H$ zB__qXNwYJUrz}5mY|o@1RaVWNU;q98^LC=I*ov=D8q7Y=b)4@!FJSM7NyZ*~`ZYZ? z-MuF0gdg}g-SVi@vHxEdq@4Qyb#d~se_!VN&HH$((pV{O$=ePWK~AlZJ}G8KoBwVN zfxtMr>gnPbQZeW4oy?%%KoQr6&7LX>wp~p(jthuvaDKze%B!^Sy{OA`dk*d9imzF7 zqwaHjTUA_tzhj>E)GXcEtM`80_wU6{GXo2gIcHD2xbfrb4nu>&&(~7Sg10Y!f2a4< z-ruSGnn#-3`xjYFd7l;Ad;IJQ-syW6N%YQ~mg}(1@aC};>B+f1RA5ZmyLQ&r+-;Kn z^QHlfFaFH^@lEAT?JmRbk5cz|-QJcVJ%I>og15ijnrm_M{*qi9Vw`mI_Owmg_Et*2 zzX$S?yj@+_t>>G%9rc6&xn z@}}OCxEQDIeM^3ve$$w1Ht_kNM~>}UUOrv9&ASRbJq%Pe&rn4TCsUHx3vIVCg!068m>UjP6A literal 0 HcmV?d00001 diff --git a/app/data/ic_play_btn.png b/app/data/ic_play_btn.png new file mode 100644 index 0000000000000000000000000000000000000000..47e4c83a59774b07436152d5798511e93cc9e410 GIT binary patch literal 1633 zcmeAS@N?(olHy`uVBq!ia0vp^NkFW@!3-pgcHB1uQjEnx?oNz1PwLbIIh+L^k;M!Q zddeWoSh3W;jDdk^R)9~4D^N1}R>LquJ{z(uD}1aQ0v!4y0(KV!A1N`*bhj$@yw1T3FlD3AjuBMiosa;2?Ns22_TrbGlcXPJ?_FThgdxHo&qj<;2tF=+r>L7s= zbgRk5QbXZEKKTh_&0Sc%V^k z^AhwztsT1~9D5>MX2crC+3WaQm}I*8ZO?@`-er2Mj-N%ug=)(@FN1J9>q`Hy(-lA| z{UGb0{e|XP9+vsu&J&^`iX$)AgrBeS+maJ{vdkdL&Ua%LL>x%kcZX}am{?c%0okrI z<239I4I*s)w&uVUP?5pDggFeDI`5SP`2_=0tAu~!iUXH!T)%R7Ltm^K3!CGd2fzNm z+!Q6mXtVZ2IJ@A--^&!0HoGuuoO&H1U}z~v4He*BsP%w1eJ^69fLDJtcEgggX#TV5N?Oq9Ux-{h;xqf$Kspf`iX@* zADYW7G0OQmQG4drGZvZa50*&hEqtgA^kJE&i(^Q|oaBTCW;ZvrG_f$VGCn`OO^oX1 z{QC0y8x)k4m6_QRQbdHr1Vx3HvrU*VWzsaq?adPd1H$^Oo;f${X;NC{E|EGVV(Q8a zMu8P8Rv8*9-CnTHF_zn*Avm~OFtK?X-`89L@#|NcZywZG>@O^RQKgBbuqX>tfgRHnWcC+YDd~4Ns+YPH6jrQeKh|3BoE#ik?49i#UCmw?<|2^k znjT(TUgN(bK0m%bAmCt2=VUeinO<|k+A>|D7<;%23m1r9PCp|uKh!Mo+nk-Bp9wE5 zW<2a9v^HW(#j{CES%tZ#v+Bk>PB}M~XN^nLMy{-*uS^{mGzi5@Z|Sp``&!aWApAn! z9hPN({vQ2nK0Sx=Svf`Ss(73dt{{xtL^Tx_lkORj+jcOe4CVfbl+cgKB48G zE+n$KeO7*Q!_i~|OV~Xh_sq=08y`Dpr}%kXxX?A(XhGSOYnr!iZV2GG6P9eV#!Fjz z$JG=CUB8*K%QKS?&)n>@p=|RR%UL%jrf_d(%sBq>^Ofz1w^&uA8yr3=O%!F{_~6o0 zS)+_t!?oJsyerZVPRwo#oAK9^?Vxbp^_7z^hj&SEC2nM3nK32rPRZV*=Y$>XcGTv+ hmp!{X>clc823LzC^^y literal 0 HcmV?d00001 diff --git a/app/debug.log b/app/debug.log new file mode 100644 index 0000000..1a7247c --- /dev/null +++ b/app/debug.log @@ -0,0 +1,6 @@ +pspOpenDir(ms0:) failed: 0x0 +pspOpenDir(ms0:) failed: 0x0 +pspOpenDir(ms0:) failed: 0x0 +pspOpenDir(ms0:) failed: 0x0 +pspOpenDir(ms0:) failed: 0x0 +pspOpenDir(ms0:) failed: 0x0 diff --git a/app/drivers/mutex-imports.S b/app/drivers/mutex-imports.S new file mode 100644 index 0000000..ae398f1 --- /dev/null +++ b/app/drivers/mutex-imports.S @@ -0,0 +1,140 @@ +.set noreorder + +#include + +IMPORT_START "ThreadManForUser", 0x40010000 +IMPORT_FUNC "ThreadManForUser", 0xB7D098C6, sceKernelCreateMutex +IMPORT_FUNC "ThreadManForUser", 0xF8170FBE, sceKernelDeleteMutex +IMPORT_FUNC "ThreadManForUser", 0x6B30100F, sceKernelUnlockMutex +IMPORT_FUNC "ThreadManForUser", 0xB011B11F, sceKernelLockMutex +IMPORT_FUNC "ThreadManForUser", 0x5bf4dd27, sceKernelLockMutexCB +IMPORT_FUNC "ThreadManForUser", 0x0DDCD2C9, sceKernelTryLockMutex + +IMPORT_FUNC "ThreadManForUser", 0x6E9EA350,_sceKernelReturnFromCallback +IMPORT_FUNC "ThreadManForUser", 0x0C106E53, sceKernelRegisterThreadEventHandler +IMPORT_FUNC "ThreadManForUser", 0x72F3C145, sceKernelReleaseThreadEventHandler +IMPORT_FUNC "ThreadManForUser", 0x369EEB6B, sceKernelReferThreadEventHandlerStatus +IMPORT_FUNC "ThreadManForUser", 0xE81CAF8F, sceKernelCreateCallback +IMPORT_FUNC "ThreadManForUser", 0xEDBA5844, sceKernelDeleteCallback +IMPORT_FUNC "ThreadManForUser", 0xC11BA8C4, sceKernelNotifyCallback +IMPORT_FUNC "ThreadManForUser", 0xBA4051D6, sceKernelCancelCallback +IMPORT_FUNC "ThreadManForUser", 0x2A3D44FF, sceKernelGetCallbackCount +IMPORT_FUNC "ThreadManForUser", 0x349D6D6C, sceKernelCheckCallback +IMPORT_FUNC "ThreadManForUser", 0x730ED8BC, sceKernelReferCallbackStatus +IMPORT_FUNC "ThreadManForUser", 0x9ACE131E, sceKernelSleepThread +IMPORT_FUNC "ThreadManForUser", 0x82826F70, sceKernelSleepThreadCB +IMPORT_FUNC "ThreadManForUser", 0xD59EAD2F, sceKernelWakeupThread +IMPORT_FUNC "ThreadManForUser", 0xFCCFAD26, sceKernelCancelWakeupThread +IMPORT_FUNC "ThreadManForUser", 0x9944F31F, sceKernelSuspendThread +IMPORT_FUNC "ThreadManForUser", 0x75156E8F, sceKernelResumeThread +IMPORT_FUNC "ThreadManForUser", 0x278C0DF5, sceKernelWaitThreadEnd +IMPORT_FUNC "ThreadManForUser", 0x840E8133, sceKernelWaitThreadEndCB +IMPORT_FUNC "ThreadManForUser", 0xCEADEB47, sceKernelDelayThread +IMPORT_FUNC "ThreadManForUser", 0x68DA9E36, sceKernelDelayThreadCB +IMPORT_FUNC "ThreadManForUser", 0xBD123D9E, sceKernelDelaySysClockThread +IMPORT_FUNC "ThreadManForUser", 0x1181E963, sceKernelDelaySysClockThreadCB +IMPORT_FUNC "ThreadManForUser", 0xD6DA4BA1, sceKernelCreateSema +IMPORT_FUNC "ThreadManForUser", 0x28B6489C, sceKernelDeleteSema +IMPORT_FUNC "ThreadManForUser", 0x3F53E640, sceKernelSignalSema +IMPORT_FUNC "ThreadManForUser", 0x4E3A1105, sceKernelWaitSema +IMPORT_FUNC "ThreadManForUser", 0x6D212BAC, sceKernelWaitSemaCB +IMPORT_FUNC "ThreadManForUser", 0x58B1F937, sceKernelPollSema +IMPORT_FUNC "ThreadManForUser", 0x8FFDF9A2, sceKernelCancelSema +IMPORT_FUNC "ThreadManForUser", 0xBC6FEBC5, sceKernelReferSemaStatus +IMPORT_FUNC "ThreadManForUser", 0x55C20A00, sceKernelCreateEventFlag +IMPORT_FUNC "ThreadManForUser", 0xEF9E4C70, sceKernelDeleteEventFlag +IMPORT_FUNC "ThreadManForUser", 0x1FB15A32, sceKernelSetEventFlag +IMPORT_FUNC "ThreadManForUser", 0x812346E4, sceKernelClearEventFlag +IMPORT_FUNC "ThreadManForUser", 0x402FCF22, sceKernelWaitEventFlag +IMPORT_FUNC "ThreadManForUser", 0x328C546A, sceKernelWaitEventFlagCB +IMPORT_FUNC "ThreadManForUser", 0x30FD48F0, sceKernelPollEventFlag +IMPORT_FUNC "ThreadManForUser", 0xCD203292, sceKernelCancelEventFlag +IMPORT_FUNC "ThreadManForUser", 0xA66B0120, sceKernelReferEventFlagStatus +IMPORT_FUNC "ThreadManForUser", 0x8125221D, sceKernelCreateMbx +IMPORT_FUNC "ThreadManForUser", 0x86255ADA, sceKernelDeleteMbx +IMPORT_FUNC "ThreadManForUser", 0xE9B3061E, sceKernelSendMbx +IMPORT_FUNC "ThreadManForUser", 0x18260574, sceKernelReceiveMbx +IMPORT_FUNC "ThreadManForUser", 0xF3986382, sceKernelReceiveMbxCB +IMPORT_FUNC "ThreadManForUser", 0x0D81716A, sceKernelPollMbx +IMPORT_FUNC "ThreadManForUser", 0x87D4DD36, sceKernelCancelReceiveMbx +IMPORT_FUNC "ThreadManForUser", 0xA8E8C846, sceKernelReferMbxStatus +IMPORT_FUNC "ThreadManForUser", 0x7C0DC2A0, sceKernelCreateMsgPipe +IMPORT_FUNC "ThreadManForUser", 0xF0B7DA1C, sceKernelDeleteMsgPipe +IMPORT_FUNC "ThreadManForUser", 0x876DBFAD, sceKernelSendMsgPipe +IMPORT_FUNC "ThreadManForUser", 0x7C41F2C2, sceKernelSendMsgPipeCB +IMPORT_FUNC "ThreadManForUser", 0x884C9F90, sceKernelTrySendMsgPipe +IMPORT_FUNC "ThreadManForUser", 0x74829B76, sceKernelReceiveMsgPipe +IMPORT_FUNC "ThreadManForUser", 0xFBFA697D, sceKernelReceiveMsgPipeCB +IMPORT_FUNC "ThreadManForUser", 0xDF52098F, sceKernelTryReceiveMsgPipe +IMPORT_FUNC "ThreadManForUser", 0x349B864D, sceKernelCancelMsgPipe +IMPORT_FUNC "ThreadManForUser", 0x33BE4024, sceKernelReferMsgPipeStatus +IMPORT_FUNC "ThreadManForUser", 0x56C039B5, sceKernelCreateVpl +IMPORT_FUNC "ThreadManForUser", 0x89B3D48C, sceKernelDeleteVpl +IMPORT_FUNC "ThreadManForUser", 0xBED27435, sceKernelAllocateVpl +IMPORT_FUNC "ThreadManForUser", 0xEC0A693F, sceKernelAllocateVplCB +IMPORT_FUNC "ThreadManForUser", 0xAF36D708, sceKernelTryAllocateVpl +IMPORT_FUNC "ThreadManForUser", 0xB736E9FF, sceKernelFreeVpl +IMPORT_FUNC "ThreadManForUser", 0x1D371B8A, sceKernelCancelVpl +IMPORT_FUNC "ThreadManForUser", 0x39810265, sceKernelReferVplStatus +IMPORT_FUNC "ThreadManForUser", 0xC07BB470, sceKernelCreateFpl +IMPORT_FUNC "ThreadManForUser", 0xED1410E0, sceKernelDeleteFpl +IMPORT_FUNC "ThreadManForUser", 0xD979E9BF, sceKernelAllocateFpl +IMPORT_FUNC "ThreadManForUser", 0xE7282CB6, sceKernelAllocateFplCB +IMPORT_FUNC "ThreadManForUser", 0x623AE665, sceKernelTryAllocateFpl +IMPORT_FUNC "ThreadManForUser", 0xF6414A71, sceKernelFreeFpl +IMPORT_FUNC "ThreadManForUser", 0xA8AA591F, sceKernelCancelFpl +IMPORT_FUNC "ThreadManForUser", 0xD8199E4C, sceKernelReferFplStatus +IMPORT_FUNC "ThreadManForUser", 0x0E927AED,_sceKernelReturnFromTimerHandler +IMPORT_FUNC "ThreadManForUser", 0x110DEC9A, sceKernelUSec2SysClock +IMPORT_FUNC "ThreadManForUser", 0xC8CD158C, sceKernelUSec2SysClockWide +IMPORT_FUNC "ThreadManForUser", 0xBA6B92E2, sceKernelSysClock2USec +IMPORT_FUNC "ThreadManForUser", 0xE1619D7C, sceKernelSysClock2USecWide +IMPORT_FUNC "ThreadManForUser", 0xDB738F35, sceKernelGetSystemTime +IMPORT_FUNC "ThreadManForUser", 0x82BC5777, sceKernelGetSystemTimeWide +IMPORT_FUNC "ThreadManForUser", 0x369ED59D, sceKernelGetSystemTimeLow +IMPORT_FUNC "ThreadManForUser", 0x6652B8CA, sceKernelSetAlarm +IMPORT_FUNC "ThreadManForUser", 0xB2C25152, sceKernelSetSysClockAlarm +IMPORT_FUNC "ThreadManForUser", 0x7E65B999, sceKernelCancelAlarm +IMPORT_FUNC "ThreadManForUser", 0xDAA3F564, sceKernelReferAlarmStatus +IMPORT_FUNC "ThreadManForUser", 0x20FFF560, sceKernelCreateVTimer +IMPORT_FUNC "ThreadManForUser", 0x328F9E52, sceKernelDeleteVTimer +IMPORT_FUNC "ThreadManForUser", 0xB3A59970, sceKernelGetVTimerBase +IMPORT_FUNC "ThreadManForUser", 0xB7C18B77, sceKernelGetVTimerBaseWide +IMPORT_FUNC "ThreadManForUser", 0x034A921F, sceKernelGetVTimerTime +IMPORT_FUNC "ThreadManForUser", 0xC0B3FFD2, sceKernelGetVTimerTimeWide +IMPORT_FUNC "ThreadManForUser", 0x542AD630, sceKernelSetVTimerTime +IMPORT_FUNC "ThreadManForUser", 0xFB6425C3, sceKernelSetVTimerTimeWide +IMPORT_FUNC "ThreadManForUser", 0xC68D9437, sceKernelStartVTimer +IMPORT_FUNC "ThreadManForUser", 0xD0AEEE87, sceKernelStopVTimer +IMPORT_FUNC "ThreadManForUser", 0xD8B299AE, sceKernelSetVTimerHandler +IMPORT_FUNC "ThreadManForUser", 0x53B00E9A, sceKernelSetVTimerHandlerWide +IMPORT_FUNC "ThreadManForUser", 0xD2D615EF, sceKernelCancelVTimerHandler +IMPORT_FUNC "ThreadManForUser", 0x5F32BEAA, sceKernelReferVTimerStatus +IMPORT_FUNC "ThreadManForUser", 0x446D8DE6, sceKernelCreateThread +IMPORT_FUNC "ThreadManForUser", 0x9FA03CD3, sceKernelDeleteThread +IMPORT_FUNC "ThreadManForUser", 0xF475845D, sceKernelStartThread +IMPORT_FUNC "ThreadManForUser", 0x532A522E,_sceKernelExitThread +IMPORT_FUNC "ThreadManForUser", 0xAA73C935, sceKernelExitThread +IMPORT_FUNC "ThreadManForUser", 0x809CE29B, sceKernelExitDeleteThread +IMPORT_FUNC "ThreadManForUser", 0x616403BA, sceKernelTerminateThread +IMPORT_FUNC "ThreadManForUser", 0x383F7BCC, sceKernelTerminateDeleteThread +IMPORT_FUNC "ThreadManForUser", 0x3AD58B8C, sceKernelSuspendDispatchThread +IMPORT_FUNC "ThreadManForUser", 0x27E22EC2, sceKernelResumeDispatchThread +IMPORT_FUNC "ThreadManForUser", 0xEA748E31, sceKernelChangeCurrentThreadAttr +IMPORT_FUNC "ThreadManForUser", 0x71BC9871, sceKernelChangeThreadPriority +IMPORT_FUNC "ThreadManForUser", 0x912354A7, sceKernelRotateThreadReadyQueue +IMPORT_FUNC "ThreadManForUser", 0x2C34E053, sceKernelReleaseWaitThread +IMPORT_FUNC "ThreadManForUser", 0x293B45B8, sceKernelGetThreadId +IMPORT_FUNC "ThreadManForUser", 0x94AA61EE, sceKernelGetThreadCurrentPriority +IMPORT_FUNC "ThreadManForUser", 0x3B183E26, sceKernelGetThreadExitStatus +IMPORT_FUNC "ThreadManForUser", 0xD13BDE95, sceKernelCheckThreadStack +IMPORT_FUNC "ThreadManForUser", 0x52089CA1, sceKernelGetThreadStackFreeSize +IMPORT_FUNC "ThreadManForUser", 0x17C1684E, sceKernelReferThreadStatus +IMPORT_FUNC "ThreadManForUser", 0xFFC36A14, sceKernelReferThreadRunStatus +IMPORT_FUNC "ThreadManForUser", 0x627E6F3A, sceKernelReferSystemStatus +IMPORT_FUNC "ThreadManForUser", 0x94416130, sceKernelGetThreadmanIdList +IMPORT_FUNC "ThreadManForUser", 0x57CF62DD, sceKernelGetThreadmanIdType +IMPORT_FUNC "ThreadManForUser", 0x64D4540E, sceKernelReferThreadProfiler +IMPORT_FUNC "ThreadManForUser", 0x8218B4DD, sceKernelReferGlobalProfiler +IMPORT_FUNC "ThreadManForUser", 0xA9C2CB9A, sceKernelReferMutexStatus +IMPORT_FUNC "ThreadManForUser", 0x87D9223C, sceKernelCancelMutex diff --git a/app/include/colours.h b/app/include/colours.h new file mode 100644 index 0000000..21be0d5 --- /dev/null +++ b/app/include/colours.h @@ -0,0 +1,24 @@ +#ifndef _CMFILEMANAGER_COLOURS_H_ +#define _CMFILEMANAGER_COLOURS_H_ + +#include + +constexpr g2dColor BLACK_BG = G2D_RGBA(48, 48, 48, 255); +constexpr g2dColor STATUS_BAR_LIGHT = G2D_RGBA(37, 79, 174, 255); +constexpr g2dColor STATUS_BAR_DARK = G2D_RGBA(38, 50, 56, 255); +constexpr g2dColor MENU_BAR_LIGHT = G2D_RGBA(51, 103, 214, 255); +constexpr g2dColor MENU_BAR_DARK = G2D_RGBA(55, 71, 79, 255); +constexpr g2dColor SELECTOR_COLOUR_LIGHT = G2D_RGBA(241, 241, 241, 255); +constexpr g2dColor SELECTOR_COLOUR_DARK = G2D_RGBA(76, 76, 76, 255); +constexpr g2dColor TITLE_COLOUR_LIGHT = G2D_RGBA(30, 136, 229, 255); +constexpr g2dColor TITLE_COLOUR_DARK = G2D_RGBA(0, 150, 136, 255); +constexpr g2dColor TEXT_COLOUR_LIGHT = G2D_RGBA(32, 32, 32, 255); +constexpr g2dColor TEXT_COLOUR_DARK = G2D_RGBA(185, 185, 185, 255); + +extern g2dColor BG_COLOUR, STATUS_BAR_COLOUR, MENU_BAR_COLOUR, SELECTOR_COLOUR, TITLE_COLOUR, TEXT_COLOUR; + +namespace Colours { + void Get(void); +} + +#endif diff --git a/app/include/config.h b/app/include/config.h new file mode 100644 index 0000000..a5102ac --- /dev/null +++ b/app/include/config.h @@ -0,0 +1,20 @@ +#ifndef _CMFILEMANAGER_CONFIG_H_ +#define _CMFILEMANAGER_CONFIG_H_ + +#include + +typedef struct { + int sort = 0; + bool dark_theme = false; + bool dev_options = false; + std::string cwd; +} config_t; + +extern config_t cfg; + +namespace Config { + int Save(config_t config); + int Load(void); +} + +#endif diff --git a/app/include/fs.h b/app/include/fs.h new file mode 100644 index 0000000..973159f --- /dev/null +++ b/app/include/fs.h @@ -0,0 +1,36 @@ +#ifndef _CMFILEMANAGER_FS_H_ +#define _CMFILEMANAGER_FS_H_ + +#include +#include +#include + +typedef enum FileType { + FileTypeNone, + FileTypeApp, + FileTypeArchive, + FileTypeAudio, + FileTypeImage, + FileTypeText +} FileType; + +namespace FS { + bool FileExists(const std::string &path); + bool DirExists(const std::string &path); + int MakeDir(const std::string &path); + int CreateFile(const std::string &path); + std::string GetFileExt(const std::string &filename); + FileType GetFileType(const std::string &filename); + SceOff GetFileSize(const std::string &path); + int ReadFile(const std::string &path, void *buf, int size); + int WriteFile(const std::string &path, void *buf, int size); + int GetDirList(const std::string &path, std::vector &entries); + int ChangeDirNext(const std::string &path, std::vector &entries); + int ChangeDirPrev(std::vector &entries); + void Copy(SceIoDirent *entry, const std::string &path); + int Paste(void); + int Move(void); + int Delete(SceIoDirent *entry); +} + +#endif diff --git a/app/include/ftppsp.h b/app/include/ftppsp.h new file mode 100644 index 0000000..62f549f --- /dev/null +++ b/app/include/ftppsp.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2021 Sergi Granell (xerpi), Joel16 + */ + +#ifndef _CMFILEMANAGER_FTPPSP_H_ +#define _CMFILEMANAGER_FTPPSP_H_ + +#include +#include + +typedef void (*ftppsp_log_cb_t)(const char *); + +/* Returns PSVita's IP and FTP port. 0 on success */ +int ftppsp_init(char *psp_ip, unsigned short int *psp_port); +void ftppsp_fini(void); +int ftppsp_is_initialized(void); +int ftppsp_add_device(const char *devname); +int ftppsp_del_device(const char *devname); +void ftppsp_set_info_log_cb(ftppsp_log_cb_t cb); +void ftppsp_set_debug_log_cb(ftppsp_log_cb_t cb); +void ftppsp_set_file_buf_size(unsigned int size); + +/* Extended functionality */ + +typedef enum { + FTP_DATA_CONNECTION_NONE, + FTP_DATA_CONNECTION_ACTIVE, + FTP_DATA_CONNECTION_PASSIVE +} DataConnectionType; + + +typedef struct ftppsp_client_info { + /* Client number */ + int num; + /* Thread UID */ + SceUID thid; + /* Control connection socket FD */ + int ctrl_sockfd; + /* Data connection attributes */ + int data_sockfd; + DataConnectionType data_con_type; + struct sockaddr_in data_sockaddr; + /* PASV mode client socket */ + struct sockaddr_in pasv_sockaddr; + int pasv_sockfd; + /* Remote client net info */ + struct sockaddr_in addr; + /* Receive buffer attributes */ + int n_recv; + char recv_buffer[1024]; + /* Points to the character after the first space */ + const char *recv_cmd_args; + /* Current working directory */ + char cur_path[1024]; + /* Rename path */ + char rename_path[1024]; + /* Client list */ + struct ftppsp_client_info *next; + struct ftppsp_client_info *prev; + /* Offset for transfer resume */ + unsigned int restore_point; +} ftppsp_client_info_t; + +typedef void (*cmd_dispatch_func)(ftppsp_client_info_t *client); // Command handler + +int ftppsp_ext_add_custom_command(const char *cmd, cmd_dispatch_func func); +int ftppsp_ext_del_custom_command(const char *cmd); +void ftppsp_ext_client_send_ctrl_msg(ftppsp_client_info_t *client, const char *msg); +void ftppsp_ext_client_send_data_msg(ftppsp_client_info_t *client, const char *str); + +#endif diff --git a/app/include/g2d.h b/app/include/g2d.h new file mode 100644 index 0000000..fd5a896 --- /dev/null +++ b/app/include/g2d.h @@ -0,0 +1,19 @@ +#ifndef _CMFILEMANAGER_GLIB2D_HELPER_H_ +#define _CMFILEMANAGER_GLIB2D_HELPER_H_ + +#include +#include +#include + +extern intraFont *font, *jpn0, *chn; + +namespace G2D { + void DrawRect(float x, float y, float width, float height, g2dColor colour); + void DrawImage(g2dTexture *tex, float x, float y); + void DrawImageScale(g2dTexture *tex, float x, float y, float w, float h); + char *KeyboardGetText(const std::string &desc_msg, const std::string &initial_msg); + void FontSetStyle(intraFont *font, float size, unsigned int colour, unsigned int options); + float GetTextHeight(intraFont *font); +} + +#endif diff --git a/app/include/gui.h b/app/include/gui.h new file mode 100644 index 0000000..0b9dbbb --- /dev/null +++ b/app/include/gui.h @@ -0,0 +1,54 @@ +#ifndef _CMFILEMANAGER_GUI_HELPER_H_ +#define _CMFILEMANAGER_GUI_HELPER_H_ + +#include +#include + +enum MENU_STATES { + MENU_STATE_FILEBROWSER, + MENU_STATE_OPTIONS, + MENU_STATE_DELETE, + MENU_STATE_PROPERTIES, + MENU_STATE_SETTINGS, + MENU_STATE_IMAGEVIEWER, + MENU_STATE_ARCHIVEEXTRACT, + MENU_STATE_TEXTREADER, + MENU_STATE_UPDATE +}; + +typedef struct { + MENU_STATES state = MENU_STATE_FILEBROWSER; + int selected = 0; + std::vector entries; + std::vector checked; + std::vector checked_copy; + std::string checked_cwd; + int checked_count = 0; + u64 used_storage = 0; + u64 total_storage = 0; + g2dTexture *texture; +} MenuItem; + +namespace GUI { + void ResetCheckbox(MenuItem *item); + void GetStorageSize(MenuItem *item); + void DisplayStatusBar(void); + int RenderLoop(void); + + void DisplayFileBrowser(MenuItem *item); + void ControlFileBrowser(MenuItem *item, int *ctrl); + + void DisplaySettings(MenuItem *item); + void ControlSettings(MenuItem *item, int *ctrl); + + void DisplayFileOptions(MenuItem *item); + void ControlFileOptions(MenuItem *item, int *ctrl); + + void DisplayDeleteOptions(MenuItem *item); + void ControlDeleteOptions(MenuItem *item, int *ctrl); + + void DisplayImageViewer(MenuItem *item); + void ControlImageViewer(MenuItem *item, float *delta_time); +} + +#endif diff --git a/app/include/kernel_functions.h b/app/include/kernel_functions.h new file mode 100644 index 0000000..87325ed --- /dev/null +++ b/app/include/kernel_functions.h @@ -0,0 +1,43 @@ +#ifndef _CMFILEMANAGER_KERNEL_FUNCTIONS_H_ +#define _CMFILEMANAGER_KERNEL_FUNCTIONS_H_ + +#if defined (__cplusplus) +extern "C" { +#endif + +#include +#include + +// Kernel function prototypes + +// audio_driver functions +extern int pspAudioSetFrequency(int frequency); + +// display_driver functions +extern int pspGetBrightness(int *brightness); +extern int pspSetBrightness(int brightness); +extern int pspDisplayEnable(void); +extern int pspDisplayDisable(void); + +// fs_driver functions +extern int pspOpenDir(const char *dirname); +extern int pspReadDir(SceUID dir, SceIoDirent *dirent); +extern int pspCloseDir(SceUID dir); + +// impose_driver functions +extern int pspGetVolume(void); +extern int pspSetVolume(int volume); +extern int pspGetMute(void); +extern int pspSetMute(int mute); +extern int pspGetEqualizerMode(void); +extern int pspSetEqualizerMode(int mode); +extern int pspSetHomePopup(int popup); + +// input_driver functions +extern unsigned int pspGetButtons(void); + +#if defined (__cplusplus) +} +#endif + +#endif diff --git a/app/include/log.h b/app/include/log.h new file mode 100644 index 0000000..5db625b --- /dev/null +++ b/app/include/log.h @@ -0,0 +1,10 @@ +#ifndef _CMFILEMANAGER_LOG_H_ +#define _CMFILEMANAGER_LOG_H_ + +namespace Log { + int OpenHande(void); + int CloseHandle(void); + int Error(const char *format, ...); +} + +#endif diff --git a/app/include/mutex.h b/app/include/mutex.h new file mode 100644 index 0000000..d749cf4 --- /dev/null +++ b/app/include/mutex.h @@ -0,0 +1,23 @@ +#ifndef _CMFILEMANAGER_MUTEX_H_ +#define _CMFILEMANAGER_MUTEX_H_ + +#define PSP_MUTEX_ATTR_FIFO 0 +#define PSP_MUTEX_ATTR_PRIORITY 0x100 +#define PSP_MUTEX_ATTR_ALLOW_RECURSIVE 0x200 + +#ifdef __cplusplus +extern "C" { +#endif + +int sceKernelCreateMutex(const char *name, uint attributes, int initial_count, void* options); +int sceKernelDeleteMutex(int mutexId); +int sceKernelLockMutex(int mutexId, int count, uint* timeout); +int sceKernelTryLockMutex(int mutexId, int count); +int sceKernelUnlockMutex(int mutexId, int count); + +#ifdef __cplusplus +} +#endif + + +#endif diff --git a/app/include/textures.h b/app/include/textures.h new file mode 100644 index 0000000..e483622 --- /dev/null +++ b/app/include/textures.h @@ -0,0 +1,23 @@ +#ifndef _CMFILEMANAGER_TEXTURES_H_ +#define _CMFILEMANAGER_TEXTURES_H_ + +#include + +constexpr int NUM_ICONS = 6; +constexpr int NUM_BATT_ICONS = 6; + +extern g2dTexture *file_icons[NUM_ICONS], *icon_dir, *icon_dir_dark, *icon_check, *icon_check_dark, *icon_uncheck, \ + *icon_uncheck_dark, *icon_toggle_on, *icon_toggle_dark_on, *icon_toggle_off, *icon_radio_off, \ + *icon_radio_on, *icon_radio_dark_off, *icon_radio_dark_on, *icon_nav_drawer, *icon_back, \ + *options_dialog, *options_dialog_dark, *properties_dialog, *properties_dialog_dark, *dialog, *dialog_dark, \ + *battery_charging[NUM_BATT_ICONS], *battery[NUM_BATT_ICONS], *usb_icon, \ + *default_artwork, *default_artwork_blur, *btn_play, *btn_pause, *btn_rewind, *btn_forward, \ + *btn_repeat, *btn_shuffle, *btn_repeat_overlay, *btn_shuffle_overlay, \ + *bg_header, *icon_sd, *icon_secure, *icon_sd_dark, *icon_secure_dark, *ic_play_btn; + +namespace Textures { + void Load(void); + void Free(void); +} + +#endif diff --git a/app/include/utils.h b/app/include/utils.h new file mode 100644 index 0000000..80d071b --- /dev/null +++ b/app/include/utils.h @@ -0,0 +1,48 @@ +#ifndef _CMFILEMANAGER_UTILS_H_ +#define _CMFILEMANAGER_UTILS_H_ + +#include +#include + +/// Checks whether a result code indicates success. +#define R_SUCCEEDED(res) ((res) >= 0) +/// Checks whether a result code indicates failure. +#define R_FAILED(res) ((res) < 0) + +enum BROWSE_STATE { + BROWSE_STATE_INTERNAL, + BROWSE_STATE_EXTERNAL +}; + +extern bool psp_usb_cable_connection, is_ms_inserted, is_psp_go; +extern enum PspCtrlButtons PSP_CTRL_ENTER, PSP_CTRL_CANCEL; +extern BROWSE_STATE device; + +namespace Utils { + void SetBounds(int *set, int min, int max); + void SetMax(int *set, int value, int max); + void SetMin(int *set, int value, int min); + void GetSizeString(char *string, double size); + void InitKernelDrivers(void); + void TermKernelDrivers(void); + void HandleUSB(void); + bool IsModelPSPGo(void); + int IsMemCardInserted(bool *is_inserted); + bool IsEF0(void); + int LaunchEboot(const char *path); + u64 GetTotalStorage(void); + u64 GetFreeStorage(void); + u64 GetUsedStorage(void); + int ReadControls(void); + int IsButtonPressed(enum PspCtrlButtons buttons); + int IsButtonHeld(enum PspCtrlButtons buttons); + int IsKButtonPressed(enum PspCtrlButtons buttons); + int IsKButtonHeld(enum PspCtrlButtons buttons); + int GetEnterButton(void); + int GetCancelButton(void); + float GetAnalogX(void); + float GetAnalogY(void); + bool IsCancelButtonPressed(void); +} + +#endif diff --git a/app/source/colours.cpp b/app/source/colours.cpp new file mode 100644 index 0000000..9277fd3 --- /dev/null +++ b/app/source/colours.cpp @@ -0,0 +1,15 @@ +#include "colours.h" +#include "config.h" + +g2dColor BG_COLOUR, STATUS_BAR_COLOUR, MENU_BAR_COLOUR, SELECTOR_COLOUR, TITLE_COLOUR, TEXT_COLOUR; + +namespace Colours { + void Get(void) { + BG_COLOUR = cfg.dark_theme? BLACK_BG : WHITE; + STATUS_BAR_COLOUR = cfg.dark_theme? STATUS_BAR_DARK : STATUS_BAR_LIGHT; + MENU_BAR_COLOUR = cfg.dark_theme? MENU_BAR_DARK : MENU_BAR_LIGHT; + SELECTOR_COLOUR = cfg.dark_theme? SELECTOR_COLOUR_DARK : SELECTOR_COLOUR_LIGHT; + TITLE_COLOUR = cfg.dark_theme? TITLE_COLOUR_DARK : TITLE_COLOUR_LIGHT; + TEXT_COLOUR = cfg.dark_theme? TEXT_COLOUR_DARK : TEXT_COLOUR_LIGHT; + } +} diff --git a/app/source/config.cpp b/app/source/config.cpp new file mode 100644 index 0000000..33390a4 --- /dev/null +++ b/app/source/config.cpp @@ -0,0 +1,86 @@ +#include "config.h" +#include "fs.h" +#include "log.h" +#include "rapidjson/document.h" +#include "utils.h" + +constexpr int config_version = 4; +constexpr char config_file[] = "{\n\t\"config_ver\": %d,\n\t\"sort\": %d,\n\t\"dark_theme\": %d,\n\t\"dev_options\": %d\n}\n"; +static int config_version_holder = 0; +config_t cfg; + +namespace Config { + int Save(config_t config) { + int ret = 0; + char *buf = new char[128]; + int len = snprintf(buf, 128, config_file, config_version, cfg.sort, cfg.dark_theme, cfg.dev_options); + + if (R_FAILED(ret = FS::WriteFile("config.json", buf, len))) { + Log::Error("Read config failed in Config_Save 0x%lx\n", ret); + delete[] buf; + return ret; + } + + delete[] buf; + return 0; + } + + static void SetDefault(config_t *config) { + config->sort = 0; + config->dark_theme = false; + config->dev_options = false; + } + + int Load(void) { + int ret = 0; + + // Set root path and current working directory based on model. + cfg.cwd = is_psp_go? "ef0:" : "ms0:"; + + if (is_psp_go) + device = BROWSE_STATE_INTERNAL; + else + device = BROWSE_STATE_EXTERNAL; + + if (!FS::FileExists("config.json")) { + Config::SetDefault(&cfg); + Log::Error("File doesn't exist\n"); + return Save(cfg); + } + + u64 size = FS::GetFileSize("config.json"); + char *buf = new char[size]; + + if (R_FAILED(ret = FS::ReadFile("config.json", buf, size))) { + Log::Error("Read config failed in Config_Load 0x%lx\n", ret); + delete[] buf; + return ret; + } + + buf[size] = '\0'; + + rapidjson::Document document; + document.Parse(buf); + assert(document.IsObject()); + assert(document.HasMember("config_ver")); + assert(document.HasMember("sort")); + assert(document.HasMember("dark_theme")); + assert(document.HasMember("dev_options")); + + config_version_holder = document["config_ver"].GetInt(); + cfg.sort = document["sort"].GetInt(); + cfg.dark_theme = document["dark_theme"].GetInt(); + cfg.dev_options = document["dev_options"].GetInt(); + + delete[] buf; + + // delete[] config file if config file is updated. This will rarely happen. + if (config_version_holder < config_version) { + sceIoRemove("config.json"); + Config::SetDefault(&cfg); + return Config::Save(cfg); + } + + return 0; + } +} diff --git a/app/source/fs.cpp b/app/source/fs.cpp new file mode 100644 index 0000000..9b3fcef --- /dev/null +++ b/app/source/fs.cpp @@ -0,0 +1,512 @@ +#include +#include +#include +#include + +#include "config.h" +#include "fs.h" +#include "kernel_functions.h" +#include "log.h" +#include "utils.h" + +namespace FS { + typedef struct { + std::string copy_path; + std::string copy_filename; + bool is_dir = false; + } FSCopyEntry; + + static FSCopyEntry fs_copy_entry; + + bool FileExists(const std::string &path) { + SceUID file = 0; + + if (R_SUCCEEDED(file = sceIoOpen(path.c_str(), PSP_O_RDONLY, 0777))) { + sceIoClose(file); + return true; + } + + return false; + } + + bool DirExists(const std::string &path) { + SceUID dir = 0; + + if (R_SUCCEEDED(dir = sceIoDopen(path.c_str()))) { + sceIoDclose(dir); + return true; + } + + return false; + } + + int MakeDir(const std::string &path) { + int ret = 0; + + if (R_FAILED(ret = sceIoMkdir(path.c_str(), 0777))) + return ret; + + return 0; + } + + int CreateFile(const std::string &path) { + SceUID file = 0; + + if (R_SUCCEEDED(file = sceIoOpen(path.c_str(), PSP_O_WRONLY | PSP_O_CREAT | PSP_O_TRUNC, 0777))) { + sceIoClose(file); + return 0; + } + + return file; + } + + std::string GetFileExt(const std::string &filename) { + std::string ext = std::filesystem::path(filename).extension(); + std::transform(ext.begin(), ext.end(), ext.begin(), ::toupper); + return ext; + } + + FileType GetFileType(const std::string &filename) { + std::string ext = FS::GetFileExt(filename); + + if (!ext.compare(".PBP")) + return FileTypeApp; + else if ((!ext.compare(".ZIP")) || (!ext.compare(".RAR")) || (!ext.compare(".7Z")) || (!ext.compare(".LZMA"))) + return FileTypeArchive; + else if ((!ext.compare(".FLAC")) || (!ext.compare(".IT")) || (!ext.compare(".MOD")) || (!ext.compare(".MP3")) || (!ext.compare(".OGG")) + || (!ext.compare(".OPUS")) || (!ext.compare(".S3M")) || (!ext.compare(".WAV")) || (!ext.compare(".XM"))) + return FileTypeAudio; + else if ((!ext.compare(".BMP")) || (!ext.compare(".GIF")) || (!ext.compare(".JPG")) || (!ext.compare(".JPEG")) || (!ext.compare(".PGM")) + || (!ext.compare(".PPM")) || (!ext.compare(".PNG")) || (!ext.compare(".PSD")) || (!ext.compare(".TGA")) || (!ext.compare(".WEBP"))) + return FileTypeImage; + else if ((!ext.compare(".JSON")) || (!ext.compare(".LOG")) || (!ext.compare(".TXT")) || (!ext.compare(".CFG")) || (!ext.compare(".INI"))) + return FileTypeText; + + return FileTypeNone; + } + + SceOff GetFileSize(const std::string &path) { + int ret = 0; + + SceIoStat stat; + std::memset(&stat, 0, sizeof(stat)); + + if (R_FAILED(ret = sceIoGetstat(path.c_str(), &stat))) + return ret; + + return stat.st_size; + } + + int ReadFile(const std::string &path, void *buf, int size) { + SceUID file = 0; + + if (R_SUCCEEDED(file = sceIoOpen(path.c_str(), PSP_O_RDONLY, 0))) { + int read = sceIoRead(file, buf, size); + sceIoClose(file); + return read; + } + + return file; + } + + int WriteFile(const std::string &path, void *buf, int size) { + SceUID file = 0; + + if (R_SUCCEEDED(file = sceIoOpen(path.c_str(), PSP_O_WRONLY | PSP_O_CREAT | PSP_O_TRUNC, 0777))) { + int written = sceIoWrite(file, buf, size); + sceIoClose(file); + return written; + } + + return file; + } + + static bool Sort(const SceIoDirent &entryA, const SceIoDirent &entryB) { + if ((FIO_S_ISDIR(entryA.d_stat.st_mode)) && !(FIO_S_ISDIR(entryB.d_stat.st_mode))) + return true; + else if (!(FIO_S_ISDIR(entryA.d_stat.st_mode)) && (FIO_S_ISDIR(entryB.d_stat.st_mode))) + return false; + else { + switch(cfg.sort) { + case 0: + if (strcasecmp(entryA.d_name, entryB.d_name) < 0) + return true; + break; + + case 1: + if (strcasecmp(entryB.d_name, entryA.d_name) < 0) + return true; + break; + + case 2: + if (entryB.d_stat.st_size < entryA.d_stat.st_size) + return true; + break; + + case 3: + if (entryA.d_stat.st_size < entryB.d_stat.st_size) + return true; + break; + + default: + break; + } + } + + return false; + } + + int GetDirList(const std::string &path, std::vector &entries) { + int ret = 0; + SceUID dir = 0; + entries.clear(); + + if (R_FAILED(ret = dir = sceIoDopen(path.c_str()))) { + Log::Error("sceIoDopen(%s) failed: 0x%lx\n", path.c_str(), ret); + return ret; + } + + do { + SceIoDirent entry; + std::memset(&entry, 0, sizeof(entry)); + + ret = sceIoDread(dir, &entry); + if (ret > 0) { + if ((std::strcmp(entry.d_name, ".") == 0) || (std::strcmp(entry.d_name, "..") == 0)) + continue; + + entries.push_back(entry); + } + } while (ret > 0); + + std::sort(entries.begin(), entries.end(), FS::Sort); + sceIoDclose(dir); + return 0; + } + + //TODO: Clean up change directory impl. + static int ChangeDir(const std::string &path, std::vector &entries) { + int ret = 0; + std::vector new_entries; + + if (R_FAILED(ret = FS::GetDirList(path, new_entries))) + return ret; + + // Free entries and change the current working directory. + entries.clear(); + cfg.cwd = path; + entries = new_entries; + return 0; + } + + static int ChangeDirUp(char path[256]) { + if (cfg.cwd.back() == ':') + return -1; + + // Remove upmost directory + bool copy = false; + int len = 0; + for (ssize_t i = cfg.cwd.length(); i >= 0; i--) { + if (cfg.cwd.c_str()[i] == '/') + copy = true; + if (copy) { + path[i] = cfg.cwd.c_str()[i]; + len++; + } + } + + // remove trailing slash + if (len > 1 && path[len - 1] == '/') + len--; + + path[len] = '\0'; + return 0; + } + + int ChangeDirNext(const std::string &path, std::vector &entries) { + std::string new_path = cfg.cwd; + new_path.append("/"); + new_path.append(path); + return FS::ChangeDir(new_path, entries); + } + + int ChangeDirPrev(std::vector &entries) { + char new_path[256]; + if (FS::ChangeDirUp(new_path) < 0) + return -1; + + return FS::ChangeDir(std::string(new_path), entries); + } + + static int CopyFile(const std::string &src_path, const std::string &dest_path) { + int ret = 0; + SceUID src_handle = 0, dest_handle = 0; + + if (R_FAILED(ret = src_handle = sceIoOpen(src_path.c_str(), PSP_O_RDONLY, 0))) { + Log::Error("sceIoOpen(%s) failed: 0x%x\n", src_path.c_str(), ret); + return ret; + } + + u64 size = sceIoLseek(src_handle, 0, PSP_SEEK_END); + sceIoLseek(src_handle, 0, PSP_SEEK_SET); + + // Make sure we have enough storage to carry out this operation + if (Utils::GetFreeStorage() < size) { + Log::Error("Not enough storage is available to process this command 0x%x\n", src_path.c_str(), ret); + sceIoClose(src_handle); + return -1; + } + + if (R_FAILED(ret = dest_handle = sceIoOpen(dest_path.c_str(), PSP_O_WRONLY | PSP_O_CREAT | PSP_O_APPEND, 0777))) { + Log::Error("sceIoOpen(%s) failed: 0x%x\n", dest_path.c_str(), ret); + sceIoClose(src_handle); + return ret; + } + + u32 bytes_read = 0, bytes_written = 0; + const u64 buf_size = 0x10000; + u64 offset = 0; + u8 *buf = new u8[buf_size]; + std::string filename = std::filesystem::path(src_path.data()).filename(); + + do { + if (Utils::IsCancelButtonPressed()) { + delete[] buf; + sceIoClose(src_handle); + sceIoClose(dest_handle); + return 0; + } + + std::memset(buf, 0, buf_size); + + if (R_FAILED(ret = bytes_read = sceIoRead(src_handle, buf, buf_size))) { + Log::Error("sceIoRead(%s) failed: 0x%x\n", src_path.c_str(), ret); + delete[] buf; + sceIoClose(src_handle); + sceIoClose(dest_handle); + return ret; + } + + if (R_FAILED(ret = bytes_written = sceIoWrite(dest_handle, buf, bytes_read))) { + Log::Error("sceIoWrite(%s) failed: 0x%x\n", dest_path.c_str(), ret); + delete[] buf; + sceIoClose(src_handle); + sceIoClose(dest_handle); + return ret; + } + + offset += bytes_read; + //GUI::ProgressBar("Copying", filename.c_str(), offset, size); + } while(offset < size); + + delete[] buf; + sceIoClose(src_handle); + sceIoClose(dest_handle); + return 0; + } + + static int CopyDir(const std::string &src_path, const std::string &dest_path) { + int ret = 0; + SceUID dir; + + if (R_FAILED(dir = sceIoDopen(src_path.c_str()))) { + Log::Error("sceIoDopen(%s) failed: 0x%lx\n", src_path.c_str(), ret); + return dir; + } + + // This may fail or not, but we don't care -> make the dir if it doesn't exist, otherwise continue. + sceIoMkdir(dest_path.c_str(), 0777); + + do { + SceIoDirent entry; + std::memset(&entry, 0, sizeof(entry)); + + ret = sceIoDread(dir, &entry); + if (ret > 0) { + if ((std::strcmp(entry.d_name, ".") == 0) || (std::strcmp(entry.d_name, "..") == 0)) + continue; + + std::string src = src_path; + src.append("/"); + src.append(entry.d_name); + + std::string dest = dest_path; + dest.append("/"); + dest.append(entry.d_name); + + if (FIO_S_ISDIR(entry.d_stat.st_mode)) + FS::CopyDir(src, dest); // Copy Folder (via recursion) + else + FS::CopyFile(src, dest); // Copy File + } + } while (ret > 0); + + sceIoDclose(dir); + return 0; + } + + static void ClearCopyData(void) { + fs_copy_entry.copy_path.clear(); + fs_copy_entry.copy_filename.clear(); + fs_copy_entry.is_dir = false; + } + + void Copy(SceIoDirent *entry, const std::string &path) { + FS::ClearCopyData(); + fs_copy_entry.copy_path = path; + fs_copy_entry.copy_path.append("/"); + fs_copy_entry.copy_path.append(entry->d_name); + fs_copy_entry.copy_filename.append(entry->d_name); + + if (FIO_S_ISDIR(entry->d_stat.st_mode)) + fs_copy_entry.is_dir = true; + } + + int Paste(void) { + int ret = 0; + std::string path = cfg.cwd; + path.append("/"); + path.append(fs_copy_entry.copy_filename); + + if (fs_copy_entry.is_dir) // Copy folder recursively + ret = FS::CopyDir(fs_copy_entry.copy_path, path); + else // Copy file + ret = FS::CopyFile(fs_copy_entry.copy_path, path); + + FS::ClearCopyData(); + return ret; + } + + // Thanks to TN for finding this. + static int sceIoMove(const char *src, const char *dest) { + int ret = 0; + size_t i = 0; + char strage[32]; + char *p1 = nullptr, *p2 = nullptr; + p1 = std::strchr(src, ':'); + + if (p1 == nullptr) + return -1; + + p2 = std::strchr(dest, ':'); + if (p2 == nullptr) + return -1; + + if ((p1 - src) != (p2 - dest)) + return -1; + + for (i = 0; (src + i) <= p1; i++) { + if ((i+1) >= sizeof(strage)) + return -1; + + if (src[i] != dest[i]) + return -1; + + strage[i] = src[i]; + } + + strage[i] = '\0'; + + u32 data[2]; + data[0] = (u32)(p1 + 1); + data[1] = (u32)(p2 + 1); + + if (R_FAILED(ret = sceIoDevctl(strage, 0x02415830, &data, sizeof(data), nullptr, 0))) { + Log::Error("sceIoDevctl() failed!", ret); + return ret; + } + + return 0; + } + + int Move(void) { + int ret = 0; + std::string path = cfg.cwd; + path.append("/"); + path.append(fs_copy_entry.copy_filename); + + if (R_FAILED(ret = sceIoMove(fs_copy_entry.copy_path.c_str(), path.c_str()))) { + Log::Error("sceIoMove(%s, %s) failed: 0x%x\n", fs_copy_entry.copy_filename.c_str(), path.c_str(), ret); + FS::ClearCopyData(); + return ret; + } + + FS::ClearCopyData(); + return 0; + } + + static int DeleteDirectoryRecursive(const std::string &path) { + int ret = 0; + SceUID dir = 0; + + if (R_FAILED(ret = dir = sceIoDopen(path.c_str()))) { + if (R_FAILED(ret = sceIoRemove(path.c_str()))) { + Log::Error("sceIoRemove(%s) failed: 0x%lx\n", path.c_str(), ret); + return ret; + } + } + + do { + SceIoDirent entry; + std::memset(&entry, 0, sizeof(entry)); + + ret = sceIoDread(dir, &entry); + if (ret > 0) { + if ((std::strcmp(entry.d_name, ".") == 0) || (std::strcmp(entry.d_name, "..") == 0)) + continue; + + std::string new_path = path; + new_path.append("/"); + new_path.append(entry.d_name); + + if (FIO_S_ISDIR(entry.d_stat.st_mode)) { + int result = FS::DeleteDirectoryRecursive(new_path); + if (result <= 0) { + Log::Error("FS::DeleteDirectoryRecursive(%s) failed: 0x%lx\n", path.c_str(), ret); + sceIoDclose(dir); + return ret; + } + } + else { + int result = sceIoRemove(new_path.c_str()); + if (R_FAILED(result)) { + Log::Error("sceIoRemove(%s) failed: 0x%lx\n", path.c_str(), ret); + sceIoDclose(dir); + return ret; + } + } + } + } while (ret > 0); + + sceIoDclose(dir); + + if (R_FAILED(ret = sceIoRmdir(path.c_str()))) { + Log::Error("sceIoRmdir(%s) failed: 0x%lx\n", path.c_str(), ret); + return ret; + } + + return 1; + } + + int Delete(SceIoDirent *entry) { + int ret = 0; + std::string path = cfg.cwd; + path.append("/"); + path.append(entry->d_name); + + if (FIO_S_ISDIR(entry->d_stat.st_mode)) { + if (R_FAILED(ret = FS::DeleteDirectoryRecursive(path))) { + Log::Error("FS::DeleteDirectoryRecursive(%s) failed: 0x%x\n", path.c_str(), ret); + return ret; + } + } + else { + if (R_FAILED(ret = sceIoRemove(path.c_str()))) { + Log::Error("sceIoRemove(%s) failed: 0x%x\n", path.c_str(), ret); + return ret; + } + } + + return 0; + } +} diff --git a/app/source/ftppsp.cpp b/app/source/ftppsp.cpp new file mode 100644 index 0000000..23f5163 --- /dev/null +++ b/app/source/ftppsp.cpp @@ -0,0 +1,1095 @@ +/* + * Copyright (c) 2019 Sergi Granell (xerpi), Joel16 + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ftppsp.h" +#include "mutex.h" + +#define UNUSED(x) (void)(x) + +#define FTP_PORT 1337 +#define DEFAULT_FILE_BUF_SIZE (1 * 1024 * 1024) + +#define FTP_DEFAULT_PATH "/" + +#define MAX_DEVICES 7 +#define MAX_CUSTOM_COMMANDS 16 + +typedef struct { + const char *cmd; + cmd_dispatch_func func; +} cmd_dispatch_entry; + +static struct { + char name[512]; + int valid; +} device_list[MAX_DEVICES]; + +static struct { + const char *cmd; + cmd_dispatch_func func; + int valid; +} custom_command_dispatchers[MAX_CUSTOM_COMMANDS]; + +static void *net_memory = nullptr; +static int ftp_initialized = 0; +static unsigned int file_buf_size = DEFAULT_FILE_BUF_SIZE; +static struct in_addr psp_addr; +static SceUID server_thid; +static int server_sockfd; +static int number_clients = 0; +static ftppsp_client_info_t *client_list = nullptr; +static SceUID client_list_mtx; + +static void (*info_log_cb)(const char *) = nullptr; +static void (*debug_log_cb)(const char *) = nullptr; + +static void log_func(ftppsp_log_cb_t log_cb, const char *s, ...) { + if (log_cb) { + char buf[256]; + va_list argptr; + va_start(argptr, s); + vsnprintf(buf, sizeof(buf), s, argptr); + va_end(argptr); + log_cb(buf); + } +} + +#define INFO(...) log_func(info_log_cb, __VA_ARGS__) +#define DEBUG(...) log_func(debug_log_cb, __VA_ARGS__) + +static int client_send_ctrl_msg(ftppsp_client_info_t *cl, const char *str) { + return sceNetInetSend(cl->ctrl_sockfd, str, std::strlen(str), 0); +} + +// Missing prototypes in the PSPSDK +int sceNetInetGetsockname(int, struct sockaddr *, socklen_t *); +const char* sceNetInetInetNtop(int, const void *, char *, socklen_t); +int sceNetInetInetPton(int, const char *, void *); + +static __inline__ unsigned int sceAllegrexWsbw(unsigned int x) { + return (((x & 0xFF)<<24) | ((x & 0xFF00)<<8) | ((x>>8) & 0xFF00) | ((x>>24) & 0xFF)); +} + +static __inline__ unsigned int sceAllegrexWsbh(unsigned int x) { + return (((x<<8) & 0xFF00FF00) | ((x>>8) & 0x00FF00FF)); +} + +static inline u32 SCE_HTONL(u32 hostlong) { + return sceAllegrexWsbw(hostlong); +} + +static inline u16 SCE_HTONS(u16 hostshort) { + return sceAllegrexWsbh(hostshort); +} + +static inline void client_send_data_msg(ftppsp_client_info_t *client, const char *str) { + if (client->data_con_type == FTP_DATA_CONNECTION_ACTIVE) + sceNetInetSend(client->data_sockfd, str, std::strlen(str), 0); + else + sceNetInetSend(client->pasv_sockfd, str, std::strlen(str), 0); +} + +static inline int client_recv_data_raw(ftppsp_client_info_t *client, void *buf, unsigned int len) { + if (client->data_con_type == FTP_DATA_CONNECTION_ACTIVE) + return sceNetInetRecv(client->data_sockfd, buf, len, 0); + else + return sceNetInetRecv(client->pasv_sockfd, buf, len, 0); +} + +static inline void client_send_data_raw(ftppsp_client_info_t *client, const void *buf, unsigned int len) { + if (client->data_con_type == FTP_DATA_CONNECTION_ACTIVE) + sceNetInetSend(client->data_sockfd, buf, len, 0); + else + sceNetInetSend(client->pasv_sockfd, buf, len, 0); +} + +static inline const char *get_psp_path(const char *path) { + if (std::strlen(path) > 1) /* /cache0:/foo/bar -> cache0:/foo/bar */ + return &path[1]; + else + return nullptr; +} + +static int file_exists(const char *path) { + SceIoStat stat; + return (sceIoGetstat(path, &stat) >= 0); +} + +static void cmd_NOOP_func(ftppsp_client_info_t *client) { + client_send_ctrl_msg(client, "200 No operation ;)\r\n"); +} + +static void cmd_USER_func(ftppsp_client_info_t *client) { + client_send_ctrl_msg(client, "331 Username OK, need password b0ss.\r\n"); +} + +static void cmd_PASS_func(ftppsp_client_info_t *client) { + client_send_ctrl_msg(client, "230 User logged in!\r\n"); +} + +static void cmd_QUIT_func(ftppsp_client_info_t *client) { + client_send_ctrl_msg(client, "221 Goodbye senpai :'(\r\n"); +} + +static void cmd_SYST_func(ftppsp_client_info_t *client) { + client_send_ctrl_msg(client, "215 UNIX Type: L8\r\n"); +} + +static void cmd_PASV_func(ftppsp_client_info_t *client) { + int ret; + UNUSED(ret); + + char cmd[512]; + unsigned int namelen; + struct sockaddr_in picked; + + /* Create the data socket */ + client->data_sockfd = sceNetInetSocket(AF_INET, SOCK_STREAM, 0); + + DEBUG("PASV data socket fd: %d\n", client->data_sockfd); + + /* Fill the data socket address */ + client->data_sockaddr.sin_family = AF_INET; + client->data_sockaddr.sin_addr.s_addr = SCE_HTONL(INADDR_ANY); + /* Let the PSVita choose a port */ + client->data_sockaddr.sin_port = SCE_HTONS(0); + + /* Bind the data socket address to the data socket */ + ret = sceNetInetBind(client->data_sockfd, (struct sockaddr *)&client->data_sockaddr, sizeof(client->data_sockaddr)); + DEBUG("sceNetInetBind(): 0x%08X\n", ret); + + /* Start listening */ + ret = sceNetInetListen(client->data_sockfd, 128); + DEBUG("sceNetInetListen(): 0x%08X\n", ret); + + /* Get the port that the PSVita has chosen */ + namelen = sizeof(picked); + sceNetInetGetsockname(client->data_sockfd, (struct sockaddr *)&picked, &namelen); + + DEBUG("PASV mode port: 0x%04X\n", picked.sin_port); + + /* Build the command */ + std::sprintf(cmd, "227 Entering Passive Mode (%hhu,%hhu,%hhu,%hhu,%hhu,%hhu)\r\n", + (psp_addr.s_addr >> 0) & 0xFF, + (psp_addr.s_addr >> 8) & 0xFF, + (psp_addr.s_addr >> 16) & 0xFF, + (psp_addr.s_addr >> 24) & 0xFF, + (picked.sin_port >> 0) & 0xFF, + (picked.sin_port >> 8) & 0xFF); + + client_send_ctrl_msg(client, cmd); + + /* Set the data connection type to passive! */ + client->data_con_type = FTP_DATA_CONNECTION_PASSIVE; +} + +static void cmd_PORT_func(ftppsp_client_info_t *client) { + unsigned int data_ip[4]; + unsigned int porthi, portlo; + unsigned short data_port; + char ip_str[16]; + struct in_addr data_addr; + + /* Using ints because of newlibc's u8 std::sscanf bug */ + std::sscanf(client->recv_cmd_args, "%d,%d,%d,%d,%d,%d", &data_ip[0], &data_ip[1], &data_ip[2], &data_ip[3], &porthi, &portlo); + + data_port = portlo + porthi*256; + + /* Convert to an X.X.X.X IP string */ + std::sprintf(ip_str, "%d.%d.%d.%d", data_ip[0], data_ip[1], data_ip[2], data_ip[3]); + + /* Convert the IP to a SceNetInAddr */ + sceNetInetInetPton(AF_INET, ip_str, &data_addr); + + DEBUG("PORT connection to client's IP: %s Port: %d\n", ip_str, data_port); + + /* Create data mode socket */ + client->data_sockfd = sceNetInetSocket(AF_INET, SOCK_STREAM, 0); + + DEBUG("Client %i data socket fd: %d\n", client->num, client->data_sockfd); + + /* Prepare socket address for the data connection */ + client->data_sockaddr.sin_family = AF_INET; + client->data_sockaddr.sin_addr = data_addr; + client->data_sockaddr.sin_port = SCE_HTONS(data_port); + + /* Set the data connection type to active! */ + client->data_con_type = FTP_DATA_CONNECTION_ACTIVE; + + client_send_ctrl_msg(client, "200 PORT command successful!\r\n"); +} + +static void client_open_data_connection(ftppsp_client_info_t *client) { + int ret; + UNUSED(ret); + + socklen_t addrlen; + if (client->data_con_type == FTP_DATA_CONNECTION_ACTIVE) { + /* Connect to the client using the data socket */ + ret = sceNetInetConnect(client->data_sockfd, (struct sockaddr *)&client->data_sockaddr, sizeof(client->data_sockaddr)); + + DEBUG("sceNetInetConnect(): 0x%08X\n", ret); + } + else { + /* Listen to the client using the data socket */ + addrlen = sizeof(client->pasv_sockaddr); + client->pasv_sockfd = sceNetInetAccept(client->data_sockfd, (struct sockaddr *)&client->pasv_sockaddr, &addrlen); + DEBUG("PASV client fd: 0x%08X\n", client->pasv_sockfd); + } +} + +static void client_close_data_connection(ftppsp_client_info_t *client) { + sceNetInetClose(client->data_sockfd); + /* In passive mode we have to close the client pasv socket too */ + if (client->data_con_type == FTP_DATA_CONNECTION_PASSIVE) + sceNetInetClose(client->pasv_sockfd); + + client->data_con_type = FTP_DATA_CONNECTION_NONE; +} + +static int gen_list_format(char *out, int n, int dir, const SceIoStat *stat, const char *filename) { + static const char num_to_month[][4] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" + }; + + char yt[13]; + pspTime cdt; + sceRtcGetCurrentClockLocalTime(&cdt); + + if (cdt.year == stat->st_mtime.year) + snprintf(yt, 12, "%02d:%02d", stat->st_mtime.hour, stat->st_mtime.minute); + else + snprintf(yt, 11, "%04d", stat->st_mtime.year); + + return snprintf(out, n, "%c%s 1 vita vita %u %s %-2d %s %s\r\n", dir ? 'd' : '-', dir ? "rwxr-xr-x" : "rw-r--r--", + (unsigned int) stat->st_size, num_to_month[stat->st_mtime.month<=0?0:(stat->st_mtime.month-1)%12], stat->st_mtime.day, + yt, filename); +} + +static void send_LIST(ftppsp_client_info_t *client, const char *path) { + char buffer[512]; + SceUID dir; + SceIoDirent dirent; + SceIoStat stat; + char *devname; + int send_devices = 0; + + /* "/" path is a special case, if we are here we have + * to send the list of devices (aka mountpoints). */ + if (std::strcmp(path, "/") == 0) + send_devices = 1; + + if (!send_devices) { + dir = sceIoDopen(get_psp_path(path)); + if (dir < 0) { + client_send_ctrl_msg(client, "550 Invalid directory.\r\n"); + return; + } + } + + client_send_ctrl_msg(client, "150 Opening ASCII mode data transfer for LIST.\r\n"); + + client_open_data_connection(client); + + if (send_devices) { + for (int i = 0; i < MAX_DEVICES; i++) { + if (device_list[i].valid) { + devname = device_list[i].name; + + if (sceIoGetstat(devname, &stat) >= 0) { + gen_list_format(buffer, sizeof(buffer), 1, &stat, devname); + client_send_data_msg(client, buffer); + } + } + } + } + else { + std::memset(&dirent, 0, sizeof(dirent)); + + while (sceIoDread(dir, &dirent) > 0) { + gen_list_format(buffer, sizeof(buffer), FIO_S_ISDIR(dirent.d_stat.st_mode), &dirent.d_stat, dirent.d_name); + client_send_data_msg(client, buffer); + std::memset(&dirent, 0, sizeof(dirent)); + std::memset(buffer, 0, sizeof(buffer)); + } + + sceIoDclose(dir); + } + + DEBUG("Done sending LIST\n"); + + client_close_data_connection(client); + client_send_ctrl_msg(client, "226 Transfer complete.\r\n"); +} + +static void cmd_LIST_func(ftppsp_client_info_t *client) { + char list_path[512]; + int list_cur_path = 1; + + int n = std::sscanf(client->recv_cmd_args, "%[^\r\n\t]", list_path); + + if (n > 0 && file_exists(list_path)) + list_cur_path = 0; + + if (list_cur_path) + send_LIST(client, client->cur_path); + else + send_LIST(client, list_path); +} + +static void cmd_PWD_func(ftppsp_client_info_t *client) { + char msg[1059]; + snprintf(msg, 1058, "257 \"%s\" is the current directory.\r\n", client->cur_path); + client_send_ctrl_msg(client, msg); +} + +static int path_is_at_root(const char *path) { + return std::strrchr(path, '/') == (path + std::strlen(path) - 1); +} + +static void dir_up(char *path) { + char *pch; + size_t len_in = std::strlen(path); + + if (len_in == 1) { + std::strcpy(path, "/"); + return; + } + + if (path_is_at_root(path)) /* Case root of the device (/foo0:/) */ + std::strcpy(path, "/"); + else { + pch = std::strrchr(path, '/'); + size_t s = len_in - (pch - path); + std::memset(pch, '\0', s); + + /* If the path is like: /foo: add slash */ + if (std::strrchr(path, '/') == path) + std::strcat(path, "/"); + } +} + +static void cmd_CWD_func(ftppsp_client_info_t *client) { + char cmd_path[512]; + char tmp_path[1537]; + SceUID pd; + int n = std::sscanf(client->recv_cmd_args, "%[^\r\n\t]", cmd_path); + + if (n < 1) + client_send_ctrl_msg(client, "500 Syntax error, command unrecognized.\r\n"); + else { + if (std::strcmp(cmd_path, "/") == 0) + std::strcpy(client->cur_path, cmd_path); + else if (std::strcmp(cmd_path, "..") == 0) + dir_up(client->cur_path); + else { + if (cmd_path[0] == '/') /* Full path */ + std::strcpy(tmp_path, cmd_path); + else { /* Change dir relative to current dir */ + /* If we are at the root of the device, don't add + * an slash to add new path */ + if (path_is_at_root(client->cur_path)) + snprintf(tmp_path, 1535, "%s%s", client->cur_path, cmd_path); + else + snprintf(tmp_path, 1536, "%s/%s", client->cur_path, cmd_path); + } + + /* If the path is like: /foo: add an slash */ + if (std::strrchr(tmp_path, '/') == tmp_path) + std::strcat(tmp_path, "/"); + + /* If the path is not "/", check if it exists */ + if (std::strcmp(tmp_path, "/") != 0) { + /* Check if the path exists */ + pd = sceIoDopen(get_psp_path(tmp_path)); + if (pd < 0) { + client_send_ctrl_msg(client, "550 Invalid directory.\r\n"); + return; + } + sceIoDclose(pd); + } + std::strcpy(client->cur_path, tmp_path); + } + client_send_ctrl_msg(client, "250 Requested file action okay, completed.\r\n"); + } +} + +static void cmd_TYPE_func(ftppsp_client_info_t *client) { + char data_type; + char format_control[8]; + int n_args = std::sscanf(client->recv_cmd_args, "%c %s", &data_type, format_control); + + if (n_args > 0) { + switch(data_type) { + case 'A': + case 'I': + client_send_ctrl_msg(client, "200 Okay\r\n"); + break; + case 'E': + case 'L': + default: + client_send_ctrl_msg(client, "504 Error: bad parameters?\r\n"); + break; + } + } + else + client_send_ctrl_msg(client, "504 Error: bad parameters?\r\n"); +} + +static void cmd_CDUP_func(ftppsp_client_info_t *client) { + dir_up(client->cur_path); + client_send_ctrl_msg(client, "200 Command okay.\r\n"); +} + +static void send_file(ftppsp_client_info_t *client, const char *path) { + unsigned char *buffer; + SceUID fd; + unsigned int bytes_read; + + DEBUG("Opening: %s\n", path); + + if ((fd = sceIoOpen(path, PSP_O_RDONLY, 0777)) >= 0) { + sceIoLseek32(fd, client->restore_point, PSP_SEEK_SET); + + buffer = new unsigned char[file_buf_size]; + if (buffer == nullptr) { + client_send_ctrl_msg(client, "550 Could not allocate memory.\r\n"); + return; + } + + client_open_data_connection(client); + client_send_ctrl_msg(client, "150 Opening Image mode data transfer.\r\n"); + + while ((bytes_read = sceIoRead (fd, buffer, file_buf_size)) > 0) + client_send_data_raw(client, buffer, bytes_read); + + sceIoClose(fd); + delete[] buffer; + client->restore_point = 0; + client_send_ctrl_msg(client, "226 Transfer completed.\r\n"); + client_close_data_connection(client); + } + else + client_send_ctrl_msg(client, "550 File not found.\r\n"); +} + +/* This function generates an FTP full-path with the input path (relative or absolute) + * from RETR, STOR, DELE, RMD, MKD, RNFR and RNTO commands */ +static void gen_ftp_fullpath(ftppsp_client_info_t *client, char *path, size_t path_size) { + char cmd_path[512]; + std::sscanf(client->recv_cmd_args, "%[^\r\n\t]", cmd_path); + + if (cmd_path[0] == '/') + strncpy(path, cmd_path, path_size); /* Full path */ + else { + if (std::strlen(cmd_path) >= 5 && cmd_path[3] == ':' && cmd_path[4] == '/') + snprintf(path, 513, "/%s", cmd_path); /* Case "ux0:/foo */ + else { + /* The file is relative to current dir, so + * append the file to the current path */ + snprintf(path, 1536, "%s/%s", client->cur_path, cmd_path); + } + } +} + +static void cmd_RETR_func(ftppsp_client_info_t *client) { + char dest_path[512]; + gen_ftp_fullpath(client, dest_path, sizeof(dest_path)); + send_file(client, get_psp_path(dest_path)); +} + +static void receive_file(ftppsp_client_info_t *client, const char *path) { + unsigned char *buffer; + SceUID fd; + int bytes_recv; + + DEBUG("Opening: %s\n", path); + + int mode = PSP_O_CREAT | PSP_O_RDWR; + /* if we resume broken - append missing part + * else - overwrite file */ + if (client->restore_point) + mode = mode | PSP_O_APPEND; + else + mode = mode | PSP_O_TRUNC; + + if ((fd = sceIoOpen(path, mode, 0777)) >= 0) { + buffer = new unsigned char[file_buf_size]; + if (buffer == nullptr) { + client_send_ctrl_msg(client, "550 Could not allocate memory.\r\n"); + return; + } + + client_open_data_connection(client); + client_send_ctrl_msg(client, "150 Opening Image mode data transfer.\r\n"); + + while ((bytes_recv = client_recv_data_raw(client, buffer, file_buf_size)) > 0) + sceIoWrite(fd, buffer, bytes_recv); + + sceIoClose(fd); + delete[] buffer; + client->restore_point = 0; + if (bytes_recv == 0) + client_send_ctrl_msg(client, "226 Transfer completed.\r\n"); + else { + sceIoRemove(path); + client_send_ctrl_msg(client, "426 Connection closed; transfer aborted.\r\n"); + } + client_close_data_connection(client); + } + else + client_send_ctrl_msg(client, "550 File not found.\r\n"); +} + +static void cmd_STOR_func(ftppsp_client_info_t *client) { + char dest_path[512]; + gen_ftp_fullpath(client, dest_path, sizeof(dest_path)); + receive_file(client, get_psp_path(dest_path)); +} + +static void delete_file(ftppsp_client_info_t *client, const char *path) { + DEBUG("Deleting: %s\n", path); + + if (sceIoRemove(path) >= 0) + client_send_ctrl_msg(client, "226 File deleted.\r\n"); + else + client_send_ctrl_msg(client, "550 Could not delete the file.\r\n"); +} + +static void cmd_DELE_func(ftppsp_client_info_t *client) { + char dest_path[512]; + gen_ftp_fullpath(client, dest_path, sizeof(dest_path)); + delete_file(client, get_psp_path(dest_path)); +} + +static void delete_dir(ftppsp_client_info_t *client, const char *path) { + unsigned int ret; + DEBUG("Deleting: %s\n", path); + ret = sceIoRmdir(path); + if (ret >= 0) + client_send_ctrl_msg(client, "226 Directory deleted.\r\n"); + else if (ret == 0x8001005A) /* DIRECTORY_IS_NOT_EMPTY */ + client_send_ctrl_msg(client, "550 Directory is not empty.\r\n"); + else + client_send_ctrl_msg(client, "550 Could not delete the directory.\r\n"); +} + +static void cmd_RMD_func(ftppsp_client_info_t *client) { + char dest_path[512]; + gen_ftp_fullpath(client, dest_path, sizeof(dest_path)); + delete_dir(client, get_psp_path(dest_path)); +} + +static void create_dir(ftppsp_client_info_t *client, const char *path) { + DEBUG("Creating: %s\n", path); + + if (sceIoMkdir(path, 0777) >= 0) + client_send_ctrl_msg(client, "226 Directory created.\r\n"); + else + client_send_ctrl_msg(client, "550 Could not create the directory.\r\n"); +} + +static void cmd_MKD_func(ftppsp_client_info_t *client) { + char dest_path[512]; + gen_ftp_fullpath(client, dest_path, sizeof(dest_path)); + create_dir(client, get_psp_path(dest_path)); +} + +static void cmd_RNFR_func(ftppsp_client_info_t *client) { + char path_src[512]; + const char *psp_path_src; + /* Get the origin filename */ + gen_ftp_fullpath(client, path_src, sizeof(path_src)); + psp_path_src = get_psp_path(path_src); + + /* Check if the file exists */ + if (!file_exists(psp_path_src)) { + client_send_ctrl_msg(client, "550 The file doesn't exist.\r\n"); + return; + } + + /* The file to be renamed is the received path */ + std::strcpy(client->rename_path, psp_path_src); + client_send_ctrl_msg(client, "350 I need the destination name b0ss.\r\n"); +} + +static void cmd_RNTO_func(ftppsp_client_info_t *client) { + char path_dst[512]; + const char *psp_path_dst; + + /* Get the destination filename */ + gen_ftp_fullpath(client, path_dst,sizeof(path_dst)); + psp_path_dst = get_psp_path(path_dst); + + DEBUG("Renaming: %s to %s\n", client->rename_path, psp_path_dst); + + if (sceIoRename(client->rename_path, psp_path_dst) < 0) + client_send_ctrl_msg(client, "550 Error renaming the file.\r\n"); + + client_send_ctrl_msg(client, "226 Rename completed.\r\n"); +} + +static void cmd_SIZE_func(ftppsp_client_info_t *client) { + SceIoStat stat; + char path[512]; + char cmd[64]; + /* Get the filename to retrieve its size */ + gen_ftp_fullpath(client, path, sizeof(path)); + + /* Check if the file exists */ + if (sceIoGetstat(get_psp_path(path), &stat) < 0) { + client_send_ctrl_msg(client, "550 The file doesn't exist.\r\n"); + return; + } + + /* Send the size of the file */ + std::sprintf(cmd, "213 %lld\r\n", stat.st_size); + client_send_ctrl_msg(client, cmd); +} + +static void cmd_REST_func(ftppsp_client_info_t *client) { + char cmd[64]; + std::sscanf(client->recv_buffer, "%*[^ ] %d", &client->restore_point); + std::sprintf(cmd, "350 Resuming at %d\r\n", client->restore_point); + client_send_ctrl_msg(client, cmd); +} + +static void cmd_FEAT_func(ftppsp_client_info_t *client) { + /*So client would know that we support resume */ + client_send_ctrl_msg(client, "211-extensions\r\n"); + client_send_ctrl_msg(client, "REST STREAM\r\n"); + client_send_ctrl_msg(client, "211 end\r\n"); +} + +static void cmd_APPE_func(ftppsp_client_info_t *client) { + /* set restore point to not 0 + restore point numeric value only matters if we RETR file from vita. + If we STOR or APPE, it is only used to indicate that we want to resume + a broken transfer */ + client->restore_point = -1; + char dest_path[512]; + gen_ftp_fullpath(client, dest_path, sizeof(dest_path)); + receive_file(client, get_psp_path(dest_path)); +} + +#define add_entry(name) {#name, cmd_##name##_func} +static const cmd_dispatch_entry cmd_dispatch_table[] = { + add_entry(NOOP), + add_entry(USER), + add_entry(PASS), + add_entry(QUIT), + add_entry(SYST), + add_entry(PASV), + add_entry(PORT), + add_entry(LIST), + add_entry(PWD), + add_entry(CWD), + add_entry(TYPE), + add_entry(CDUP), + add_entry(RETR), + add_entry(STOR), + add_entry(DELE), + add_entry(RMD), + add_entry(MKD), + add_entry(RNFR), + add_entry(RNTO), + add_entry(SIZE), + add_entry(REST), + add_entry(FEAT), + add_entry(APPE), + {nullptr, nullptr} +}; + +static cmd_dispatch_func get_dispatch_func(const char *cmd) { + for(int i = 0; cmd_dispatch_table[i].cmd && cmd_dispatch_table[i].func; i++) { + if (std::strcmp(cmd, cmd_dispatch_table[i].cmd) == 0) + return cmd_dispatch_table[i].func; + } + + // Check for custom commands + for(int i = 0; i < MAX_CUSTOM_COMMANDS; i++) { + if (custom_command_dispatchers[i].valid) { + if (std::strcmp(cmd, custom_command_dispatchers[i].cmd) == 0) + return custom_command_dispatchers[i].func; + } + } + + return nullptr; +} + +static void client_list_add(ftppsp_client_info_t *client) { + /* Add the client at the front of the client list */ + sceKernelLockMutex(client_list_mtx, 1, nullptr); + + if (client_list == nullptr) { /* List is empty */ + client_list = client; + client->prev = nullptr; + client->next = nullptr; + } else { + client->next = client_list; + client_list->prev = client; + client->prev = nullptr; + client_list = client; + } + client->restore_point = 0; + number_clients++; + + sceKernelUnlockMutex(client_list_mtx, 1); +} + +static void client_list_delete(ftppsp_client_info_t *client) { + /* Remove the client from the client list */ + sceKernelLockMutex(client_list_mtx, 1, nullptr); + + if (client->prev) + client->prev->next = client->next; + if (client->next) + client->next->prev = client->prev; + if (client == client_list) + client_list = client->next; + + number_clients--; + + sceKernelUnlockMutex(client_list_mtx, 1); +} + +static void client_list_thread_end(void) { + ftppsp_client_info_t *it, *next; + SceUID client_thid; + + sceKernelLockMutex(client_list_mtx, 1, nullptr); + + it = client_list; + + /* Iterate over the client list and close their sockets */ + while (it) { + next = it->next; + client_thid = it->thid; + + /* Abort the client's control socket, only abort + * receiving data so we can still send control messages */ + sceNetInetShutdown(it->ctrl_sockfd, SHUT_RDWR); + + // If there's an open data connection, abort it + if (it->data_con_type != FTP_DATA_CONNECTION_NONE) { + sceNetInetShutdown(it->data_sockfd, SHUT_RDWR); + + if (it->data_con_type == FTP_DATA_CONNECTION_PASSIVE) + sceNetInetShutdown(it->pasv_sockfd, SHUT_RDWR); + } + + /* Wait until the client threads ends */ + SceUInt timeout = 1000000; + sceKernelWaitThreadEnd(client_thid, &timeout); + + it = next; + } + + sceKernelUnlockMutex(client_list_mtx, 1); +} + +static int client_thread(SceSize args, void *argp) { + char cmd[16]; + cmd_dispatch_func dispatch_func; + ftppsp_client_info_t *client = *(ftppsp_client_info_t **)argp; + + DEBUG("Client thread %i started!\n", client->num); + + client_send_ctrl_msg(client, "220 FTPVita Server ready.\r\n"); + + while (true) { + std::memset(client->recv_buffer, 0, sizeof(client->recv_buffer)); + + client->n_recv = sceNetInetRecv(client->ctrl_sockfd, client->recv_buffer, sizeof(client->recv_buffer), 0); + if (client->n_recv > 0) { + DEBUG("Received %i bytes from client number %i:\n", client->n_recv, client->num); + + INFO("\t%i> %s", client->num, client->recv_buffer); + + /* The command is the first chars until the first space */ + std::sscanf(client->recv_buffer, "%s", cmd); + + client->recv_cmd_args = strchr(client->recv_buffer, ' '); + if (client->recv_cmd_args) + client->recv_cmd_args++; /* Skip the space */ + else + client->recv_cmd_args = client->recv_buffer; + + /* Wait 1 ms before sending any data */ + sceKernelDelayThread(1*1000); + + if ((dispatch_func = get_dispatch_func(cmd))) + dispatch_func(client); + else + client_send_ctrl_msg(client, "502 Sorry, command not implemented. :(\r\n"); + } + else if (client->n_recv == 0) { + /* Value 0 means connection closed by the remote peer */ + INFO("Connection closed by the client %i.\n", client->num); + /* Delete itself from the client list */ + client_list_delete(client); + break; + } /*else if (client->n_recv == EINTR) { + // Socket aborted (ftppsp_fini() called) + INFO("Client %i socket aborted.\n", client->num); + break; + }*/ else { + /* Other errors */ + INFO("Client %i socket error: 0x%08X\n", client->num, client->n_recv); + client_list_delete(client); + break; + } + } + + /* Close the client's socket */ + sceNetInetClose(client->ctrl_sockfd); + + /* If there's an open data connection, close it */ + if (client->data_con_type != FTP_DATA_CONNECTION_NONE) { + sceNetInetClose(client->data_sockfd); + + if (client->data_con_type == FTP_DATA_CONNECTION_PASSIVE) + sceNetInetClose(client->pasv_sockfd); + } + + DEBUG("Client thread %i exiting!\n", client->num); + + delete[] client; + + sceKernelExitDeleteThread(0); + return 0; +} + +static int server_thread(SceSize args, void *argp) { + int ret; + UNUSED(ret); + + struct sockaddr_in serveraddr; + + DEBUG("Server thread started!\n"); + + /* Create server socket */ + server_sockfd = sceNetInetSocket(AF_INET, SOCK_STREAM, 0); + + DEBUG("Server socket fd: %d\n", server_sockfd); + + /* Fill the server's address */ + serveraddr.sin_family = AF_INET; + serveraddr.sin_addr.s_addr = SCE_HTONL(INADDR_ANY); + serveraddr.sin_port = SCE_HTONS(FTP_PORT); + + /* Bind the server's address to the socket */ + ret = sceNetInetBind(server_sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)); + DEBUG("sceNetInetBind(): 0x%08X\n", ret); + + /* Start listening */ + ret = sceNetInetListen(server_sockfd, 128); + DEBUG("sceNetInetListen(): 0x%08X\n", ret); + + while (true) { + /* Accept clients */ + struct sockaddr_in clientaddr; + int client_sockfd; + socklen_t addrlen = sizeof(clientaddr); + + DEBUG("Waiting for incoming connections...\n"); + + client_sockfd = sceNetInetAccept(server_sockfd, (struct sockaddr *)&clientaddr, &addrlen); + if (client_sockfd >= 0) { + DEBUG("New connection, client fd: 0x%08X\n", client_sockfd); + + /* Get the client's IP address */ + char remote_ip[16]; + sceNetInetInetNtop(AF_INET, &clientaddr.sin_addr.s_addr, remote_ip, sizeof(remote_ip)); + + INFO("Client %i connected, IP: %s port: %i\n", number_clients, remote_ip, clientaddr.sin_port); + + /* Create a new thread for the client */ + char client_thread_name[64]; + std::sprintf(client_thread_name, "FTPpsp_client_%i_thread", number_clients); + + SceUID client_thid = sceKernelCreateThread(client_thread_name, client_thread, 0x12, 0x2000, PSP_THREAD_ATTR_USBWLAN, nullptr); + + DEBUG("Client %i thread UID: 0x%08X\n", number_clients, client_thid); + + /* Allocate the ftppsp_client_info_t struct for the new client */ + ftppsp_client_info_t *client = new ftppsp_client_info_t[sizeof(*client)]; + client->num = number_clients; + client->thid = client_thid; + client->ctrl_sockfd = client_sockfd; + client->data_con_type = FTP_DATA_CONNECTION_NONE; + std::strcpy(client->cur_path, FTP_DEFAULT_PATH); + std::memcpy(&client->addr, &clientaddr, sizeof(client->addr)); + + /* Add the new client to the client list */ + client_list_add(client); + + /* Start the client thread */ + sceKernelStartThread(client_thid, sizeof(client), &client); + } + else { + /* if sceNetAccept returns < 0, it means that the listening + * socket has been closed, this means that we want to + * finish the server thread */ + DEBUG("Server socket closed, 0x%08X\n", client_sockfd); + break; + } + } + + DEBUG("Server thread exiting!\n"); + + sceKernelExitDeleteThread(0); + return 0; +} + +int ftppsp_init(char *psp_ip, unsigned short int *psp_port) { + if (ftp_initialized) + return -1; + + union SceNetApctlInfo info; + if (sceNetApctlGetInfo(8, &info) < 0) + return -1; + else + std::strcpy(psp_ip, info.ip); + + *psp_port = FTP_PORT; + + /* Save the IP of PSVita to a global variable */ + if (sceNetInetInetPton(AF_INET, info.ip, &psp_addr) < 0) + return -1; + + /* Create server thread */ + server_thid = sceKernelCreateThread("FTPpsp_server_thread", server_thread, 0x20, 0x6000, PSP_THREAD_ATTR_USBWLAN, nullptr); + DEBUG("Server thread UID: 0x%08X\n", server_thid); + + /* Create the client list mutex */ + client_list_mtx = sceKernelCreateMutex("ftpsp_list_mutex", PSP_MUTEX_ATTR_FIFO, 0, nullptr); + DEBUG("Client list mutex UID: 0x%08X\n", client_list_mtx); + + /* Init device list */ + for (int i = 0; i < MAX_DEVICES; i++) + device_list[i].valid = 0; + + for (int i = 0; i < MAX_CUSTOM_COMMANDS; i++) + custom_command_dispatchers[i].valid = 0; + + /* Start the server thread */ + sceKernelStartThread(server_thid, 0, nullptr); + ftp_initialized = 1; + return 0; +} + +void ftppsp_fini(void) { + if (ftp_initialized) { + /* In order to "stop" the blocking sceNetAccept, + * we have to close the server socket; this way + * the accept call will return an error */ + sceNetInetClose(server_sockfd); + + /* Wait until the server threads ends */ + SceUInt timeout = 1000000; + sceKernelWaitThreadEnd(server_thid, &timeout); + //sceKernelTerminateDeleteThread(server_thid); + + /* To close the clients we have to do the same: + * we have to iterate over all the clients + * and shutdown their sockets */ + client_list_thread_end(); + + /* Delete the client list mutex */ + sceKernelDeleteMutex(client_list_mtx); + + client_list = nullptr; + number_clients = 0; + + if (net_memory) + std::free(net_memory); + + net_memory = nullptr; + ftp_initialized = 0; + } +} + +int ftppsp_is_initialized(void) { + return ftp_initialized; +} + +int ftppsp_add_device(const char *devname) { + for (int i = 0; i < MAX_DEVICES; i++) { + if (!device_list[i].valid) { + std::strcpy(device_list[i].name, devname); + device_list[i].valid = 1; + return 1; + } + } + + return 0; +} + +int ftppsp_del_device(const char *devname) { + for (int i = 0; i < MAX_DEVICES; i++) { + if (std::strcmp(devname, device_list[i].name) == 0) { + device_list[i].valid = 0; + return 1; + } + } + + return 0; +} + +void ftppsp_set_info_log_cb(ftppsp_log_cb_t cb) { + info_log_cb = cb; +} + +void ftppsp_set_debug_log_cb(ftppsp_log_cb_t cb) { + debug_log_cb = cb; +} + +void ftppsp_set_file_buf_size(unsigned int size) { + file_buf_size = size; +} + +int ftppsp_ext_add_custom_command(const char *cmd, cmd_dispatch_func func) { + for (int i = 0; i < MAX_CUSTOM_COMMANDS; i++) { + if (!custom_command_dispatchers[i].valid) { + custom_command_dispatchers[i].cmd = cmd; + custom_command_dispatchers[i].func = func; + custom_command_dispatchers[i].valid = 1; + return 1; + } + } + + return 0; +} + +int ftppsp_ext_del_custom_command(const char *cmd) { + for (int i = 0; i < MAX_CUSTOM_COMMANDS; i++) { + if (std::strcmp(cmd, custom_command_dispatchers[i].cmd) == 0) { + custom_command_dispatchers[i].valid = 0; + return 1; + } + } + + return 0; +} + +void ftppsp_ext_client_send_ctrl_msg(ftppsp_client_info_t *client, const char *msg) { + client_send_ctrl_msg(client, msg); +} + +void ftppsp_ext_client_send_data_msg(ftppsp_client_info_t *client, const char *str) { + client_send_data_msg(client, str); +} diff --git a/app/source/g2d.cpp b/app/source/g2d.cpp new file mode 100644 index 0000000..9a59b4c --- /dev/null +++ b/app/source/g2d.cpp @@ -0,0 +1,147 @@ +#include +#include +#include +#include +#include + +#include "g2d.h" +#include "utils.h" + +intraFont *font, *jpn0, *chn; + +namespace G2D { + void DrawRect(float x, float y, float width, float height, g2dColor colour) { + g2dBeginRects(nullptr); { + g2dSetColor(colour); + g2dSetScaleWH(width, height); + g2dSetCoordXY(x, y); + g2dAdd(); + } + g2dEnd(); + } + + void DrawImage(g2dTexture *tex, float x, float y) { + g2dBeginRects(tex); { + g2dSetCoordXY(x, y); + g2dAdd(); + } + g2dEnd(); + } + + void DrawImageScale(g2dTexture *tex, float x, float y, float w, float h) { + g2dBeginRects(tex); { + g2dSetScaleWH(w, h); + g2dSetCoordXY(x, y); + g2dAdd(); + } + g2dEnd(); + } + + static int GetText(char *input, unsigned short *intext, unsigned short *desc) { + bool done = false; + unsigned short outtext[128] = { 0 }; + + SceUtilityOskData data; + std::memset(&data, 0, sizeof(SceUtilityOskData)); + + data.language = PSP_UTILITY_OSK_LANGUAGE_DEFAULT; // Use system default for text input + data.lines = 1; + data.unk_24 = 1; + data.inputtype = PSP_UTILITY_OSK_INPUTTYPE_ALL; // Allow all input types + data.desc = desc; + data.intext = intext; + data.outtextlength = 128; + data.outtextlimit = 32; // Limit input to 32 characters + data.outtext = outtext; + + SceUtilityOskParams params; + memset(¶ms, 0, sizeof(params)); + + params.base.size = sizeof(params); + sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, ¶ms.base.language); + sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, ¶ms.base.buttonSwap); + params.base.graphicsThread = 17; + params.base.accessThread = 19; + params.base.fontThread = 18; + params.base.soundThread = 16; + params.datacount = 1; + params.data = &data; + + int ret = 0; + if (R_FAILED(ret = sceUtilityOskInitStart(¶ms))) + return ret; + + while(!done) { + int i = 0, j = 0; + + g2dClear(G2D_RGBA(39, 50, 56, 255)); + sceGuFinish(); + sceGuSync(0, 0); + + switch(sceUtilityOskGetStatus()) { + case PSP_UTILITY_DIALOG_INIT: + break; + + case PSP_UTILITY_DIALOG_VISIBLE: + sceUtilityOskUpdate(1); + break; + + case PSP_UTILITY_DIALOG_QUIT: + sceUtilityOskShutdownStart(); + break; + + case PSP_UTILITY_DIALOG_FINISHED: + break; + + case PSP_UTILITY_DIALOG_NONE: + done = true; + + default: + break; + } + + for(i = 0; data.outtext[i]; i++) { + if (data.outtext[i] != '\0' && data.outtext[i] != '\n' && data.outtext[i] != '\r') { + input[j] = data.outtext[i]; + j++; + } + } + + input[j] = 0; + g2dFlip(G2D_VSYNC); + } + + return 0; + } + + char *KeyboardGetText(const std::string &desc_msg, const std::string &initial_msg) { + int ret = 0; + size_t i = 0; + static char str[64]; + unsigned short initial[128] = { 0 }; + unsigned short desc[128] = { 0 }; + + if (initial_msg.c_str()[0] != 0) { + for (i = 0; i <= initial_msg.length(); i++) + initial[i] = static_cast(initial_msg.c_str()[i]); + } + + if (desc_msg.c_str()[0] != 0) { + for (i = 0; i <= desc_msg.length(); i++) + desc[i] = static_cast(desc_msg.c_str()[i]); + } + + if (R_SUCCEEDED(ret = G2D::GetText(str, initial, desc))) + return str; + + return 0; + } + + void FontSetStyle(intraFont *font, float size, unsigned int colour, unsigned int options) { + intraFontSetStyle(font, size, colour, G2D_RGBA(0, 0, 0, 0), 0.f, options); + } + + float GetTextHeight(intraFont *font) { + return font->advancey * font->size / 4.f + 2.f; + } +} diff --git a/app/source/gui.cpp b/app/source/gui.cpp new file mode 100644 index 0000000..fb71314 --- /dev/null +++ b/app/source/gui.cpp @@ -0,0 +1,122 @@ +#include +#include +#include + +#include "config.h" +#include "colours.h" +#include "fs.h" +#include "g2d.h" +#include "gui.h" +#include "textures.h" +#include "utils.h" + +namespace GUI { + void ResetCheckbox(MenuItem *item) { + item->checked.clear(); + item->checked_copy.clear(); + item->checked.resize(item->entries.size()); + item->checked.assign(item->checked.size(), false); + item->checked_cwd.clear(); + item->checked_count = 0; + }; + + void GetStorageSize(MenuItem *item) { + item->total_storage = Utils::GetTotalStorage(); + item->used_storage = Utils::GetUsedStorage(); + } + + void DisplayStatusBar(void) { + pspTime time; + static char time_string[30]; + + if (R_SUCCEEDED(sceRtcGetCurrentClockLocalTime(&time))) + snprintf(time_string, 30, "%2i:%02i %s", ((time.hour % 12) == 0)? 12 : time.hour % 12, time.minutes, (time.hour / 12)? "PM" : "AM"); + + G2D::FontSetStyle(font, 1.0f, WHITE, INTRAFONT_ALIGN_LEFT); + intraFontPrint(font, 5, 14, time_string); + + int state = scePowerIsBatteryCharging(); + int percent = scePowerGetBatteryLifePercent(); + int battery_val = (percent / 20); + + static char percent_string[13]; + snprintf(percent_string, 13, "%d%%", percent); + int percent_width = intraFontMeasureText(font, percent_string); + intraFontPrint(font, 475 - percent_width, 14, percent_string); + + G2D::DrawImage(state != 0? battery_charging[battery_val] : battery[battery_val], 475 - percent_width - battery[battery_val]->w, 2); + } + + int RenderLoop(void) { + bool done = false; + MenuItem item; + + int ret = 0; + if (R_FAILED(ret = FS::GetDirList(cfg.cwd, item.entries))) + return ret; + + GUI::ResetCheckbox(&item); + GUI::GetStorageSize(&item); + + u64 last = 0; + u32 tick = sceRtcGetTickResolution(); + sceRtcGetCurrentTick(&last); + + Colours::Get(); + + while(!done) { + u64 current = 0; + sceRtcGetCurrentTick(¤t); + + float delta_time = (current - last) / static_cast(tick); + last = current; + + int ctrl = Utils::ReadControls(); + + g2dClear(BG_COLOUR); + G2D::DrawRect(0, 0, 480, 18, STATUS_BAR_COLOUR); + G2D::DrawRect(0, 18, 480, 34, MENU_BAR_COLOUR); + G2D::DrawImageScale(icon_nav_drawer, 5, 24, 26.f, 26.f); + GUI::DisplayStatusBar(); + GUI::DisplayFileBrowser(&item); + + switch(item.state) { + case MENU_STATE_FILEBROWSER: + GUI::ControlFileBrowser(&item, &ctrl); + break; + + case MENU_STATE_OPTIONS: + GUI::DisplayFileOptions(&item); + GUI::ControlFileOptions(&item, &ctrl); + break; + + case MENU_STATE_DELETE: + GUI::DisplayDeleteOptions(&item); + GUI::ControlDeleteOptions(&item, &ctrl); + break; + + case MENU_STATE_SETTINGS: + GUI::DisplaySettings(&item); + GUI::ControlSettings(&item, &ctrl); + break; + + case MENU_STATE_IMAGEVIEWER: + GUI::DisplayImageViewer(&item); + GUI::ControlImageViewer(&item, &delta_time); + break; + + default: + break; + } + + g2dFlip(G2D_VSYNC); + + if (Utils::IsButtonPressed(PSP_CTRL_START)) + item.state = MENU_STATE_SETTINGS; + else if (Utils::IsKButtonPressed(PSP_CTRL_HOME)) + break; + } + + return 0; + } +} diff --git a/app/source/gui/delete.cpp b/app/source/gui/delete.cpp new file mode 100644 index 0000000..fb5dbe9 --- /dev/null +++ b/app/source/gui/delete.cpp @@ -0,0 +1,87 @@ +#include "config.h" +#include "fs.h" +#include "colours.h" +#include "g2d.h" +#include "gui.h" +#include "log.h" +#include "textures.h" +#include "utils.h" + +namespace Options { + void Delete(MenuItem *item, int *selection) { + int ret = 0; + Log::CloseHandle(); + + if ((item->checked_count > 1) && (!item->checked_cwd.compare(cfg.cwd))) { + for (u32 i = 0; i < item->checked.size(); i++) { + if (item->checked.at(i)) { + if (R_FAILED(ret = FS::Delete(&item->entries[i]))) { + FS::GetDirList(cfg.cwd, item->entries); + GUI::ResetCheckbox(item); + break; + } + } + } + } + else + ret = FS::Delete(&item->entries[item->selected]); + + if (R_SUCCEEDED(ret)) { + FS::GetDirList(cfg.cwd, item->entries); + GUI::ResetCheckbox(item); + } + + GUI::GetStorageSize(item); + Log::OpenHande(); + *selection = 0; + item->selected = 0; + item->state = MENU_STATE_FILEBROWSER; + } +} + +namespace GUI { + static int selection = 0; + static const std::string prompt = "Do you wish to continue?"; + + void DisplayDeleteOptions(MenuItem *item) { + G2D::DrawRect(0, 18, 480, 254, G2D_RGBA(0, 0, 0, cfg.dark_theme? 50: 80)); + G2D::DrawImage(cfg.dark_theme? dialog_dark : dialog, ((480 - (dialog->w)) / 2), ((272 - (dialog->h)) / 2)); + G2D::FontSetStyle(font, 1.0f, TITLE_COLOUR, INTRAFONT_ALIGN_LEFT); + intraFontPrint(font, ((480 - (dialog->w)) / 2) + 10, ((272 - (dialog->h)) / 2) + 20, "Delete"); + + int prompt_width = intraFontMeasureText(font, prompt.c_str()); + G2D::FontSetStyle(font, 1.0f, TEXT_COLOUR, INTRAFONT_ALIGN_LEFT); + intraFontPrint(font, ((480 - (prompt_width)) / 2), ((272 - (dialog->h)) / 2) + 60, prompt.c_str()); + + int confirm_width = intraFontMeasureText(font, "YES"); + int cancel_width = intraFontMeasureText(font, "NO"); + + if (selection == 0) + G2D::DrawRect((364 - cancel_width) - 5, (180 - (font->texYSize - 15)) - 5, cancel_width + 10, (font->texYSize - 5) + 10, SELECTOR_COLOUR); + else + G2D::DrawRect((409 - (confirm_width)) - 5, (180 - (font->texYSize - 15)) - 5, confirm_width + 10, (font->texYSize - 5) + 10, SELECTOR_COLOUR); + + G2D::FontSetStyle(font, 1.0f, TITLE_COLOUR, INTRAFONT_ALIGN_LEFT); + intraFontPrint(font, 409 - (confirm_width), (192 - (font->texYSize - 15)) - 3, "YES"); + intraFontPrint(font, 364 - cancel_width, (192 - (font->texYSize - 15)) - 3, "NO"); + } + + void ControlDeleteOptions(MenuItem *item, int *ctrl) { + if (*ctrl & PSP_CTRL_RIGHT) + selection++; + else if (*ctrl & PSP_CTRL_LEFT) + selection--; + + if (Utils::IsButtonPressed(PSP_CTRL_ENTER)) { + if (selection == 1) + Options::Delete(item, &selection); + else + item->state = MENU_STATE_OPTIONS; + + } + else if (Utils::IsButtonPressed(PSP_CTRL_CANCEL)) + item->state = MENU_STATE_OPTIONS; + + Utils::SetBounds(&selection, 0, 1); + } +} diff --git a/app/source/gui/filebrowser.cpp b/app/source/gui/filebrowser.cpp new file mode 100644 index 0000000..5d4955a --- /dev/null +++ b/app/source/gui/filebrowser.cpp @@ -0,0 +1,148 @@ +#include +#include + +#include "config.h" +#include "fs.h" +#include "colours.h" +#include "g2d.h" +#include "gui.h" +#include "textures.h" +#include "utils.h" + +namespace GUI { + static const int sel_dist = 20; + static const int start_y = 52; + static const u32 max_entries = 11; + static int start = 0; + + // static std::string empty_dir = "This is an empty directory"; + // static float empty_dir_width = 0.f, empty_dir_height = 0.f; + + void DisplayFileBrowser(MenuItem *item) { + G2D::FontSetStyle(font, 1.0f, WHITE, INTRAFONT_ALIGN_LEFT); + float height = G2D::GetTextHeight(font); + intraFontPrint(font, 40, 36, cfg.cwd.c_str()); + G2D::DrawRect(40, 43, 400, 3, SELECTOR_COLOUR); + float fill = (static_cast(item->used_storage)/static_cast(item->total_storage)) * 400.f; + G2D::DrawRect(40, 43, fill, 3, TITLE_COLOUR); + + for (u32 i = start; i < item->entries.size(); i++) { + std::string filename = item->entries[i].d_name; + + if (i == static_cast(item->selected)) + G2D::DrawRect(0, start_y + (sel_dist * (i - start)), 480, sel_dist, SELECTOR_COLOUR); + + if ((item->checked[i]) && (!item->checked_cwd.compare(cfg.cwd))) + G2D::DrawImageScale(cfg.dark_theme? icon_check_dark : icon_check, 0, start_y + (sel_dist * (i - start)), 18.f, 18.f); + else + G2D::DrawImageScale(cfg.dark_theme? icon_uncheck_dark : icon_uncheck, 0, start_y + (sel_dist * (i - start)), 18.f, 18.f); + + FileType file_type = FS::GetFileType(filename); + if (FIO_S_ISDIR(item->entries[i].d_stat.st_mode)) + G2D::DrawImageScale(cfg.dark_theme? icon_dir_dark : icon_dir, 20, start_y + (sel_dist * (i - start)), 18.f, 18.f); + else + G2D::DrawImageScale(file_icons[file_type], 20, start_y + (sel_dist * (i - start)), 18.f, 18.f); + + G2D::FontSetStyle(font, 1.0f, cfg.dark_theme? WHITE : BLACK, INTRAFONT_ALIGN_LEFT); + intraFontPrintf(font, 45, start_y + 10 + ((sel_dist - height) / 2) + (i - start) * sel_dist, filename.length() > 52? "%.52s..." : "%s", filename.c_str()); + } + } + + void ControlFileBrowser(MenuItem *item, int *ctrl) { + u32 size = (item->entries.size() - 1); + Utils::SetBounds(&item->selected, 0, size); + + if (*ctrl & PSP_CTRL_UP) { + item->selected--; + if (item->selected < 0) + item->selected = size; + + if (size < max_entries) + start = 0; + else if (start > item->selected) + start--; + else if ((static_cast(item->selected) == size) && (size > (max_entries - 1))) + start = size - (max_entries - 1); + } + else if (*ctrl & PSP_CTRL_DOWN) { + item->selected++; + if(static_cast(item->selected) > size) + item->selected = 0; + + if ((static_cast(item->selected) > (start + (max_entries - 1))) && ((start + (max_entries - 1)) < size)) + start++; + if (item->selected == 0) + start = 0; + } + + if (Utils::IsButtonPressed(PSP_CTRL_LEFT)) { + item->selected = 0; + start = 0; + } + else if (Utils::IsButtonPressed(PSP_CTRL_RIGHT)) { + item->selected = item->entries.size() - 1; + if ((item->entries.size() - 1) > max_entries) + start = size - (max_entries - 1); + } + + if (Utils::IsButtonPressed(PSP_CTRL_ENTER)) { + if (FIO_S_ISDIR(item->entries[item->selected].d_stat.st_mode)) { + if (item->entries.size() != 0) { + if (R_SUCCEEDED(FS::ChangeDirNext(item->entries[item->selected].d_name, item->entries))) { + start = 0; + // Make a copy before resizing our vector. + if ((item->checked_count > 1) && (item->checked_copy.empty())) + item->checked_copy = item->checked; + + item->checked.resize(item->entries.size()); + item->selected = 0; + } + } + } + else { + std::string path = cfg.cwd; + path.append(item->entries[item->selected].d_name); + FileType file_type = FS::GetFileType(item->entries[item->selected].d_name); + + switch(file_type) { + case FileTypeImage: + item->texture = g2dTexLoad(path.c_str(), G2D_SWIZZLE); + if (item->texture) + item->state = MENU_STATE_IMAGEVIEWER; + break; + + // case FileTypeZip: + // if (R_SUCCEEDED(ArchiveHelper::Extract(path))) { + // FS::GetDirList(cfg.cwd, item->entries); + // GUI::ResetCheckbox(item); + // } + // break; + + default: + break; + } + } + } + else if (Utils::IsButtonPressed(PSP_CTRL_CANCEL)) { + if (R_SUCCEEDED(FS::ChangeDirPrev(item->entries))) { + // Make a copy before resizing our vector. + if (item->checked_count > 1) + item->checked_copy = item->checked; + + item->checked.resize(item->entries.size()); + item->selected = 0; + start = 0; + } + } + else if (Utils::IsButtonPressed(PSP_CTRL_SQUARE)) { + if ((!item->checked_cwd.empty()) && (item->checked_cwd.compare(cfg.cwd) != 0)) + GUI::ResetCheckbox(item); + + item->checked_cwd = cfg.cwd; + item->checked[item->selected] = !item->checked[item->selected]; + item->checked_count = std::count(item->checked.begin(), item->checked.end(), true); + } + else if (Utils::IsButtonPressed(PSP_CTRL_TRIANGLE)) + item->state = MENU_STATE_OPTIONS; + } +} diff --git a/app/source/gui/imageviewer.cpp b/app/source/gui/imageviewer.cpp new file mode 100644 index 0000000..3d0aa99 --- /dev/null +++ b/app/source/gui/imageviewer.cpp @@ -0,0 +1,125 @@ +#include "config.h" +#include "fs.h" +#include "colours.h" +#include "g2d.h" +#include "gui.h" +#include "utils.h" + +namespace ImageViewer { + static void Draw(g2dTexture *tex, float w, float h, float zoom_factor, int angle, int pos_x, int pos_y) { + g2dBeginRects(tex); { + g2dSetCoordMode(G2D_CENTER); + g2dSetScaleWH(w * zoom_factor, h * zoom_factor); + g2dSetCoordXY((G2D_SCR_W / 2) - (pos_x * zoom_factor - pos_x) / 2, (G2D_SCR_H / 2) - (pos_y * zoom_factor - pos_y) / 2); + g2dSetRotation(angle); + g2dAdd(); + } + g2dEnd(); + } +} + +namespace GUI { + static bool properties = false, horizantal_flip = false, vertical_flip = false; + static float scale_factor = 0.f, width = 0.f, height = 0.f, zoom_factor = 1.f; + static int degrees = 0, pos_x = 0, pos_y = 0; + + void DisplayImageViewer(MenuItem *item) { + g2dClear(BLACK_BG); + + if (static_cast(item->texture->h) > 272.f) { + scale_factor = (272.f / static_cast(item->texture->h)); + width = static_cast(item->texture->w) * scale_factor; + height = static_cast(item->texture->h) * scale_factor; + } + else { + width = static_cast(item->texture->w); + height = static_cast(item->texture->h); + } + + ImageViewer::Draw(item->texture, width, height, zoom_factor, degrees, pos_x, pos_y); + } + + void ControlImageViewer(MenuItem *item, float *delta_time) { + if (Utils::IsButtonPressed(PSP_CTRL_LTRIGGER)) { + degrees -= 90; + + if (degrees < 0) + degrees = 270; + } + else if (Utils::IsButtonPressed(PSP_CTRL_RTRIGGER)) { + degrees += 90; + + if (degrees > 270) + degrees = 0; + } + + // Flip horizantally + if (Utils::IsButtonPressed(PSP_CTRL_SQUARE)) { + horizantal_flip = !horizantal_flip; + width = -width; + } + + // Flip vertically + if (Utils::IsButtonPressed(PSP_CTRL_TRIANGLE)) { + vertical_flip = !vertical_flip; + height = -height; + } + + if (Utils::IsButtonHeld(PSP_CTRL_UP)) { + zoom_factor += 0.5f * (*delta_time); + + if (zoom_factor > 2.0f) + zoom_factor = 2.0f; + } + else if (Utils::IsButtonHeld(PSP_CTRL_DOWN)) { + zoom_factor -= 0.5f * (*delta_time); + + if (zoom_factor < 0.5f) + zoom_factor = 0.5f; + + if (zoom_factor <= 1.0f) { + pos_x = 0; + pos_y = 0; + } + } + + if ((height * zoom_factor > 272.f) || (width * zoom_factor > 480.f)) { + double velocity = 2.f / zoom_factor; + if (Utils::GetAnalogY() < -0.4f) + pos_y -= ((velocity * zoom_factor) * (*delta_time) * 1000.f); + if (Utils::GetAnalogY() > 0.4f) + pos_y += ((velocity * zoom_factor) * (*delta_time) * 1000.f); + if (Utils::GetAnalogX() < -0.4f) + pos_x -= ((velocity * zoom_factor) * (*delta_time) * 1000.f); + if (Utils::GetAnalogX() > 0.4f) + pos_x += ((velocity * zoom_factor) * (*delta_time) * 1000.f); + } + + if ((degrees == 0) || (degrees == 180)) { + Utils::SetMax(&pos_x, horizantal_flip? -width : width, horizantal_flip? -width : width); + Utils::SetMin(&pos_x, horizantal_flip? width : -width, horizantal_flip? width : -width); + Utils::SetMax(&pos_y, vertical_flip? -height : height, vertical_flip? -height : height); + Utils::SetMin(&pos_y, vertical_flip? height : -height, vertical_flip? height : -height); + } + else { + Utils::SetMax(&pos_x, vertical_flip? -height : height, vertical_flip? -height : height); + Utils::SetMin(&pos_x, vertical_flip? height : -height, vertical_flip? height : -height); + Utils::SetMax(&pos_y, horizantal_flip? -width : width, horizantal_flip? -width : width); + Utils::SetMin(&pos_y, horizantal_flip? width : -width, horizantal_flip? width : -width); + } + + if (Utils::IsButtonPressed(PSP_CTRL_CANCEL)) { + if (!properties) { + if (item->texture) + g2dTexFree(&item->texture); + + zoom_factor = 1.f; + pos_x = 0; + pos_y = 0; + item->state = MENU_STATE_FILEBROWSER; + } + else + properties = false; + } + } +} diff --git a/app/source/gui/options.cpp b/app/source/gui/options.cpp new file mode 100644 index 0000000..4c5aed1 --- /dev/null +++ b/app/source/gui/options.cpp @@ -0,0 +1,258 @@ +#include + +#include "config.h" +#include "fs.h" +#include "colours.h" +#include "g2d.h" +#include "gui.h" +#include "textures.h" +#include "utils.h" + +static int row = 0, column = 0; +static bool copy = false, move = false, options_more = false; + +namespace Options { + static void ResetSelector(void) { + row = 0; + column = 0; + } + + static void HandleMultipleCopy(MenuItem *item, int (*func)()) { + int ret = 0; + std::vector entries; + + if (R_FAILED(ret = FS::GetDirList(item->checked_cwd.data(), entries))) + return; + + for (u32 i = 0; i < item->checked_copy.size(); i++) { + if (item->checked_copy.at(i)) { + FS::Copy(&entries[i], item->checked_cwd); + if (R_FAILED((*func)())) { + FS::GetDirList(cfg.cwd, item->entries); + GUI::ResetCheckbox(item); + break; + } + } + } + + FS::GetDirList(cfg.cwd, item->entries); + GUI::ResetCheckbox(item); + entries.clear(); + } + + static void CreateFolder(MenuItem *item) { + std::string path = cfg.cwd; + path.append("/"); + std::string name = G2D::KeyboardGetText("Enter folder name", "New folder"); + path.append(name); + + if (R_SUCCEEDED(FS::MakeDir(path.c_str()))) { + FS::GetDirList(cfg.cwd, item->entries); + GUI::ResetCheckbox(item); + } + } + + static void CreateFile(MenuItem *item) { + std::string path = cfg.cwd; + path.append("/"); + std::string name = G2D::KeyboardGetText("Enter file name", "New File"); + path.append(name); + + if (R_SUCCEEDED(FS::CreateFile(path.c_str()))) { + FS::GetDirList(cfg.cwd, item->entries); + GUI::ResetCheckbox(item); + } + } + + static void Rename(MenuItem *item, const std::string &filename) { + std::string src_path = cfg.cwd; + src_path.append("/"); + src_path.append(item->entries[item->selected].d_name); + + std::string dest_path = cfg.cwd; + dest_path.append("/"); + std::string name = G2D::KeyboardGetText("Enter new name", filename); + dest_path.append(name); + + if (R_SUCCEEDED(sceIoRename(src_path.c_str(), dest_path.c_str()))) { + FS::GetDirList(cfg.cwd, item->entries); + Options::ResetSelector(); + options_more = false; + item->state = MENU_STATE_FILEBROWSER; + } + } + + static void Copy(MenuItem *item) { + if (!copy) { + if ((item->checked_count >= 1) && (item->checked_cwd.compare(cfg.cwd) != 0)) + GUI::ResetCheckbox(item); + if (item->checked_count <= 1) + FS::Copy(&item->entries[item->selected], cfg.cwd); + + copy = !copy; + item->state = MENU_STATE_FILEBROWSER; + } + else { + if ((item->checked_count > 1) && (item->checked_cwd.compare(cfg.cwd) != 0)) + Options::HandleMultipleCopy(item, &FS::Paste); + else { + if (R_SUCCEEDED(FS::Paste())) { + FS::GetDirList(cfg.cwd, item->entries); + GUI::ResetCheckbox(item); + } + } + + GUI::GetStorageSize(item); + copy = !copy; + item->state = MENU_STATE_FILEBROWSER; + } + } + + static void Move(MenuItem *item) { + if (!move) { + if ((item->checked_count >= 1) && (item->checked_cwd.compare(cfg.cwd) != 0)) + GUI::ResetCheckbox(item); + + if (item->checked_count <= 1) + FS::Copy(&item->entries[item->selected], cfg.cwd); + } + else { + if ((item->checked_count > 1) && (item->checked_cwd.compare(cfg.cwd) != 0)) + Options::HandleMultipleCopy(item, &FS::Move); + else if (R_SUCCEEDED(FS::Move())) { + FS::GetDirList(cfg.cwd, item->entries); + GUI::ResetCheckbox(item); + } + } + + move = !move; + item->state = MENU_STATE_FILEBROWSER; + } +} + +namespace GUI { + void DisplayFileOptions(MenuItem *item) { + G2D::DrawRect(0, 18, 480, 254, G2D_RGBA(0, 0, 0, cfg.dark_theme? 50: 80)); + G2D::DrawImage(cfg.dark_theme? options_dialog_dark : options_dialog, (480 - options_dialog->w) / 2, (272 - options_dialog->h) / 2); + G2D::FontSetStyle(font, 1.0f, TITLE_COLOUR, INTRAFONT_ALIGN_LEFT); + intraFontPrint(font, 140, 52, "Actions"); + + if (row == 0 && column == 0) + G2D::DrawRect(132, 71, 107, 38, SELECTOR_COLOUR); + else if (row == 1 && column == 0) + G2D::DrawRect(241, 71, 107, 38, SELECTOR_COLOUR); + else if (row == 0 && column == 1) + G2D::DrawRect(132, 110, 107, 38, SELECTOR_COLOUR); + else if (row == 1 && column == 1) + G2D::DrawRect(241, 110, 107, 38, SELECTOR_COLOUR); + else if (row == 0 && column == 2 && !options_more) + G2D::DrawRect(132, 148, 107, 38, SELECTOR_COLOUR); + else if (row == 1 && column == 2 && !options_more) + G2D::DrawRect(241, 148, 107, 38, SELECTOR_COLOUR); + else if (column == 3 && !options_more) + G2D::DrawRect((340 - intraFontMeasureText(font, "CANCEL")) - 5, (230 - (font->texYSize - 6)) - 5, intraFontMeasureText(font, "CANCEL") + 10, + (font->texYSize - 6) + 10, SELECTOR_COLOUR); + else if (column == 2 && options_more) + G2D::DrawRect((340 - intraFontMeasureText(font, "CANCEL")) - 5, (230 - (font->texYSize - 6)) - 5, intraFontMeasureText(font, "CANCEL") + 10, + (font->texYSize - 6) + 10, SELECTOR_COLOUR); + + intraFontPrint(font, 340 - intraFontMeasureText(font, "CANCEL"), 230 - (font->texYSize - 15), "CANCEL"); + G2D::FontSetStyle(font, 1.0f, TEXT_COLOUR, INTRAFONT_ALIGN_LEFT); + + if (!options_more) { + intraFontPrint(font, 143, 95, "Properties"); + intraFontPrint(font, 143, 133, copy? "Paste" : "Copy"); + intraFontPrint(font, 143, 171, "Delete"); + intraFontPrint(font, 247, 95, "Refresh"); + intraFontPrint(font, 247, 133, move? "Paste" : "Move"); + intraFontPrint(font, 247, 171, "More..."); + } + else { + intraFontPrint(font, 143, 95, "New folder"); + intraFontPrint(font, 143, 133, "Rename"); + intraFontPrint(font, 247, 95, "New file"); + } + } + + void ControlFileOptions(MenuItem *item, int *ctrl) { + if (*ctrl & PSP_CTRL_RIGHT) + row++; + else if (*ctrl & PSP_CTRL_LEFT) + row--; + + if (*ctrl & PSP_CTRL_DOWN) + column++; + else if (*ctrl & PSP_CTRL_UP) + column--; + + if (!options_more) { + Utils::SetBounds(&row, 0, 1); + Utils::SetBounds(&column, 0, 3); + } + else { + Utils::SetBounds(&column, 0, 2); + + if (column == 1) + Utils::SetBounds(&row, 0, 0); + else + Utils::SetBounds(&row, 0, 1); + } + + if (Utils::IsButtonPressed(PSP_CTRL_CROSS)) { + const std::string filename = item->entries[item->selected].d_name; + + if (row == 0) { + if (!options_more) { + if (column == 0) + item->state = MENU_STATE_PROPERTIES; + else if (column == 1) + Options::Copy(item); + else if (column == 2) + item->state = MENU_STATE_DELETE; + } + else { + if (column == 0) + Options::CreateFolder(item); + else if (column == 1) + Options::Rename(item, filename); + } + } + else if (row == 1) { + if (!options_more) { + if (column == 0) { + FS::GetDirList(cfg.cwd, item->entries); + Options::ResetSelector(); + options_more = false; + item->selected = 0; + item->state = MENU_STATE_FILEBROWSER; + } + else if (column == 1) + Options::Move(item); + else if (column == 2) { + Options::ResetSelector(); + options_more = true; + } + } + else { + if (column == 0) + Options::CreateFile(item); + } + } + if (column == 3) { + copy = false; + move = false; + Options::ResetSelector(); + options_more = false; + item->state = MENU_STATE_FILEBROWSER; + } + } + if (Utils::IsButtonPressed(PSP_CTRL_CANCEL)) { + Options::ResetSelector(); + + if (!options_more) + item->state = MENU_STATE_FILEBROWSER; + else + options_more = false; + } + } +} diff --git a/app/source/gui/settings.cpp b/app/source/gui/settings.cpp new file mode 100644 index 0000000..58e581c --- /dev/null +++ b/app/source/gui/settings.cpp @@ -0,0 +1,156 @@ +#include "config.h" +#include "colours.h" +#include "fs.h" +#include "g2d.h" +#include "gui.h" +#include "textures.h" +#include "utils.h" + +namespace GUI { + enum SETTINGS_STATE { + GENERAL_SETTINGS, + FTP_SETTINGS, + SORT_SETTINGS, + ABOUT_SETTINGS + }; + + static SETTINGS_STATE settings_state = GENERAL_SETTINGS; + static int selection = 0; + static const int sel_dist = 44; + + static void DisplaySortSettings(void) { + intraFontPrint(font, 40, 40, "Sorting Options"); + + G2D::FontSetStyle(font, 1.0f, cfg.dark_theme? WHITE : BLACK, INTRAFONT_ALIGN_LEFT); + intraFontPrint(font, 40, 72, "Alphabetical"); + intraFontPrint(font, 40, 86, "Sort alphabetically in ascending order."); + + intraFontPrint(font, 40, 116, "Alphabetical"); + intraFontPrint(font, 40, 130, "Sort alphabetically in descending order."); + + intraFontPrint(font, 40, 160, "Size"); + intraFontPrint(font, 40, 174, "Sort by size (largest first)."); + + intraFontPrint(font, 40, 204, "Size"); + intraFontPrint(font, 40, 218, "Sort by size (smallest first)."); + + G2D::DrawImage(cfg.sort == 0? (cfg.dark_theme? icon_radio_dark_on : icon_radio_on) : (cfg.dark_theme? icon_radio_dark_off : icon_radio_off), 425, 60); + G2D::DrawImage(cfg.sort == 1? (cfg.dark_theme? icon_radio_dark_on : icon_radio_on) : (cfg.dark_theme? icon_radio_dark_off : icon_radio_off), 425, 104); + G2D::DrawImage(cfg.sort == 2? (cfg.dark_theme? icon_radio_dark_on : icon_radio_on) : (cfg.dark_theme? icon_radio_dark_off : icon_radio_off), 425, 148); + G2D::DrawImage(cfg.sort == 3? (cfg.dark_theme? icon_radio_dark_on : icon_radio_on) : (cfg.dark_theme? icon_radio_dark_off : icon_radio_off), 425, 192); + } + + static void ControlSortSettings(MenuItem *item, int *ctrl) { + if (Utils::IsButtonPressed(PSP_CTRL_ENTER)) { + cfg.sort = selection; + Config::Save(cfg); + FS::GetDirList(cfg.cwd, item->entries); + } + else if (Utils::IsButtonPressed(PSP_CTRL_CANCEL)) { + selection = 0; + settings_state = GENERAL_SETTINGS; + } + + Utils::SetBounds(&selection, 0, 3); + } + + static void DisplayGeneralSettings(void) { + intraFontPrint(font, 40, 40, "Settings"); + + G2D::FontSetStyle(font, 1.0f, cfg.dark_theme? WHITE : BLACK, INTRAFONT_ALIGN_LEFT); + intraFontPrint(font, 40, 72, "FTP connection"); + intraFontPrint(font, 40, 86, "Wireless connection"); + + intraFontPrint(font, 40, 116, "Sorting options"); + intraFontPrint(font, 40, 130, "Select between various sorting options."); + + intraFontPrint(font, 40, 160, "Dark theme"); + intraFontPrint(font, 40, 174, "Enables dark theme mode."); + + intraFontPrint(font, 40, 204, "Developer options"); + intraFontPrint(font, 40, 218, "Enable logging and fs access to NAND."); + + intraFontPrint(font, 40, 248, "About"); + intraFontPrint(font, 40, 262, "Application and device info"); + + if (cfg.dark_theme) + G2D::DrawImage(cfg.dark_theme? icon_toggle_dark_on : icon_toggle_on, 415, 143); + else + G2D::DrawImage(icon_toggle_off, 415, 143); + + G2D::DrawImage(cfg.dev_options? (cfg.dark_theme? icon_toggle_dark_on : icon_toggle_on) : icon_toggle_off, 415, 187); + } + + static void ControlGeneralSettings(MenuItem *item, int *ctrl) { + if (Utils::IsButtonPressed(PSP_CTRL_ENTER)) { + switch(selection) { + case 1: + settings_state = SORT_SETTINGS; + selection = 0; + break; + + case 2: + cfg.dark_theme = !cfg.dark_theme; + Colours::Get(); + Config::Save(cfg); + break; + + case 3: + cfg.dev_options = !cfg.dev_options; + Config::Save(cfg); + break; + + default: + break; + } + } + else if (Utils::IsButtonPressed(PSP_CTRL_CANCEL)) { + selection = 0; + item->state = MENU_STATE_FILEBROWSER; + } + + Utils::SetBounds(&selection, 0, 4); + } + + void DisplaySettings(MenuItem *item) { + G2D::DrawRect(0, 18, 480, 34, MENU_BAR_COLOUR); + G2D::DrawRect(0, 52, 480, 220, BG_COLOUR); + G2D::DrawImage(icon_back, 5, 20); + + G2D::DrawRect(0, 52 + (selection * sel_dist), 480, sel_dist, SELECTOR_COLOUR); + G2D::FontSetStyle(font, 1.0f, WHITE, INTRAFONT_ALIGN_LEFT); + + switch(settings_state) { + case GENERAL_SETTINGS: + DisplayGeneralSettings(); + break; + + case SORT_SETTINGS: + DisplaySortSettings(); + break; + + default: + break; + } + } + + void ControlSettings(MenuItem *item, int *ctrl) { + if (*ctrl & PSP_CTRL_UP) + selection--; + else if (*ctrl & PSP_CTRL_DOWN) + selection++; + + switch(settings_state) { + case GENERAL_SETTINGS: + ControlGeneralSettings(item, ctrl); + break; + + case SORT_SETTINGS: + ControlSortSettings(item, ctrl); + break; + + default: + break; + } + } +} diff --git a/app/source/kernel_functions.cpp b/app/source/kernel_functions.cpp new file mode 100644 index 0000000..9e8c89d --- /dev/null +++ b/app/source/kernel_functions.cpp @@ -0,0 +1,27 @@ +#include "kernel_functions.h" + +// audio_driver functions +int pspAudioSetFrequency(int frequency); + +// display driver functions +int pspGetBrightness(int *brightness); +int pspSetBrightness(int brightness); +int pspDisplayEnable(void); +int pspDisplayDisable(void); + +// fs_driver functions +int pspOpenDir(const char *dirname); +int pspReadDir(SceUID dir, SceIoDirent *dirent); +int pspCloseDir(SceUID dir); + +// impose_driver functions +int pspGetVolume(void); +int pspSetVolume(int volume); +int pspGetMute(void); +int pspSetMute(int mute); +int pspGetEqualizerMode(void); +int pspSetEqualizerMode(int mode); +int pspSetHomePopup(int popup); + +// input_driver functions +unsigned int pspGetButtons(void); diff --git a/app/source/log.cpp b/app/source/log.cpp new file mode 100644 index 0000000..2b534f3 --- /dev/null +++ b/app/source/log.cpp @@ -0,0 +1,47 @@ +#include +#include +#include +#include + +#include "config.h" +#include "utils.h" + +namespace Log { + SceUID log_handle = 0; + + int OpenHande(void) { + if (R_FAILED(log_handle = sceIoOpen("debug.log", PSP_O_WRONLY | PSP_O_CREAT | PSP_O_APPEND, 0777))) + return log_handle; + + return 0; + } + + int CloseHandle(void) { + int ret = 0; + + if (R_FAILED(ret = sceIoClose(log_handle))) + return ret; + + return 0; + } + + int Error(const char *format, ...) { + if (!cfg.dev_options) + return -1; + + va_list list; + char string[512] = {0}; + + va_start(list, format); + std::vsprintf(string, format, list); + va_end(list); + + std::printf("%s", string); + + int ret = 0; + if (R_FAILED(ret = sceIoWrite(log_handle, string, std::strlen(string)))) + return ret; + + return 0; + } +} diff --git a/app/source/main.cpp b/app/source/main.cpp new file mode 100644 index 0000000..749586a --- /dev/null +++ b/app/source/main.cpp @@ -0,0 +1,64 @@ +#include +#include + +#include "config.h" +#include "g2d.h" +#include "gui.h" +#include "log.h" +#include "textures.h" +#include "utils.h" + +PSP_MODULE_INFO("CMFileManager", 0x800, VERSION_MAJOR, VERSION_MINOR); +PSP_MAIN_THREAD_ATTR(THREAD_ATTR_USER | THREAD_ATTR_VFPU); +PSP_HEAP_SIZE_MAX(); + +namespace Services { + int Init(void) { + sceCtrlSetSamplingCycle(0); + sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG); + Log::OpenHande(); + Utils::InitKernelDrivers(); + Textures::Load(); + + int ret = 0; + if (R_FAILED(ret = Config::Load())) { + Log::Error("Config::Load failed: 0x%lx\n", ret); + return ret; + } + + if (R_FAILED(ret = intraFontInit())) { + Log::Error("intraFontInit failed: 0x%lx\n", ret); + return ret; + } + + font = intraFontLoad("flash0:/font/ltn8.pgf", 0); + jpn0 = intraFontLoad("flash0:/font/jpn0.pgf", INTRAFONT_STRING_UTF8); + chn = intraFontLoad("flash0:/font/gb3s1518.bwfon", 0); + intraFontSetAltFont(font, jpn0); + intraFontSetAltFont(jpn0, chn); + intraFontSetEncoding(font, INTRAFONT_STRING_UTF8); + + Utils::IsMemCardInserted(&is_ms_inserted); + is_psp_go = Utils::IsModelPSPGo(); + + PSP_CTRL_ENTER = static_cast(Utils::GetEnterButton()); + PSP_CTRL_CANCEL = static_cast(Utils::GetCancelButton()); + return 0; + } + + void Exit(void) { + intraFontUnload(chn); + intraFontUnload(jpn0); + intraFontUnload(font); + Textures::Free(); + Log::CloseHandle(); + Utils::TermKernelDrivers(); + sceKernelExitGame(); + } +} + +int main(int argc, char* argv[]) { + Services::Init(); + GUI::RenderLoop(); + Services::Exit(); +} diff --git a/app/source/textures.cpp b/app/source/textures.cpp new file mode 100644 index 0000000..afecfc9 --- /dev/null +++ b/app/source/textures.cpp @@ -0,0 +1,156 @@ +#include "textures.h" + +extern unsigned char ic_fso_type_app_png_start[], ic_fso_type_compress_png_start[], ic_fso_type_audio_png_start[], + ic_fso_folder_png_start[], ic_fso_folder_dark_png_start[], ic_fso_default_png_start[], ic_fso_type_image_png_start[], + ic_fso_type_text_png_start[], btn_material_light_check_on_normal_png_start[], btn_material_light_check_on_normal_dark_png_start[], + btn_material_light_check_off_normal_png_start[], btn_material_light_check_off_normal_dark_png_start[], btn_material_light_toggle_on_normal_png_start[], + btn_material_light_toggle_on_normal_dark_png_start[], btn_material_light_toggle_off_normal_png_start[], btn_material_light_radio_off_normal_png_start[], + btn_material_light_radio_on_normal_png_start[], btn_material_light_radio_off_normal_dark_png_start[], btn_material_light_radio_on_normal_dark_png_start[], + ic_material_light_navigation_drawer_png_start[], ic_arrow_back_normal_png_start[], ic_material_options_dialog_png_start[], + ic_material_options_dialog_dark_png_start[], ic_material_properties_dialog_png_start[], ic_material_properties_dialog_dark_png_start[], + ic_material_dialog_png_start[], ic_material_dialog_dark_png_start[], battery_20_png_start[], battery_20_charging_png_start[], battery_30_png_start[], + battery_30_charging_png_start[], battery_50_png_start[], battery_50_charging_png_start[], battery_60_png_start[], battery_60_charging_png_start[], + battery_80_png_start[], battery_80_charging_png_start[], battery_full_png_start[], battery_full_charging_png_start[], ic_material_light_usb_png_start[], + default_artwork_png_start[], default_artwork_blur_png_start[], btn_playback_play_png_start[], btn_playback_pause_png_start[], + btn_playback_rewind_png_start[], btn_playback_forward_png_start[], btn_playback_repeat_png_start[], btn_playback_shuffle_png_start[], + btn_playback_repeat_overlay_png_start[], btn_playback_shuffle_overlay_png_start[], bg_header_png_start[], ic_material_light_sdcard_png_start[], + ic_material_light_secure_png_start[], ic_material_light_sdcard_dark_png_start[], ic_material_light_secure_dark_png_start[], ic_play_btn_png_start[]; + +extern unsigned int ic_fso_type_app_png_size, ic_fso_type_compress_png_size, ic_fso_type_audio_png_size, ic_fso_folder_png_size, + ic_fso_folder_dark_png_size, ic_fso_default_png_size, ic_fso_type_image_png_size, ic_fso_type_text_png_size, + btn_material_light_check_on_normal_png_size, btn_material_light_check_on_normal_dark_png_size, btn_material_light_check_off_normal_png_size, + btn_material_light_check_off_normal_dark_png_size, btn_material_light_toggle_on_normal_png_size, btn_material_light_toggle_on_normal_dark_png_size, + btn_material_light_toggle_off_normal_png_size, btn_material_light_radio_off_normal_png_size, btn_material_light_radio_on_normal_png_size, + btn_material_light_radio_off_normal_dark_png_size, btn_material_light_radio_on_normal_dark_png_size, ic_material_light_navigation_drawer_png_size, + ic_arrow_back_normal_png_size, ic_material_options_dialog_png_size, ic_material_options_dialog_dark_png_size, ic_material_properties_dialog_png_size, + ic_material_properties_dialog_dark_png_size, ic_material_dialog_png_size, ic_material_dialog_dark_png_size, battery_20_png_size, + battery_20_charging_png_size, battery_30_png_size, battery_30_charging_png_size, battery_50_png_size, battery_50_charging_png_size, + battery_60_png_size, battery_60_charging_png_size, battery_80_png_size, battery_80_charging_png_size, battery_full_png_size, + battery_full_charging_png_size, ic_material_light_usb_png_size, + default_artwork_png_size, default_artwork_blur_png_size, btn_playback_play_png_size, btn_playback_pause_png_size, btn_playback_rewind_png_size, + btn_playback_forward_png_size, btn_playback_repeat_png_size, btn_playback_shuffle_png_size, btn_playback_repeat_overlay_png_size, + btn_playback_shuffle_overlay_png_size, bg_header_png_size, ic_material_light_sdcard_png_size, ic_material_light_secure_png_size, + ic_material_light_sdcard_dark_png_size, ic_material_light_secure_dark_png_size, ic_play_btn_png_size; + +g2dTexture *file_icons[NUM_ICONS], *icon_dir, *icon_dir_dark, *icon_check, *icon_check_dark, *icon_uncheck, \ + *icon_uncheck_dark, *icon_toggle_on, *icon_toggle_dark_on, *icon_toggle_off, *icon_radio_off, \ + *icon_radio_on, *icon_radio_dark_off, *icon_radio_dark_on, *icon_nav_drawer, *icon_back, \ + *options_dialog, *options_dialog_dark, *properties_dialog, *properties_dialog_dark, *dialog, *dialog_dark, \ + *battery_charging[NUM_BATT_ICONS], *battery[NUM_BATT_ICONS], *usb_icon, \ + *default_artwork, *default_artwork_blur, *btn_play, *btn_pause, *btn_rewind, *btn_forward, \ + *btn_repeat, *btn_shuffle, *btn_repeat_overlay, *btn_shuffle_overlay, \ + *bg_header, *icon_sd, *icon_secure, *icon_sd_dark, *icon_secure_dark, *ic_play_btn; + +namespace Textures { + void Load(void) { + file_icons[0] = g2dTexLoadMemory(ic_fso_default_png_start, ic_fso_default_png_size, G2D_SWIZZLE); + file_icons[1] = g2dTexLoadMemory(ic_fso_type_app_png_start, ic_fso_type_app_png_size, G2D_SWIZZLE); + file_icons[2] = g2dTexLoadMemory(ic_fso_type_compress_png_start, ic_fso_type_compress_png_size, G2D_SWIZZLE); + file_icons[3] = g2dTexLoadMemory(ic_fso_type_audio_png_start, ic_fso_type_audio_png_size, G2D_SWIZZLE); + file_icons[4] = g2dTexLoadMemory(ic_fso_type_image_png_start, ic_fso_type_image_png_size, G2D_SWIZZLE); + file_icons[5] = g2dTexLoadMemory(ic_fso_type_text_png_start, ic_fso_type_text_png_size, G2D_SWIZZLE); + + icon_dir = g2dTexLoadMemory(ic_fso_folder_png_start, ic_fso_folder_png_size, G2D_SWIZZLE); + icon_dir_dark = g2dTexLoadMemory(ic_fso_folder_dark_png_start, ic_fso_folder_dark_png_size, G2D_SWIZZLE); + icon_check = g2dTexLoadMemory(btn_material_light_check_on_normal_png_start, btn_material_light_check_on_normal_png_size, G2D_SWIZZLE); + icon_check_dark = g2dTexLoadMemory(btn_material_light_check_on_normal_dark_png_start, btn_material_light_check_on_normal_dark_png_size, G2D_SWIZZLE); + icon_uncheck = g2dTexLoadMemory(btn_material_light_check_off_normal_png_start, btn_material_light_check_off_normal_png_size, G2D_SWIZZLE); + icon_uncheck_dark = g2dTexLoadMemory(btn_material_light_check_off_normal_dark_png_start, btn_material_light_check_off_normal_dark_png_size, G2D_SWIZZLE); + icon_toggle_on = g2dTexLoadMemory(btn_material_light_toggle_on_normal_png_start, btn_material_light_toggle_on_normal_png_size, G2D_SWIZZLE); + icon_toggle_dark_on = g2dTexLoadMemory(btn_material_light_toggle_on_normal_dark_png_start, btn_material_light_toggle_on_normal_dark_png_size, G2D_SWIZZLE); + icon_toggle_off = g2dTexLoadMemory(btn_material_light_toggle_off_normal_png_start, btn_material_light_toggle_off_normal_png_size, G2D_SWIZZLE); + icon_radio_off = g2dTexLoadMemory(btn_material_light_radio_off_normal_png_start, btn_material_light_radio_off_normal_png_size, G2D_SWIZZLE); + icon_radio_on = g2dTexLoadMemory(btn_material_light_radio_on_normal_png_start, btn_material_light_radio_on_normal_png_size, G2D_SWIZZLE); + icon_radio_dark_off = g2dTexLoadMemory(btn_material_light_radio_off_normal_dark_png_start, btn_material_light_radio_off_normal_dark_png_size, G2D_SWIZZLE); + icon_radio_dark_on = g2dTexLoadMemory(btn_material_light_radio_on_normal_dark_png_start, btn_material_light_radio_on_normal_dark_png_size, G2D_SWIZZLE); + icon_nav_drawer = g2dTexLoadMemory(ic_material_light_navigation_drawer_png_start, ic_material_light_navigation_drawer_png_size, G2D_SWIZZLE); + icon_back = g2dTexLoadMemory(ic_arrow_back_normal_png_start, ic_arrow_back_normal_png_size, G2D_SWIZZLE); + options_dialog = g2dTexLoadMemory(ic_material_options_dialog_png_start, ic_material_options_dialog_png_size, G2D_SWIZZLE); + options_dialog_dark = g2dTexLoadMemory(ic_material_options_dialog_dark_png_start, ic_material_options_dialog_dark_png_size, G2D_SWIZZLE); + properties_dialog = g2dTexLoadMemory(ic_material_properties_dialog_png_start, ic_material_properties_dialog_png_size, G2D_SWIZZLE); + properties_dialog_dark = g2dTexLoadMemory(ic_material_properties_dialog_dark_png_start, ic_material_properties_dialog_dark_png_size, G2D_SWIZZLE); + dialog = g2dTexLoadMemory(ic_material_dialog_png_start, ic_material_dialog_png_size, G2D_SWIZZLE); + dialog_dark = g2dTexLoadMemory(ic_material_dialog_dark_png_start, ic_material_dialog_dark_png_size, G2D_SWIZZLE); + + battery_charging[0] = g2dTexLoadMemory(battery_20_charging_png_start, battery_20_charging_png_size, G2D_SWIZZLE); + battery_charging[1] = g2dTexLoadMemory(battery_30_charging_png_start, battery_30_charging_png_size, G2D_SWIZZLE); + battery_charging[2] = g2dTexLoadMemory(battery_50_charging_png_start, battery_50_charging_png_size, G2D_SWIZZLE); + battery_charging[3] = g2dTexLoadMemory(battery_60_charging_png_start, battery_60_charging_png_size, G2D_SWIZZLE); + battery_charging[4] = g2dTexLoadMemory(battery_80_charging_png_start, battery_80_charging_png_size, G2D_SWIZZLE); + battery_charging[5] = g2dTexLoadMemory(battery_full_charging_png_start, battery_full_charging_png_size, G2D_SWIZZLE); + + battery[0] = g2dTexLoadMemory(battery_20_png_start, battery_30_png_size, G2D_SWIZZLE); + battery[1] = g2dTexLoadMemory(battery_30_png_start, battery_30_png_size, G2D_SWIZZLE); + battery[2] = g2dTexLoadMemory(battery_50_png_start, battery_50_png_size, G2D_SWIZZLE); + battery[3] = g2dTexLoadMemory(battery_60_png_start, battery_60_png_size, G2D_SWIZZLE); + battery[4] = g2dTexLoadMemory(battery_80_png_start, battery_80_png_size, G2D_SWIZZLE); + battery[5] = g2dTexLoadMemory(battery_full_png_start, battery_full_png_size, G2D_SWIZZLE); + + usb_icon = g2dTexLoadMemory(ic_material_light_usb_png_start, ic_material_light_usb_png_size, G2D_SWIZZLE); + default_artwork = g2dTexLoadMemory(default_artwork_png_start, default_artwork_png_size, G2D_SWIZZLE); + default_artwork_blur = g2dTexLoadMemory(default_artwork_blur_png_start, default_artwork_blur_png_size, G2D_SWIZZLE); + btn_play = g2dTexLoadMemory(btn_playback_play_png_start, btn_playback_play_png_size, G2D_SWIZZLE); + btn_pause = g2dTexLoadMemory(btn_playback_pause_png_start, btn_playback_pause_png_size, G2D_SWIZZLE); + btn_rewind = g2dTexLoadMemory(btn_playback_rewind_png_start, btn_playback_rewind_png_size, G2D_SWIZZLE); + btn_forward = g2dTexLoadMemory(btn_playback_forward_png_start, btn_playback_forward_png_size, G2D_SWIZZLE); + btn_repeat = g2dTexLoadMemory(btn_playback_repeat_png_start, btn_playback_repeat_png_size, G2D_SWIZZLE); + btn_shuffle = g2dTexLoadMemory(btn_playback_shuffle_png_start, btn_playback_shuffle_png_size, G2D_SWIZZLE); + btn_repeat_overlay = g2dTexLoadMemory(btn_playback_repeat_overlay_png_start, btn_playback_repeat_overlay_png_size, G2D_SWIZZLE); + btn_shuffle_overlay = g2dTexLoadMemory(btn_playback_shuffle_overlay_png_start, btn_playback_shuffle_overlay_png_size, G2D_SWIZZLE); + bg_header = g2dTexLoadMemory(bg_header_png_start, bg_header_png_size, G2D_SWIZZLE); + icon_sd = g2dTexLoadMemory(ic_material_light_sdcard_png_start, ic_material_light_sdcard_png_size, G2D_SWIZZLE); + icon_secure = g2dTexLoadMemory(ic_material_light_secure_png_start, ic_material_light_secure_png_size, G2D_SWIZZLE); + icon_sd_dark = g2dTexLoadMemory(ic_material_light_sdcard_dark_png_start, ic_material_light_sdcard_dark_png_size, G2D_SWIZZLE); + icon_secure_dark = g2dTexLoadMemory(ic_material_light_secure_dark_png_start, ic_material_light_secure_dark_png_size, G2D_SWIZZLE); + ic_play_btn = g2dTexLoadMemory(ic_play_btn_png_start, ic_play_btn_png_size, G2D_SWIZZLE); + } + + void Free(void) { + g2dTexFree(&ic_play_btn); + g2dTexFree(&icon_secure_dark); + g2dTexFree(&icon_sd_dark); + g2dTexFree(&icon_secure); + g2dTexFree(&icon_sd); + g2dTexFree(&bg_header); + g2dTexFree(&btn_shuffle_overlay); + g2dTexFree(&btn_repeat_overlay); + g2dTexFree(&btn_shuffle); + g2dTexFree(&btn_repeat); + g2dTexFree(&btn_forward); + g2dTexFree(&btn_rewind); + g2dTexFree(&btn_pause); + g2dTexFree(&btn_play); + g2dTexFree(&default_artwork_blur); + g2dTexFree(&default_artwork); + g2dTexFree(&usb_icon); + g2dTexFree(&dialog_dark); + g2dTexFree(&dialog); + g2dTexFree(&properties_dialog_dark); + g2dTexFree(&properties_dialog); + g2dTexFree(&options_dialog_dark); + g2dTexFree(&options_dialog); + g2dTexFree(&icon_back); + g2dTexFree(&icon_nav_drawer); + g2dTexFree(&icon_radio_dark_on); + g2dTexFree(&icon_radio_dark_off); + g2dTexFree(&icon_radio_on); + g2dTexFree(&icon_radio_off); + g2dTexFree(&icon_toggle_off); + g2dTexFree(&icon_toggle_dark_on); + g2dTexFree(&icon_toggle_on); + g2dTexFree(&icon_uncheck_dark); + g2dTexFree(&icon_uncheck); + g2dTexFree(&icon_check_dark); + g2dTexFree(&icon_check); + g2dTexFree(&icon_dir_dark); + g2dTexFree(&icon_dir); + + for (int i = 0; i < NUM_ICONS; i++) + g2dTexFree(&file_icons[i]); + + for (int i = 0; i < NUM_BATT_ICONS; i++) { + g2dTexFree(&battery_charging[i]); + g2dTexFree(&battery[i]); + } + } +} diff --git a/app/source/utils.cpp b/app/source/utils.cpp new file mode 100644 index 0000000..9f2298e --- /dev/null +++ b/app/source/utils.cpp @@ -0,0 +1,435 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "config.h" +#include "kernel_functions.h" +#include "kubridge.h" +#include "log.h" +#include "pspusbdevice.h" +#include "systemctrl.h" +#include "systemctrl_se.h" +#include "utils.h" + +bool psp_usb_cable_connection = false, is_ms_inserted = false, is_psp_go = false; +enum PspCtrlButtons PSP_CTRL_ENTER, PSP_CTRL_CANCEL; +BROWSE_STATE device = BROWSE_STATE_EXTERNAL; + +namespace Utils { + constexpr unsigned int CTRL_DEADZONE_DELAY = 500000; + constexpr unsigned int CTRL_DELAY = 100000; + + static SceCtrlData pad, kernel_pad, prev_pad; + static unsigned int last_button = 0; + static int last_button_tick = 0, deadzone_tick = 0; + static bool usb_module_loaded = false; + static bool usb_actived = false; + + typedef struct { + const char *path = nullptr; + int id = 0; + } Module; + + static std::vector kernel_modules { + { "audio_driver.prx", -1, }, + { "display_driver.prx", -1, }, + { "fs_driver.prx", -1, }, + { "impose_driver.prx", -1, }, + { "input_driver.prx", -1, } + }; + + static std::vector usb_modules { + { "flash0:/kd/_usbdevice.prx", -1, }, + { "flash0:/kd/semawm.prx", -1, }, + { "flash0:/kd/usbstor.prx", -1, }, + { "flash0:/kd/usbstormgr.prx", -1, }, + { "flash0:/kd/usbstorms.prx", -1, }, + { "flash0:/kd/usbstoreflash.prx", -1, }, + { "flash0:/kd/usbstorboot.prx", -1, } + }; + + typedef struct { + unsigned long maxclusters = 0; + unsigned long freeclusters = 0; + int unk1 = 0; + unsigned int sectorsize = 0; + u64 sectorcount = 0; + } SystemDevCtl; + + typedef struct { + SystemDevCtl *pdevinf; + } SystemDevCommand; + + void SetBounds(int *set, int min, int max) { + if (*set > max) + *set = min; + else if (*set < min) + *set = max; + } + + void SetMax(int *set, int value, int max) { + if (*set > max) + *set = value; + } + + void SetMin(int *set, int value, int min) { + if (*set < min) + *set = value; + } + + void GetSizeString(char *string, double size) { + int i = 0; + const char *units[] = {"B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"}; + + while (size >= 1024.0f) { + size /= 1024.0f; + i++; + } + + std::sprintf(string, "%.*f %s", (i == 0) ? 0 : 2, size, units[i]); + } + + static int LoadStartModule(const char *path) { + int ret = 0, status = 0; + SceUID modID = 0; + + if (R_FAILED(ret = modID = kuKernelLoadModule(path, 0, nullptr))) { + Log::Error("kuKernelLoadModule(%s) failed: 0x%lx\n", path, ret); + return ret; + } + + if (R_FAILED(ret = sceKernelStartModule(modID, 0, nullptr, &status, nullptr))) { + Log::Error("sceKernelStartModule(%s) failed: 0x%lx\n", path, ret); + return ret; + } + + return ret; + } + + static void StopUnloadModules(SceUID modID) { + sceKernelStopModule(modID, 0, nullptr, nullptr, nullptr); + sceKernelUnloadModule(modID); + } + + static int InitUSB(void) { + int ret = 0; + + if (!usb_module_loaded) { + for (unsigned int i = 0; i < usb_modules.size(); ++i) + usb_modules[i].id = Utils::LoadStartModule(usb_modules[i].path); + + usb_module_loaded = true; + } + + if (R_FAILED(ret = sceUsbStart(PSP_USBBUS_DRIVERNAME, 0, 0))) { + Log::Error("sceUsbStart(PSP_USBBUS_DRIVERNAME) failed: 0x%lx\n", ret); + return ret; + } + + if (R_FAILED(ret = sceUsbStart(PSP_USBSTOR_DRIVERNAME, 0, 0))) { + Log::Error("sceUsbStart(PSP_USBSTOR_DRIVERNAME) failed: 0x%lx\n", ret); + return ret; + } + + if (R_FAILED(ret = sceUsbstorBootSetCapacity(0x800000))) { + Log::Error("sceUsbstorBootSetCapacity(0x800000) failed: 0x%lx\n", ret); + return ret; + } + + usb_actived = true; + return 0; + } + + static int StartUSBStorage(void) { + int ret = 0; + + if (R_FAILED(ret = sceUsbActivate(0x1c8))) { + Log::Error("sceUsbActivate(0x1c8) failed: 0x%lx\n", ret); + return ret; + } + + psp_usb_cable_connection = true; + return 0; + } + + static int StopUSBStorage(void) { + int ret = 0; + + if (R_FAILED(ret = sceUsbDeactivate(0x1c8))) { + Log::Error("sceUsbActivate(0x1c8) failed: 0x%lx\n", ret); + return ret; + } + + if (R_FAILED(ret = sceIoDevctl("fatms0:", 0x0240D81E, nullptr, 0, nullptr, 0))) { // Avoid corrupted files + Log::Error("sceIoDevctl(\"fatms0:\", 0x0240D81E, nullptr, 0, nullptr, 0) failed: 0x%lx\n", ret); + return ret; + } + + psp_usb_cable_connection = false; + return 0; + } + + static int DisableUSB(void) { + int ret = 0; + + if (!usb_actived) + return -1; + + if (R_FAILED(ret = Utils::StopUSBStorage())) + return ret; + + if (R_FAILED(ret = sceUsbStop(PSP_USBSTOR_DRIVERNAME, 0, 0))) { + Log::Error("sceUsbStop(PSP_USBSTOR_DRIVERNAME) failed: 0x%lx\n", ret); + return ret; + } + + if (R_FAILED(ret = sceUsbStop(PSP_USBBUS_DRIVERNAME, 0, 0))) { + Log::Error("sceUsbStop(PSP_USBBUS_DRIVERNAME) failed: 0x%lx\n", ret); + return ret; + } + + if (R_FAILED(ret = pspUsbDeviceFinishDevice())) { + Log::Error("pspUsbDeviceFinishDevice() failed: 0x%lx\n", ret); + return ret; + } + + usb_actived = false; + return 0; + } + + static void ExitUSB(void) { + Utils::DisableUSB(); + + if (usb_module_loaded) { + for (int i = usb_modules.size() - 1; i >= 0; --i) { + Utils::StopUnloadModules(usb_modules[i].id); + usb_modules[i].id = -1; + } + + usb_module_loaded = false; + } + } + + void InitKernelDrivers(void) { + for (unsigned int i = 0; i < kernel_modules.size(); ++i) + kernel_modules[i].id = Utils::LoadStartModule(kernel_modules[i].path); + + Utils::InitUSB(); + } + + void TermKernelDrivers(void) { + for (int i = kernel_modules.size() - 1; i >= 0; --i) { + Utils::StopUnloadModules(kernel_modules[i].id); + kernel_modules[i].id = -1; + } + + Utils::ExitUSB(); + } + + void UpdateUSB(void) { + if (sceUsbGetState() & PSP_USB_CABLE_CONNECTED) { + if (psp_usb_cable_connection == false) + Utils::StartUSBStorage(); + } + else { + if (psp_usb_cable_connection == true) + Utils::StopUSBStorage(); + } + } + + bool IsModelPSPGo(void) { + return (kuKernelGetModel() == 4); + } + + int IsMemCardInserted(bool *is_inserted) { + int status = 0, ret = 0; + if (R_FAILED(ret = sceIoDevctl("mscmhc0:", 0x02025806, 0, 0, &status, sizeof(status)))) + return ret; + + if (status != 1) + *is_inserted = false; + else + *is_inserted = true; + + return 0; + } + + bool IsEF0(void) { + if (is_psp_go) { + if (!is_ms_inserted) + return true; + + return true; + } + + return false; + } + + int LaunchEboot(const char *path) { + int ret = 0; + struct SceKernelLoadExecVSHParam param; + std::memset(¶m, 0, sizeof(param)); + + param.size = sizeof(param); + param.args = std::strlen(path) + 1; + param.argp = (void *)path; + param.key = "game"; + + if (R_FAILED(ret = sctrlKernelLoadExecVSHWithApitype(IsEF0()? 0x152 : 0x141, path, ¶m))) { + Log::Error("sctrlKernelLoadExecVSHWithApitype(%x, %s) failed: 0x%lx\n", IsEF0()? 0x152 : 0x141, path, ret); + return ret; + } + + return 0; + } + + u64 GetTotalStorage(void) { + int ret = 0; + SystemDevCtl devctl; + SystemDevCommand command; + command.pdevinf = &devctl; + + if (R_FAILED(ret = sceIoDevctl(device == BROWSE_STATE_INTERNAL? "ef0": "ms0:", 0x02425818, &command, sizeof(SystemDevCommand), nullptr, 0))) + return 0; + + u64 size = (devctl.maxclusters * devctl.sectorcount) * devctl.sectorsize; + return size; + } + + u64 GetFreeStorage(void) { + int ret = 0; + SystemDevCtl devctl; + SystemDevCommand command; + command.pdevinf = &devctl; + + if (R_FAILED(ret = sceIoDevctl(device == BROWSE_STATE_INTERNAL? "ef0": "ms0:", 0x02425818, &command, sizeof(SystemDevCommand), nullptr, 0))) + return 0; + + u64 size = (devctl.freeclusters * devctl.sectorcount) * devctl.sectorsize; + return size; + } + + u64 GetUsedStorage(void) { + return (Utils::GetTotalStorage() - Utils::GetFreeStorage()); + } + + static int GetRegistryValue(const char *dir, const char *name, unsigned int *value) { + int ret = 0; + struct RegParam reg; + REGHANDLE h; + + std::memset(®, 0, sizeof(reg)); + reg.regtype = 1; + reg.namelen = std::strlen("/system"); + reg.unk2 = 1; + reg.unk3 = 1; + std::strcpy(reg.name, "/system"); + + if (R_SUCCEEDED(sceRegOpenRegistry(®, 2, &h))) { + REGHANDLE hd; + + if (R_SUCCEEDED(sceRegOpenCategory(h, dir, 2, &hd))) { + REGHANDLE hk; + unsigned int type, size; + + if (R_SUCCEEDED(sceRegGetKeyInfo(hd, name, &hk, &type, &size))) { + if (!sceRegGetKeyValue(hd, hk, value, 4)) { + ret = 1; + sceRegFlushCategory(hd); + } + } + + sceRegCloseCategory(hd); + } + + sceRegFlushRegistry(h); + sceRegCloseRegistry(h); + } + + return ret; + } + + int ReadControls(void) { + prev_pad = pad; + kernel_pad.Buttons = pspGetButtons(); + sceCtrlReadBufferPositive(&pad, 1); + + if (pad.Buttons == last_button) { + if (pad.TimeStamp - deadzone_tick < CTRL_DEADZONE_DELAY) + return 0; + + if (pad.TimeStamp - last_button_tick < CTRL_DELAY) + return 0; + + last_button_tick = pad.TimeStamp; + return last_button; + } + + last_button = pad.Buttons; + deadzone_tick = last_button_tick = pad.TimeStamp; + return last_button; + } + + int IsButtonPressed(enum PspCtrlButtons buttons) { + return ((pad.Buttons & buttons) == buttons) && ((prev_pad.Buttons & buttons) != buttons); + } + + int IsButtonHeld(enum PspCtrlButtons buttons) { + return pad.Buttons & buttons; + } + + int IsKButtonPressed(enum PspCtrlButtons buttons) { + return ((kernel_pad.Buttons & buttons) == buttons) && ((prev_pad.Buttons & buttons) != buttons); + } + + int IsKButtonHeld(enum PspCtrlButtons buttons) { + return kernel_pad.Buttons & buttons; + } + + int GetEnterButton(void) { + unsigned int button = 0; + + if (R_SUCCEEDED(GetRegistryValue("/CONFIG/SYSTEM/XMB", "button_assign", &button))) { + if (button == 0) + return 0x002000; // PSP_CTRL_CIRCLE + else + return 0x004000; // PSP_CTRL_CROSS + } + + return 0x004000; // By default return PSP_CTRL_CROSS + } + + // Basically the opposite of GetEnterButton() + int GetCancelButton(void) { + unsigned int button = 0; + if (R_SUCCEEDED(GetRegistryValue("/CONFIG/SYSTEM/XMB", "button_assign", &button))) { + if (button == 0) + return 0x004000; // PSP_CTRL_CROSS + else + return 0x002000; // PSP_CTRL_CIRCLE + } + + return 0x002000; // By default return PSP_CTRL_CIRCLE + } + + float GetAnalogX(void) { + return ((static_cast(pad.Lx - 122.5f)) / 122.5f); + } + + float GetAnalogY(void) { + return ((static_cast(pad.Ly - 122.5f)) / 122.5f); + } + + bool IsCancelButtonPressed(void) { + Utils::ReadControls(); + + if (Utils::IsButtonPressed(PSP_CTRL_CANCEL)) + return true; + + return false; + } +} diff --git a/audio_driver/Makefile b/audio_driver/Makefile new file mode 100644 index 0000000..28da760 --- /dev/null +++ b/audio_driver/Makefile @@ -0,0 +1,26 @@ +TARGET = audio_driver +OBJS = audio_driver.o exports.o + +PRX_EXPORTS = exports.exp + +# Use the kernel's small inbuilt libc +USE_KERNEL_LIBC = 1 +# Use only kernel libraries +USE_KERNEL_LIBS = 1 + +INCDIR = +CFLAGS = -Os -G0 -Wall -fno-builtin-printf +CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti +ASFLAGS = $(CFLAGS) + +LIBDIR = + +LDFLAGS = -nostartfiles +LIBS = -lpspaudio_driver + +PSPSDK=$(shell psp-config --pspsdk-path) +include $(PSPSDK)/lib/build_prx.mak + +all: + psp-build-exports -s $(PRX_EXPORTS) + mv audio_driver.S "../app/drivers/" diff --git a/audio_driver/audio_driver.c b/audio_driver/audio_driver.c new file mode 100644 index 0000000..e5d0d33 --- /dev/null +++ b/audio_driver/audio_driver.c @@ -0,0 +1,20 @@ +#include +#include + +PSP_MODULE_INFO("audio_driver", PSP_MODULE_KERNEL, 1, 3); +PSP_NO_CREATE_MAIN_THREAD(); + +int pspAudioSetFrequency(int frequency) { + u32 k1 = pspSdkSetK1(0); + int ret = sceAudioSetFrequency(frequency); + pspSdkSetK1(k1); + return ret; +} + +int module_start(SceSize args, void *argp) { + return 0; +} + +int module_stop(void) { + return 0; +} diff --git a/audio_driver/exports.exp b/audio_driver/exports.exp new file mode 100644 index 0000000..b171d25 --- /dev/null +++ b/audio_driver/exports.exp @@ -0,0 +1,16 @@ +# Define the exports for the prx +PSP_BEGIN_EXPORTS + +# These four lines are mandatory (although you can add other functions like module_stop) +# syslib is a psynonym for the single mandatory export. +PSP_EXPORT_START(syslib, 0, 0x8000) +PSP_EXPORT_FUNC(module_start) +PSP_EXPORT_FUNC(module_stop) +PSP_EXPORT_VAR(module_info) +PSP_EXPORT_END + +PSP_EXPORT_START(audio_driver, 0, 0x4001) +PSP_EXPORT_FUNC(pspAudioSetFrequency) +PSP_EXPORT_END + +PSP_END_EXPORTS diff --git a/display_driver/Makefile b/display_driver/Makefile new file mode 100644 index 0000000..114ee89 --- /dev/null +++ b/display_driver/Makefile @@ -0,0 +1,26 @@ +TARGET = display_driver +OBJS = display_driver.o exports.o sceDisplay_driver.o + +PRX_EXPORTS = exports.exp + +# Use the kernel's small inbuilt libc +USE_KERNEL_LIBC = 1 +# Use only kernel libraries +USE_KERNEL_LIBS = 1 + +INCDIR = +CFLAGS = -Os -G0 -Wall -fno-builtin-printf +CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti +ASFLAGS = $(CFLAGS) + +LIBDIR = + +LDFLAGS = -nostartfiles +LIBS = + +PSPSDK=$(shell psp-config --pspsdk-path) +include $(PSPSDK)/lib/build_prx.mak + +all: + psp-build-exports -s $(PRX_EXPORTS) + mv display_driver.S "../app/drivers/" diff --git a/display_driver/display_driver.c b/display_driver/display_driver.c new file mode 100644 index 0000000..3ec5360 --- /dev/null +++ b/display_driver/display_driver.c @@ -0,0 +1,59 @@ +#include +#include +#include + +PSP_MODULE_INFO("display_driver", PSP_MODULE_KERNEL, 1, 3); +PSP_NO_CREATE_MAIN_THREAD(); + +int sceDisplayEnable(void); +int sceDisplayDisable(void); +int sceDisplayEnable371(void); +int sceDisplayDisable371(void); + +int pspGetBrightness(int *brightness) { + u32 k1 = pspSdkSetK1(0); + sceDisplayGetBrightness(brightness, 0); + pspSdkSetK1(k1); + return 0; +} + +int pspSetBrightness(int brightness) { + u32 k1 = pspSdkSetK1(0); + sceDisplaySetBrightness(brightness, 0); + pspSdkSetK1(k1); + return 0; +} + +int pspDisplayEnable(void) { + u32 k1 = pspSdkSetK1(0); + + int ret = 0; + if (sceKernelDevkitVersion() < 0x03070110) + ret = sceDisplayEnable(); + else + ret = sceDisplayEnable371(); + + pspSdkSetK1(k1); + return ret; +} + +int pspDisplayDisable(void) { + u32 k1 = pspSdkSetK1(0); + + int ret = 0; + if (sceKernelDevkitVersion() < 0x03070110) + ret = sceDisplayDisable(); + else + ret = sceDisplayDisable371(); + + pspSdkSetK1(k1); + return ret; +} + +int module_start(SceSize args, void *argp) { + return 0; +} + +int module_stop(void) { + return 0; +} diff --git a/display_driver/exports.exp b/display_driver/exports.exp new file mode 100644 index 0000000..c9e3e0d --- /dev/null +++ b/display_driver/exports.exp @@ -0,0 +1,19 @@ +# Define the exports for the prx +PSP_BEGIN_EXPORTS + +# These four lines are mandatory (although you can add other functions like module_stop) +# syslib is a psynonym for the single mandatory export. +PSP_EXPORT_START(syslib, 0, 0x8000) +PSP_EXPORT_FUNC(module_start) +PSP_EXPORT_FUNC(module_stop) +PSP_EXPORT_VAR(module_info) +PSP_EXPORT_END + +PSP_EXPORT_START(display_driver, 0, 0x4001) +PSP_EXPORT_FUNC(pspGetBrightness) +PSP_EXPORT_FUNC(pspSetBrightness) +PSP_EXPORT_FUNC(pspDisplayEnable) +PSP_EXPORT_FUNC(pspDisplayDisable) +PSP_EXPORT_END + +PSP_END_EXPORTS diff --git a/display_driver/sceDisplay_driver.S b/display_driver/sceDisplay_driver.S new file mode 100644 index 0000000..5073ab6 --- /dev/null +++ b/display_driver/sceDisplay_driver.S @@ -0,0 +1,14 @@ + .set noreorder + +#include "pspimport.s" + + IMPORT_START "sceDisplay_driver",0x00010000 + IMPORT_FUNC "sceDisplay_driver",0x1CB8CB47,sceDisplayGetBrightness371 + IMPORT_FUNC "sceDisplay_driver",0x776ADFDB,sceDisplaySetBrightness371 + IMPORT_FUNC "sceDisplay_driver",0x946155FD,sceDisplayEnable371 + IMPORT_FUNC "sceDisplay_driver",0x32B67781,sceDisplayDisable371 + + IMPORT_FUNC "sceDisplay_driver",0x31C4BAA8,sceDisplayGetBrightness + IMPORT_FUNC "sceDisplay_driver",0x9E3C6DC6,sceDisplaySetBrightness + IMPORT_FUNC "sceDisplay_driver",0x432D133F,sceDisplayEnable + IMPORT_FUNC "sceDisplay_driver",0x681EE6A7,sceDisplayDisable diff --git a/fs_driver/Makefile b/fs_driver/Makefile new file mode 100644 index 0000000..99aae19 --- /dev/null +++ b/fs_driver/Makefile @@ -0,0 +1,26 @@ +TARGET = fs_driver +OBJS = fs_driver.o exports.o + +PRX_EXPORTS = exports.exp + +# Use the kernel's small inbuilt libc +USE_KERNEL_LIBC = 1 +# Use only kernel libraries +USE_KERNEL_LIBS = 1 + +INCDIR = ../libs/include +CFLAGS = -Os -G0 -Wall -fno-builtin-printf +CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti +ASFLAGS = $(CFLAGS) + +LIBDIR = ../libs/lib + +LDFLAGS = -nostartfiles +LIBS = -lpspsystemctrl_kernel + +PSPSDK=$(shell psp-config --pspsdk-path) +include $(PSPSDK)/lib/build_prx.mak + +all: + psp-build-exports -s $(PRX_EXPORTS) + mv fs_driver.S "../app/drivers/" diff --git a/fs_driver/exports.exp b/fs_driver/exports.exp new file mode 100644 index 0000000..42fc160 --- /dev/null +++ b/fs_driver/exports.exp @@ -0,0 +1,18 @@ +# Define the exports for the prx +PSP_BEGIN_EXPORTS + +# These four lines are mandatory (although you can add other functions like module_stop) +# syslib is a psynonym for the single mandatory export. +PSP_EXPORT_START(syslib, 0, 0x8000) +PSP_EXPORT_FUNC(module_start) +PSP_EXPORT_FUNC(module_stop) +PSP_EXPORT_VAR(module_info) +PSP_EXPORT_END + +PSP_EXPORT_START(fs_driver, 0, 0x4001) +PSP_EXPORT_FUNC(pspOpenDir) +PSP_EXPORT_FUNC(pspReadDir) +PSP_EXPORT_FUNC(pspCloseDir) +PSP_EXPORT_END + +PSP_END_EXPORTS diff --git a/fs_driver/fs_driver.c b/fs_driver/fs_driver.c new file mode 100644 index 0000000..bf9db60 --- /dev/null +++ b/fs_driver/fs_driver.c @@ -0,0 +1,41 @@ +#include +#include + +#include "systemctrl.h" + +PSP_MODULE_INFO("fs_driver", PSP_MODULE_KERNEL, 1, 1); +PSP_NO_CREATE_MAIN_THREAD(); + +int pspOpenDir(const char *dirname) { + u32 k1 = 0; + int oldlevel = sctrlKernelSetUserLevel(4); + k1 = pspSdkSetK1(0); + + int ret = sceIoDopen(dirname); + + pspSdkSetK1(k1); + sctrlKernelSetUserLevel(oldlevel); + return ret; +} + +int pspReadDir(SceUID dir, SceIoDirent *dirent) { + u32 k1 = pspSdkSetK1(0); + int ret = sceIoDread(dir, dirent); + pspSdkSetK1(k1); + return ret; +} + +int pspCloseDir(SceUID dir) { + u32 k1 = pspSdkSetK1(0); + int ret = sceIoDclose(dir); + pspSdkSetK1(k1); + return ret; +} + +int module_start(SceSize args, void *argp) { + return 0; +} + +int module_stop(void) { + return 0; +} diff --git a/impose_driver/Makefile b/impose_driver/Makefile new file mode 100644 index 0000000..a74c5a2 --- /dev/null +++ b/impose_driver/Makefile @@ -0,0 +1,26 @@ +TARGET = impose_driver +OBJS = impose_driver.o exports.o + +PRX_EXPORTS = exports.exp + +# Use the kernel's small inbuilt libc +USE_KERNEL_LIBC = 1 +# Use only kernel libraries +USE_KERNEL_LIBS = 1 + +INCDIR = +CFLAGS = -Os -G0 -Wall -fno-builtin-printf +CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti +ASFLAGS = $(CFLAGS) + +LIBDIR = + +LDFLAGS = -nostartfiles +LIBS = + +PSPSDK=$(shell psp-config --pspsdk-path) +include $(PSPSDK)/lib/build_prx.mak + +all: + psp-build-exports -s $(PRX_EXPORTS) + mv impose_driver.S "../app/drivers/" diff --git a/impose_driver/exports.exp b/impose_driver/exports.exp new file mode 100644 index 0000000..8686be7 --- /dev/null +++ b/impose_driver/exports.exp @@ -0,0 +1,22 @@ +# Define the exports for the prx +PSP_BEGIN_EXPORTS + +# These four lines are mandatory (although you can add other functions like module_stop) +# syslib is a psynonym for the single mandatory export. +PSP_EXPORT_START(syslib, 0, 0x8000) +PSP_EXPORT_FUNC(module_start) +PSP_EXPORT_FUNC(module_stop) +PSP_EXPORT_VAR(module_info) +PSP_EXPORT_END + +PSP_EXPORT_START(impose_driver, 0, 0x4001) +PSP_EXPORT_FUNC(pspGetVolume) +PSP_EXPORT_FUNC(pspSetVolume) +PSP_EXPORT_FUNC(pspGetMute) +PSP_EXPORT_FUNC(pspSetMute) +PSP_EXPORT_FUNC(pspGetEqualizerMode) +PSP_EXPORT_FUNC(pspSetEqualizerMode) +PSP_EXPORT_FUNC(pspSetHomePopup) +PSP_EXPORT_END + +PSP_END_EXPORTS diff --git a/impose_driver/impose_driver.c b/impose_driver/impose_driver.c new file mode 100644 index 0000000..3bceecb --- /dev/null +++ b/impose_driver/impose_driver.c @@ -0,0 +1,62 @@ +#include +#include + +PSP_MODULE_INFO("impose_driver", PSP_MODULE_KERNEL, 1, 1); +PSP_NO_CREATE_MAIN_THREAD(); + +int pspGetVolume(void) { + u32 k1 = pspSdkSetK1(0); + int ret = sceImposeGetParam(PSP_IMPOSE_MAIN_VOLUME); + pspSdkSetK1(k1); + return ret; +} + +int pspSetVolume(int volume) { + u32 k1 = pspSdkSetK1(0); + int ret = sceImposeSetParam(PSP_IMPOSE_MAIN_VOLUME, volume); + pspSdkSetK1(k1); + return ret; +} + +int pspGetMute(void) { + u32 k1 = pspSdkSetK1(0); + int ret = sceImposeGetParam(PSP_IMPOSE_MUTE); + pspSdkSetK1(k1); + return ret; +} + +int pspSetMute(int mute) { + u32 k1 = pspSdkSetK1(0); + int ret = sceImposeSetParam(PSP_IMPOSE_MUTE, mute); + pspSdkSetK1(k1); + return ret; +} + +int pspGetEqualizerMode(void) { + u32 k1 = pspSdkSetK1(0); + int ret = sceImposeGetParam(PSP_IMPOSE_EQUALIZER_MODE); + pspSdkSetK1(k1); + return ret; +} + +int pspSetEqualizerMode(int mode) { + u32 k1 = pspSdkSetK1(0); + int ret = sceImposeSetParam(PSP_IMPOSE_EQUALIZER_MODE, mode); + pspSdkSetK1(k1); + return ret; +} + +int pspSetHomePopup(int popup) { + u32 k1 = pspSdkSetK1(0); + int ret = sceImposeSetHomePopup(popup); + pspSdkSetK1(k1); + return ret; +} + +int module_start(SceSize args, void *argp) { + return 0; +} + +int module_stop(void) { + return 0; +} diff --git a/input_driver/Makefile b/input_driver/Makefile new file mode 100644 index 0000000..a87f779 --- /dev/null +++ b/input_driver/Makefile @@ -0,0 +1,26 @@ +TARGET = input_driver +OBJS = input_driver.o exports.o + +PRX_EXPORTS = exports.exp + +# Use the kernel's small inbuilt libc +USE_KERNEL_LIBC = 1 +# Use only kernel libraries +USE_KERNEL_LIBS = 1 + +INCDIR = +CFLAGS = -Os -G0 -Wall -fno-builtin-printf +CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti +ASFLAGS = $(CFLAGS) + +LIBDIR = + +LDFLAGS = -nostartfiles +LIBS = + +PSPSDK=$(shell psp-config --pspsdk-path) +include $(PSPSDK)/lib/build_prx.mak + +all: + psp-build-exports -s $(PRX_EXPORTS) + mv input_driver.S "../app/drivers/" diff --git a/input_driver/exports.exp b/input_driver/exports.exp new file mode 100644 index 0000000..6046ce9 --- /dev/null +++ b/input_driver/exports.exp @@ -0,0 +1,16 @@ +# Define the exports for the prx +PSP_BEGIN_EXPORTS + +# These four lines are mandatory (although you can add other functions like module_stop) +# syslib is a psynonym for the single mandatory export. +PSP_EXPORT_START(syslib, 0, 0x8000) +PSP_EXPORT_FUNC(module_start) +PSP_EXPORT_FUNC(module_stop) +PSP_EXPORT_VAR(module_info) +PSP_EXPORT_END + +PSP_EXPORT_START(input_driver, 0, 0x4001) +PSP_EXPORT_FUNC(pspGetButtons) +PSP_EXPORT_END + +PSP_END_EXPORTS diff --git a/input_driver/input_driver.c b/input_driver/input_driver.c new file mode 100644 index 0000000..cb569c6 --- /dev/null +++ b/input_driver/input_driver.c @@ -0,0 +1,21 @@ +#include +#include + +PSP_MODULE_INFO("input_driver", PSP_MODULE_KERNEL, 1, 1); +PSP_NO_CREATE_MAIN_THREAD(); + +unsigned int pspGetButtons(void) { + u32 k1 = pspSdkSetK1(0); + SceCtrlData pad; + sceCtrlPeekBufferPositive(&pad, 1); + pspSdkSetK1(k1); + return pad.Buttons; +} + +int module_start(SceSize args, void *argp) { + return 0; +} + +int module_stop(void) { + return 0; +} diff --git a/launcher/Makefile b/launcher/Makefile new file mode 100644 index 0000000..5545ef3 --- /dev/null +++ b/launcher/Makefile @@ -0,0 +1,31 @@ +TARGET = CMFileManager + +OBJS = source/main.o + +PSP_LARGE_MEMORY = 1 + +VERSION_MAJOR := 3 +VERSION_MINOR := 3 +VERSION_MICRO := 0 + +INCDIR = ../libs/include +CFLAGS = -Os -G0 -Wall -Werror -DVERSION_MAJOR=$(VERSION_MAJOR) -DVERSION_MINOR=$(VERSION_MINOR) -DVERSION_MICRO=$(VERSION_MICRO) +CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti +ASFLAGS := $(CFLAGS) + +LIBDIR = ../libs/lib +LDFLAGS = +LIBS = -lpspsdk -lpspsystemctrl_user + +EXTRA_TARGETS = EBOOT.PBP +PSP_EBOOT_TITLE = CM File Manager PSP v$(VERSION_MAJOR).$(VERSION_MINOR)$(VERSION_MICRO) +PSP_EBOOT_ICON = ../ICON0.PNG + +PSPSDK=$(shell psp-config --pspsdk-path) +include $(PSPSDK)/lib/build.mak + +%.o: %.png + bin2o -i $< $@ $(addsuffix _png, $(basename $(notdir $<) )) + +%.o: %.pgf + bin2o -i $< $@ $(addsuffix _pgf, $(basename $(notdir $<) )) diff --git a/launcher/source/main.c b/launcher/source/main.c new file mode 100644 index 0000000..b2cb7bb --- /dev/null +++ b/launcher/source/main.c @@ -0,0 +1,31 @@ +#include +#include +#include +#include +#include + +#include "systemctrl.h" + +PSP_MODULE_INFO("CMFileManager Launcher", PSP_MODULE_USER, VERSION_MAJOR, VERSION_MINOR); +PSP_MAIN_THREAD_ATTR(THREAD_ATTR_USER | THREAD_ATTR_VFPU); +PSP_HEAP_SIZE_MAX(); + +int main(int argc, char **argv) { + int ret = 0; + char path[264], cwd[256]; + struct SceKernelLoadExecVSHParam param; + + getcwd(cwd, 256); + snprintf(path, 264, "%s/APP.PBP", cwd); + + memset(¶m, 0, sizeof(param)); + param.size = sizeof(param); + param.key = "game"; + param.args = strlen(path + 1); + param.argp = path; + + ret = sctrlKernelLoadExecVSHWithApitype(0x141, path, ¶m); + + sceKernelExitGame(); + return ret; +} diff --git a/libs/include/FLAC/all.h b/libs/include/FLAC/all.h new file mode 100644 index 0000000..b37a68f --- /dev/null +++ b/libs/include/FLAC/all.h @@ -0,0 +1,371 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2016 Xiph.Org Foundation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * - Neither the name of the Xiph.org Foundation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FLAC__ALL_H +#define FLAC__ALL_H + +#include "export.h" + +#include "assert.h" +#include "callback.h" +#include "format.h" +#include "metadata.h" +#include "ordinals.h" +#include "stream_decoder.h" +#include "stream_encoder.h" + +/** \mainpage + * + * \section intro Introduction + * + * This is the documentation for the FLAC C and C++ APIs. It is + * highly interconnected; this introduction should give you a top + * level idea of the structure and how to find the information you + * need. As a prerequisite you should have at least a basic + * knowledge of the FLAC format, documented + * here. + * + * \section c_api FLAC C API + * + * The FLAC C API is the interface to libFLAC, a set of structures + * describing the components of FLAC streams, and functions for + * encoding and decoding streams, as well as manipulating FLAC + * metadata in files. The public include files will be installed + * in your include area (for example /usr/include/FLAC/...). + * + * By writing a little code and linking against libFLAC, it is + * relatively easy to add FLAC support to another program. The + * library is licensed under Xiph's BSD license. + * Complete source code of libFLAC as well as the command-line + * encoder and plugins is available and is a useful source of + * examples. + * + * Aside from encoders and decoders, libFLAC provides a powerful + * metadata interface for manipulating metadata in FLAC files. It + * allows the user to add, delete, and modify FLAC metadata blocks + * and it can automatically take advantage of PADDING blocks to avoid + * rewriting the entire FLAC file when changing the size of the + * metadata. + * + * libFLAC usually only requires the standard C library and C math + * library. In particular, threading is not used so there is no + * dependency on a thread library. However, libFLAC does not use + * global variables and should be thread-safe. + * + * libFLAC also supports encoding to and decoding from Ogg FLAC. + * However the metadata editing interfaces currently have limited + * read-only support for Ogg FLAC files. + * + * \section cpp_api FLAC C++ API + * + * The FLAC C++ API is a set of classes that encapsulate the + * structures and functions in libFLAC. They provide slightly more + * functionality with respect to metadata but are otherwise + * equivalent. For the most part, they share the same usage as + * their counterparts in libFLAC, and the FLAC C API documentation + * can be used as a supplement. The public include files + * for the C++ API will be installed in your include area (for + * example /usr/include/FLAC++/...). + * + * libFLAC++ is also licensed under + * Xiph's BSD license. + * + * \section getting_started Getting Started + * + * A good starting point for learning the API is to browse through + * the modules. Modules are logical + * groupings of related functions or classes, which correspond roughly + * to header files or sections of header files. Each module includes a + * detailed description of the general usage of its functions or + * classes. + * + * From there you can go on to look at the documentation of + * individual functions. You can see different views of the individual + * functions through the links in top bar across this page. + * + * If you prefer a more hands-on approach, you can jump right to some + * example code. + * + * \section porting_guide Porting Guide + * + * Starting with FLAC 1.1.3 a \link porting Porting Guide \endlink + * has been introduced which gives detailed instructions on how to + * port your code to newer versions of FLAC. + * + * \section embedded_developers Embedded Developers + * + * libFLAC has grown larger over time as more functionality has been + * included, but much of it may be unnecessary for a particular embedded + * implementation. Unused parts may be pruned by some simple editing of + * src/libFLAC/Makefile.am. In general, the decoders, encoders, and + * metadata interface are all independent from each other. + * + * It is easiest to just describe the dependencies: + * + * - All modules depend on the \link flac_format Format \endlink module. + * - The decoders and encoders depend on the bitbuffer. + * - The decoder is independent of the encoder. The encoder uses the + * decoder because of the verify feature, but this can be removed if + * not needed. + * - Parts of the metadata interface require the stream decoder (but not + * the encoder). + * - Ogg support is selectable through the compile time macro + * \c FLAC__HAS_OGG. + * + * For example, if your application only requires the stream decoder, no + * encoder, and no metadata interface, you can remove the stream encoder + * and the metadata interface, which will greatly reduce the size of the + * library. + * + * Also, there are several places in the libFLAC code with comments marked + * with "OPT:" where a #define can be changed to enable code that might be + * faster on a specific platform. Experimenting with these can yield faster + * binaries. + */ + +/** \defgroup porting Porting Guide for New Versions + * + * This module describes differences in the library interfaces from + * version to version. It assists in the porting of code that uses + * the libraries to newer versions of FLAC. + * + * One simple facility for making porting easier that has been added + * in FLAC 1.1.3 is a set of \c #defines in \c export.h of each + * library's includes (e.g. \c include/FLAC/export.h). The + * \c #defines mirror the libraries' + * libtool version numbers, + * e.g. in libFLAC there are \c FLAC_API_VERSION_CURRENT, + * \c FLAC_API_VERSION_REVISION, and \c FLAC_API_VERSION_AGE. + * These can be used to support multiple versions of an API during the + * transition phase, e.g. + * + * \code + * #if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7 + * legacy code + * #else + * new code + * #endif + * \endcode + * + * The source will work for multiple versions and the legacy code can + * easily be removed when the transition is complete. + * + * Another available symbol is FLAC_API_SUPPORTS_OGG_FLAC (defined in + * include/FLAC/export.h), which can be used to determine whether or not + * the library has been compiled with support for Ogg FLAC. This is + * simpler than trying to call an Ogg init function and catching the + * error. + */ + +/** \defgroup porting_1_1_2_to_1_1_3 Porting from FLAC 1.1.2 to 1.1.3 + * \ingroup porting + * + * \brief + * This module describes porting from FLAC 1.1.2 to FLAC 1.1.3. + * + * The main change between the APIs in 1.1.2 and 1.1.3 is that they have + * been simplified. First, libOggFLAC has been merged into libFLAC and + * libOggFLAC++ has been merged into libFLAC++. Second, both the three + * decoding layers and three encoding layers have been merged into a + * single stream decoder and stream encoder. That is, the functionality + * of FLAC__SeekableStreamDecoder and FLAC__FileDecoder has been merged + * into FLAC__StreamDecoder, and FLAC__SeekableStreamEncoder and + * FLAC__FileEncoder into FLAC__StreamEncoder. Only the + * FLAC__StreamDecoder and FLAC__StreamEncoder remain. What this means + * is there is now a single API that can be used to encode or decode + * streams to/from native FLAC or Ogg FLAC and the single API can work + * on both seekable and non-seekable streams. + * + * Instead of creating an encoder or decoder of a certain layer, now the + * client will always create a FLAC__StreamEncoder or + * FLAC__StreamDecoder. The old layers are now differentiated by the + * initialization function. For example, for the decoder, + * FLAC__stream_decoder_init() has been replaced by + * FLAC__stream_decoder_init_stream(). This init function takes + * callbacks for the I/O, and the seeking callbacks are optional. This + * allows the client to use the same object for seekable and + * non-seekable streams. For decoding a FLAC file directly, the client + * can use FLAC__stream_decoder_init_file() and pass just a filename + * and fewer callbacks; most of the other callbacks are supplied + * internally. For situations where fopen()ing by filename is not + * possible (e.g. Unicode filenames on Windows) the client can instead + * open the file itself and supply the FILE* to + * FLAC__stream_decoder_init_FILE(). The init functions now returns a + * FLAC__StreamDecoderInitStatus instead of FLAC__StreamDecoderState. + * Since the callbacks and client data are now passed to the init + * function, the FLAC__stream_decoder_set_*_callback() functions and + * FLAC__stream_decoder_set_client_data() are no longer needed. The + * rest of the calls to the decoder are the same as before. + * + * There are counterpart init functions for Ogg FLAC, e.g. + * FLAC__stream_decoder_init_ogg_stream(). All the rest of the calls + * and callbacks are the same as for native FLAC. + * + * As an example, in FLAC 1.1.2 a seekable stream decoder would have + * been set up like so: + * + * \code + * FLAC__SeekableStreamDecoder *decoder = FLAC__seekable_stream_decoder_new(); + * if(decoder == NULL) do_something; + * FLAC__seekable_stream_decoder_set_md5_checking(decoder, true); + * [... other settings ...] + * FLAC__seekable_stream_decoder_set_read_callback(decoder, my_read_callback); + * FLAC__seekable_stream_decoder_set_seek_callback(decoder, my_seek_callback); + * FLAC__seekable_stream_decoder_set_tell_callback(decoder, my_tell_callback); + * FLAC__seekable_stream_decoder_set_length_callback(decoder, my_length_callback); + * FLAC__seekable_stream_decoder_set_eof_callback(decoder, my_eof_callback); + * FLAC__seekable_stream_decoder_set_write_callback(decoder, my_write_callback); + * FLAC__seekable_stream_decoder_set_metadata_callback(decoder, my_metadata_callback); + * FLAC__seekable_stream_decoder_set_error_callback(decoder, my_error_callback); + * FLAC__seekable_stream_decoder_set_client_data(decoder, my_client_data); + * if(FLAC__seekable_stream_decoder_init(decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK) do_something; + * \endcode + * + * In FLAC 1.1.3 it is like this: + * + * \code + * FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new(); + * if(decoder == NULL) do_something; + * FLAC__stream_decoder_set_md5_checking(decoder, true); + * [... other settings ...] + * if(FLAC__stream_decoder_init_stream( + * decoder, + * my_read_callback, + * my_seek_callback, // or NULL + * my_tell_callback, // or NULL + * my_length_callback, // or NULL + * my_eof_callback, // or NULL + * my_write_callback, + * my_metadata_callback, // or NULL + * my_error_callback, + * my_client_data + * ) != FLAC__STREAM_DECODER_INIT_STATUS_OK) do_something; + * \endcode + * + * or you could do; + * + * \code + * [...] + * FILE *file = fopen("somefile.flac","rb"); + * if(file == NULL) do_somthing; + * if(FLAC__stream_decoder_init_FILE( + * decoder, + * file, + * my_write_callback, + * my_metadata_callback, // or NULL + * my_error_callback, + * my_client_data + * ) != FLAC__STREAM_DECODER_INIT_STATUS_OK) do_something; + * \endcode + * + * or just: + * + * \code + * [...] + * if(FLAC__stream_decoder_init_file( + * decoder, + * "somefile.flac", + * my_write_callback, + * my_metadata_callback, // or NULL + * my_error_callback, + * my_client_data + * ) != FLAC__STREAM_DECODER_INIT_STATUS_OK) do_something; + * \endcode + * + * Another small change to the decoder is in how it handles unparseable + * streams. Before, when the decoder found an unparseable stream + * (reserved for when the decoder encounters a stream from a future + * encoder that it can't parse), it changed the state to + * \c FLAC__STREAM_DECODER_UNPARSEABLE_STREAM. Now the decoder instead + * drops sync and calls the error callback with a new error code + * \c FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM. This is + * more robust. If your error callback does not discriminate on the the + * error state, your code does not need to be changed. + * + * The encoder now has a new setting: + * FLAC__stream_encoder_set_apodization(). This is for setting the + * method used to window the data before LPC analysis. You only need to + * add a call to this function if the default is not suitable. There + * are also two new convenience functions that may be useful: + * FLAC__metadata_object_cuesheet_calculate_cddb_id() and + * FLAC__metadata_get_cuesheet(). + * + * The \a bytes parameter to FLAC__StreamDecoderReadCallback, + * FLAC__StreamEncoderReadCallback, and FLAC__StreamEncoderWriteCallback + * is now \c size_t instead of \c uint32_t. + */ + +/** \defgroup porting_1_1_3_to_1_1_4 Porting from FLAC 1.1.3 to 1.1.4 + * \ingroup porting + * + * \brief + * This module describes porting from FLAC 1.1.3 to FLAC 1.1.4. + * + * There were no changes to any of the interfaces from 1.1.3 to 1.1.4. + * There was a slight change in the implementation of + * FLAC__stream_encoder_set_metadata(); the function now makes a copy + * of the \a metadata array of pointers so the client no longer needs + * to maintain it after the call. The objects themselves that are + * pointed to by the array are still not copied though and must be + * maintained until the call to FLAC__stream_encoder_finish(). + */ + +/** \defgroup porting_1_1_4_to_1_2_0 Porting from FLAC 1.1.4 to 1.2.0 + * \ingroup porting + * + * \brief + * This module describes porting from FLAC 1.1.4 to FLAC 1.2.0. + * + * There were only very minor changes to the interfaces from 1.1.4 to 1.2.0. + * In libFLAC, \c FLAC__format_sample_rate_is_subset() was added. + * In libFLAC++, \c FLAC::Decoder::Stream::get_decode_position() was added. + * + * Finally, value of the constant \c FLAC__FRAME_HEADER_RESERVED_LEN + * has changed to reflect the conversion of one of the reserved bits + * into active use. It used to be \c 2 and now is \c 1. However the + * FLAC frame header length has not changed, so to skip the proper + * number of bits, use \c FLAC__FRAME_HEADER_RESERVED_LEN + + * \c FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN + */ + +/** \defgroup flac FLAC C API + * + * The FLAC C API is the interface to libFLAC, a set of structures + * describing the components of FLAC streams, and functions for + * encoding and decoding streams, as well as manipulating FLAC + * metadata in files. + * + * You should start with the format components as all other modules + * are dependent on it. + */ + +#endif diff --git a/libs/include/FLAC/assert.h b/libs/include/FLAC/assert.h new file mode 100644 index 0000000..55b3477 --- /dev/null +++ b/libs/include/FLAC/assert.h @@ -0,0 +1,46 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2001-2009 Josh Coalson + * Copyright (C) 2011-2016 Xiph.Org Foundation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * - Neither the name of the Xiph.org Foundation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FLAC__ASSERT_H +#define FLAC__ASSERT_H + +/* we need this since some compilers (like MSVC) leave assert()s on release code (and we don't want to use their ASSERT) */ +#ifndef NDEBUG +#include +#define FLAC__ASSERT(x) assert(x) +#define FLAC__ASSERT_DECLARATION(x) x +#else +#define FLAC__ASSERT(x) +#define FLAC__ASSERT_DECLARATION(x) +#endif + +#endif diff --git a/libs/include/FLAC/callback.h b/libs/include/FLAC/callback.h new file mode 100644 index 0000000..38e2300 --- /dev/null +++ b/libs/include/FLAC/callback.h @@ -0,0 +1,185 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2004-2009 Josh Coalson + * Copyright (C) 2011-2016 Xiph.Org Foundation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * - Neither the name of the Xiph.org Foundation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FLAC__CALLBACK_H +#define FLAC__CALLBACK_H + +#include "ordinals.h" +#include /* for size_t */ + +/** \file include/FLAC/callback.h + * + * \brief + * This module defines the structures for describing I/O callbacks + * to the other FLAC interfaces. + * + * See the detailed documentation for callbacks in the + * \link flac_callbacks callbacks \endlink module. + */ + +/** \defgroup flac_callbacks FLAC/callback.h: I/O callback structures + * \ingroup flac + * + * \brief + * This module defines the structures for describing I/O callbacks + * to the other FLAC interfaces. + * + * The purpose of the I/O callback functions is to create a common way + * for the metadata interfaces to handle I/O. + * + * Originally the metadata interfaces required filenames as the way of + * specifying FLAC files to operate on. This is problematic in some + * environments so there is an additional option to specify a set of + * callbacks for doing I/O on the FLAC file, instead of the filename. + * + * In addition to the callbacks, a FLAC__IOHandle type is defined as an + * opaque structure for a data source. + * + * The callback function prototypes are similar (but not identical) to the + * stdio functions fread, fwrite, fseek, ftell, feof, and fclose. If you use + * stdio streams to implement the callbacks, you can pass fread, fwrite, and + * fclose anywhere a FLAC__IOCallback_Read, FLAC__IOCallback_Write, or + * FLAC__IOCallback_Close is required, and a FILE* anywhere a FLAC__IOHandle + * is required. \warning You generally CANNOT directly use fseek or ftell + * for FLAC__IOCallback_Seek or FLAC__IOCallback_Tell since on most systems + * these use 32-bit offsets and FLAC requires 64-bit offsets to deal with + * large files. You will have to find an equivalent function (e.g. ftello), + * or write a wrapper. The same is true for feof() since this is usually + * implemented as a macro, not as a function whose address can be taken. + * + * \{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** This is the opaque handle type used by the callbacks. Typically + * this is a \c FILE* or address of a file descriptor. + */ +typedef void* FLAC__IOHandle; + +/** Signature for the read callback. + * The signature and semantics match POSIX fread() implementations + * and can generally be used interchangeably. + * + * \param ptr The address of the read buffer. + * \param size The size of the records to be read. + * \param nmemb The number of records to be read. + * \param handle The handle to the data source. + * \retval size_t + * The number of records read. + */ +typedef size_t (*FLAC__IOCallback_Read) (void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle); + +/** Signature for the write callback. + * The signature and semantics match POSIX fwrite() implementations + * and can generally be used interchangeably. + * + * \param ptr The address of the write buffer. + * \param size The size of the records to be written. + * \param nmemb The number of records to be written. + * \param handle The handle to the data source. + * \retval size_t + * The number of records written. + */ +typedef size_t (*FLAC__IOCallback_Write) (const void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle); + +/** Signature for the seek callback. + * The signature and semantics mostly match POSIX fseek() WITH ONE IMPORTANT + * EXCEPTION: the offset is a 64-bit type whereas fseek() is generally 'long' + * and 32-bits wide. + * + * \param handle The handle to the data source. + * \param offset The new position, relative to \a whence + * \param whence \c SEEK_SET, \c SEEK_CUR, or \c SEEK_END + * \retval int + * \c 0 on success, \c -1 on error. + */ +typedef int (*FLAC__IOCallback_Seek) (FLAC__IOHandle handle, FLAC__int64 offset, int whence); + +/** Signature for the tell callback. + * The signature and semantics mostly match POSIX ftell() WITH ONE IMPORTANT + * EXCEPTION: the offset is a 64-bit type whereas ftell() is generally 'long' + * and 32-bits wide. + * + * \param handle The handle to the data source. + * \retval FLAC__int64 + * The current position on success, \c -1 on error. + */ +typedef FLAC__int64 (*FLAC__IOCallback_Tell) (FLAC__IOHandle handle); + +/** Signature for the EOF callback. + * The signature and semantics mostly match POSIX feof() but WATCHOUT: + * on many systems, feof() is a macro, so in this case a wrapper function + * must be provided instead. + * + * \param handle The handle to the data source. + * \retval int + * \c 0 if not at end of file, nonzero if at end of file. + */ +typedef int (*FLAC__IOCallback_Eof) (FLAC__IOHandle handle); + +/** Signature for the close callback. + * The signature and semantics match POSIX fclose() implementations + * and can generally be used interchangeably. + * + * \param handle The handle to the data source. + * \retval int + * \c 0 on success, \c EOF on error. + */ +typedef int (*FLAC__IOCallback_Close) (FLAC__IOHandle handle); + +/** A structure for holding a set of callbacks. + * Each FLAC interface that requires a FLAC__IOCallbacks structure will + * describe which of the callbacks are required. The ones that are not + * required may be set to NULL. + * + * If the seek requirement for an interface is optional, you can signify that + * a data source is not seekable by setting the \a seek field to \c NULL. + */ +typedef struct { + FLAC__IOCallback_Read read; + FLAC__IOCallback_Write write; + FLAC__IOCallback_Seek seek; + FLAC__IOCallback_Tell tell; + FLAC__IOCallback_Eof eof; + FLAC__IOCallback_Close close; +} FLAC__IOCallbacks; + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libs/include/FLAC/export.h b/libs/include/FLAC/export.h new file mode 100644 index 0000000..d52f0bb --- /dev/null +++ b/libs/include/FLAC/export.h @@ -0,0 +1,97 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2016 Xiph.Org Foundation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * - Neither the name of the Xiph.org Foundation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FLAC__EXPORT_H +#define FLAC__EXPORT_H + +/** \file include/FLAC/export.h + * + * \brief + * This module contains #defines and symbols for exporting function + * calls, and providing version information and compiled-in features. + * + * See the \link flac_export export \endlink module. + */ + +/** \defgroup flac_export FLAC/export.h: export symbols + * \ingroup flac + * + * \brief + * This module contains #defines and symbols for exporting function + * calls, and providing version information and compiled-in features. + * + * If you are compiling with MSVC and will link to the static library + * (libFLAC.lib) you should define FLAC__NO_DLL in your project to + * make sure the symbols are exported properly. + * + * \{ + */ + +#if defined(FLAC__NO_DLL) +#define FLAC_API + +#elif defined(_MSC_VER) +#ifdef FLAC_API_EXPORTS +#define FLAC_API __declspec(dllexport) +#else +#define FLAC_API __declspec(dllimport) +#endif + +#elif defined(FLAC__USE_VISIBILITY_ATTR) +#define FLAC_API __attribute__ ((visibility ("default"))) + +#else +#define FLAC_API + +#endif + +/** These #defines will mirror the libtool-based library version number, see + * http://www.gnu.org/software/libtool/manual/libtool.html#Libtool-versioning + */ +#define FLAC_API_VERSION_CURRENT 11 +#define FLAC_API_VERSION_REVISION 0 /**< see above */ +#define FLAC_API_VERSION_AGE 3 /**< see above */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** \c 1 if the library has been compiled with support for Ogg FLAC, else \c 0. */ +extern FLAC_API int FLAC_API_SUPPORTS_OGG_FLAC; + +#ifdef __cplusplus +} +#endif + +/* \} */ + +#endif diff --git a/libs/include/FLAC/format.h b/libs/include/FLAC/format.h new file mode 100644 index 0000000..769ab8a --- /dev/null +++ b/libs/include/FLAC/format.h @@ -0,0 +1,1025 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2016 Xiph.Org Foundation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * - Neither the name of the Xiph.org Foundation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FLAC__FORMAT_H +#define FLAC__FORMAT_H + +#include "export.h" +#include "ordinals.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** \file include/FLAC/format.h + * + * \brief + * This module contains structure definitions for the representation + * of FLAC format components in memory. These are the basic + * structures used by the rest of the interfaces. + * + * See the detailed documentation in the + * \link flac_format format \endlink module. + */ + +/** \defgroup flac_format FLAC/format.h: format components + * \ingroup flac + * + * \brief + * This module contains structure definitions for the representation + * of FLAC format components in memory. These are the basic + * structures used by the rest of the interfaces. + * + * First, you should be familiar with the + * FLAC format. Many of the values here + * follow directly from the specification. As a user of libFLAC, the + * interesting parts really are the structures that describe the frame + * header and metadata blocks. + * + * The format structures here are very primitive, designed to store + * information in an efficient way. Reading information from the + * structures is easy but creating or modifying them directly is + * more complex. For the most part, as a user of a library, editing + * is not necessary; however, for metadata blocks it is, so there are + * convenience functions provided in the \link flac_metadata metadata + * module \endlink to simplify the manipulation of metadata blocks. + * + * \note + * It's not the best convention, but symbols ending in _LEN are in bits + * and _LENGTH are in bytes. _LENGTH symbols are \#defines instead of + * global variables because they are usually used when declaring byte + * arrays and some compilers require compile-time knowledge of array + * sizes when declared on the stack. + * + * \{ + */ + + +/* + Most of the values described in this file are defined by the FLAC + format specification. There is nothing to tune here. +*/ + +/** The largest legal metadata type code. */ +#define FLAC__MAX_METADATA_TYPE_CODE (126u) + +/** The minimum block size, in samples, permitted by the format. */ +#define FLAC__MIN_BLOCK_SIZE (16u) + +/** The maximum block size, in samples, permitted by the format. */ +#define FLAC__MAX_BLOCK_SIZE (65535u) + +/** The maximum block size, in samples, permitted by the FLAC subset for + * sample rates up to 48kHz. */ +#define FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ (4608u) + +/** The maximum number of channels permitted by the format. */ +#define FLAC__MAX_CHANNELS (8u) + +/** The minimum sample resolution permitted by the format. */ +#define FLAC__MIN_BITS_PER_SAMPLE (4u) + +/** The maximum sample resolution permitted by the format. */ +#define FLAC__MAX_BITS_PER_SAMPLE (32u) + +/** The maximum sample resolution permitted by libFLAC. + * + * \warning + * FLAC__MAX_BITS_PER_SAMPLE is the limit of the FLAC format. However, + * the reference encoder/decoder is currently limited to 24 bits because + * of prevalent 32-bit math, so make sure and use this value when + * appropriate. + */ +#define FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE (24u) + +/** The maximum sample rate permitted by the format. The value is + * ((2 ^ 16) - 1) * 10; see FLAC format + * as to why. + */ +#define FLAC__MAX_SAMPLE_RATE (655350u) + +/** The maximum LPC order permitted by the format. */ +#define FLAC__MAX_LPC_ORDER (32u) + +/** The maximum LPC order permitted by the FLAC subset for sample rates + * up to 48kHz. */ +#define FLAC__SUBSET_MAX_LPC_ORDER_48000HZ (12u) + +/** The minimum quantized linear predictor coefficient precision + * permitted by the format. + */ +#define FLAC__MIN_QLP_COEFF_PRECISION (5u) + +/** The maximum quantized linear predictor coefficient precision + * permitted by the format. + */ +#define FLAC__MAX_QLP_COEFF_PRECISION (15u) + +/** The maximum order of the fixed predictors permitted by the format. */ +#define FLAC__MAX_FIXED_ORDER (4u) + +/** The maximum Rice partition order permitted by the format. */ +#define FLAC__MAX_RICE_PARTITION_ORDER (15u) + +/** The maximum Rice partition order permitted by the FLAC Subset. */ +#define FLAC__SUBSET_MAX_RICE_PARTITION_ORDER (8u) + +/** The version string of the release, stamped onto the libraries and binaries. + * + * \note + * This does not correspond to the shared library version number, which + * is used to determine binary compatibility. + */ +extern FLAC_API const char *FLAC__VERSION_STRING; + +/** The vendor string inserted by the encoder into the VORBIS_COMMENT block. + * This is a NUL-terminated ASCII string; when inserted into the + * VORBIS_COMMENT the trailing null is stripped. + */ +extern FLAC_API const char *FLAC__VENDOR_STRING; + +/** The byte string representation of the beginning of a FLAC stream. */ +extern FLAC_API const FLAC__byte FLAC__STREAM_SYNC_STRING[4]; /* = "fLaC" */ + +/** The 32-bit integer big-endian representation of the beginning of + * a FLAC stream. + */ +extern FLAC_API const uint32_t FLAC__STREAM_SYNC; /* = 0x664C6143 */ + +/** The length of the FLAC signature in bits. */ +extern FLAC_API const uint32_t FLAC__STREAM_SYNC_LEN; /* = 32 bits */ + +/** The length of the FLAC signature in bytes. */ +#define FLAC__STREAM_SYNC_LENGTH (4u) + + +/***************************************************************************** + * + * Subframe structures + * + *****************************************************************************/ + +/*****************************************************************************/ + +/** An enumeration of the available entropy coding methods. */ +typedef enum { + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE = 0, + /**< Residual is coded by partitioning into contexts, each with it's own + * 4-bit Rice parameter. */ + + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 = 1 + /**< Residual is coded by partitioning into contexts, each with it's own + * 5-bit Rice parameter. */ +} FLAC__EntropyCodingMethodType; + +/** Maps a FLAC__EntropyCodingMethodType to a C string. + * + * Using a FLAC__EntropyCodingMethodType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__EntropyCodingMethodTypeString[]; + + +/** Contents of a Rice partitioned residual + */ +typedef struct { + + uint32_t *parameters; + /**< The Rice parameters for each context. */ + + uint32_t *raw_bits; + /**< Widths for escape-coded partitions. Will be non-zero for escaped + * partitions and zero for unescaped partitions. + */ + + uint32_t capacity_by_order; + /**< The capacity of the \a parameters and \a raw_bits arrays + * specified as an order, i.e. the number of array elements + * allocated is 2 ^ \a capacity_by_order. + */ +} FLAC__EntropyCodingMethod_PartitionedRiceContents; + +/** Header for a Rice partitioned residual. (c.f. format specification) + */ +typedef struct { + + uint32_t order; + /**< The partition order, i.e. # of contexts = 2 ^ \a order. */ + + const FLAC__EntropyCodingMethod_PartitionedRiceContents *contents; + /**< The context's Rice parameters and/or raw bits. */ + +} FLAC__EntropyCodingMethod_PartitionedRice; + +extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; /**< == 4 (bits) */ +extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; /**< == 4 (bits) */ +extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN; /**< == 5 (bits) */ +extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN; /**< == 5 (bits) */ + +extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER; +/**< == (1<format specification) + */ +typedef struct { + FLAC__EntropyCodingMethodType type; + union { + FLAC__EntropyCodingMethod_PartitionedRice partitioned_rice; + } data; +} FLAC__EntropyCodingMethod; + +extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_TYPE_LEN; /**< == 2 (bits) */ + +/*****************************************************************************/ + +/** An enumeration of the available subframe types. */ +typedef enum { + FLAC__SUBFRAME_TYPE_CONSTANT = 0, /**< constant signal */ + FLAC__SUBFRAME_TYPE_VERBATIM = 1, /**< uncompressed signal */ + FLAC__SUBFRAME_TYPE_FIXED = 2, /**< fixed polynomial prediction */ + FLAC__SUBFRAME_TYPE_LPC = 3 /**< linear prediction */ +} FLAC__SubframeType; + +/** Maps a FLAC__SubframeType to a C string. + * + * Using a FLAC__SubframeType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__SubframeTypeString[]; + + +/** CONSTANT subframe. (c.f. format specification) + */ +typedef struct { + FLAC__int32 value; /**< The constant signal value. */ +} FLAC__Subframe_Constant; + + +/** VERBATIM subframe. (c.f. format specification) + */ +typedef struct { + const FLAC__int32 *data; /**< A pointer to verbatim signal. */ +} FLAC__Subframe_Verbatim; + + +/** FIXED subframe. (c.f. format specification) + */ +typedef struct { + FLAC__EntropyCodingMethod entropy_coding_method; + /**< The residual coding method. */ + + uint32_t order; + /**< The polynomial order. */ + + FLAC__int32 warmup[FLAC__MAX_FIXED_ORDER]; + /**< Warmup samples to prime the predictor, length == order. */ + + const FLAC__int32 *residual; + /**< The residual signal, length == (blocksize minus order) samples. */ +} FLAC__Subframe_Fixed; + + +/** LPC subframe. (c.f. format specification) + */ +typedef struct { + FLAC__EntropyCodingMethod entropy_coding_method; + /**< The residual coding method. */ + + uint32_t order; + /**< The FIR order. */ + + uint32_t qlp_coeff_precision; + /**< Quantized FIR filter coefficient precision in bits. */ + + int quantization_level; + /**< The qlp coeff shift needed. */ + + FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; + /**< FIR filter coefficients. */ + + FLAC__int32 warmup[FLAC__MAX_LPC_ORDER]; + /**< Warmup samples to prime the predictor, length == order. */ + + const FLAC__int32 *residual; + /**< The residual signal, length == (blocksize minus order) samples. */ +} FLAC__Subframe_LPC; + +extern FLAC_API const uint32_t FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN; /**< == 4 (bits) */ +extern FLAC_API const uint32_t FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN; /**< == 5 (bits) */ + + +/** FLAC subframe structure. (c.f. format specification) + */ +typedef struct { + FLAC__SubframeType type; + union { + FLAC__Subframe_Constant constant; + FLAC__Subframe_Fixed fixed; + FLAC__Subframe_LPC lpc; + FLAC__Subframe_Verbatim verbatim; + } data; + uint32_t wasted_bits; +} FLAC__Subframe; + +/** == 1 (bit) + * + * This used to be a zero-padding bit (hence the name + * FLAC__SUBFRAME_ZERO_PAD_LEN) but is now a reserved bit. It still has a + * mandatory value of \c 0 but in the future may take on the value \c 0 or \c 1 + * to mean something else. + */ +extern FLAC_API const uint32_t FLAC__SUBFRAME_ZERO_PAD_LEN; +extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_LEN; /**< == 6 (bits) */ +extern FLAC_API const uint32_t FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN; /**< == 1 (bit) */ + +extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK; /**< = 0x00 */ +extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK; /**< = 0x02 */ +extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK; /**< = 0x10 */ +extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK; /**< = 0x40 */ + +/*****************************************************************************/ + + +/***************************************************************************** + * + * Frame structures + * + *****************************************************************************/ + +/** An enumeration of the available channel assignments. */ +typedef enum { + FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT = 0, /**< independent channels */ + FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE = 1, /**< left+side stereo */ + FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE = 2, /**< right+side stereo */ + FLAC__CHANNEL_ASSIGNMENT_MID_SIDE = 3 /**< mid+side stereo */ +} FLAC__ChannelAssignment; + +/** Maps a FLAC__ChannelAssignment to a C string. + * + * Using a FLAC__ChannelAssignment as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__ChannelAssignmentString[]; + +/** An enumeration of the possible frame numbering methods. */ +typedef enum { + FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER, /**< number contains the frame number */ + FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER /**< number contains the sample number of first sample in frame */ +} FLAC__FrameNumberType; + +/** Maps a FLAC__FrameNumberType to a C string. + * + * Using a FLAC__FrameNumberType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__FrameNumberTypeString[]; + + +/** FLAC frame header structure. (c.f. format specification) + */ +typedef struct { + uint32_t blocksize; + /**< The number of samples per subframe. */ + + uint32_t sample_rate; + /**< The sample rate in Hz. */ + + uint32_t channels; + /**< The number of channels (== number of subframes). */ + + FLAC__ChannelAssignment channel_assignment; + /**< The channel assignment for the frame. */ + + uint32_t bits_per_sample; + /**< The sample resolution. */ + + FLAC__FrameNumberType number_type; + /**< The numbering scheme used for the frame. As a convenience, the + * decoder will always convert a frame number to a sample number because + * the rules are complex. */ + + union { + FLAC__uint32 frame_number; + FLAC__uint64 sample_number; + } number; + /**< The frame number or sample number of first sample in frame; + * use the \a number_type value to determine which to use. */ + + FLAC__uint8 crc; + /**< CRC-8 (polynomial = x^8 + x^2 + x^1 + x^0, initialized with 0) + * of the raw frame header bytes, meaning everything before the CRC byte + * including the sync code. + */ +} FLAC__FrameHeader; + +extern FLAC_API const uint32_t FLAC__FRAME_HEADER_SYNC; /**< == 0x3ffe; the frame header sync code */ +extern FLAC_API const uint32_t FLAC__FRAME_HEADER_SYNC_LEN; /**< == 14 (bits) */ +extern FLAC_API const uint32_t FLAC__FRAME_HEADER_RESERVED_LEN; /**< == 1 (bits) */ +extern FLAC_API const uint32_t FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN; /**< == 1 (bits) */ +extern FLAC_API const uint32_t FLAC__FRAME_HEADER_BLOCK_SIZE_LEN; /**< == 4 (bits) */ +extern FLAC_API const uint32_t FLAC__FRAME_HEADER_SAMPLE_RATE_LEN; /**< == 4 (bits) */ +extern FLAC_API const uint32_t FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN; /**< == 4 (bits) */ +extern FLAC_API const uint32_t FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN; /**< == 3 (bits) */ +extern FLAC_API const uint32_t FLAC__FRAME_HEADER_ZERO_PAD_LEN; /**< == 1 (bit) */ +extern FLAC_API const uint32_t FLAC__FRAME_HEADER_CRC_LEN; /**< == 8 (bits) */ + + +/** FLAC frame footer structure. (c.f. format specification) + */ +typedef struct { + FLAC__uint16 crc; + /**< CRC-16 (polynomial = x^16 + x^15 + x^2 + x^0, initialized with + * 0) of the bytes before the crc, back to and including the frame header + * sync code. + */ +} FLAC__FrameFooter; + +extern FLAC_API const uint32_t FLAC__FRAME_FOOTER_CRC_LEN; /**< == 16 (bits) */ + + +/** FLAC frame structure. (c.f. format specification) + */ +typedef struct { + FLAC__FrameHeader header; + FLAC__Subframe subframes[FLAC__MAX_CHANNELS]; + FLAC__FrameFooter footer; +} FLAC__Frame; + +/*****************************************************************************/ + + +/***************************************************************************** + * + * Meta-data structures + * + *****************************************************************************/ + +/** An enumeration of the available metadata block types. */ +typedef enum { + + FLAC__METADATA_TYPE_STREAMINFO = 0, + /**< STREAMINFO block */ + + FLAC__METADATA_TYPE_PADDING = 1, + /**< PADDING block */ + + FLAC__METADATA_TYPE_APPLICATION = 2, + /**< APPLICATION block */ + + FLAC__METADATA_TYPE_SEEKTABLE = 3, + /**< SEEKTABLE block */ + + FLAC__METADATA_TYPE_VORBIS_COMMENT = 4, + /**< VORBISCOMMENT block (a.k.a. FLAC tags) */ + + FLAC__METADATA_TYPE_CUESHEET = 5, + /**< CUESHEET block */ + + FLAC__METADATA_TYPE_PICTURE = 6, + /**< PICTURE block */ + + FLAC__METADATA_TYPE_UNDEFINED = 7, + /**< marker to denote beginning of undefined type range; this number will increase as new metadata types are added */ + + FLAC__MAX_METADATA_TYPE = FLAC__MAX_METADATA_TYPE_CODE, + /**< No type will ever be greater than this. There is not enough room in the protocol block. */ +} FLAC__MetadataType; + +/** Maps a FLAC__MetadataType to a C string. + * + * Using a FLAC__MetadataType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__MetadataTypeString[]; + + +/** FLAC STREAMINFO structure. (c.f. format specification) + */ +typedef struct { + uint32_t min_blocksize, max_blocksize; + uint32_t min_framesize, max_framesize; + uint32_t sample_rate; + uint32_t channels; + uint32_t bits_per_sample; + FLAC__uint64 total_samples; + FLAC__byte md5sum[16]; +} FLAC__StreamMetadata_StreamInfo; + +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN; /**< == 16 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN; /**< == 16 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN; /**< == 24 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN; /**< == 24 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN; /**< == 20 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN; /**< == 3 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN; /**< == 5 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN; /**< == 36 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN; /**< == 128 (bits) */ + +/** The total stream length of the STREAMINFO block in bytes. */ +#define FLAC__STREAM_METADATA_STREAMINFO_LENGTH (34u) + +/** FLAC PADDING structure. (c.f. format specification) + */ +typedef struct { + int dummy; + /**< Conceptually this is an empty struct since we don't store the + * padding bytes. Empty structs are not allowed by some C compilers, + * hence the dummy. + */ +} FLAC__StreamMetadata_Padding; + + +/** FLAC APPLICATION structure. (c.f. format specification) + */ +typedef struct { + FLAC__byte id[4]; + FLAC__byte *data; +} FLAC__StreamMetadata_Application; + +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_APPLICATION_ID_LEN; /**< == 32 (bits) */ + +/** SeekPoint structure used in SEEKTABLE blocks. (c.f. format specification) + */ +typedef struct { + FLAC__uint64 sample_number; + /**< The sample number of the target frame. */ + + FLAC__uint64 stream_offset; + /**< The offset, in bytes, of the target frame with respect to + * beginning of the first frame. */ + + uint32_t frame_samples; + /**< The number of samples in the target frame. */ +} FLAC__StreamMetadata_SeekPoint; + +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN; /**< == 64 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN; /**< == 64 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN; /**< == 16 (bits) */ + +/** The total stream length of a seek point in bytes. */ +#define FLAC__STREAM_METADATA_SEEKPOINT_LENGTH (18u) + +/** The value used in the \a sample_number field of + * FLAC__StreamMetadataSeekPoint used to indicate a placeholder + * point (== 0xffffffffffffffff). + */ +extern FLAC_API const FLAC__uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; + + +/** FLAC SEEKTABLE structure. (c.f. format specification) + * + * \note From the format specification: + * - The seek points must be sorted by ascending sample number. + * - Each seek point's sample number must be the first sample of the + * target frame. + * - Each seek point's sample number must be unique within the table. + * - Existence of a SEEKTABLE block implies a correct setting of + * total_samples in the stream_info block. + * - Behavior is undefined when more than one SEEKTABLE block is + * present in a stream. + */ +typedef struct { + uint32_t num_points; + FLAC__StreamMetadata_SeekPoint *points; +} FLAC__StreamMetadata_SeekTable; + + +/** Vorbis comment entry structure used in VORBIS_COMMENT blocks. (c.f. format specification) + * + * For convenience, the APIs maintain a trailing NUL character at the end of + * \a entry which is not counted toward \a length, i.e. + * \code strlen(entry) == length \endcode + */ +typedef struct { + FLAC__uint32 length; + FLAC__byte *entry; +} FLAC__StreamMetadata_VorbisComment_Entry; + +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN; /**< == 32 (bits) */ + + +/** FLAC VORBIS_COMMENT structure. (c.f. format specification) + */ +typedef struct { + FLAC__StreamMetadata_VorbisComment_Entry vendor_string; + FLAC__uint32 num_comments; + FLAC__StreamMetadata_VorbisComment_Entry *comments; +} FLAC__StreamMetadata_VorbisComment; + +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN; /**< == 32 (bits) */ + + +/** FLAC CUESHEET track index structure. (See the + * format specification for + * the full description of each field.) + */ +typedef struct { + FLAC__uint64 offset; + /**< Offset in samples, relative to the track offset, of the index + * point. + */ + + FLAC__byte number; + /**< The index point number. */ +} FLAC__StreamMetadata_CueSheet_Index; + +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN; /**< == 64 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN; /**< == 8 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN; /**< == 3*8 (bits) */ + + +/** FLAC CUESHEET track structure. (See the + * format specification for + * the full description of each field.) + */ +typedef struct { + FLAC__uint64 offset; + /**< Track offset in samples, relative to the beginning of the FLAC audio stream. */ + + FLAC__byte number; + /**< The track number. */ + + char isrc[13]; + /**< Track ISRC. This is a 12-digit alphanumeric code plus a trailing \c NUL byte */ + + uint32_t type:1; + /**< The track type: 0 for audio, 1 for non-audio. */ + + uint32_t pre_emphasis:1; + /**< The pre-emphasis flag: 0 for no pre-emphasis, 1 for pre-emphasis. */ + + FLAC__byte num_indices; + /**< The number of track index points. */ + + FLAC__StreamMetadata_CueSheet_Index *indices; + /**< NULL if num_indices == 0, else pointer to array of index points. */ + +} FLAC__StreamMetadata_CueSheet_Track; + +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN; /**< == 64 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN; /**< == 8 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN; /**< == 12*8 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN; /**< == 1 (bit) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN; /**< == 1 (bit) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN; /**< == 6+13*8 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN; /**< == 8 (bits) */ + + +/** FLAC CUESHEET structure. (See the + * format specification + * for the full description of each field.) + */ +typedef struct { + char media_catalog_number[129]; + /**< Media catalog number, in ASCII printable characters 0x20-0x7e. In + * general, the media catalog number may be 0 to 128 bytes long; any + * unused characters should be right-padded with NUL characters. + */ + + FLAC__uint64 lead_in; + /**< The number of lead-in samples. */ + + FLAC__bool is_cd; + /**< \c true if CUESHEET corresponds to a Compact Disc, else \c false. */ + + uint32_t num_tracks; + /**< The number of tracks. */ + + FLAC__StreamMetadata_CueSheet_Track *tracks; + /**< NULL if num_tracks == 0, else pointer to array of tracks. */ + +} FLAC__StreamMetadata_CueSheet; + +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN; /**< == 128*8 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN; /**< == 64 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN; /**< == 1 (bit) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN; /**< == 7+258*8 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN; /**< == 8 (bits) */ + + +/** An enumeration of the PICTURE types (see FLAC__StreamMetadataPicture and id3 v2.4 APIC tag). */ +typedef enum { + FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER = 0, /**< Other */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD = 1, /**< 32x32 pixels 'file icon' (PNG only) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON = 2, /**< Other file icon */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER = 3, /**< Cover (front) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_BACK_COVER = 4, /**< Cover (back) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_LEAFLET_PAGE = 5, /**< Leaflet page */ + FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA = 6, /**< Media (e.g. label side of CD) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_LEAD_ARTIST = 7, /**< Lead artist/lead performer/soloist */ + FLAC__STREAM_METADATA_PICTURE_TYPE_ARTIST = 8, /**< Artist/performer */ + FLAC__STREAM_METADATA_PICTURE_TYPE_CONDUCTOR = 9, /**< Conductor */ + FLAC__STREAM_METADATA_PICTURE_TYPE_BAND = 10, /**< Band/Orchestra */ + FLAC__STREAM_METADATA_PICTURE_TYPE_COMPOSER = 11, /**< Composer */ + FLAC__STREAM_METADATA_PICTURE_TYPE_LYRICIST = 12, /**< Lyricist/text writer */ + FLAC__STREAM_METADATA_PICTURE_TYPE_RECORDING_LOCATION = 13, /**< Recording Location */ + FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_RECORDING = 14, /**< During recording */ + FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_PERFORMANCE = 15, /**< During performance */ + FLAC__STREAM_METADATA_PICTURE_TYPE_VIDEO_SCREEN_CAPTURE = 16, /**< Movie/video screen capture */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FISH = 17, /**< A bright coloured fish */ + FLAC__STREAM_METADATA_PICTURE_TYPE_ILLUSTRATION = 18, /**< Illustration */ + FLAC__STREAM_METADATA_PICTURE_TYPE_BAND_LOGOTYPE = 19, /**< Band/artist logotype */ + FLAC__STREAM_METADATA_PICTURE_TYPE_PUBLISHER_LOGOTYPE = 20, /**< Publisher/Studio logotype */ + FLAC__STREAM_METADATA_PICTURE_TYPE_UNDEFINED +} FLAC__StreamMetadata_Picture_Type; + +/** Maps a FLAC__StreamMetadata_Picture_Type to a C string. + * + * Using a FLAC__StreamMetadata_Picture_Type as the index to this array + * will give the string equivalent. The contents should not be + * modified. + */ +extern FLAC_API const char * const FLAC__StreamMetadata_Picture_TypeString[]; + +/** FLAC PICTURE structure. (See the + * format specification + * for the full description of each field.) + */ +typedef struct { + FLAC__StreamMetadata_Picture_Type type; + /**< The kind of picture stored. */ + + char *mime_type; + /**< Picture data's MIME type, in ASCII printable characters + * 0x20-0x7e, NUL terminated. For best compatibility with players, + * use picture data of MIME type \c image/jpeg or \c image/png. A + * MIME type of '-->' is also allowed, in which case the picture + * data should be a complete URL. In file storage, the MIME type is + * stored as a 32-bit length followed by the ASCII string with no NUL + * terminator, but is converted to a plain C string in this structure + * for convenience. + */ + + FLAC__byte *description; + /**< Picture's description in UTF-8, NUL terminated. In file storage, + * the description is stored as a 32-bit length followed by the UTF-8 + * string with no NUL terminator, but is converted to a plain C string + * in this structure for convenience. + */ + + FLAC__uint32 width; + /**< Picture's width in pixels. */ + + FLAC__uint32 height; + /**< Picture's height in pixels. */ + + FLAC__uint32 depth; + /**< Picture's color depth in bits-per-pixel. */ + + FLAC__uint32 colors; + /**< For indexed palettes (like GIF), picture's number of colors (the + * number of palette entries), or \c 0 for non-indexed (i.e. 2^depth). + */ + + FLAC__uint32 data_length; + /**< Length of binary picture data in bytes. */ + + FLAC__byte *data; + /**< Binary picture data. */ + +} FLAC__StreamMetadata_Picture; + +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_TYPE_LEN; /**< == 32 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN; /**< == 32 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_COLORS_LEN; /**< == 32 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN; /**< == 32 (bits) */ + + +/** Structure that is used when a metadata block of unknown type is loaded. + * The contents are opaque. The structure is used only internally to + * correctly handle unknown metadata. + */ +typedef struct { + FLAC__byte *data; +} FLAC__StreamMetadata_Unknown; + + +/** FLAC metadata block structure. (c.f. format specification) + */ +typedef struct { + FLAC__MetadataType type; + /**< The type of the metadata block; used determine which member of the + * \a data union to dereference. If type >= FLAC__METADATA_TYPE_UNDEFINED + * then \a data.unknown must be used. */ + + FLAC__bool is_last; + /**< \c true if this metadata block is the last, else \a false */ + + uint32_t length; + /**< Length, in bytes, of the block data as it appears in the stream. */ + + union { + FLAC__StreamMetadata_StreamInfo stream_info; + FLAC__StreamMetadata_Padding padding; + FLAC__StreamMetadata_Application application; + FLAC__StreamMetadata_SeekTable seek_table; + FLAC__StreamMetadata_VorbisComment vorbis_comment; + FLAC__StreamMetadata_CueSheet cue_sheet; + FLAC__StreamMetadata_Picture picture; + FLAC__StreamMetadata_Unknown unknown; + } data; + /**< Polymorphic block data; use the \a type value to determine which + * to use. */ +} FLAC__StreamMetadata; + +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_IS_LAST_LEN; /**< == 1 (bit) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_TYPE_LEN; /**< == 7 (bits) */ +extern FLAC_API const uint32_t FLAC__STREAM_METADATA_LENGTH_LEN; /**< == 24 (bits) */ + +/** The total stream length of a metadata block header in bytes. */ +#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) + +/*****************************************************************************/ + + +/***************************************************************************** + * + * Utility functions + * + *****************************************************************************/ + +/** Tests that a sample rate is valid for FLAC. + * + * \param sample_rate The sample rate to test for compliance. + * \retval FLAC__bool + * \c true if the given sample rate conforms to the specification, else + * \c false. + */ +FLAC_API FLAC__bool FLAC__format_sample_rate_is_valid(uint32_t sample_rate); + +/** Tests that a blocksize at the given sample rate is valid for the FLAC + * subset. + * + * \param blocksize The blocksize to test for compliance. + * \param sample_rate The sample rate is needed, since the valid subset + * blocksize depends on the sample rate. + * \retval FLAC__bool + * \c true if the given blocksize conforms to the specification for the + * subset at the given sample rate, else \c false. + */ +FLAC_API FLAC__bool FLAC__format_blocksize_is_subset(uint32_t blocksize, uint32_t sample_rate); + +/** Tests that a sample rate is valid for the FLAC subset. The subset rules + * for valid sample rates are slightly more complex since the rate has to + * be expressible completely in the frame header. + * + * \param sample_rate The sample rate to test for compliance. + * \retval FLAC__bool + * \c true if the given sample rate conforms to the specification for the + * subset, else \c false. + */ +FLAC_API FLAC__bool FLAC__format_sample_rate_is_subset(uint32_t sample_rate); + +/** Check a Vorbis comment entry name to see if it conforms to the Vorbis + * comment specification. + * + * Vorbis comment names must be composed only of characters from + * [0x20-0x3C,0x3E-0x7D]. + * + * \param name A NUL-terminated string to be checked. + * \assert + * \code name != NULL \endcode + * \retval FLAC__bool + * \c false if entry name is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_name_is_legal(const char *name); + +/** Check a Vorbis comment entry value to see if it conforms to the Vorbis + * comment specification. + * + * Vorbis comment values must be valid UTF-8 sequences. + * + * \param value A string to be checked. + * \param length A the length of \a value in bytes. May be + * \c (uint32_t)(-1) to indicate that \a value is a plain + * UTF-8 NUL-terminated string. + * \assert + * \code value != NULL \endcode + * \retval FLAC__bool + * \c false if entry name is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_value_is_legal(const FLAC__byte *value, uint32_t length); + +/** Check a Vorbis comment entry to see if it conforms to the Vorbis + * comment specification. + * + * Vorbis comment entries must be of the form 'name=value', and 'name' and + * 'value' must be legal according to + * FLAC__format_vorbiscomment_entry_name_is_legal() and + * FLAC__format_vorbiscomment_entry_value_is_legal() respectively. + * + * \param entry An entry to be checked. + * \param length The length of \a entry in bytes. + * \assert + * \code value != NULL \endcode + * \retval FLAC__bool + * \c false if entry name is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_is_legal(const FLAC__byte *entry, uint32_t length); + +/** Check a seek table to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * seek table. + * + * \param seek_table A pointer to a seek table to be checked. + * \assert + * \code seek_table != NULL \endcode + * \retval FLAC__bool + * \c false if seek table is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_seektable_is_legal(const FLAC__StreamMetadata_SeekTable *seek_table); + +/** Sort a seek table's seek points according to the format specification. + * This includes a "unique-ification" step to remove duplicates, i.e. + * seek points with identical \a sample_number values. Duplicate seek + * points are converted into placeholder points and sorted to the end of + * the table. + * + * \param seek_table A pointer to a seek table to be sorted. + * \assert + * \code seek_table != NULL \endcode + * \retval uint32_t + * The number of duplicate seek points converted into placeholders. + */ +FLAC_API uint32_t FLAC__format_seektable_sort(FLAC__StreamMetadata_SeekTable *seek_table); + +/** Check a cue sheet to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * cue sheet. + * + * \param cue_sheet A pointer to an existing cue sheet to be checked. + * \param check_cd_da_subset If \c true, check CUESHEET against more + * stringent requirements for a CD-DA (audio) disc. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code cue_sheet != NULL \endcode + * \retval FLAC__bool + * \c false if cue sheet is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_cuesheet_is_legal(const FLAC__StreamMetadata_CueSheet *cue_sheet, FLAC__bool check_cd_da_subset, const char **violation); + +/** Check picture data to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * PICTURE block. + * + * \param picture A pointer to existing picture data to be checked. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code picture != NULL \endcode + * \retval FLAC__bool + * \c false if picture data is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_picture_is_legal(const FLAC__StreamMetadata_Picture *picture, const char **violation); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libs/include/FLAC/metadata.h b/libs/include/FLAC/metadata.h new file mode 100644 index 0000000..4c67b87 --- /dev/null +++ b/libs/include/FLAC/metadata.h @@ -0,0 +1,2182 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2001-2009 Josh Coalson + * Copyright (C) 2011-2016 Xiph.Org Foundation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * - Neither the name of the Xiph.org Foundation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FLAC__METADATA_H +#define FLAC__METADATA_H + +#include /* for off_t */ +#include "export.h" +#include "callback.h" +#include "format.h" + +/* -------------------------------------------------------------------- + (For an example of how all these routines are used, see the source + code for the unit tests in src/test_libFLAC/metadata_*.c, or + metaflac in src/metaflac/) + ------------------------------------------------------------------*/ + +/** \file include/FLAC/metadata.h + * + * \brief + * This module provides functions for creating and manipulating FLAC + * metadata blocks in memory, and three progressively more powerful + * interfaces for traversing and editing metadata in FLAC files. + * + * See the detailed documentation for each interface in the + * \link flac_metadata metadata \endlink module. + */ + +/** \defgroup flac_metadata FLAC/metadata.h: metadata interfaces + * \ingroup flac + * + * \brief + * This module provides functions for creating and manipulating FLAC + * metadata blocks in memory, and three progressively more powerful + * interfaces for traversing and editing metadata in native FLAC files. + * Note that currently only the Chain interface (level 2) supports Ogg + * FLAC files, and it is read-only i.e. no writing back changed + * metadata to file. + * + * There are three metadata interfaces of increasing complexity: + * + * Level 0: + * Read-only access to the STREAMINFO, VORBIS_COMMENT, CUESHEET, and + * PICTURE blocks. + * + * Level 1: + * Read-write access to all metadata blocks. This level is write- + * efficient in most cases (more on this below), and uses less memory + * than level 2. + * + * Level 2: + * Read-write access to all metadata blocks. This level is write- + * efficient in all cases, but uses more memory since all metadata for + * the whole file is read into memory and manipulated before writing + * out again. + * + * What do we mean by efficient? Since FLAC metadata appears at the + * beginning of the file, when writing metadata back to a FLAC file + * it is possible to grow or shrink the metadata such that the entire + * file must be rewritten. However, if the size remains the same during + * changes or PADDING blocks are utilized, only the metadata needs to be + * overwritten, which is much faster. + * + * Efficient means the whole file is rewritten at most one time, and only + * when necessary. Level 1 is not efficient only in the case that you + * cause more than one metadata block to grow or shrink beyond what can + * be accommodated by padding. In this case you should probably use level + * 2, which allows you to edit all the metadata for a file in memory and + * write it out all at once. + * + * All levels know how to skip over and not disturb an ID3v2 tag at the + * front of the file. + * + * All levels access files via their filenames. In addition, level 2 + * has additional alternative read and write functions that take an I/O + * handle and callbacks, for situations where access by filename is not + * possible. + * + * In addition to the three interfaces, this module defines functions for + * creating and manipulating various metadata objects in memory. As we see + * from the Format module, FLAC metadata blocks in memory are very primitive + * structures for storing information in an efficient way. Reading + * information from the structures is easy but creating or modifying them + * directly is more complex. The metadata object routines here facilitate + * this by taking care of the consistency and memory management drudgery. + * + * Unless you will be using the level 1 or 2 interfaces to modify existing + * metadata however, you will not probably not need these. + * + * From a dependency standpoint, none of the encoders or decoders require + * the metadata module. This is so that embedded users can strip out the + * metadata module from libFLAC to reduce the size and complexity. + */ + +#ifdef __cplusplus +extern "C" { +#endif + + +/** \defgroup flac_metadata_level0 FLAC/metadata.h: metadata level 0 interface + * \ingroup flac_metadata + * + * \brief + * The level 0 interface consists of individual routines to read the + * STREAMINFO, VORBIS_COMMENT, CUESHEET, and PICTURE blocks, requiring + * only a filename. + * + * They try to skip any ID3v2 tag at the head of the file. + * + * \{ + */ + +/** Read the STREAMINFO metadata block of the given FLAC file. This function + * will try to skip any ID3v2 tag at the head of the file. + * + * \param filename The path to the FLAC file to read. + * \param streaminfo A pointer to space for the STREAMINFO block. Since + * FLAC__StreamMetadata is a simple structure with no + * memory allocation involved, you pass the address of + * an existing structure. It need not be initialized. + * \assert + * \code filename != NULL \endcode + * \code streaminfo != NULL \endcode + * \retval FLAC__bool + * \c true if a valid STREAMINFO block was read from \a filename. Returns + * \c false if there was a memory allocation error, a file decoder error, + * or the file contained no STREAMINFO block. (A memory allocation error + * is possible because this function must set up a file decoder.) + */ +FLAC_API FLAC__bool FLAC__metadata_get_streaminfo(const char *filename, FLAC__StreamMetadata *streaminfo); + +/** Read the VORBIS_COMMENT metadata block of the given FLAC file. This + * function will try to skip any ID3v2 tag at the head of the file. + * + * \param filename The path to the FLAC file to read. + * \param tags The address where the returned pointer will be + * stored. The \a tags object must be deleted by + * the caller using FLAC__metadata_object_delete(). + * \assert + * \code filename != NULL \endcode + * \code tags != NULL \endcode + * \retval FLAC__bool + * \c true if a valid VORBIS_COMMENT block was read from \a filename, + * and \a *tags will be set to the address of the metadata structure. + * Returns \c false if there was a memory allocation error, a file + * decoder error, or the file contained no VORBIS_COMMENT block, and + * \a *tags will be set to \c NULL. + */ +FLAC_API FLAC__bool FLAC__metadata_get_tags(const char *filename, FLAC__StreamMetadata **tags); + +/** Read the CUESHEET metadata block of the given FLAC file. This + * function will try to skip any ID3v2 tag at the head of the file. + * + * \param filename The path to the FLAC file to read. + * \param cuesheet The address where the returned pointer will be + * stored. The \a cuesheet object must be deleted by + * the caller using FLAC__metadata_object_delete(). + * \assert + * \code filename != NULL \endcode + * \code cuesheet != NULL \endcode + * \retval FLAC__bool + * \c true if a valid CUESHEET block was read from \a filename, + * and \a *cuesheet will be set to the address of the metadata + * structure. Returns \c false if there was a memory allocation + * error, a file decoder error, or the file contained no CUESHEET + * block, and \a *cuesheet will be set to \c NULL. + */ +FLAC_API FLAC__bool FLAC__metadata_get_cuesheet(const char *filename, FLAC__StreamMetadata **cuesheet); + +/** Read a PICTURE metadata block of the given FLAC file. This + * function will try to skip any ID3v2 tag at the head of the file. + * Since there can be more than one PICTURE block in a file, this + * function takes a number of parameters that act as constraints to + * the search. The PICTURE block with the largest area matching all + * the constraints will be returned, or \a *picture will be set to + * \c NULL if there was no such block. + * + * \param filename The path to the FLAC file to read. + * \param picture The address where the returned pointer will be + * stored. The \a picture object must be deleted by + * the caller using FLAC__metadata_object_delete(). + * \param type The desired picture type. Use \c -1 to mean + * "any type". + * \param mime_type The desired MIME type, e.g. "image/jpeg". The + * string will be matched exactly. Use \c NULL to + * mean "any MIME type". + * \param description The desired description. The string will be + * matched exactly. Use \c NULL to mean "any + * description". + * \param max_width The maximum width in pixels desired. Use + * \c (uint32_t)(-1) to mean "any width". + * \param max_height The maximum height in pixels desired. Use + * \c (uint32_t)(-1) to mean "any height". + * \param max_depth The maximum color depth in bits-per-pixel desired. + * Use \c (uint32_t)(-1) to mean "any depth". + * \param max_colors The maximum number of colors desired. Use + * \c (uint32_t)(-1) to mean "any number of colors". + * \assert + * \code filename != NULL \endcode + * \code picture != NULL \endcode + * \retval FLAC__bool + * \c true if a valid PICTURE block was read from \a filename, + * and \a *picture will be set to the address of the metadata + * structure. Returns \c false if there was a memory allocation + * error, a file decoder error, or the file contained no PICTURE + * block, and \a *picture will be set to \c NULL. + */ +FLAC_API FLAC__bool FLAC__metadata_get_picture(const char *filename, FLAC__StreamMetadata **picture, FLAC__StreamMetadata_Picture_Type type, const char *mime_type, const FLAC__byte *description, uint32_t max_width, uint32_t max_height, uint32_t max_depth, uint32_t max_colors); + +/* \} */ + + +/** \defgroup flac_metadata_level1 FLAC/metadata.h: metadata level 1 interface + * \ingroup flac_metadata + * + * \brief + * The level 1 interface provides read-write access to FLAC file metadata and + * operates directly on the FLAC file. + * + * The general usage of this interface is: + * + * - Create an iterator using FLAC__metadata_simple_iterator_new() + * - Attach it to a file using FLAC__metadata_simple_iterator_init() and check + * the exit code. Call FLAC__metadata_simple_iterator_is_writable() to + * see if the file is writable, or only read access is allowed. + * - Use FLAC__metadata_simple_iterator_next() and + * FLAC__metadata_simple_iterator_prev() to traverse the blocks. + * This is does not read the actual blocks themselves. + * FLAC__metadata_simple_iterator_next() is relatively fast. + * FLAC__metadata_simple_iterator_prev() is slower since it needs to search + * forward from the front of the file. + * - Use FLAC__metadata_simple_iterator_get_block_type() or + * FLAC__metadata_simple_iterator_get_block() to access the actual data at + * the current iterator position. The returned object is yours to modify + * and free. + * - Use FLAC__metadata_simple_iterator_set_block() to write a modified block + * back. You must have write permission to the original file. Make sure to + * read the whole comment to FLAC__metadata_simple_iterator_set_block() + * below. + * - Use FLAC__metadata_simple_iterator_insert_block_after() to add new blocks. + * Use the object creation functions from + * \link flac_metadata_object here \endlink to generate new objects. + * - Use FLAC__metadata_simple_iterator_delete_block() to remove the block + * currently referred to by the iterator, or replace it with padding. + * - Destroy the iterator with FLAC__metadata_simple_iterator_delete() when + * finished. + * + * \note + * The FLAC file remains open the whole time between + * FLAC__metadata_simple_iterator_init() and + * FLAC__metadata_simple_iterator_delete(), so make sure you are not altering + * the file during this time. + * + * \note + * Do not modify the \a is_last, \a length, or \a type fields of returned + * FLAC__StreamMetadata objects. These are managed automatically. + * + * \note + * If any of the modification functions + * (FLAC__metadata_simple_iterator_set_block(), + * FLAC__metadata_simple_iterator_delete_block(), + * FLAC__metadata_simple_iterator_insert_block_after(), etc.) return \c false, + * you should delete the iterator as it may no longer be valid. + * + * \{ + */ + +struct FLAC__Metadata_SimpleIterator; +/** The opaque structure definition for the level 1 iterator type. + * See the + * \link flac_metadata_level1 metadata level 1 module \endlink + * for a detailed description. + */ +typedef struct FLAC__Metadata_SimpleIterator FLAC__Metadata_SimpleIterator; + +/** Status type for FLAC__Metadata_SimpleIterator. + * + * The iterator's current status can be obtained by calling FLAC__metadata_simple_iterator_status(). + */ +typedef enum { + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK = 0, + /**< The iterator is in the normal OK state */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT, + /**< The data passed into a function violated the function's usage criteria */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE, + /**< The iterator could not open the target file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE, + /**< The iterator could not find the FLAC signature at the start of the file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE, + /**< The iterator tried to write to a file that was not writable */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_BAD_METADATA, + /**< The iterator encountered input that does not conform to the FLAC metadata specification */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR, + /**< The iterator encountered an error while reading the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR, + /**< The iterator encountered an error while seeking in the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR, + /**< The iterator encountered an error while writing the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR, + /**< The iterator encountered an error renaming the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR, + /**< The iterator encountered an error removing the temporary file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR, + /**< Memory allocation failed */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_INTERNAL_ERROR + /**< The caller violated an assertion or an unexpected error occurred */ + +} FLAC__Metadata_SimpleIteratorStatus; + +/** Maps a FLAC__Metadata_SimpleIteratorStatus to a C string. + * + * Using a FLAC__Metadata_SimpleIteratorStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__Metadata_SimpleIteratorStatusString[]; + + +/** Create a new iterator instance. + * + * \retval FLAC__Metadata_SimpleIterator* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__Metadata_SimpleIterator *FLAC__metadata_simple_iterator_new(void); + +/** Free an iterator instance. Deletes the object pointed to by \a iterator. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + */ +FLAC_API void FLAC__metadata_simple_iterator_delete(FLAC__Metadata_SimpleIterator *iterator); + +/** Get the current status of the iterator. Call this after a function + * returns \c false to get the reason for the error. Also resets the status + * to FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + * \retval FLAC__Metadata_SimpleIteratorStatus + * The current status of the iterator. + */ +FLAC_API FLAC__Metadata_SimpleIteratorStatus FLAC__metadata_simple_iterator_status(FLAC__Metadata_SimpleIterator *iterator); + +/** Initialize the iterator to point to the first metadata block in the + * given FLAC file. + * + * \param iterator A pointer to an existing iterator. + * \param filename The path to the FLAC file. + * \param read_only If \c true, the FLAC file will be opened + * in read-only mode; if \c false, the FLAC + * file will be opened for edit even if no + * edits are performed. + * \param preserve_file_stats If \c true, the owner and modification + * time will be preserved even if the FLAC + * file is written to. + * \assert + * \code iterator != NULL \endcode + * \code filename != NULL \endcode + * \retval FLAC__bool + * \c false if a memory allocation error occurs, the file can't be + * opened, or another error occurs, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_init(FLAC__Metadata_SimpleIterator *iterator, const char *filename, FLAC__bool read_only, FLAC__bool preserve_file_stats); + +/** Returns \c true if the FLAC file is writable. If \c false, calls to + * FLAC__metadata_simple_iterator_set_block() and + * FLAC__metadata_simple_iterator_insert_block_after() will fail. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + * \retval FLAC__bool + * See above. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_is_writable(const FLAC__Metadata_SimpleIterator *iterator); + +/** Moves the iterator forward one metadata block, returning \c false if + * already at the end. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c false if already at the last metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_next(FLAC__Metadata_SimpleIterator *iterator); + +/** Moves the iterator backward one metadata block, returning \c false if + * already at the beginning. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c false if already at the first metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_prev(FLAC__Metadata_SimpleIterator *iterator); + +/** Returns a flag telling if the current metadata block is the last. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c true if the current metadata block is the last in the file, + * else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_is_last(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the offset of the metadata block at the current position. This + * avoids reading the actual block data which can save time for large + * blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval off_t + * The offset of the metadata block at the current iterator position. + * This is the byte offset relative to the beginning of the file of + * the current metadata block's header. + */ +FLAC_API off_t FLAC__metadata_simple_iterator_get_block_offset(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the type of the metadata block at the current position. This + * avoids reading the actual block data which can save time for large + * blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__MetadataType + * The type of the metadata block at the current iterator position. + */ +FLAC_API FLAC__MetadataType FLAC__metadata_simple_iterator_get_block_type(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the length of the metadata block at the current position. This + * avoids reading the actual block data which can save time for large + * blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval uint32_t + * The length of the metadata block at the current iterator position. + * The is same length as that in the + * metadata block header, + * i.e. the length of the metadata body that follows the header. + */ +FLAC_API uint32_t FLAC__metadata_simple_iterator_get_block_length(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the application ID of the \c APPLICATION block at the current + * position. This avoids reading the actual block data which can save + * time for large blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \param id A pointer to a buffer of at least \c 4 bytes where + * the ID will be stored. + * \assert + * \code iterator != NULL \endcode + * \code id != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c true if the ID was successfully read, else \c false, in which + * case you should check FLAC__metadata_simple_iterator_status() to + * find out why. If the status is + * \c FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT, then the + * current metadata block is not an \c APPLICATION block. Otherwise + * if the status is + * \c FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR or + * \c FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR, an I/O error + * occurred and the iterator can no longer be used. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_get_application_id(FLAC__Metadata_SimpleIterator *iterator, FLAC__byte *id); + +/** Get the metadata block at the current position. You can modify the + * block but must use FLAC__metadata_simple_iterator_set_block() to + * write it back to the FLAC file. + * + * You must call FLAC__metadata_object_delete() on the returned object + * when you are finished with it. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__StreamMetadata* + * The current metadata block, or \c NULL if there was a memory + * allocation error. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_simple_iterator_get_block(FLAC__Metadata_SimpleIterator *iterator); + +/** Write a block back to the FLAC file. This function tries to be + * as efficient as possible; how the block is actually written is + * shown by the following: + * + * Existing block is a STREAMINFO block and the new block is a + * STREAMINFO block: the new block is written in place. Make sure + * you know what you're doing when changing the values of a + * STREAMINFO block. + * + * Existing block is a STREAMINFO block and the new block is a + * not a STREAMINFO block: this is an error since the first block + * must be a STREAMINFO block. Returns \c false without altering the + * file. + * + * Existing block is not a STREAMINFO block and the new block is a + * STREAMINFO block: this is an error since there may be only one + * STREAMINFO block. Returns \c false without altering the file. + * + * Existing block and new block are the same length: the existing + * block will be replaced by the new block, written in place. + * + * Existing block is longer than new block: if use_padding is \c true, + * the existing block will be overwritten in place with the new + * block followed by a PADDING block, if possible, to make the total + * size the same as the existing block. Remember that a padding + * block requires at least four bytes so if the difference in size + * between the new block and existing block is less than that, the + * entire file will have to be rewritten, using the new block's + * exact size. If use_padding is \c false, the entire file will be + * rewritten, replacing the existing block by the new block. + * + * Existing block is shorter than new block: if use_padding is \c true, + * the function will try and expand the new block into the following + * PADDING block, if it exists and doing so won't shrink the PADDING + * block to less than 4 bytes. If there is no following PADDING + * block, or it will shrink to less than 4 bytes, or use_padding is + * \c false, the entire file is rewritten, replacing the existing block + * with the new block. Note that in this case any following PADDING + * block is preserved as is. + * + * After writing the block, the iterator will remain in the same + * place, i.e. pointing to the new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block The block to set. + * \param use_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \code block != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_set_block(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool use_padding); + +/** This is similar to FLAC__metadata_simple_iterator_set_block() + * except that instead of writing over an existing block, it appends + * a block after the existing block. \a use_padding is again used to + * tell the function to try an expand into following padding in an + * attempt to avoid rewriting the entire file. + * + * This function will fail and return \c false if given a STREAMINFO + * block. + * + * After writing the block, the iterator will be pointing to the + * new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block The block to set. + * \param use_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \code block != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_insert_block_after(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool use_padding); + +/** Deletes the block at the current position. This will cause the + * entire FLAC file to be rewritten, unless \a use_padding is \c true, + * in which case the block will be replaced by an equal-sized PADDING + * block. The iterator will be left pointing to the block before the + * one just deleted. + * + * You may not delete the STREAMINFO block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param use_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_delete_block(FLAC__Metadata_SimpleIterator *iterator, FLAC__bool use_padding); + +/* \} */ + + +/** \defgroup flac_metadata_level2 FLAC/metadata.h: metadata level 2 interface + * \ingroup flac_metadata + * + * \brief + * The level 2 interface provides read-write access to FLAC file metadata; + * all metadata is read into memory, operated on in memory, and then written + * to file, which is more efficient than level 1 when editing multiple blocks. + * + * Currently Ogg FLAC is supported for read only, via + * FLAC__metadata_chain_read_ogg() but a subsequent + * FLAC__metadata_chain_write() will fail. + * + * The general usage of this interface is: + * + * - Create a new chain using FLAC__metadata_chain_new(). A chain is a + * linked list of FLAC metadata blocks. + * - Read all metadata into the chain from a FLAC file using + * FLAC__metadata_chain_read() or FLAC__metadata_chain_read_ogg() and + * check the status. + * - Optionally, consolidate the padding using + * FLAC__metadata_chain_merge_padding() or + * FLAC__metadata_chain_sort_padding(). + * - Create a new iterator using FLAC__metadata_iterator_new() + * - Initialize the iterator to point to the first element in the chain + * using FLAC__metadata_iterator_init() + * - Traverse the chain using FLAC__metadata_iterator_next and + * FLAC__metadata_iterator_prev(). + * - Get a block for reading or modification using + * FLAC__metadata_iterator_get_block(). The pointer to the object + * inside the chain is returned, so the block is yours to modify. + * Changes will be reflected in the FLAC file when you write the + * chain. You can also add and delete blocks (see functions below). + * - When done, write out the chain using FLAC__metadata_chain_write(). + * Make sure to read the whole comment to the function below. + * - Delete the chain using FLAC__metadata_chain_delete(). + * + * \note + * Even though the FLAC file is not open while the chain is being + * manipulated, you must not alter the file externally during + * this time. The chain assumes the FLAC file will not change + * between the time of FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg() + * and FLAC__metadata_chain_write(). + * + * \note + * Do not modify the is_last, length, or type fields of returned + * FLAC__StreamMetadata objects. These are managed automatically. + * + * \note + * The metadata objects returned by FLAC__metadata_iterator_get_block() + * are owned by the chain; do not FLAC__metadata_object_delete() them. + * In the same way, blocks passed to FLAC__metadata_iterator_set_block() + * become owned by the chain and they will be deleted when the chain is + * deleted. + * + * \{ + */ + +struct FLAC__Metadata_Chain; +/** The opaque structure definition for the level 2 chain type. + */ +typedef struct FLAC__Metadata_Chain FLAC__Metadata_Chain; + +struct FLAC__Metadata_Iterator; +/** The opaque structure definition for the level 2 iterator type. + */ +typedef struct FLAC__Metadata_Iterator FLAC__Metadata_Iterator; + +typedef enum { + FLAC__METADATA_CHAIN_STATUS_OK = 0, + /**< The chain is in the normal OK state */ + + FLAC__METADATA_CHAIN_STATUS_ILLEGAL_INPUT, + /**< The data passed into a function violated the function's usage criteria */ + + FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE, + /**< The chain could not open the target file */ + + FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE, + /**< The chain could not find the FLAC signature at the start of the file */ + + FLAC__METADATA_CHAIN_STATUS_NOT_WRITABLE, + /**< The chain tried to write to a file that was not writable */ + + FLAC__METADATA_CHAIN_STATUS_BAD_METADATA, + /**< The chain encountered input that does not conform to the FLAC metadata specification */ + + FLAC__METADATA_CHAIN_STATUS_READ_ERROR, + /**< The chain encountered an error while reading the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR, + /**< The chain encountered an error while seeking in the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR, + /**< The chain encountered an error while writing the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_RENAME_ERROR, + /**< The chain encountered an error renaming the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_UNLINK_ERROR, + /**< The chain encountered an error removing the temporary file */ + + FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR, + /**< Memory allocation failed */ + + FLAC__METADATA_CHAIN_STATUS_INTERNAL_ERROR, + /**< The caller violated an assertion or an unexpected error occurred */ + + FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS, + /**< One or more of the required callbacks was NULL */ + + FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH, + /**< FLAC__metadata_chain_write() was called on a chain read by + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(), + * or + * FLAC__metadata_chain_write_with_callbacks()/FLAC__metadata_chain_write_with_callbacks_and_tempfile() + * was called on a chain read by + * FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(). + * Matching read/write methods must always be used. */ + + FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL + /**< FLAC__metadata_chain_write_with_callbacks() was called when the + * chain write requires a tempfile; use + * FLAC__metadata_chain_write_with_callbacks_and_tempfile() instead. + * Or, FLAC__metadata_chain_write_with_callbacks_and_tempfile() was + * called when the chain write does not require a tempfile; use + * FLAC__metadata_chain_write_with_callbacks() instead. + * Always check FLAC__metadata_chain_check_if_tempfile_needed() + * before writing via callbacks. */ + +} FLAC__Metadata_ChainStatus; + +/** Maps a FLAC__Metadata_ChainStatus to a C string. + * + * Using a FLAC__Metadata_ChainStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__Metadata_ChainStatusString[]; + +/*********** FLAC__Metadata_Chain ***********/ + +/** Create a new chain instance. + * + * \retval FLAC__Metadata_Chain* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__Metadata_Chain *FLAC__metadata_chain_new(void); + +/** Free a chain instance. Deletes the object pointed to by \a chain. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_chain_delete(FLAC__Metadata_Chain *chain); + +/** Get the current status of the chain. Call this after a function + * returns \c false to get the reason for the error. Also resets the + * status to FLAC__METADATA_CHAIN_STATUS_OK. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__Metadata_ChainStatus + * The current status of the chain. + */ +FLAC_API FLAC__Metadata_ChainStatus FLAC__metadata_chain_status(FLAC__Metadata_Chain *chain); + +/** Read all metadata from a FLAC file into the chain. + * + * \param chain A pointer to an existing chain. + * \param filename The path to the FLAC file to read. + * \assert + * \code chain != NULL \endcode + * \code filename != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a filename, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read(FLAC__Metadata_Chain *chain, const char *filename); + +/** Read all metadata from an Ogg FLAC file into the chain. + * + * \note Ogg FLAC metadata data writing is not supported yet and + * FLAC__metadata_chain_write() will fail. + * + * \param chain A pointer to an existing chain. + * \param filename The path to the Ogg FLAC file to read. + * \assert + * \code chain != NULL \endcode + * \code filename != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a filename, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read_ogg(FLAC__Metadata_Chain *chain, const char *filename); + +/** Read all metadata from a FLAC stream into the chain via I/O callbacks. + * + * The \a handle need only be open for reading, but must be seekable. + * The equivalent minimum stdio fopen() file mode is \c "r" (or \c "rb" + * for Windows). + * + * \param chain A pointer to an existing chain. + * \param handle The I/O handle of the FLAC stream to read. The + * handle will NOT be closed after the metadata is read; + * that is the duty of the caller. + * \param callbacks + * A set of callbacks to use for I/O. The mandatory + * callbacks are \a read, \a seek, and \a tell. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a handle, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks); + +/** Read all metadata from an Ogg FLAC stream into the chain via I/O callbacks. + * + * The \a handle need only be open for reading, but must be seekable. + * The equivalent minimum stdio fopen() file mode is \c "r" (or \c "rb" + * for Windows). + * + * \note Ogg FLAC metadata data writing is not supported yet and + * FLAC__metadata_chain_write() will fail. + * + * \param chain A pointer to an existing chain. + * \param handle The I/O handle of the Ogg FLAC stream to read. The + * handle will NOT be closed after the metadata is read; + * that is the duty of the caller. + * \param callbacks + * A set of callbacks to use for I/O. The mandatory + * callbacks are \a read, \a seek, and \a tell. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a handle, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read_ogg_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks); + +/** Checks if writing the given chain would require the use of a + * temporary file, or if it could be written in place. + * + * Under certain conditions, padding can be utilized so that writing + * edited metadata back to the FLAC file does not require rewriting the + * entire file. If rewriting is required, then a temporary workfile is + * required. When writing metadata using callbacks, you must check + * this function to know whether to call + * FLAC__metadata_chain_write_with_callbacks() or + * FLAC__metadata_chain_write_with_callbacks_and_tempfile(). When + * writing with FLAC__metadata_chain_write(), the temporary file is + * handled internally. + * + * \param chain A pointer to an existing chain. + * \param use_padding + * Whether or not padding will be allowed to be used + * during the write. The value of \a use_padding given + * here must match the value later passed to + * FLAC__metadata_chain_write_with_callbacks() or + * FLAC__metadata_chain_write_with_callbacks_with_tempfile(). + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if writing the current chain would require a tempfile, or + * \c false if metadata can be written in place. + */ +FLAC_API FLAC__bool FLAC__metadata_chain_check_if_tempfile_needed(FLAC__Metadata_Chain *chain, FLAC__bool use_padding); + +/** Write all metadata out to the FLAC file. This function tries to be as + * efficient as possible; how the metadata is actually written is shown by + * the following: + * + * If the current chain is the same size as the existing metadata, the new + * data is written in place. + * + * If the current chain is longer than the existing metadata, and + * \a use_padding is \c true, and the last block is a PADDING block of + * sufficient length, the function will truncate the final padding block + * so that the overall size of the metadata is the same as the existing + * metadata, and then just rewrite the metadata. Otherwise, if not all of + * the above conditions are met, the entire FLAC file must be rewritten. + * If you want to use padding this way it is a good idea to call + * FLAC__metadata_chain_sort_padding() first so that you have the maximum + * amount of padding to work with, unless you need to preserve ordering + * of the PADDING blocks for some reason. + * + * If the current chain is shorter than the existing metadata, and + * \a use_padding is \c true, and the final block is a PADDING block, the padding + * is extended to make the overall size the same as the existing data. If + * \a use_padding is \c true and the last block is not a PADDING block, a new + * PADDING block is added to the end of the new data to make it the same + * size as the existing data (if possible, see the note to + * FLAC__metadata_simple_iterator_set_block() about the four byte limit) + * and the new data is written in place. If none of the above apply or + * \a use_padding is \c false, the entire FLAC file is rewritten. + * + * If \a preserve_file_stats is \c true, the owner and modification time will + * be preserved even if the FLAC file is written. + * + * For this write function to be used, the chain must have been read with + * FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(), not + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(). + * + * \param chain A pointer to an existing chain. + * \param use_padding See above. + * \param preserve_file_stats See above. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if the write succeeded, else \c false. On failure, + * check the status with FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_write(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__bool preserve_file_stats); + +/** Write all metadata out to a FLAC stream via callbacks. + * + * (See FLAC__metadata_chain_write() for the details on how padding is + * used to write metadata in place if possible.) + * + * The \a handle must be open for updating and be seekable. The + * equivalent minimum stdio fopen() file mode is \c "r+" (or \c "r+b" + * for Windows). + * + * For this write function to be used, the chain must have been read with + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(), + * not FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(). + * Also, FLAC__metadata_chain_check_if_tempfile_needed() must have returned + * \c false. + * + * \param chain A pointer to an existing chain. + * \param use_padding See FLAC__metadata_chain_write() + * \param handle The I/O handle of the FLAC stream to write. The + * handle will NOT be closed after the metadata is + * written; that is the duty of the caller. + * \param callbacks A set of callbacks to use for I/O. The mandatory + * callbacks are \a write and \a seek. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if the write succeeded, else \c false. On failure, + * check the status with FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_write_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks); + +/** Write all metadata out to a FLAC stream via callbacks. + * + * (See FLAC__metadata_chain_write() for the details on how padding is + * used to write metadata in place if possible.) + * + * This version of the write-with-callbacks function must be used when + * FLAC__metadata_chain_check_if_tempfile_needed() returns true. In + * this function, you must supply an I/O handle corresponding to the + * FLAC file to edit, and a temporary handle to which the new FLAC + * file will be written. It is the caller's job to move this temporary + * FLAC file on top of the original FLAC file to complete the metadata + * edit. + * + * The \a handle must be open for reading and be seekable. The + * equivalent minimum stdio fopen() file mode is \c "r" (or \c "rb" + * for Windows). + * + * The \a temp_handle must be open for writing. The + * equivalent minimum stdio fopen() file mode is \c "w" (or \c "wb" + * for Windows). It should be an empty stream, or at least positioned + * at the start-of-file (in which case it is the caller's duty to + * truncate it on return). + * + * For this write function to be used, the chain must have been read with + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(), + * not FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(). + * Also, FLAC__metadata_chain_check_if_tempfile_needed() must have returned + * \c true. + * + * \param chain A pointer to an existing chain. + * \param use_padding See FLAC__metadata_chain_write() + * \param handle The I/O handle of the original FLAC stream to read. + * The handle will NOT be closed after the metadata is + * written; that is the duty of the caller. + * \param callbacks A set of callbacks to use for I/O on \a handle. + * The mandatory callbacks are \a read, \a seek, and + * \a eof. + * \param temp_handle The I/O handle of the FLAC stream to write. The + * handle will NOT be closed after the metadata is + * written; that is the duty of the caller. + * \param temp_callbacks + * A set of callbacks to use for I/O on temp_handle. + * The only mandatory callback is \a write. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if the write succeeded, else \c false. On failure, + * check the status with FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_write_with_callbacks_and_tempfile(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks, FLAC__IOHandle temp_handle, FLAC__IOCallbacks temp_callbacks); + +/** Merge adjacent PADDING blocks into a single block. + * + * \note This function does not write to the FLAC file, it only + * modifies the chain. + * + * \warning Any iterator on the current chain will become invalid after this + * call. You should delete the iterator and get a new one. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_chain_merge_padding(FLAC__Metadata_Chain *chain); + +/** This function will move all PADDING blocks to the end on the metadata, + * then merge them into a single block. + * + * \note This function does not write to the FLAC file, it only + * modifies the chain. + * + * \warning Any iterator on the current chain will become invalid after this + * call. You should delete the iterator and get a new one. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_chain_sort_padding(FLAC__Metadata_Chain *chain); + + +/*********** FLAC__Metadata_Iterator ***********/ + +/** Create a new iterator instance. + * + * \retval FLAC__Metadata_Iterator* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__Metadata_Iterator *FLAC__metadata_iterator_new(void); + +/** Free an iterator instance. Deletes the object pointed to by \a iterator. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + */ +FLAC_API void FLAC__metadata_iterator_delete(FLAC__Metadata_Iterator *iterator); + +/** Initialize the iterator to point to the first metadata block in the + * given chain. + * + * \param iterator A pointer to an existing iterator. + * \param chain A pointer to an existing and initialized (read) chain. + * \assert + * \code iterator != NULL \endcode + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_iterator_init(FLAC__Metadata_Iterator *iterator, FLAC__Metadata_Chain *chain); + +/** Moves the iterator forward one metadata block, returning \c false if + * already at the end. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if already at the last metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_next(FLAC__Metadata_Iterator *iterator); + +/** Moves the iterator backward one metadata block, returning \c false if + * already at the beginning. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if already at the first metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_prev(FLAC__Metadata_Iterator *iterator); + +/** Get the type of the metadata block at the current position. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__MetadataType + * The type of the metadata block at the current iterator position. + */ +FLAC_API FLAC__MetadataType FLAC__metadata_iterator_get_block_type(const FLAC__Metadata_Iterator *iterator); + +/** Get the metadata block at the current position. You can modify + * the block in place but must write the chain before the changes + * are reflected to the FLAC file. You do not need to call + * FLAC__metadata_iterator_set_block() to reflect the changes; + * the pointer returned by FLAC__metadata_iterator_get_block() + * points directly into the chain. + * + * \warning + * Do not call FLAC__metadata_object_delete() on the returned object; + * to delete a block use FLAC__metadata_iterator_delete_block(). + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__StreamMetadata* + * The current metadata block. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_iterator_get_block(FLAC__Metadata_Iterator *iterator); + +/** Set the metadata block at the current position, replacing the existing + * block. The new block passed in becomes owned by the chain and it will be + * deleted when the chain is deleted. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block A pointer to a metadata block. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \code block != NULL \endcode + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, or + * a memory allocation error occurs, otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_set_block(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block); + +/** Removes the current block from the chain. If \a replace_with_padding is + * \c true, the block will instead be replaced with a padding block of equal + * size. You can not delete the STREAMINFO block. The iterator will be + * left pointing to the block before the one just "deleted", even if + * \a replace_with_padding is \c true. + * + * \param iterator A pointer to an existing initialized iterator. + * \param replace_with_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, + * otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_delete_block(FLAC__Metadata_Iterator *iterator, FLAC__bool replace_with_padding); + +/** Insert a new block before the current block. You cannot insert a block + * before the first STREAMINFO block. You cannot insert a STREAMINFO block + * as there can be only one, the one that already exists at the head when you + * read in a chain. The chain takes ownership of the new block and it will be + * deleted when the chain is deleted. The iterator will be left pointing to + * the new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block A pointer to a metadata block to insert. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, or + * a memory allocation error occurs, otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_insert_block_before(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block); + +/** Insert a new block after the current block. You cannot insert a STREAMINFO + * block as there can be only one, the one that already exists at the head when + * you read in a chain. The chain takes ownership of the new block and it will + * be deleted when the chain is deleted. The iterator will be left pointing to + * the new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block A pointer to a metadata block to insert. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, or + * a memory allocation error occurs, otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_insert_block_after(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block); + +/* \} */ + + +/** \defgroup flac_metadata_object FLAC/metadata.h: metadata object methods + * \ingroup flac_metadata + * + * \brief + * This module contains methods for manipulating FLAC metadata objects. + * + * Since many are variable length we have to be careful about the memory + * management. We decree that all pointers to data in the object are + * owned by the object and memory-managed by the object. + * + * Use the FLAC__metadata_object_new() and FLAC__metadata_object_delete() + * functions to create all instances. When using the + * FLAC__metadata_object_set_*() functions to set pointers to data, set + * \a copy to \c true to have the function make it's own copy of the data, or + * to \c false to give the object ownership of your data. In the latter case + * your pointer must be freeable by free() and will be free()d when the object + * is FLAC__metadata_object_delete()d. It is legal to pass a null pointer as + * the data pointer to a FLAC__metadata_object_set_*() function as long as + * the length argument is 0 and the \a copy argument is \c false. + * + * The FLAC__metadata_object_new() and FLAC__metadata_object_clone() function + * will return \c NULL in the case of a memory allocation error, otherwise a new + * object. The FLAC__metadata_object_set_*() functions return \c false in the + * case of a memory allocation error. + * + * We don't have the convenience of C++ here, so note that the library relies + * on you to keep the types straight. In other words, if you pass, for + * example, a FLAC__StreamMetadata* that represents a STREAMINFO block to + * FLAC__metadata_object_application_set_data(), you will get an assertion + * failure. + * + * For convenience the FLAC__metadata_object_vorbiscomment_*() functions + * maintain a trailing NUL on each Vorbis comment entry. This is not counted + * toward the length or stored in the stream, but it can make working with plain + * comments (those that don't contain embedded-NULs in the value) easier. + * Entries passed into these functions have trailing NULs added if missing, and + * returned entries are guaranteed to have a trailing NUL. + * + * The FLAC__metadata_object_vorbiscomment_*() functions that take a Vorbis + * comment entry/name/value will first validate that it complies with the Vorbis + * comment specification and return false if it does not. + * + * There is no need to recalculate the length field on metadata blocks you + * have modified. They will be calculated automatically before they are + * written back to a file. + * + * \{ + */ + + +/** Create a new metadata object instance of the given type. + * + * The object will be "empty"; i.e. values and data pointers will be \c 0, + * with the exception of FLAC__METADATA_TYPE_VORBIS_COMMENT, which will have + * the vendor string set (but zero comments). + * + * Do not pass in a value greater than or equal to + * \a FLAC__METADATA_TYPE_UNDEFINED unless you really know what you're + * doing. + * + * \param type Type of object to create + * \retval FLAC__StreamMetadata* + * \c NULL if there was an error allocating memory or the type code is + * greater than FLAC__MAX_METADATA_TYPE_CODE, else the new instance. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_new(FLAC__MetadataType type); + +/** Create a copy of an existing metadata object. + * + * The copy is a "deep" copy, i.e. dynamically allocated data within the + * object is also copied. The caller takes ownership of the new block and + * is responsible for freeing it with FLAC__metadata_object_delete(). + * + * \param object Pointer to object to copy. + * \assert + * \code object != NULL \endcode + * \retval FLAC__StreamMetadata* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_clone(const FLAC__StreamMetadata *object); + +/** Free a metadata object. Deletes the object pointed to by \a object. + * + * The delete is a "deep" delete, i.e. dynamically allocated data within the + * object is also deleted. + * + * \param object A pointer to an existing object. + * \assert + * \code object != NULL \endcode + */ +FLAC_API void FLAC__metadata_object_delete(FLAC__StreamMetadata *object); + +/** Compares two metadata objects. + * + * The compare is "deep", i.e. dynamically allocated data within the + * object is also compared. + * + * \param block1 A pointer to an existing object. + * \param block2 A pointer to an existing object. + * \assert + * \code block1 != NULL \endcode + * \code block2 != NULL \endcode + * \retval FLAC__bool + * \c true if objects are identical, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_object_is_equal(const FLAC__StreamMetadata *block1, const FLAC__StreamMetadata *block2); + +/** Sets the application data of an APPLICATION block. + * + * If \a copy is \c true, a copy of the data is stored; otherwise, the object + * takes ownership of the pointer. The existing data will be freed if this + * function is successful, otherwise the original data will remain if \a copy + * is \c true and malloc() fails. + * + * \note It is safe to pass a const pointer to \a data if \a copy is \c true. + * + * \param object A pointer to an existing APPLICATION object. + * \param data A pointer to the data to set. + * \param length The length of \a data in bytes. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_APPLICATION \endcode + * \code (data != NULL && length > 0) || + * (data == NULL && length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_application_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, uint32_t length, FLAC__bool copy); + +/** Resize the seekpoint array. + * + * If the size shrinks, elements will truncated; if it grows, new placeholder + * points will be added to the end. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param new_num_points The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code (object->data.seek_table.points == NULL && object->data.seek_table.num_points == 0) || + * (object->data.seek_table.points != NULL && object->data.seek_table.num_points > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_resize_points(FLAC__StreamMetadata *object, uint32_t new_num_points); + +/** Set a seekpoint in a seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param point_num Index into seekpoint array to set. + * \param point The point to set. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code object->data.seek_table.num_points > point_num \endcode + */ +FLAC_API void FLAC__metadata_object_seektable_set_point(FLAC__StreamMetadata *object, uint32_t point_num, FLAC__StreamMetadata_SeekPoint point); + +/** Insert a seekpoint into a seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param point_num Index into seekpoint array to set. + * \param point The point to set. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code object->data.seek_table.num_points >= point_num \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_insert_point(FLAC__StreamMetadata *object, uint32_t point_num, FLAC__StreamMetadata_SeekPoint point); + +/** Delete a seekpoint from a seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param point_num Index into seekpoint array to set. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code object->data.seek_table.num_points > point_num \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_delete_point(FLAC__StreamMetadata *object, uint32_t point_num); + +/** Check a seektable to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if seek table is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_is_legal(const FLAC__StreamMetadata *object); + +/** Append a number of placeholder points to the end of a seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param num The number of placeholder points to append. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_placeholders(FLAC__StreamMetadata *object, uint32_t num); + +/** Append a specific seek point template to the end of a seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param sample_number The sample number of the seek point template. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_point(FLAC__StreamMetadata *object, FLAC__uint64 sample_number); + +/** Append specific seek point templates to the end of a seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param sample_numbers An array of sample numbers for the seek points. + * \param num The number of seek point templates to append. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_points(FLAC__StreamMetadata *object, FLAC__uint64 sample_numbers[], uint32_t num); + +/** Append a set of evenly-spaced seek point templates to the end of a + * seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param num The number of placeholder points to append. + * \param total_samples The total number of samples to be encoded; + * the seekpoints will be spaced approximately + * \a total_samples / \a num samples apart. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code total_samples > 0 \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points(FLAC__StreamMetadata *object, uint32_t num, FLAC__uint64 total_samples); + +/** Append a set of evenly-spaced seek point templates to the end of a + * seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param samples The number of samples apart to space the placeholder + * points. The first point will be at sample \c 0, the + * second at sample \a samples, then 2*\a samples, and + * so on. As long as \a samples and \a total_samples + * are greater than \c 0, there will always be at least + * one seekpoint at sample \c 0. + * \param total_samples The total number of samples to be encoded; + * the seekpoints will be spaced + * \a samples samples apart. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code samples > 0 \endcode + * \code total_samples > 0 \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(FLAC__StreamMetadata *object, uint32_t samples, FLAC__uint64 total_samples); + +/** Sort a seek table's seek points according to the format specification, + * removing duplicates. + * + * \param object A pointer to a seek table to be sorted. + * \param compact If \c false, behaves like FLAC__format_seektable_sort(). + * If \c true, duplicates are deleted and the seek table is + * shrunk appropriately; the number of placeholder points + * present in the seek table will be the same after the call + * as before. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_sort(FLAC__StreamMetadata *object, FLAC__bool compact); + +/** Sets the vendor string in a VORBIS_COMMENT block. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param entry The entry to set the vendor string to. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_vendor_string(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Resize the comment array. + * + * If the size shrinks, elements will truncated; if it grows, new empty + * fields will be added to the end. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param new_num_comments The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (object->data.vorbis_comment.comments == NULL && object->data.vorbis_comment.num_comments == 0) || + * (object->data.vorbis_comment.comments != NULL && object->data.vorbis_comment.num_comments > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_resize_comments(FLAC__StreamMetadata *object, uint32_t new_num_comments); + +/** Sets a comment in a VORBIS_COMMENT block. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param comment_num Index into comment array to set. + * \param entry The entry to set the comment to. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code comment_num < object->data.vorbis_comment.num_comments \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_comment(FLAC__StreamMetadata *object, uint32_t comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Insert a comment in a VORBIS_COMMENT block at the given index. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param comment_num The index at which to insert the comment. The comments + * at and after \a comment_num move right one position. + * To append a comment to the end, set \a comment_num to + * \c object->data.vorbis_comment.num_comments . + * \param entry The comment to insert. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code object->data.vorbis_comment.num_comments >= comment_num \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_insert_comment(FLAC__StreamMetadata *object, uint32_t comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Appends a comment to a VORBIS_COMMENT block. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param entry The comment to insert. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_append_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Replaces comments in a VORBIS_COMMENT block with a new one. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * Depending on the value of \a all, either all or just the first comment + * whose field name(s) match the given entry's name will be replaced by the + * given entry. If no comments match, \a entry will simply be appended. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param entry The comment to insert. + * \param all If \c true, all comments whose field name matches + * \a entry's field name will be removed, and \a entry will + * be inserted at the position of the first matching + * comment. If \c false, only the first comment whose + * field name matches \a entry's field name will be + * replaced with \a entry. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_replace_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool all, FLAC__bool copy); + +/** Delete a comment in a VORBIS_COMMENT block at the given index. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param comment_num The index of the comment to delete. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code object->data.vorbis_comment.num_comments > comment_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_delete_comment(FLAC__StreamMetadata *object, uint32_t comment_num); + +/** Creates a Vorbis comment entry from NUL-terminated name and value strings. + * + * On return, the filled-in \a entry->entry pointer will point to malloc()ed + * memory and shall be owned by the caller. For convenience the entry will + * have a terminating NUL. + * + * \param entry A pointer to a Vorbis comment entry. The entry's + * \c entry pointer should not point to allocated + * memory as it will be overwritten. + * \param field_name The field name in ASCII, \c NUL terminated. + * \param field_value The field value in UTF-8, \c NUL terminated. + * \assert + * \code entry != NULL \endcode + * \code field_name != NULL \endcode + * \code field_value != NULL \endcode + * \retval FLAC__bool + * \c false if malloc() fails, or if \a field_name or \a field_value does + * not comply with the Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(FLAC__StreamMetadata_VorbisComment_Entry *entry, const char *field_name, const char *field_value); + +/** Splits a Vorbis comment entry into NUL-terminated name and value strings. + * + * The returned pointers to name and value will be allocated by malloc() + * and shall be owned by the caller. + * + * \param entry An existing Vorbis comment entry. + * \param field_name The address of where the returned pointer to the + * field name will be stored. + * \param field_value The address of where the returned pointer to the + * field value will be stored. + * \assert + * \code (entry.entry != NULL && entry.length > 0) \endcode + * \code memchr(entry.entry, '=', entry.length) != NULL \endcode + * \code field_name != NULL \endcode + * \code field_value != NULL \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(const FLAC__StreamMetadata_VorbisComment_Entry entry, char **field_name, char **field_value); + +/** Check if the given Vorbis comment entry's field name matches the given + * field name. + * + * \param entry An existing Vorbis comment entry. + * \param field_name The field name to check. + * \param field_name_length The length of \a field_name, not including the + * terminating \c NUL. + * \assert + * \code (entry.entry != NULL && entry.length > 0) \endcode + * \retval FLAC__bool + * \c true if the field names match, else \c false + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_matches(const FLAC__StreamMetadata_VorbisComment_Entry entry, const char *field_name, uint32_t field_name_length); + +/** Find a Vorbis comment with the given field name. + * + * The search begins at entry number \a offset; use an offset of 0 to + * search from the beginning of the comment array. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param offset The offset into the comment array from where to start + * the search. + * \param field_name The field name of the comment to find. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code field_name != NULL \endcode + * \retval int + * The offset in the comment array of the first comment whose field + * name matches \a field_name, or \c -1 if no match was found. + */ +FLAC_API int FLAC__metadata_object_vorbiscomment_find_entry_from(const FLAC__StreamMetadata *object, uint32_t offset, const char *field_name); + +/** Remove first Vorbis comment matching the given field name. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param field_name The field name of comment to delete. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \retval int + * \c -1 for memory allocation error, \c 0 for no matching entries, + * \c 1 for one matching entry deleted. + */ +FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entry_matching(FLAC__StreamMetadata *object, const char *field_name); + +/** Remove all Vorbis comments matching the given field name. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param field_name The field name of comments to delete. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \retval int + * \c -1 for memory allocation error, \c 0 for no matching entries, + * else the number of matching entries deleted. + */ +FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entries_matching(FLAC__StreamMetadata *object, const char *field_name); + +/** Create a new CUESHEET track instance. + * + * The object will be "empty"; i.e. values and data pointers will be \c 0. + * + * \retval FLAC__StreamMetadata_CueSheet_Track* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_new(void); + +/** Create a copy of an existing CUESHEET track object. + * + * The copy is a "deep" copy, i.e. dynamically allocated data within the + * object is also copied. The caller takes ownership of the new object and + * is responsible for freeing it with + * FLAC__metadata_object_cuesheet_track_delete(). + * + * \param object Pointer to object to copy. + * \assert + * \code object != NULL \endcode + * \retval FLAC__StreamMetadata_CueSheet_Track* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_clone(const FLAC__StreamMetadata_CueSheet_Track *object); + +/** Delete a CUESHEET track object + * + * \param object A pointer to an existing CUESHEET track object. + * \assert + * \code object != NULL \endcode + */ +FLAC_API void FLAC__metadata_object_cuesheet_track_delete(FLAC__StreamMetadata_CueSheet_Track *object); + +/** Resize a track's index point array. + * + * If the size shrinks, elements will truncated; if it grows, new blank + * indices will be added to the end. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index of the track to modify. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param new_num_indices The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code (object->data.cue_sheet.tracks[track_num].indices == NULL && object->data.cue_sheet.tracks[track_num].num_indices == 0) || + * (object->data.cue_sheet.tracks[track_num].indices != NULL && object->data.cue_sheet.tracks[track_num].num_indices > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_resize_indices(FLAC__StreamMetadata *object, uint32_t track_num, uint32_t new_num_indices); + +/** Insert an index point in a CUESHEET track at the given index. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index of the track to modify. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param index_num The index into the track's index array at which to + * insert the index point. NOTE: this is not necessarily + * the same as the index point's \a number field. The + * indices at and after \a index_num move right one + * position. To append an index point to the end, set + * \a index_num to + * \c object->data.cue_sheet.tracks[track_num].num_indices . + * \param index The index point to insert. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code object->data.cue_sheet.tracks[track_num].num_indices >= index_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_index(FLAC__StreamMetadata *object, uint32_t track_num, uint32_t index_num, FLAC__StreamMetadata_CueSheet_Index index); + +/** Insert a blank index point in a CUESHEET track at the given index. + * + * A blank index point is one in which all field values are zero. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index of the track to modify. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param index_num The index into the track's index array at which to + * insert the index point. NOTE: this is not necessarily + * the same as the index point's \a number field. The + * indices at and after \a index_num move right one + * position. To append an index point to the end, set + * \a index_num to + * \c object->data.cue_sheet.tracks[track_num].num_indices . + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code object->data.cue_sheet.tracks[track_num].num_indices >= index_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_blank_index(FLAC__StreamMetadata *object, uint32_t track_num, uint32_t index_num); + +/** Delete an index point in a CUESHEET track at the given index. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index into the track array of the track to + * modify. NOTE: this is not necessarily the same + * as the track's \a number field. + * \param index_num The index into the track's index array of the index + * to delete. NOTE: this is not necessarily the same + * as the index's \a number field. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code object->data.cue_sheet.tracks[track_num].num_indices > index_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_delete_index(FLAC__StreamMetadata *object, uint32_t track_num, uint32_t index_num); + +/** Resize the track array. + * + * If the size shrinks, elements will truncated; if it grows, new blank + * tracks will be added to the end. + * + * \param object A pointer to an existing CUESHEET object. + * \param new_num_tracks The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code (object->data.cue_sheet.tracks == NULL && object->data.cue_sheet.num_tracks == 0) || + * (object->data.cue_sheet.tracks != NULL && object->data.cue_sheet.num_tracks > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_resize_tracks(FLAC__StreamMetadata *object, uint32_t new_num_tracks); + +/** Sets a track in a CUESHEET block. + * + * If \a copy is \c true, a copy of the track is stored; otherwise, the object + * takes ownership of the \a track pointer. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num Index into track array to set. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param track The track to set the track to. You may safely pass in + * a const pointer if \a copy is \c true. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code track_num < object->data.cue_sheet.num_tracks \endcode + * \code (track->indices != NULL && track->num_indices > 0) || + * (track->indices == NULL && track->num_indices == 0) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_set_track(FLAC__StreamMetadata *object, uint32_t track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy); + +/** Insert a track in a CUESHEET block at the given index. + * + * If \a copy is \c true, a copy of the track is stored; otherwise, the object + * takes ownership of the \a track pointer. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index at which to insert the track. NOTE: this + * is not necessarily the same as the track's \a number + * field. The tracks at and after \a track_num move right + * one position. To append a track to the end, set + * \a track_num to \c object->data.cue_sheet.num_tracks . + * \param track The track to insert. You may safely pass in a const + * pointer if \a copy is \c true. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks >= track_num \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_track(FLAC__StreamMetadata *object, uint32_t track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy); + +/** Insert a blank track in a CUESHEET block at the given index. + * + * A blank track is one in which all field values are zero. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index at which to insert the track. NOTE: this + * is not necessarily the same as the track's \a number + * field. The tracks at and after \a track_num move right + * one position. To append a track to the end, set + * \a track_num to \c object->data.cue_sheet.num_tracks . + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks >= track_num \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_blank_track(FLAC__StreamMetadata *object, uint32_t track_num); + +/** Delete a track in a CUESHEET block at the given index. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index into the track array of the track to + * delete. NOTE: this is not necessarily the same + * as the track's \a number field. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_delete_track(FLAC__StreamMetadata *object, uint32_t track_num); + +/** Check a cue sheet to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * cue sheet. + * + * \param object A pointer to an existing CUESHEET object. + * \param check_cd_da_subset If \c true, check CUESHEET against more + * stringent requirements for a CD-DA (audio) disc. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \retval FLAC__bool + * \c false if cue sheet is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_is_legal(const FLAC__StreamMetadata *object, FLAC__bool check_cd_da_subset, const char **violation); + +/** Calculate and return the CDDB/freedb ID for a cue sheet. The function + * assumes the cue sheet corresponds to a CD; the result is undefined + * if the cuesheet's is_cd bit is not set. + * + * \param object A pointer to an existing CUESHEET object. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \retval FLAC__uint32 + * The unsigned integer representation of the CDDB/freedb ID + */ +FLAC_API FLAC__uint32 FLAC__metadata_object_cuesheet_calculate_cddb_id(const FLAC__StreamMetadata *object); + +/** Sets the MIME type of a PICTURE block. + * + * If \a copy is \c true, a copy of the string is stored; otherwise, the object + * takes ownership of the pointer. The existing string will be freed if this + * function is successful, otherwise the original string will remain if \a copy + * is \c true and malloc() fails. + * + * \note It is safe to pass a const pointer to \a mime_type if \a copy is \c true. + * + * \param object A pointer to an existing PICTURE object. + * \param mime_type A pointer to the MIME type string. The string must be + * ASCII characters 0x20-0x7e, NUL-terminated. No validation + * is done. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \code (mime_type != NULL) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_set_mime_type(FLAC__StreamMetadata *object, char *mime_type, FLAC__bool copy); + +/** Sets the description of a PICTURE block. + * + * If \a copy is \c true, a copy of the string is stored; otherwise, the object + * takes ownership of the pointer. The existing string will be freed if this + * function is successful, otherwise the original string will remain if \a copy + * is \c true and malloc() fails. + * + * \note It is safe to pass a const pointer to \a description if \a copy is \c true. + * + * \param object A pointer to an existing PICTURE object. + * \param description A pointer to the description string. The string must be + * valid UTF-8, NUL-terminated. No validation is done. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \code (description != NULL) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_set_description(FLAC__StreamMetadata *object, FLAC__byte *description, FLAC__bool copy); + +/** Sets the picture data of a PICTURE block. + * + * If \a copy is \c true, a copy of the data is stored; otherwise, the object + * takes ownership of the pointer. Also sets the \a data_length field of the + * metadata object to what is passed in as the \a length parameter. The + * existing data will be freed if this function is successful, otherwise the + * original data and data_length will remain if \a copy is \c true and + * malloc() fails. + * + * \note It is safe to pass a const pointer to \a data if \a copy is \c true. + * + * \param object A pointer to an existing PICTURE object. + * \param data A pointer to the data to set. + * \param length The length of \a data in bytes. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \code (data != NULL && length > 0) || + * (data == NULL && length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, FLAC__uint32 length, FLAC__bool copy); + +/** Check a PICTURE block to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * PICTURE block. + * + * \param object A pointer to existing PICTURE block to be checked. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \retval FLAC__bool + * \c false if PICTURE block is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_is_legal(const FLAC__StreamMetadata *object, const char **violation); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libs/include/FLAC/ordinals.h b/libs/include/FLAC/ordinals.h new file mode 100644 index 0000000..75b830d --- /dev/null +++ b/libs/include/FLAC/ordinals.h @@ -0,0 +1,85 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2016 Xiph.Org Foundation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * - Neither the name of the Xiph.org Foundation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FLAC__ORDINALS_H +#define FLAC__ORDINALS_H + +#if defined(_MSC_VER) && _MSC_VER < 1600 + +/* Microsoft Visual Studio earlier than the 2010 version did not provide + * the 1999 ISO C Standard header file . + */ + +typedef signed __int8 FLAC__int8; +typedef signed __int16 FLAC__int16; +typedef signed __int32 FLAC__int32; +typedef signed __int64 FLAC__int64; +typedef unsigned __int8 FLAC__uint8; +typedef unsigned __int16 FLAC__uint16; +typedef unsigned __int32 FLAC__uint32; +typedef unsigned __int64 FLAC__uint64; + +#else + +/* For MSVC 2010 and everything else which provides . */ + +#include + +typedef int8_t FLAC__int8; +typedef uint8_t FLAC__uint8; + +typedef int16_t FLAC__int16; +typedef int32_t FLAC__int32; +typedef int64_t FLAC__int64; +typedef uint16_t FLAC__uint16; +typedef uint32_t FLAC__uint32; +typedef uint64_t FLAC__uint64; + +#endif + +typedef int FLAC__bool; + +typedef FLAC__uint8 FLAC__byte; + + +#ifdef true +#undef true +#endif +#ifdef false +#undef false +#endif +#ifndef __cplusplus +#define true 1 +#define false 0 +#endif + +#endif diff --git a/libs/include/FLAC/stream_decoder.h b/libs/include/FLAC/stream_decoder.h new file mode 100644 index 0000000..57215c5 --- /dev/null +++ b/libs/include/FLAC/stream_decoder.h @@ -0,0 +1,1559 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2016 Xiph.Org Foundation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * - Neither the name of the Xiph.org Foundation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FLAC__STREAM_DECODER_H +#define FLAC__STREAM_DECODER_H + +#include /* for FILE */ +#include "export.h" +#include "format.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** \file include/FLAC/stream_decoder.h + * + * \brief + * This module contains the functions which implement the stream + * decoder. + * + * See the detailed documentation in the + * \link flac_stream_decoder stream decoder \endlink module. + */ + +/** \defgroup flac_decoder FLAC/ \*_decoder.h: decoder interfaces + * \ingroup flac + * + * \brief + * This module describes the decoder layers provided by libFLAC. + * + * The stream decoder can be used to decode complete streams either from + * the client via callbacks, or directly from a file, depending on how + * it is initialized. When decoding via callbacks, the client provides + * callbacks for reading FLAC data and writing decoded samples, and + * handling metadata and errors. If the client also supplies seek-related + * callback, the decoder function for sample-accurate seeking within the + * FLAC input is also available. When decoding from a file, the client + * needs only supply a filename or open \c FILE* and write/metadata/error + * callbacks; the rest of the callbacks are supplied internally. For more + * info see the \link flac_stream_decoder stream decoder \endlink module. + */ + +/** \defgroup flac_stream_decoder FLAC/stream_decoder.h: stream decoder interface + * \ingroup flac_decoder + * + * \brief + * This module contains the functions which implement the stream + * decoder. + * + * The stream decoder can decode native FLAC, and optionally Ogg FLAC + * (check FLAC_API_SUPPORTS_OGG_FLAC) streams and files. + * + * The basic usage of this decoder is as follows: + * - The program creates an instance of a decoder using + * FLAC__stream_decoder_new(). + * - The program overrides the default settings using + * FLAC__stream_decoder_set_*() functions. + * - The program initializes the instance to validate the settings and + * prepare for decoding using + * - FLAC__stream_decoder_init_stream() or FLAC__stream_decoder_init_FILE() + * or FLAC__stream_decoder_init_file() for native FLAC, + * - FLAC__stream_decoder_init_ogg_stream() or FLAC__stream_decoder_init_ogg_FILE() + * or FLAC__stream_decoder_init_ogg_file() for Ogg FLAC + * - The program calls the FLAC__stream_decoder_process_*() functions + * to decode data, which subsequently calls the callbacks. + * - The program finishes the decoding with FLAC__stream_decoder_finish(), + * which flushes the input and output and resets the decoder to the + * uninitialized state. + * - The instance may be used again or deleted with + * FLAC__stream_decoder_delete(). + * + * In more detail, the program will create a new instance by calling + * FLAC__stream_decoder_new(), then call FLAC__stream_decoder_set_*() + * functions to override the default decoder options, and call + * one of the FLAC__stream_decoder_init_*() functions. + * + * There are three initialization functions for native FLAC, one for + * setting up the decoder to decode FLAC data from the client via + * callbacks, and two for decoding directly from a FLAC file. + * + * For decoding via callbacks, use FLAC__stream_decoder_init_stream(). + * You must also supply several callbacks for handling I/O. Some (like + * seeking) are optional, depending on the capabilities of the input. + * + * For decoding directly from a file, use FLAC__stream_decoder_init_FILE() + * or FLAC__stream_decoder_init_file(). Then you must only supply an open + * \c FILE* or filename and fewer callbacks; the decoder will handle + * the other callbacks internally. + * + * There are three similarly-named init functions for decoding from Ogg + * FLAC streams. Check \c FLAC_API_SUPPORTS_OGG_FLAC to find out if the + * library has been built with Ogg support. + * + * Once the decoder is initialized, your program will call one of several + * functions to start the decoding process: + * + * - FLAC__stream_decoder_process_single() - Tells the decoder to process at + * most one metadata block or audio frame and return, calling either the + * metadata callback or write callback, respectively, once. If the decoder + * loses sync it will return with only the error callback being called. + * - FLAC__stream_decoder_process_until_end_of_metadata() - Tells the decoder + * to process the stream from the current location and stop upon reaching + * the first audio frame. The client will get one metadata, write, or error + * callback per metadata block, audio frame, or sync error, respectively. + * - FLAC__stream_decoder_process_until_end_of_stream() - Tells the decoder + * to process the stream from the current location until the read callback + * returns FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM or + * FLAC__STREAM_DECODER_READ_STATUS_ABORT. The client will get one metadata, + * write, or error callback per metadata block, audio frame, or sync error, + * respectively. + * + * When the decoder has finished decoding (normally or through an abort), + * the instance is finished by calling FLAC__stream_decoder_finish(), which + * ensures the decoder is in the correct state and frees memory. Then the + * instance may be deleted with FLAC__stream_decoder_delete() or initialized + * again to decode another stream. + * + * Seeking is exposed through the FLAC__stream_decoder_seek_absolute() method. + * At any point after the stream decoder has been initialized, the client can + * call this function to seek to an exact sample within the stream. + * Subsequently, the first time the write callback is called it will be + * passed a (possibly partial) block starting at that sample. + * + * If the client cannot seek via the callback interface provided, but still + * has another way of seeking, it can flush the decoder using + * FLAC__stream_decoder_flush() and start feeding data from the new position + * through the read callback. + * + * The stream decoder also provides MD5 signature checking. If this is + * turned on before initialization, FLAC__stream_decoder_finish() will + * report when the decoded MD5 signature does not match the one stored + * in the STREAMINFO block. MD5 checking is automatically turned off + * (until the next FLAC__stream_decoder_reset()) if there is no signature + * in the STREAMINFO block or when a seek is attempted. + * + * The FLAC__stream_decoder_set_metadata_*() functions deserve special + * attention. By default, the decoder only calls the metadata_callback for + * the STREAMINFO block. These functions allow you to tell the decoder + * explicitly which blocks to parse and return via the metadata_callback + * and/or which to skip. Use a FLAC__stream_decoder_set_metadata_respond_all(), + * FLAC__stream_decoder_set_metadata_ignore() ... or FLAC__stream_decoder_set_metadata_ignore_all(), + * FLAC__stream_decoder_set_metadata_respond() ... sequence to exactly specify + * which blocks to return. Remember that metadata blocks can potentially + * be big (for example, cover art) so filtering out the ones you don't + * use can reduce the memory requirements of the decoder. Also note the + * special forms FLAC__stream_decoder_set_metadata_respond_application(id) + * and FLAC__stream_decoder_set_metadata_ignore_application(id) for + * filtering APPLICATION blocks based on the application ID. + * + * STREAMINFO and SEEKTABLE blocks are always parsed and used internally, but + * they still can legally be filtered from the metadata_callback. + * + * \note + * The "set" functions may only be called when the decoder is in the + * state FLAC__STREAM_DECODER_UNINITIALIZED, i.e. after + * FLAC__stream_decoder_new() or FLAC__stream_decoder_finish(), but + * before FLAC__stream_decoder_init_*(). If this is the case they will + * return \c true, otherwise \c false. + * + * \note + * FLAC__stream_decoder_finish() resets all settings to the constructor + * defaults, including the callbacks. + * + * \{ + */ + + +/** State values for a FLAC__StreamDecoder + * + * The decoder's state can be obtained by calling FLAC__stream_decoder_get_state(). + */ +typedef enum { + + FLAC__STREAM_DECODER_SEARCH_FOR_METADATA = 0, + /**< The decoder is ready to search for metadata. */ + + FLAC__STREAM_DECODER_READ_METADATA, + /**< The decoder is ready to or is in the process of reading metadata. */ + + FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC, + /**< The decoder is ready to or is in the process of searching for the + * frame sync code. + */ + + FLAC__STREAM_DECODER_READ_FRAME, + /**< The decoder is ready to or is in the process of reading a frame. */ + + FLAC__STREAM_DECODER_END_OF_STREAM, + /**< The decoder has reached the end of the stream. */ + + FLAC__STREAM_DECODER_OGG_ERROR, + /**< An error occurred in the underlying Ogg layer. */ + + FLAC__STREAM_DECODER_SEEK_ERROR, + /**< An error occurred while seeking. The decoder must be flushed + * with FLAC__stream_decoder_flush() or reset with + * FLAC__stream_decoder_reset() before decoding can continue. + */ + + FLAC__STREAM_DECODER_ABORTED, + /**< The decoder was aborted by the read or write callback. */ + + FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR, + /**< An error occurred allocating memory. The decoder is in an invalid + * state and can no longer be used. + */ + + FLAC__STREAM_DECODER_UNINITIALIZED + /**< The decoder is in the uninitialized state; one of the + * FLAC__stream_decoder_init_*() functions must be called before samples + * can be processed. + */ + +} FLAC__StreamDecoderState; + +/** Maps a FLAC__StreamDecoderState to a C string. + * + * Using a FLAC__StreamDecoderState as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderStateString[]; + + +/** Possible return values for the FLAC__stream_decoder_init_*() functions. + */ +typedef enum { + + FLAC__STREAM_DECODER_INIT_STATUS_OK = 0, + /**< Initialization was successful. */ + + FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER, + /**< The library was not compiled with support for the given container + * format. + */ + + FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS, + /**< A required callback was not supplied. */ + + FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR, + /**< An error occurred allocating memory. */ + + FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE, + /**< fopen() failed in FLAC__stream_decoder_init_file() or + * FLAC__stream_decoder_init_ogg_file(). */ + + FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED + /**< FLAC__stream_decoder_init_*() was called when the decoder was + * already initialized, usually because + * FLAC__stream_decoder_finish() was not called. + */ + +} FLAC__StreamDecoderInitStatus; + +/** Maps a FLAC__StreamDecoderInitStatus to a C string. + * + * Using a FLAC__StreamDecoderInitStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderInitStatusString[]; + + +/** Return values for the FLAC__StreamDecoder read callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_READ_STATUS_CONTINUE, + /**< The read was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM, + /**< The read was attempted while at the end of the stream. Note that + * the client must only return this value when the read callback was + * called when already at the end of the stream. Otherwise, if the read + * itself moves to the end of the stream, the client should still return + * the data and \c FLAC__STREAM_DECODER_READ_STATUS_CONTINUE, and then on + * the next read callback it should return + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM with a byte count + * of \c 0. + */ + + FLAC__STREAM_DECODER_READ_STATUS_ABORT + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + +} FLAC__StreamDecoderReadStatus; + +/** Maps a FLAC__StreamDecoderReadStatus to a C string. + * + * Using a FLAC__StreamDecoderReadStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderReadStatusString[]; + + +/** Return values for the FLAC__StreamDecoder seek callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_SEEK_STATUS_OK, + /**< The seek was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_SEEK_STATUS_ERROR, + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + + FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED + /**< Client does not support seeking. */ + +} FLAC__StreamDecoderSeekStatus; + +/** Maps a FLAC__StreamDecoderSeekStatus to a C string. + * + * Using a FLAC__StreamDecoderSeekStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderSeekStatusString[]; + + +/** Return values for the FLAC__StreamDecoder tell callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_TELL_STATUS_OK, + /**< The tell was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_TELL_STATUS_ERROR, + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + + FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED + /**< Client does not support telling the position. */ + +} FLAC__StreamDecoderTellStatus; + +/** Maps a FLAC__StreamDecoderTellStatus to a C string. + * + * Using a FLAC__StreamDecoderTellStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderTellStatusString[]; + + +/** Return values for the FLAC__StreamDecoder length callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_LENGTH_STATUS_OK, + /**< The length call was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR, + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + + FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED + /**< Client does not support reporting the length. */ + +} FLAC__StreamDecoderLengthStatus; + +/** Maps a FLAC__StreamDecoderLengthStatus to a C string. + * + * Using a FLAC__StreamDecoderLengthStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderLengthStatusString[]; + + +/** Return values for the FLAC__StreamDecoder write callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE, + /**< The write was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_WRITE_STATUS_ABORT + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + +} FLAC__StreamDecoderWriteStatus; + +/** Maps a FLAC__StreamDecoderWriteStatus to a C string. + * + * Using a FLAC__StreamDecoderWriteStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderWriteStatusString[]; + + +/** Possible values passed back to the FLAC__StreamDecoder error callback. + * \c FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC is the generic catch- + * all. The rest could be caused by bad sync (false synchronization on + * data that is not the start of a frame) or corrupted data. The error + * itself is the decoder's best guess at what happened assuming a correct + * sync. For example \c FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER + * could be caused by a correct sync on the start of a frame, but some + * data in the frame header was corrupted. Or it could be the result of + * syncing on a point the stream that looked like the starting of a frame + * but was not. \c FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM + * could be because the decoder encountered a valid frame made by a future + * version of the encoder which it cannot parse, or because of a false + * sync making it appear as though an encountered frame was generated by + * a future encoder. + */ +typedef enum { + + FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC, + /**< An error in the stream caused the decoder to lose synchronization. */ + + FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER, + /**< The decoder encountered a corrupted frame header. */ + + FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH, + /**< The frame's data did not match the CRC in the footer. */ + + FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM + /**< The decoder encountered reserved fields in use in the stream. */ + +} FLAC__StreamDecoderErrorStatus; + +/** Maps a FLAC__StreamDecoderErrorStatus to a C string. + * + * Using a FLAC__StreamDecoderErrorStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderErrorStatusString[]; + + +/*********************************************************************** + * + * class FLAC__StreamDecoder + * + ***********************************************************************/ + +struct FLAC__StreamDecoderProtected; +struct FLAC__StreamDecoderPrivate; +/** The opaque structure definition for the stream decoder type. + * See the \link flac_stream_decoder stream decoder module \endlink + * for a detailed description. + */ +typedef struct { + struct FLAC__StreamDecoderProtected *protected_; /* avoid the C++ keyword 'protected' */ + struct FLAC__StreamDecoderPrivate *private_; /* avoid the C++ keyword 'private' */ +} FLAC__StreamDecoder; + +/** Signature for the read callback. + * + * A function pointer matching this signature must be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder needs more input data. The address of the + * buffer to be filled is supplied, along with the number of bytes the + * buffer can hold. The callback may choose to supply less data and + * modify the byte count but must be careful not to overflow the buffer. + * The callback then returns a status code chosen from + * FLAC__StreamDecoderReadStatus. + * + * Here is an example of a read callback for stdio streams: + * \code + * FLAC__StreamDecoderReadStatus read_cb(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(*bytes > 0) { + * *bytes = fread(buffer, sizeof(FLAC__byte), *bytes, file); + * if(ferror(file)) + * return FLAC__STREAM_DECODER_READ_STATUS_ABORT; + * else if(*bytes == 0) + * return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM; + * else + * return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; + * } + * else + * return FLAC__STREAM_DECODER_READ_STATUS_ABORT; + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param buffer A pointer to a location for the callee to store + * data to be decoded. + * \param bytes A pointer to the size of the buffer. On entry + * to the callback, it contains the maximum number + * of bytes that may be stored in \a buffer. The + * callee must set it to the actual number of bytes + * stored (0 in case of error or end-of-stream) before + * returning. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderReadStatus + * The callee's return status. Note that the callback should return + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM if and only if + * zero bytes were read and there is no more data to be read. + */ +typedef FLAC__StreamDecoderReadStatus (*FLAC__StreamDecoderReadCallback)(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data); + +/** Signature for the seek callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder needs to seek the input stream. The decoder + * will pass the absolute byte offset to seek to, 0 meaning the + * beginning of the stream. + * + * Here is an example of a seek callback for stdio streams: + * \code + * FLAC__StreamDecoderSeekStatus seek_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(file == stdin) + * return FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED; + * else if(fseeko(file, (off_t)absolute_byte_offset, SEEK_SET) < 0) + * return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR; + * else + * return FLAC__STREAM_DECODER_SEEK_STATUS_OK; + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param absolute_byte_offset The offset from the beginning of the stream + * to seek to. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderSeekStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderSeekStatus (*FLAC__StreamDecoderSeekCallback)(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data); + +/** Signature for the tell callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder wants to know the current position of the + * stream. The callback should return the byte offset from the + * beginning of the stream. + * + * Here is an example of a tell callback for stdio streams: + * \code + * FLAC__StreamDecoderTellStatus tell_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * off_t pos; + * if(file == stdin) + * return FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED; + * else if((pos = ftello(file)) < 0) + * return FLAC__STREAM_DECODER_TELL_STATUS_ERROR; + * else { + * *absolute_byte_offset = (FLAC__uint64)pos; + * return FLAC__STREAM_DECODER_TELL_STATUS_OK; + * } + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param absolute_byte_offset A pointer to storage for the current offset + * from the beginning of the stream. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderTellStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderTellStatus (*FLAC__StreamDecoderTellCallback)(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data); + +/** Signature for the length callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder wants to know the total length of the stream + * in bytes. + * + * Here is an example of a length callback for stdio streams: + * \code + * FLAC__StreamDecoderLengthStatus length_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * struct stat filestats; + * + * if(file == stdin) + * return FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED; + * else if(fstat(fileno(file), &filestats) != 0) + * return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR; + * else { + * *stream_length = (FLAC__uint64)filestats.st_size; + * return FLAC__STREAM_DECODER_LENGTH_STATUS_OK; + * } + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param stream_length A pointer to storage for the length of the stream + * in bytes. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderLengthStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderLengthStatus (*FLAC__StreamDecoderLengthCallback)(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data); + +/** Signature for the EOF callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder needs to know if the end of the stream has + * been reached. + * + * Here is an example of a EOF callback for stdio streams: + * FLAC__bool eof_cb(const FLAC__StreamDecoder *decoder, void *client_data) + * \code + * { + * FILE *file = ((MyClientData*)client_data)->file; + * return feof(file)? true : false; + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__bool + * \c true if the currently at the end of the stream, else \c false. + */ +typedef FLAC__bool (*FLAC__StreamDecoderEofCallback)(const FLAC__StreamDecoder *decoder, void *client_data); + +/** Signature for the write callback. + * + * A function pointer matching this signature must be passed to one of + * the FLAC__stream_decoder_init_*() functions. + * The supplied function will be called when the decoder has decoded a + * single audio frame. The decoder will pass the frame metadata as well + * as an array of pointers (one for each channel) pointing to the + * decoded audio. + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param frame The description of the decoded frame. See + * FLAC__Frame. + * \param buffer An array of pointers to decoded channels of data. + * Each pointer will point to an array of signed + * samples of length \a frame->header.blocksize. + * Channels will be ordered according to the FLAC + * specification; see the documentation for the + * frame header. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderWriteStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderWriteStatus (*FLAC__StreamDecoderWriteCallback)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data); + +/** Signature for the metadata callback. + * + * A function pointer matching this signature must be passed to one of + * the FLAC__stream_decoder_init_*() functions. + * The supplied function will be called when the decoder has decoded a + * metadata block. In a valid FLAC file there will always be one + * \c STREAMINFO block, followed by zero or more other metadata blocks. + * These will be supplied by the decoder in the same order as they + * appear in the stream and always before the first audio frame (i.e. + * write callback). The metadata block that is passed in must not be + * modified, and it doesn't live beyond the callback, so you should make + * a copy of it with FLAC__metadata_object_clone() if you will need it + * elsewhere. Since metadata blocks can potentially be large, by + * default the decoder only calls the metadata callback for the + * \c STREAMINFO block; you can instruct the decoder to pass or filter + * other blocks with FLAC__stream_decoder_set_metadata_*() calls. + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param metadata The decoded metadata block. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + */ +typedef void (*FLAC__StreamDecoderMetadataCallback)(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data); + +/** Signature for the error callback. + * + * A function pointer matching this signature must be passed to one of + * the FLAC__stream_decoder_init_*() functions. + * The supplied function will be called whenever an error occurs during + * decoding. + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param status The error encountered by the decoder. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + */ +typedef void (*FLAC__StreamDecoderErrorCallback)(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data); + + +/*********************************************************************** + * + * Class constructor/destructor + * + ***********************************************************************/ + +/** Create a new stream decoder instance. The instance is created with + * default settings; see the individual FLAC__stream_decoder_set_*() + * functions for each setting's default. + * + * \retval FLAC__StreamDecoder* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamDecoder *FLAC__stream_decoder_new(void); + +/** Free a decoder instance. Deletes the object pointed to by \a decoder. + * + * \param decoder A pointer to an existing decoder. + * \assert + * \code decoder != NULL \endcode + */ +FLAC_API void FLAC__stream_decoder_delete(FLAC__StreamDecoder *decoder); + + +/*********************************************************************** + * + * Public class method prototypes + * + ***********************************************************************/ + +/** Set the serial number for the FLAC stream within the Ogg container. + * The default behavior is to use the serial number of the first Ogg + * page. Setting a serial number here will explicitly specify which + * stream is to be decoded. + * + * \note + * This does not need to be set for native FLAC decoding. + * + * \default \c use serial number of first page + * \param decoder A decoder instance to set. + * \param serial_number See above. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_ogg_serial_number(FLAC__StreamDecoder *decoder, long serial_number); + +/** Set the "MD5 signature checking" flag. If \c true, the decoder will + * compute the MD5 signature of the unencoded audio data while decoding + * and compare it to the signature from the STREAMINFO block, if it + * exists, during FLAC__stream_decoder_finish(). + * + * MD5 signature checking will be turned off (until the next + * FLAC__stream_decoder_reset()) if there is no signature in the + * STREAMINFO block or when a seek is attempted. + * + * Clients that do not use the MD5 check should leave this off to speed + * up decoding. + * + * \default \c false + * \param decoder A decoder instance to set. + * \param value Flag value (see above). + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_md5_checking(FLAC__StreamDecoder *decoder, FLAC__bool value); + +/** Direct the decoder to pass on all metadata blocks of type \a type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param type See above. + * \assert + * \code decoder != NULL \endcode + * \a type is valid + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond(FLAC__StreamDecoder *decoder, FLAC__MetadataType type); + +/** Direct the decoder to pass on all APPLICATION metadata blocks of the + * given \a id. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param id See above. + * \assert + * \code decoder != NULL \endcode + * \code id != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond_application(FLAC__StreamDecoder *decoder, const FLAC__byte id[4]); + +/** Direct the decoder to pass on all metadata blocks of any type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond_all(FLAC__StreamDecoder *decoder); + +/** Direct the decoder to filter out all metadata blocks of type \a type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param type See above. + * \assert + * \code decoder != NULL \endcode + * \a type is valid + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore(FLAC__StreamDecoder *decoder, FLAC__MetadataType type); + +/** Direct the decoder to filter out all APPLICATION metadata blocks of + * the given \a id. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param id See above. + * \assert + * \code decoder != NULL \endcode + * \code id != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore_application(FLAC__StreamDecoder *decoder, const FLAC__byte id[4]); + +/** Direct the decoder to filter out all metadata blocks of any type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore_all(FLAC__StreamDecoder *decoder); + +/** Get the current decoder state. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderState + * The current decoder state. + */ +FLAC_API FLAC__StreamDecoderState FLAC__stream_decoder_get_state(const FLAC__StreamDecoder *decoder); + +/** Get the current decoder state as a C string. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval const char * + * The decoder state as a C string. Do not modify the contents. + */ +FLAC_API const char *FLAC__stream_decoder_get_resolved_state_string(const FLAC__StreamDecoder *decoder); + +/** Get the "MD5 signature checking" flag. + * This is the value of the setting, not whether or not the decoder is + * currently checking the MD5 (remember, it can be turned off automatically + * by a seek). When the decoder is reset the flag will be restored to the + * value returned by this function. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * See above. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_get_md5_checking(const FLAC__StreamDecoder *decoder); + +/** Get the total number of samples in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the \c STREAMINFO block. A value of \c 0 means "unknown". + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval uint32_t + * See above. + */ +FLAC_API FLAC__uint64 FLAC__stream_decoder_get_total_samples(const FLAC__StreamDecoder *decoder); + +/** Get the current number of channels in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval uint32_t + * See above. + */ +FLAC_API uint32_t FLAC__stream_decoder_get_channels(const FLAC__StreamDecoder *decoder); + +/** Get the current channel assignment in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__ChannelAssignment + * See above. + */ +FLAC_API FLAC__ChannelAssignment FLAC__stream_decoder_get_channel_assignment(const FLAC__StreamDecoder *decoder); + +/** Get the current sample resolution in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval uint32_t + * See above. + */ +FLAC_API uint32_t FLAC__stream_decoder_get_bits_per_sample(const FLAC__StreamDecoder *decoder); + +/** Get the current sample rate in Hz of the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval uint32_t + * See above. + */ +FLAC_API uint32_t FLAC__stream_decoder_get_sample_rate(const FLAC__StreamDecoder *decoder); + +/** Get the current blocksize of the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval uint32_t + * See above. + */ +FLAC_API uint32_t FLAC__stream_decoder_get_blocksize(const FLAC__StreamDecoder *decoder); + +/** Returns the decoder's current read position within the stream. + * The position is the byte offset from the start of the stream. + * Bytes before this position have been fully decoded. Note that + * there may still be undecoded bytes in the decoder's read FIFO. + * The returned position is correct even after a seek. + * + * \warning This function currently only works for native FLAC, + * not Ogg FLAC streams. + * + * \param decoder A decoder instance to query. + * \param position Address at which to return the desired position. + * \assert + * \code decoder != NULL \endcode + * \code position != NULL \endcode + * \retval FLAC__bool + * \c true if successful, \c false if the stream is not native FLAC, + * or there was an error from the 'tell' callback or it returned + * \c FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_get_decode_position(const FLAC__StreamDecoder *decoder, FLAC__uint64 *position); + +/** Initialize the decoder instance to decode native FLAC streams. + * + * This flavor of initialization sets up the decoder to decode from a + * native FLAC stream. I/O is performed via callbacks to the client. + * For decoding from a plain file via filename or open FILE*, + * FLAC__stream_decoder_init_file() and FLAC__stream_decoder_init_FILE() + * provide a simpler interface. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \param decoder An uninitialized decoder instance. + * \param read_callback See FLAC__StreamDecoderReadCallback. This + * pointer must not be \c NULL. + * \param seek_callback See FLAC__StreamDecoderSeekCallback. This + * pointer may be \c NULL if seeking is not + * supported. If \a seek_callback is not \c NULL then a + * \a tell_callback, \a length_callback, and \a eof_callback must also be supplied. + * Alternatively, a dummy seek callback that just + * returns \c FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param tell_callback See FLAC__StreamDecoderTellCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a tell_callback must also be supplied. + * Alternatively, a dummy tell callback that just + * returns \c FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param length_callback See FLAC__StreamDecoderLengthCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a length_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param eof_callback See FLAC__StreamDecoderEofCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a eof_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c false + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_stream( + FLAC__StreamDecoder *decoder, + FLAC__StreamDecoderReadCallback read_callback, + FLAC__StreamDecoderSeekCallback seek_callback, + FLAC__StreamDecoderTellCallback tell_callback, + FLAC__StreamDecoderLengthCallback length_callback, + FLAC__StreamDecoderEofCallback eof_callback, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode Ogg FLAC streams. + * + * This flavor of initialization sets up the decoder to decode from a + * FLAC stream in an Ogg container. I/O is performed via callbacks to the + * client. For decoding from a plain file via filename or open FILE*, + * FLAC__stream_decoder_init_ogg_file() and FLAC__stream_decoder_init_ogg_FILE() + * provide a simpler interface. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \note Support for Ogg FLAC in the library is optional. If this + * library has been built without support for Ogg FLAC, this function + * will return \c FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER. + * + * \param decoder An uninitialized decoder instance. + * \param read_callback See FLAC__StreamDecoderReadCallback. This + * pointer must not be \c NULL. + * \param seek_callback See FLAC__StreamDecoderSeekCallback. This + * pointer may be \c NULL if seeking is not + * supported. If \a seek_callback is not \c NULL then a + * \a tell_callback, \a length_callback, and \a eof_callback must also be supplied. + * Alternatively, a dummy seek callback that just + * returns \c FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param tell_callback See FLAC__StreamDecoderTellCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a tell_callback must also be supplied. + * Alternatively, a dummy tell callback that just + * returns \c FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param length_callback See FLAC__StreamDecoderLengthCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a length_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param eof_callback See FLAC__StreamDecoderEofCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a eof_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c false + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_stream( + FLAC__StreamDecoder *decoder, + FLAC__StreamDecoderReadCallback read_callback, + FLAC__StreamDecoderSeekCallback seek_callback, + FLAC__StreamDecoderTellCallback tell_callback, + FLAC__StreamDecoderLengthCallback length_callback, + FLAC__StreamDecoderEofCallback eof_callback, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode native FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a + * plain native FLAC file. For non-stdio streams, you must use + * FLAC__stream_decoder_init_stream() and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \param decoder An uninitialized decoder instance. + * \param file An open FLAC file. The file should have been + * opened with mode \c "rb" and rewound. The file + * becomes owned by the decoder and should not be + * manipulated by the client while decoding. + * Unless \a file is \c stdin, it will be closed + * when FLAC__stream_decoder_finish() is called. + * Note however that seeking will not work when + * decoding from \c stdin since it is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \code file != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_FILE( + FLAC__StreamDecoder *decoder, + FILE *file, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode Ogg FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a + * plain Ogg FLAC file. For non-stdio streams, you must use + * FLAC__stream_decoder_init_ogg_stream() and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \note Support for Ogg FLAC in the library is optional. If this + * library has been built without support for Ogg FLAC, this function + * will return \c FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER. + * + * \param decoder An uninitialized decoder instance. + * \param file An open FLAC file. The file should have been + * opened with mode \c "rb" and rewound. The file + * becomes owned by the decoder and should not be + * manipulated by the client while decoding. + * Unless \a file is \c stdin, it will be closed + * when FLAC__stream_decoder_finish() is called. + * Note however that seeking will not work when + * decoding from \c stdin since it is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \code file != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_FILE( + FLAC__StreamDecoder *decoder, + FILE *file, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode native FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a plain + * native FLAC file. If POSIX fopen() semantics are not sufficient, (for + * example, with Unicode filenames on Windows), you must use + * FLAC__stream_decoder_init_FILE(), or FLAC__stream_decoder_init_stream() + * and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \param decoder An uninitialized decoder instance. + * \param filename The name of the file to decode from. The file will + * be opened with fopen(). Use \c NULL to decode from + * \c stdin. Note that \c stdin is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_file( + FLAC__StreamDecoder *decoder, + const char *filename, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode Ogg FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a plain + * Ogg FLAC file. If POSIX fopen() semantics are not sufficient, (for + * example, with Unicode filenames on Windows), you must use + * FLAC__stream_decoder_init_ogg_FILE(), or FLAC__stream_decoder_init_ogg_stream() + * and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \note Support for Ogg FLAC in the library is optional. If this + * library has been built without support for Ogg FLAC, this function + * will return \c FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER. + * + * \param decoder An uninitialized decoder instance. + * \param filename The name of the file to decode from. The file will + * be opened with fopen(). Use \c NULL to decode from + * \c stdin. Note that \c stdin is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_file( + FLAC__StreamDecoder *decoder, + const char *filename, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Finish the decoding process. + * Flushes the decoding buffer, releases resources, resets the decoder + * settings to their defaults, and returns the decoder state to + * FLAC__STREAM_DECODER_UNINITIALIZED. + * + * In the event of a prematurely-terminated decode, it is not strictly + * necessary to call this immediately before FLAC__stream_decoder_delete() + * but it is good practice to match every FLAC__stream_decoder_init_*() + * with a FLAC__stream_decoder_finish(). + * + * \param decoder An uninitialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if MD5 checking is on AND a STREAMINFO block was available + * AND the MD5 signature in the STREAMINFO block was non-zero AND the + * signature does not match the one computed by the decoder; else + * \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_finish(FLAC__StreamDecoder *decoder); + +/** Flush the stream input. + * The decoder's input buffer will be cleared and the state set to + * \c FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC. This will also turn + * off MD5 checking. + * + * \param decoder A decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false if a memory allocation + * error occurs (in which case the state will be set to + * \c FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder); + +/** Reset the decoding process. + * The decoder's input buffer will be cleared and the state set to + * \c FLAC__STREAM_DECODER_SEARCH_FOR_METADATA. This is similar to + * FLAC__stream_decoder_finish() except that the settings are + * preserved; there is no need to call FLAC__stream_decoder_init_*() + * before decoding again. MD5 checking will be restored to its original + * setting. + * + * If the decoder is seekable, or was initialized with + * FLAC__stream_decoder_init*_FILE() or FLAC__stream_decoder_init*_file(), + * the decoder will also attempt to seek to the beginning of the file. + * If this rewind fails, this function will return \c false. It follows + * that FLAC__stream_decoder_reset() cannot be used when decoding from + * \c stdin. + * + * If the decoder was initialized with FLAC__stream_encoder_init*_stream() + * and is not seekable (i.e. no seek callback was provided or the seek + * callback returns \c FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED), it + * is the duty of the client to start feeding data from the beginning of + * the stream on the next FLAC__stream_decoder_process_*() call. + * + * \param decoder A decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false if a memory allocation occurs + * (in which case the state will be set to + * \c FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR) or a seek error + * occurs (the state will be unchanged). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_reset(FLAC__StreamDecoder *decoder); + +/** Decode one metadata block or audio frame. + * This version instructs the decoder to decode a either a single metadata + * block or a single frame and stop, unless the callbacks return a fatal + * error or the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM. + * + * As the decoder needs more input it will call the read callback. + * Depending on what was decoded, the metadata or write callback will be + * called with the decoded metadata block or audio frame. + * + * Unless there is a fatal read error or end of stream, this function + * will return once one whole frame is decoded. In other words, if the + * stream is not synchronized or points to a corrupt frame header, the + * decoder will continue to try and resync until it gets to a valid + * frame, then decode one frame, then return. If the decoder points to + * a frame whose frame CRC in the frame footer does not match the + * computed frame CRC, this function will issue a + * FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH error to the + * error callback, and return, having decoded one complete, although + * corrupt, frame. (Such corrupted frames are sent as silence of the + * correct length to the write callback.) + * + * \param decoder An initialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_process_single(FLAC__StreamDecoder *decoder); + +/** Decode until the end of the metadata. + * This version instructs the decoder to decode from the current position + * and continue until all the metadata has been read, or until the + * callbacks return a fatal error or the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM. + * + * As the decoder needs more input it will call the read callback. + * As each metadata block is decoded, the metadata callback will be called + * with the decoded metadata. + * + * \param decoder An initialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_process_until_end_of_metadata(FLAC__StreamDecoder *decoder); + +/** Decode until the end of the stream. + * This version instructs the decoder to decode from the current position + * and continue until the end of stream (the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM), or until the + * callbacks return a fatal error. + * + * As the decoder needs more input it will call the read callback. + * As each metadata block and frame is decoded, the metadata or write + * callback will be called with the decoded metadata or frame. + * + * \param decoder An initialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_process_until_end_of_stream(FLAC__StreamDecoder *decoder); + +/** Skip one audio frame. + * This version instructs the decoder to 'skip' a single frame and stop, + * unless the callbacks return a fatal error or the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM. + * + * The decoding flow is the same as what occurs when + * FLAC__stream_decoder_process_single() is called to process an audio + * frame, except that this function does not decode the parsed data into + * PCM or call the write callback. The integrity of the frame is still + * checked the same way as in the other process functions. + * + * This function will return once one whole frame is skipped, in the + * same way that FLAC__stream_decoder_process_single() will return once + * one whole frame is decoded. + * + * This function can be used in more quickly determining FLAC frame + * boundaries when decoding of the actual data is not needed, for + * example when an application is separating a FLAC stream into frames + * for editing or storing in a container. To do this, the application + * can use FLAC__stream_decoder_skip_single_frame() to quickly advance + * to the next frame, then use + * FLAC__stream_decoder_get_decode_position() to find the new frame + * boundary. + * + * This function should only be called when the stream has advanced + * past all the metadata, otherwise it will return \c false. + * + * \param decoder An initialized decoder instance not in a metadata + * state. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), or if the decoder + * is in the FLAC__STREAM_DECODER_SEARCH_FOR_METADATA or + * FLAC__STREAM_DECODER_READ_METADATA state, else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_skip_single_frame(FLAC__StreamDecoder *decoder); + +/** Flush the input and seek to an absolute sample. + * Decoding will resume at the given sample. Note that because of + * this, the next write callback may contain a partial block. The + * client must support seeking the input or this function will fail + * and return \c false. Furthermore, if the decoder state is + * \c FLAC__STREAM_DECODER_SEEK_ERROR, then the decoder must be flushed + * with FLAC__stream_decoder_flush() or reset with + * FLAC__stream_decoder_reset() before decoding can continue. + * + * \param decoder A decoder instance. + * \param sample The target sample number to seek to. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_seek_absolute(FLAC__StreamDecoder *decoder, FLAC__uint64 sample); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libs/include/FLAC/stream_encoder.h b/libs/include/FLAC/stream_encoder.h new file mode 100644 index 0000000..d154ac4 --- /dev/null +++ b/libs/include/FLAC/stream_encoder.h @@ -0,0 +1,1790 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2016 Xiph.Org Foundation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * - Neither the name of the Xiph.org Foundation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FLAC__STREAM_ENCODER_H +#define FLAC__STREAM_ENCODER_H + +#include /* for FILE */ +#include "export.h" +#include "format.h" +#include "stream_decoder.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** \file include/FLAC/stream_encoder.h + * + * \brief + * This module contains the functions which implement the stream + * encoder. + * + * See the detailed documentation in the + * \link flac_stream_encoder stream encoder \endlink module. + */ + +/** \defgroup flac_encoder FLAC/ \*_encoder.h: encoder interfaces + * \ingroup flac + * + * \brief + * This module describes the encoder layers provided by libFLAC. + * + * The stream encoder can be used to encode complete streams either to the + * client via callbacks, or directly to a file, depending on how it is + * initialized. When encoding via callbacks, the client provides a write + * callback which will be called whenever FLAC data is ready to be written. + * If the client also supplies a seek callback, the encoder will also + * automatically handle the writing back of metadata discovered while + * encoding, like stream info, seek points offsets, etc. When encoding to + * a file, the client needs only supply a filename or open \c FILE* and an + * optional progress callback for periodic notification of progress; the + * write and seek callbacks are supplied internally. For more info see the + * \link flac_stream_encoder stream encoder \endlink module. + */ + +/** \defgroup flac_stream_encoder FLAC/stream_encoder.h: stream encoder interface + * \ingroup flac_encoder + * + * \brief + * This module contains the functions which implement the stream + * encoder. + * + * The stream encoder can encode to native FLAC, and optionally Ogg FLAC + * (check FLAC_API_SUPPORTS_OGG_FLAC) streams and files. + * + * The basic usage of this encoder is as follows: + * - The program creates an instance of an encoder using + * FLAC__stream_encoder_new(). + * - The program overrides the default settings using + * FLAC__stream_encoder_set_*() functions. At a minimum, the following + * functions should be called: + * - FLAC__stream_encoder_set_channels() + * - FLAC__stream_encoder_set_bits_per_sample() + * - FLAC__stream_encoder_set_sample_rate() + * - FLAC__stream_encoder_set_ogg_serial_number() (if encoding to Ogg FLAC) + * - FLAC__stream_encoder_set_total_samples_estimate() (if known) + * - If the application wants to control the compression level or set its own + * metadata, then the following should also be called: + * - FLAC__stream_encoder_set_compression_level() + * - FLAC__stream_encoder_set_verify() + * - FLAC__stream_encoder_set_metadata() + * - The rest of the set functions should only be called if the client needs + * exact control over how the audio is compressed; thorough understanding + * of the FLAC format is necessary to achieve good results. + * - The program initializes the instance to validate the settings and + * prepare for encoding using + * - FLAC__stream_encoder_init_stream() or FLAC__stream_encoder_init_FILE() + * or FLAC__stream_encoder_init_file() for native FLAC + * - FLAC__stream_encoder_init_ogg_stream() or FLAC__stream_encoder_init_ogg_FILE() + * or FLAC__stream_encoder_init_ogg_file() for Ogg FLAC + * - The program calls FLAC__stream_encoder_process() or + * FLAC__stream_encoder_process_interleaved() to encode data, which + * subsequently calls the callbacks when there is encoder data ready + * to be written. + * - The program finishes the encoding with FLAC__stream_encoder_finish(), + * which causes the encoder to encode any data still in its input pipe, + * update the metadata with the final encoding statistics if output + * seeking is possible, and finally reset the encoder to the + * uninitialized state. + * - The instance may be used again or deleted with + * FLAC__stream_encoder_delete(). + * + * In more detail, the stream encoder functions similarly to the + * \link flac_stream_decoder stream decoder \endlink, but has fewer + * callbacks and more options. Typically the client will create a new + * instance by calling FLAC__stream_encoder_new(), then set the necessary + * parameters with FLAC__stream_encoder_set_*(), and initialize it by + * calling one of the FLAC__stream_encoder_init_*() functions. + * + * Unlike the decoders, the stream encoder has many options that can + * affect the speed and compression ratio. When setting these parameters + * you should have some basic knowledge of the format (see the + * user-level documentation + * or the formal description). The + * FLAC__stream_encoder_set_*() functions themselves do not validate the + * values as many are interdependent. The FLAC__stream_encoder_init_*() + * functions will do this, so make sure to pay attention to the state + * returned by FLAC__stream_encoder_init_*() to make sure that it is + * FLAC__STREAM_ENCODER_INIT_STATUS_OK. Any parameters that are not set + * before FLAC__stream_encoder_init_*() will take on the defaults from + * the constructor. + * + * There are three initialization functions for native FLAC, one for + * setting up the encoder to encode FLAC data to the client via + * callbacks, and two for encoding directly to a file. + * + * For encoding via callbacks, use FLAC__stream_encoder_init_stream(). + * You must also supply a write callback which will be called anytime + * there is raw encoded data to write. If the client can seek the output + * it is best to also supply seek and tell callbacks, as this allows the + * encoder to go back after encoding is finished to write back + * information that was collected while encoding, like seek point offsets, + * frame sizes, etc. + * + * For encoding directly to a file, use FLAC__stream_encoder_init_FILE() + * or FLAC__stream_encoder_init_file(). Then you must only supply a + * filename or open \c FILE*; the encoder will handle all the callbacks + * internally. You may also supply a progress callback for periodic + * notification of the encoding progress. + * + * There are three similarly-named init functions for encoding to Ogg + * FLAC streams. Check \c FLAC_API_SUPPORTS_OGG_FLAC to find out if the + * library has been built with Ogg support. + * + * The call to FLAC__stream_encoder_init_*() currently will also immediately + * call the write callback several times, once with the \c fLaC signature, + * and once for each encoded metadata block. Note that for Ogg FLAC + * encoding you will usually get at least twice the number of callbacks than + * with native FLAC, one for the Ogg page header and one for the page body. + * + * After initializing the instance, the client may feed audio data to the + * encoder in one of two ways: + * + * - Channel separate, through FLAC__stream_encoder_process() - The client + * will pass an array of pointers to buffers, one for each channel, to + * the encoder, each of the same length. The samples need not be + * block-aligned, but each channel should have the same number of samples. + * - Channel interleaved, through + * FLAC__stream_encoder_process_interleaved() - The client will pass a single + * pointer to data that is channel-interleaved (i.e. channel0_sample0, + * channel1_sample0, ... , channelN_sample0, channel0_sample1, ...). + * Again, the samples need not be block-aligned but they must be + * sample-aligned, i.e. the first value should be channel0_sample0 and + * the last value channelN_sampleM. + * + * Note that for either process call, each sample in the buffers should be a + * signed integer, right-justified to the resolution set by + * FLAC__stream_encoder_set_bits_per_sample(). For example, if the resolution + * is 16 bits per sample, the samples should all be in the range [-32768,32767]. + * + * When the client is finished encoding data, it calls + * FLAC__stream_encoder_finish(), which causes the encoder to encode any + * data still in its input pipe, and call the metadata callback with the + * final encoding statistics. Then the instance may be deleted with + * FLAC__stream_encoder_delete() or initialized again to encode another + * stream. + * + * For programs that write their own metadata, but that do not know the + * actual metadata until after encoding, it is advantageous to instruct + * the encoder to write a PADDING block of the correct size, so that + * instead of rewriting the whole stream after encoding, the program can + * just overwrite the PADDING block. If only the maximum size of the + * metadata is known, the program can write a slightly larger padding + * block, then split it after encoding. + * + * Make sure you understand how lengths are calculated. All FLAC metadata + * blocks have a 4 byte header which contains the type and length. This + * length does not include the 4 bytes of the header. See the format page + * for the specification of metadata blocks and their lengths. + * + * \note + * If you are writing the FLAC data to a file via callbacks, make sure it + * is open for update (e.g. mode "w+" for stdio streams). This is because + * after the first encoding pass, the encoder will try to seek back to the + * beginning of the stream, to the STREAMINFO block, to write some data + * there. (If using FLAC__stream_encoder_init*_file() or + * FLAC__stream_encoder_init*_FILE(), the file is managed internally.) + * + * \note + * The "set" functions may only be called when the encoder is in the + * state FLAC__STREAM_ENCODER_UNINITIALIZED, i.e. after + * FLAC__stream_encoder_new() or FLAC__stream_encoder_finish(), but + * before FLAC__stream_encoder_init_*(). If this is the case they will + * return \c true, otherwise \c false. + * + * \note + * FLAC__stream_encoder_finish() resets all settings to the constructor + * defaults. + * + * \{ + */ + + +/** State values for a FLAC__StreamEncoder. + * + * The encoder's state can be obtained by calling FLAC__stream_encoder_get_state(). + * + * If the encoder gets into any other state besides \c FLAC__STREAM_ENCODER_OK + * or \c FLAC__STREAM_ENCODER_UNINITIALIZED, it becomes invalid for encoding and + * must be deleted with FLAC__stream_encoder_delete(). + */ +typedef enum { + + FLAC__STREAM_ENCODER_OK = 0, + /**< The encoder is in the normal OK state and samples can be processed. */ + + FLAC__STREAM_ENCODER_UNINITIALIZED, + /**< The encoder is in the uninitialized state; one of the + * FLAC__stream_encoder_init_*() functions must be called before samples + * can be processed. + */ + + FLAC__STREAM_ENCODER_OGG_ERROR, + /**< An error occurred in the underlying Ogg layer. */ + + FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR, + /**< An error occurred in the underlying verify stream decoder; + * check FLAC__stream_encoder_get_verify_decoder_state(). + */ + + FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA, + /**< The verify decoder detected a mismatch between the original + * audio signal and the decoded audio signal. + */ + + FLAC__STREAM_ENCODER_CLIENT_ERROR, + /**< One of the callbacks returned a fatal error. */ + + FLAC__STREAM_ENCODER_IO_ERROR, + /**< An I/O error occurred while opening/reading/writing a file. + * Check \c errno. + */ + + FLAC__STREAM_ENCODER_FRAMING_ERROR, + /**< An error occurred while writing the stream; usually, the + * write_callback returned an error. + */ + + FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR + /**< Memory allocation failed. */ + +} FLAC__StreamEncoderState; + +/** Maps a FLAC__StreamEncoderState to a C string. + * + * Using a FLAC__StreamEncoderState as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderStateString[]; + + +/** Possible return values for the FLAC__stream_encoder_init_*() functions. + */ +typedef enum { + + FLAC__STREAM_ENCODER_INIT_STATUS_OK = 0, + /**< Initialization was successful. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR, + /**< General failure to set up encoder; call FLAC__stream_encoder_get_state() for cause. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER, + /**< The library was not compiled with support for the given container + * format. + */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS, + /**< A required callback was not supplied. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS, + /**< The encoder has an invalid setting for number of channels. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE, + /**< The encoder has an invalid setting for bits-per-sample. + * FLAC supports 4-32 bps but the reference encoder currently supports + * only up to 24 bps. + */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE, + /**< The encoder has an invalid setting for the input sample rate. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE, + /**< The encoder has an invalid setting for the block size. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER, + /**< The encoder has an invalid setting for the maximum LPC order. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION, + /**< The encoder has an invalid setting for the precision of the quantized linear predictor coefficients. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER, + /**< The specified block size is less than the maximum LPC order. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE, + /**< The encoder is bound to the Subset but other settings violate it. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA, + /**< The metadata input to the encoder is invalid, in one of the following ways: + * - FLAC__stream_encoder_set_metadata() was called with a null pointer but a block count > 0 + * - One of the metadata blocks contains an undefined type + * - It contains an illegal CUESHEET as checked by FLAC__format_cuesheet_is_legal() + * - It contains an illegal SEEKTABLE as checked by FLAC__format_seektable_is_legal() + * - It contains more than one SEEKTABLE block or more than one VORBIS_COMMENT block + */ + + FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED + /**< FLAC__stream_encoder_init_*() was called when the encoder was + * already initialized, usually because + * FLAC__stream_encoder_finish() was not called. + */ + +} FLAC__StreamEncoderInitStatus; + +/** Maps a FLAC__StreamEncoderInitStatus to a C string. + * + * Using a FLAC__StreamEncoderInitStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderInitStatusString[]; + + +/** Return values for the FLAC__StreamEncoder read callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE, + /**< The read was OK and decoding can continue. */ + + FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM, + /**< The read was attempted at the end of the stream. */ + + FLAC__STREAM_ENCODER_READ_STATUS_ABORT, + /**< An unrecoverable error occurred. */ + + FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED + /**< Client does not support reading back from the output. */ + +} FLAC__StreamEncoderReadStatus; + +/** Maps a FLAC__StreamEncoderReadStatus to a C string. + * + * Using a FLAC__StreamEncoderReadStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderReadStatusString[]; + + +/** Return values for the FLAC__StreamEncoder write callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_WRITE_STATUS_OK = 0, + /**< The write was OK and encoding can continue. */ + + FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR + /**< An unrecoverable error occurred. The encoder will return from the process call. */ + +} FLAC__StreamEncoderWriteStatus; + +/** Maps a FLAC__StreamEncoderWriteStatus to a C string. + * + * Using a FLAC__StreamEncoderWriteStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderWriteStatusString[]; + + +/** Return values for the FLAC__StreamEncoder seek callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_SEEK_STATUS_OK, + /**< The seek was OK and encoding can continue. */ + + FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR, + /**< An unrecoverable error occurred. */ + + FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED + /**< Client does not support seeking. */ + +} FLAC__StreamEncoderSeekStatus; + +/** Maps a FLAC__StreamEncoderSeekStatus to a C string. + * + * Using a FLAC__StreamEncoderSeekStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderSeekStatusString[]; + + +/** Return values for the FLAC__StreamEncoder tell callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_TELL_STATUS_OK, + /**< The tell was OK and encoding can continue. */ + + FLAC__STREAM_ENCODER_TELL_STATUS_ERROR, + /**< An unrecoverable error occurred. */ + + FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED + /**< Client does not support seeking. */ + +} FLAC__StreamEncoderTellStatus; + +/** Maps a FLAC__StreamEncoderTellStatus to a C string. + * + * Using a FLAC__StreamEncoderTellStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderTellStatusString[]; + + +/*********************************************************************** + * + * class FLAC__StreamEncoder + * + ***********************************************************************/ + +struct FLAC__StreamEncoderProtected; +struct FLAC__StreamEncoderPrivate; +/** The opaque structure definition for the stream encoder type. + * See the \link flac_stream_encoder stream encoder module \endlink + * for a detailed description. + */ +typedef struct { + struct FLAC__StreamEncoderProtected *protected_; /* avoid the C++ keyword 'protected' */ + struct FLAC__StreamEncoderPrivate *private_; /* avoid the C++ keyword 'private' */ +} FLAC__StreamEncoder; + +/** Signature for the read callback. + * + * A function pointer matching this signature must be passed to + * FLAC__stream_encoder_init_ogg_stream() if seeking is supported. + * The supplied function will be called when the encoder needs to read back + * encoded data. This happens during the metadata callback, when the encoder + * has to read, modify, and rewrite the metadata (e.g. seekpoints) gathered + * while encoding. The address of the buffer to be filled is supplied, along + * with the number of bytes the buffer can hold. The callback may choose to + * supply less data and modify the byte count but must be careful not to + * overflow the buffer. The callback then returns a status code chosen from + * FLAC__StreamEncoderReadStatus. + * + * Here is an example of a read callback for stdio streams: + * \code + * FLAC__StreamEncoderReadStatus read_cb(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(*bytes > 0) { + * *bytes = fread(buffer, sizeof(FLAC__byte), *bytes, file); + * if(ferror(file)) + * return FLAC__STREAM_ENCODER_READ_STATUS_ABORT; + * else if(*bytes == 0) + * return FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM; + * else + * return FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE; + * } + * else + * return FLAC__STREAM_ENCODER_READ_STATUS_ABORT; + * } + * \endcode + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param buffer A pointer to a location for the callee to store + * data to be encoded. + * \param bytes A pointer to the size of the buffer. On entry + * to the callback, it contains the maximum number + * of bytes that may be stored in \a buffer. The + * callee must set it to the actual number of bytes + * stored (0 in case of error or end-of-stream) before + * returning. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_set_client_data(). + * \retval FLAC__StreamEncoderReadStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderReadStatus (*FLAC__StreamEncoderReadCallback)(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data); + +/** Signature for the write callback. + * + * A function pointer matching this signature must be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * by the encoder anytime there is raw encoded data ready to write. It may + * include metadata mixed with encoded audio frames and the data is not + * guaranteed to be aligned on frame or metadata block boundaries. + * + * The only duty of the callback is to write out the \a bytes worth of data + * in \a buffer to the current position in the output stream. The arguments + * \a samples and \a current_frame are purely informational. If \a samples + * is greater than \c 0, then \a current_frame will hold the current frame + * number that is being written; otherwise it indicates that the write + * callback is being called to write metadata. + * + * \note + * Unlike when writing to native FLAC, when writing to Ogg FLAC the + * write callback will be called twice when writing each audio + * frame; once for the page header, and once for the page body. + * When writing the page header, the \a samples argument to the + * write callback will be \c 0. + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param buffer An array of encoded data of length \a bytes. + * \param bytes The byte length of \a buffer. + * \param samples The number of samples encoded by \a buffer. + * \c 0 has a special meaning; see above. + * \param current_frame The number of the current frame being encoded. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + * \retval FLAC__StreamEncoderWriteStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderWriteStatus (*FLAC__StreamEncoderWriteCallback)(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, uint32_t samples, uint32_t current_frame, void *client_data); + +/** Signature for the seek callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * when the encoder needs to seek the output stream. The encoder will pass + * the absolute byte offset to seek to, 0 meaning the beginning of the stream. + * + * Here is an example of a seek callback for stdio streams: + * \code + * FLAC__StreamEncoderSeekStatus seek_cb(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(file == stdin) + * return FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED; + * else if(fseeko(file, (off_t)absolute_byte_offset, SEEK_SET) < 0) + * return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR; + * else + * return FLAC__STREAM_ENCODER_SEEK_STATUS_OK; + * } + * \endcode + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param absolute_byte_offset The offset from the beginning of the stream + * to seek to. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + * \retval FLAC__StreamEncoderSeekStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderSeekStatus (*FLAC__StreamEncoderSeekCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data); + +/** Signature for the tell callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * when the encoder needs to know the current position of the output stream. + * + * \warning + * The callback must return the true current byte offset of the output to + * which the encoder is writing. If you are buffering the output, make + * sure and take this into account. If you are writing directly to a + * FILE* from your write callback, ftell() is sufficient. If you are + * writing directly to a file descriptor from your write callback, you + * can use lseek(fd, SEEK_CUR, 0). The encoder may later seek back to + * these points to rewrite metadata after encoding. + * + * Here is an example of a tell callback for stdio streams: + * \code + * FLAC__StreamEncoderTellStatus tell_cb(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * off_t pos; + * if(file == stdin) + * return FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED; + * else if((pos = ftello(file)) < 0) + * return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR; + * else { + * *absolute_byte_offset = (FLAC__uint64)pos; + * return FLAC__STREAM_ENCODER_TELL_STATUS_OK; + * } + * } + * \endcode + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param absolute_byte_offset The address at which to store the current + * position of the output. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + * \retval FLAC__StreamEncoderTellStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderTellStatus (*FLAC__StreamEncoderTellCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data); + +/** Signature for the metadata callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * once at the end of encoding with the populated STREAMINFO structure. This + * is so the client can seek back to the beginning of the file and write the + * STREAMINFO block with the correct statistics after encoding (like + * minimum/maximum frame size and total samples). + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param metadata The final populated STREAMINFO block. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + */ +typedef void (*FLAC__StreamEncoderMetadataCallback)(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data); + +/** Signature for the progress callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_file() or FLAC__stream_encoder_init*_FILE(). + * The supplied function will be called when the encoder has finished + * writing a frame. The \c total_frames_estimate argument to the + * callback will be based on the value from + * FLAC__stream_encoder_set_total_samples_estimate(). + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param bytes_written Bytes written so far. + * \param samples_written Samples written so far. + * \param frames_written Frames written so far. + * \param total_frames_estimate The estimate of the total number of + * frames to be written. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + */ +typedef void (*FLAC__StreamEncoderProgressCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, uint32_t frames_written, uint32_t total_frames_estimate, void *client_data); + + +/*********************************************************************** + * + * Class constructor/destructor + * + ***********************************************************************/ + +/** Create a new stream encoder instance. The instance is created with + * default settings; see the individual FLAC__stream_encoder_set_*() + * functions for each setting's default. + * + * \retval FLAC__StreamEncoder* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamEncoder *FLAC__stream_encoder_new(void); + +/** Free an encoder instance. Deletes the object pointed to by \a encoder. + * + * \param encoder A pointer to an existing encoder. + * \assert + * \code encoder != NULL \endcode + */ +FLAC_API void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder); + + +/*********************************************************************** + * + * Public class method prototypes + * + ***********************************************************************/ + +/** Set the serial number for the FLAC stream to use in the Ogg container. + * + * \note + * This does not need to be set for native FLAC encoding. + * + * \note + * It is recommended to set a serial number explicitly as the default of '0' + * may collide with other streams. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param serial_number See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncoder *encoder, long serial_number); + +/** Set the "verify" flag. If \c true, the encoder will verify it's own + * encoded output by feeding it through an internal decoder and comparing + * the original signal against the decoded signal. If a mismatch occurs, + * the process call will return \c false. Note that this will slow the + * encoding process by the extra time required for decoding and comparison. + * + * \default \c false + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Set the Subset flag. If \c true, + * the encoder will comply with the Subset and will check the + * settings during FLAC__stream_encoder_init_*() to see if all settings + * comply. If \c false, the settings may take advantage of the full + * range that the format allows. + * + * Make sure you know what it entails before setting this to \c false. + * + * \default \c true + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Set the number of channels to be encoded. + * + * \default \c 2 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, uint32_t value); + +/** Set the sample resolution of the input to be encoded. + * + * \warning + * Do not feed the encoder data that is wider than the value you + * set here or you will generate an invalid stream. + * + * \default \c 16 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, uint32_t value); + +/** Set the sample rate (in Hz) of the input to be encoded. + * + * \default \c 44100 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, uint32_t value); + +/** Set the compression level + * + * The compression level is roughly proportional to the amount of effort + * the encoder expends to compress the file. A higher level usually + * means more computation but higher compression. The default level is + * suitable for most applications. + * + * Currently the levels range from \c 0 (fastest, least compression) to + * \c 8 (slowest, most compression). A value larger than \c 8 will be + * treated as \c 8. + * + * This function automatically calls the following other \c _set_ + * functions with appropriate values, so the client does not need to + * unless it specifically wants to override them: + * - FLAC__stream_encoder_set_do_mid_side_stereo() + * - FLAC__stream_encoder_set_loose_mid_side_stereo() + * - FLAC__stream_encoder_set_apodization() + * - FLAC__stream_encoder_set_max_lpc_order() + * - FLAC__stream_encoder_set_qlp_coeff_precision() + * - FLAC__stream_encoder_set_do_qlp_coeff_prec_search() + * - FLAC__stream_encoder_set_do_escape_coding() + * - FLAC__stream_encoder_set_do_exhaustive_model_search() + * - FLAC__stream_encoder_set_min_residual_partition_order() + * - FLAC__stream_encoder_set_max_residual_partition_order() + * - FLAC__stream_encoder_set_rice_parameter_search_dist() + * + * The actual values set for each level are: + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
leveldo mid-side stereoloose mid-side stereoapodizationmax lpc orderqlp coeff precisionqlp coeff prec searchescape codingexhaustive model searchmin residual partition ordermax residual partition orderrice parameter search dist
0 false false tukey(0.5) 0 0 false false false 0 3 0
1 true true tukey(0.5) 0 0 false false false 0 3 0
2 true false tukey(0.5) 0 0 false false false 0 3 0
3 false false tukey(0.5) 6 0 false false false 0 4 0
4 true true tukey(0.5) 8 0 false false false 0 4 0
5 true false tukey(0.5) 8 0 false false false 0 5 0
6 true false tukey(0.5);partial_tukey(2) 8 0 false false false 0 6 0
7 true false tukey(0.5);partial_tukey(2) 12 0 false false false 0 6 0
8 true false tukey(0.5);partial_tukey(2);punchout_tukey(3) 12 0 false false false 0 6 0
+ * + * \default \c 5 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, uint32_t value); + +/** Set the blocksize to use while encoding. + * + * The number of samples to use per frame. Use \c 0 to let the encoder + * estimate a blocksize; this is usually best. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, uint32_t value); + +/** Set to \c true to enable mid-side encoding on stereo input. The + * number of channels must be 2 for this to have any effect. Set to + * \c false to use only independent channel coding. + * + * \default \c true + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Set to \c true to enable adaptive switching between mid-side and + * left-right encoding on stereo input. Set to \c false to use + * exhaustive searching. Setting this to \c true requires + * FLAC__stream_encoder_set_do_mid_side_stereo() to also be set to + * \c true in order to have any effect. + * + * \default \c false + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Sets the apodization function(s) the encoder will use when windowing + * audio data for LPC analysis. + * + * The \a specification is a plain ASCII string which specifies exactly + * which functions to use. There may be more than one (up to 32), + * separated by \c ';' characters. Some functions take one or more + * comma-separated arguments in parentheses. + * + * The available functions are \c bartlett, \c bartlett_hann, + * \c blackman, \c blackman_harris_4term_92db, \c connes, \c flattop, + * \c gauss(STDDEV), \c hamming, \c hann, \c kaiser_bessel, \c nuttall, + * \c rectangle, \c triangle, \c tukey(P), \c partial_tukey(n[/ov[/P]]), + * \c punchout_tukey(n[/ov[/P]]), \c welch. + * + * For \c gauss(STDDEV), STDDEV specifies the standard deviation + * (0blocksize / (2 ^ order). + * + * Set both min and max values to \c 0 to force a single context, + * whose Rice parameter is based on the residual signal variance. + * Otherwise, set a min and max order, and the encoder will search + * all orders, using the mean of each context for its Rice parameter, + * and use the best. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, uint32_t value); + +/** Set the maximum partition order to search when coding the residual. + * This is used in tandem with + * FLAC__stream_encoder_set_min_residual_partition_order(). + * + * The partition order determines the context size in the residual. + * The context size will be approximately blocksize / (2 ^ order). + * + * Set both min and max values to \c 0 to force a single context, + * whose Rice parameter is based on the residual signal variance. + * Otherwise, set a min and max order, and the encoder will search + * all orders, using the mean of each context for its Rice parameter, + * and use the best. + * + * \default \c 5 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, uint32_t value); + +/** Deprecated. Setting this value has no effect. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, uint32_t value); + +/** Set an estimate of the total samples that will be encoded. + * This is merely an estimate and may be set to \c 0 if unknown. + * This value will be written to the STREAMINFO block before encoding, + * and can remove the need for the caller to rewrite the value later + * if the value is known before encoding. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value); + +/** Set the metadata blocks to be emitted to the stream before encoding. + * A value of \c NULL, \c 0 implies no metadata; otherwise, supply an + * array of pointers to metadata blocks. The array is non-const since + * the encoder may need to change the \a is_last flag inside them, and + * in some cases update seek point offsets. Otherwise, the encoder will + * not modify or free the blocks. It is up to the caller to free the + * metadata blocks after encoding finishes. + * + * \note + * The encoder stores only copies of the pointers in the \a metadata array; + * the metadata blocks themselves must survive at least until after + * FLAC__stream_encoder_finish() returns. Do not free the blocks until then. + * + * \note + * The STREAMINFO block is always written and no STREAMINFO block may + * occur in the supplied array. + * + * \note + * By default the encoder does not create a SEEKTABLE. If one is supplied + * in the \a metadata array, but the client has specified that it does not + * support seeking, then the SEEKTABLE will be written verbatim. However + * by itself this is not very useful as the client will not know the stream + * offsets for the seekpoints ahead of time. In order to get a proper + * seektable the client must support seeking. See next note. + * + * \note + * SEEKTABLE blocks are handled specially. Since you will not know + * the values for the seek point stream offsets, you should pass in + * a SEEKTABLE 'template', that is, a SEEKTABLE object with the + * required sample numbers (or placeholder points), with \c 0 for the + * \a frame_samples and \a stream_offset fields for each point. If the + * client has specified that it supports seeking by providing a seek + * callback to FLAC__stream_encoder_init_stream() or both seek AND read + * callback to FLAC__stream_encoder_init_ogg_stream() (or by using + * FLAC__stream_encoder_init*_file() or FLAC__stream_encoder_init*_FILE()), + * then while it is encoding the encoder will fill the stream offsets in + * for you and when encoding is finished, it will seek back and write the + * real values into the SEEKTABLE block in the stream. There are helper + * routines for manipulating seektable template blocks; see metadata.h: + * FLAC__metadata_object_seektable_template_*(). If the client does + * not support seeking, the SEEKTABLE will have inaccurate offsets which + * will slow down or remove the ability to seek in the FLAC stream. + * + * \note + * The encoder instance \b will modify the first \c SEEKTABLE block + * as it transforms the template to a valid seektable while encoding, + * but it is still up to the caller to free all metadata blocks after + * encoding. + * + * \note + * A VORBIS_COMMENT block may be supplied. The vendor string in it + * will be ignored. libFLAC will use it's own vendor string. libFLAC + * will not modify the passed-in VORBIS_COMMENT's vendor string, it + * will simply write it's own into the stream. If no VORBIS_COMMENT + * block is present in the \a metadata array, libFLAC will write an + * empty one, containing only the vendor string. + * + * \note The Ogg FLAC mapping requires that the VORBIS_COMMENT block be + * the second metadata block of the stream. The encoder already supplies + * the STREAMINFO block automatically. If \a metadata does not contain a + * VORBIS_COMMENT block, the encoder will supply that too. Otherwise, if + * \a metadata does contain a VORBIS_COMMENT block and it is not the + * first, the init function will reorder \a metadata by moving the + * VORBIS_COMMENT block to the front; the relative ordering of the other + * blocks will remain as they were. + * + * \note The Ogg FLAC mapping limits the number of metadata blocks per + * stream to \c 65535. If \a num_blocks exceeds this the function will + * return \c false. + * + * \default \c NULL, 0 + * \param encoder An encoder instance to set. + * \param metadata See above. + * \param num_blocks See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + * \c false if the encoder is already initialized, or if + * \a num_blocks > 65535 if encoding to Ogg FLAC, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, uint32_t num_blocks); + +/** Get the current encoder state. + * + * \param encoder An encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__StreamEncoderState + * The current encoder state. + */ +FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder); + +/** Get the state of the verify stream decoder. + * Useful when the stream encoder state is + * \c FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR. + * + * \param encoder An encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__StreamDecoderState + * The verify stream decoder state. + */ +FLAC_API FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder); + +/** Get the current encoder state as a C string. + * This version automatically resolves + * \c FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR by getting the + * verify decoder's state. + * + * \param encoder A encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval const char * + * The encoder state as a C string. Do not modify the contents. + */ +FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder *encoder); + +/** Get relevant values about the nature of a verify decoder error. + * Useful when the stream encoder state is + * \c FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR. The arguments should + * be addresses in which the stats will be returned, or NULL if value + * is not desired. + * + * \param encoder An encoder instance to query. + * \param absolute_sample The absolute sample number of the mismatch. + * \param frame_number The number of the frame in which the mismatch occurred. + * \param channel The channel in which the mismatch occurred. + * \param sample The number of the sample (relative to the frame) in + * which the mismatch occurred. + * \param expected The expected value for the sample in question. + * \param got The actual value returned by the decoder. + * \assert + * \code encoder != NULL \endcode + */ +FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, uint32_t *frame_number, uint32_t *channel, uint32_t *sample, FLAC__int32 *expected, FLAC__int32 *got); + +/** Get the "verify" flag. + * + * \param encoder An encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * See FLAC__stream_encoder_set_verify(). + */ +FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder); + +/** Get the frame header. + * + * \param encoder An initialized encoder instance in the OK state. + * \param buffer An array of pointers to each channel's signal. + * \param samples The number of samples in one channel. + * \assert + * \code encoder != NULL \endcode + * \code FLAC__stream_encoder_get_state(encoder) == FLAC__STREAM_ENCODER_OK \endcode + * \retval FLAC__bool + * \c true if successful, else \c false; in this case, check the + * encoder state with FLAC__stream_encoder_get_state() to see what + * went wrong. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], uint32_t samples); + +/** Submit data for encoding. + * This version allows you to supply the input data where the channels + * are interleaved into a single array (i.e. channel0_sample0, + * channel1_sample0, ... , channelN_sample0, channel0_sample1, ...). + * The samples need not be block-aligned but they must be + * sample-aligned, i.e. the first value should be channel0_sample0 + * and the last value channelN_sampleM. Each sample should be a signed + * integer, right-justified to the resolution set by + * FLAC__stream_encoder_set_bits_per_sample(). For example, if the + * resolution is 16 bits per sample, the samples should all be in the + * range [-32768,32767]. + * + * For applications where channel order is important, channels must + * follow the order as described in the + * frame header. + * + * \param encoder An initialized encoder instance in the OK state. + * \param buffer An array of channel-interleaved data (see above). + * \param samples The number of samples in one channel, the same as for + * FLAC__stream_encoder_process(). For example, if + * encoding two channels, \c 1000 \a samples corresponds + * to a \a buffer of 2000 values. + * \assert + * \code encoder != NULL \endcode + * \code FLAC__stream_encoder_get_state(encoder) == FLAC__STREAM_ENCODER_OK \endcode + * \retval FLAC__bool + * \c true if successful, else \c false; in this case, check the + * encoder state with FLAC__stream_encoder_get_state() to see what + * went wrong. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], uint32_t samples); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libs/include/dr_flac.h b/libs/include/dr_flac.h new file mode 100644 index 0000000..66821cd --- /dev/null +++ b/libs/include/dr_flac.h @@ -0,0 +1,12120 @@ +/* +FLAC audio decoder. Choice of public domain or MIT-0. See license statements at the end of this file. +dr_flac - v0.12.15 - 2020-07-06 + +David Reid - mackron@gmail.com + +GitHub: https://github.com/mackron/dr_libs +*/ + +/* +RELEASE NOTES - v0.12.0 +======================= +Version 0.12.0 has breaking API changes including changes to the existing API and the removal of deprecated APIs. + + +Improved Client-Defined Memory Allocation +----------------------------------------- +The main change with this release is the addition of a more flexible way of implementing custom memory allocation routines. The +existing system of DRFLAC_MALLOC, DRFLAC_REALLOC and DRFLAC_FREE are still in place and will be used by default when no custom +allocation callbacks are specified. + +To use the new system, you pass in a pointer to a drflac_allocation_callbacks object to drflac_open() and family, like this: + + void* my_malloc(size_t sz, void* pUserData) + { + return malloc(sz); + } + void* my_realloc(void* p, size_t sz, void* pUserData) + { + return realloc(p, sz); + } + void my_free(void* p, void* pUserData) + { + free(p); + } + + ... + + drflac_allocation_callbacks allocationCallbacks; + allocationCallbacks.pUserData = &myData; + allocationCallbacks.onMalloc = my_malloc; + allocationCallbacks.onRealloc = my_realloc; + allocationCallbacks.onFree = my_free; + drflac* pFlac = drflac_open_file("my_file.flac", &allocationCallbacks); + +The advantage of this new system is that it allows you to specify user data which will be passed in to the allocation routines. + +Passing in null for the allocation callbacks object will cause dr_flac to use defaults which is the same as DRFLAC_MALLOC, +DRFLAC_REALLOC and DRFLAC_FREE and the equivalent of how it worked in previous versions. + +Every API that opens a drflac object now takes this extra parameter. These include the following: + + drflac_open() + drflac_open_relaxed() + drflac_open_with_metadata() + drflac_open_with_metadata_relaxed() + drflac_open_file() + drflac_open_file_with_metadata() + drflac_open_memory() + drflac_open_memory_with_metadata() + drflac_open_and_read_pcm_frames_s32() + drflac_open_and_read_pcm_frames_s16() + drflac_open_and_read_pcm_frames_f32() + drflac_open_file_and_read_pcm_frames_s32() + drflac_open_file_and_read_pcm_frames_s16() + drflac_open_file_and_read_pcm_frames_f32() + drflac_open_memory_and_read_pcm_frames_s32() + drflac_open_memory_and_read_pcm_frames_s16() + drflac_open_memory_and_read_pcm_frames_f32() + + + +Optimizations +------------- +Seeking performance has been greatly improved. A new binary search based seeking algorithm has been introduced which significantly +improves performance over the brute force method which was used when no seek table was present. Seek table based seeking also takes +advantage of the new binary search seeking system to further improve performance there as well. Note that this depends on CRC which +means it will be disabled when DR_FLAC_NO_CRC is used. + +The SSE4.1 pipeline has been cleaned up and optimized. You should see some improvements with decoding speed of 24-bit files in +particular. 16-bit streams should also see some improvement. + +drflac_read_pcm_frames_s16() has been optimized. Previously this sat on top of drflac_read_pcm_frames_s32() and performed it's s32 +to s16 conversion in a second pass. This is now all done in a single pass. This includes SSE2 and ARM NEON optimized paths. + +A minor optimization has been implemented for drflac_read_pcm_frames_s32(). This will now use an SSE2 optimized pipeline for stereo +channel reconstruction which is the last part of the decoding process. + +The ARM build has seen a few improvements. The CLZ (count leading zeroes) and REV (byte swap) instructions are now used when +compiling with GCC and Clang which is achieved using inline assembly. The CLZ instruction requires ARM architecture version 5 at +compile time and the REV instruction requires ARM architecture version 6. + +An ARM NEON optimized pipeline has been implemented. To enable this you'll need to add -mfpu=neon to the command line when compiling. + + +Removed APIs +------------ +The following APIs were deprecated in version 0.11.0 and have been completely removed in version 0.12.0: + + drflac_read_s32() -> drflac_read_pcm_frames_s32() + drflac_read_s16() -> drflac_read_pcm_frames_s16() + drflac_read_f32() -> drflac_read_pcm_frames_f32() + drflac_seek_to_sample() -> drflac_seek_to_pcm_frame() + drflac_open_and_decode_s32() -> drflac_open_and_read_pcm_frames_s32() + drflac_open_and_decode_s16() -> drflac_open_and_read_pcm_frames_s16() + drflac_open_and_decode_f32() -> drflac_open_and_read_pcm_frames_f32() + drflac_open_and_decode_file_s32() -> drflac_open_file_and_read_pcm_frames_s32() + drflac_open_and_decode_file_s16() -> drflac_open_file_and_read_pcm_frames_s16() + drflac_open_and_decode_file_f32() -> drflac_open_file_and_read_pcm_frames_f32() + drflac_open_and_decode_memory_s32() -> drflac_open_memory_and_read_pcm_frames_s32() + drflac_open_and_decode_memory_s16() -> drflac_open_memory_and_read_pcm_frames_s16() + drflac_open_and_decode_memory_f32() -> drflac_open_memroy_and_read_pcm_frames_f32() + +Prior versions of dr_flac operated on a per-sample basis whereas now it operates on PCM frames. The removed APIs all relate +to the old per-sample APIs. You now need to use the "pcm_frame" versions. +*/ + + +/* +Introduction +============ +dr_flac is a single file library. To use it, do something like the following in one .c file. + + ```c + #define DR_FLAC_IMPLEMENTATION + #include "dr_flac.h" + ``` + +You can then #include this file in other parts of the program as you would with any other header file. To decode audio data, do something like the following: + + ```c + drflac* pFlac = drflac_open_file("MySong.flac", NULL); + if (pFlac == NULL) { + // Failed to open FLAC file + } + + drflac_int32* pSamples = malloc(pFlac->totalPCMFrameCount * pFlac->channels * sizeof(drflac_int32)); + drflac_uint64 numberOfInterleavedSamplesActuallyRead = drflac_read_pcm_frames_s32(pFlac, pFlac->totalPCMFrameCount, pSamples); + ``` + +The drflac object represents the decoder. It is a transparent type so all the information you need, such as the number of channels and the bits per sample, +should be directly accessible - just make sure you don't change their values. Samples are always output as interleaved signed 32-bit PCM. In the example above +a native FLAC stream was opened, however dr_flac has seamless support for Ogg encapsulated FLAC streams as well. + +You do not need to decode the entire stream in one go - you just specify how many samples you'd like at any given time and the decoder will give you as many +samples as it can, up to the amount requested. Later on when you need the next batch of samples, just call it again. Example: + + ```c + while (drflac_read_pcm_frames_s32(pFlac, chunkSizeInPCMFrames, pChunkSamples) > 0) { + do_something(); + } + ``` + +You can seek to a specific PCM frame with `drflac_seek_to_pcm_frame()`. + +If you just want to quickly decode an entire FLAC file in one go you can do something like this: + + ```c + unsigned int channels; + unsigned int sampleRate; + drflac_uint64 totalPCMFrameCount; + drflac_int32* pSampleData = drflac_open_file_and_read_pcm_frames_s32("MySong.flac", &channels, &sampleRate, &totalPCMFrameCount, NULL); + if (pSampleData == NULL) { + // Failed to open and decode FLAC file. + } + + ... + + drflac_free(pSampleData); + ``` + +You can read samples as signed 16-bit integer and 32-bit floating-point PCM with the *_s16() and *_f32() family of APIs respectively, but note that these +should be considered lossy. + + +If you need access to metadata (album art, etc.), use `drflac_open_with_metadata()`, `drflac_open_file_with_metdata()` or `drflac_open_memory_with_metadata()`. +The rationale for keeping these APIs separate is that they're slightly slower than the normal versions and also just a little bit harder to use. dr_flac +reports metadata to the application through the use of a callback, and every metadata block is reported before `drflac_open_with_metdata()` returns. + +The main opening APIs (`drflac_open()`, etc.) will fail if the header is not present. The presents a problem in certain scenarios such as broadcast style +streams or internet radio where the header may not be present because the user has started playback mid-stream. To handle this, use the relaxed APIs: + + `drflac_open_relaxed()` + `drflac_open_with_metadata_relaxed()` + +It is not recommended to use these APIs for file based streams because a missing header would usually indicate a corrupt or perverse file. In addition, these +APIs can take a long time to initialize because they may need to spend a lot of time finding the first frame. + + + +Build Options +============= +#define these options before including this file. + +#define DR_FLAC_NO_STDIO + Disable `drflac_open_file()` and family. + +#define DR_FLAC_NO_OGG + Disables support for Ogg/FLAC streams. + +#define DR_FLAC_BUFFER_SIZE + Defines the size of the internal buffer to store data from onRead(). This buffer is used to reduce the number of calls back to the client for more data. + Larger values means more memory, but better performance. My tests show diminishing returns after about 4KB (which is the default). Consider reducing this if + you have a very efficient implementation of onRead(), or increase it if it's very inefficient. Must be a multiple of 8. + +#define DR_FLAC_NO_CRC + Disables CRC checks. This will offer a performance boost when CRC is unnecessary. This will disable binary search seeking. When seeking, the seek table will + be used if available. Otherwise the seek will be performed using brute force. + +#define DR_FLAC_NO_SIMD + Disables SIMD optimizations (SSE on x86/x64 architectures, NEON on ARM architectures). Use this if you are having compatibility issues with your compiler. + + + +Notes +===== +- dr_flac does not support changing the sample rate nor channel count mid stream. +- dr_flac is not thread-safe, but its APIs can be called from any thread so long as you do your own synchronization. +- When using Ogg encapsulation, a corrupted metadata block will result in `drflac_open_with_metadata()` and `drflac_open()` returning inconsistent samples due + to differences in corrupted stream recorvery logic between the two APIs. +*/ + +#ifndef dr_flac_h +#define dr_flac_h + +#ifdef __cplusplus +extern "C" { +#endif + +#define DRFLAC_STRINGIFY(x) #x +#define DRFLAC_XSTRINGIFY(x) DRFLAC_STRINGIFY(x) + +#define DRFLAC_VERSION_MAJOR 0 +#define DRFLAC_VERSION_MINOR 12 +#define DRFLAC_VERSION_REVISION 15 +#define DRFLAC_VERSION_STRING DRFLAC_XSTRINGIFY(DRFLAC_VERSION_MAJOR) "." DRFLAC_XSTRINGIFY(DRFLAC_VERSION_MINOR) "." DRFLAC_XSTRINGIFY(DRFLAC_VERSION_REVISION) + +#include /* For size_t. */ + +/* Sized types. Prefer built-in types. Fall back to stdint. */ +#ifdef _MSC_VER + #if defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wlanguage-extension-token" + #pragma GCC diagnostic ignored "-Wlong-long" + #pragma GCC diagnostic ignored "-Wc++11-long-long" + #endif + typedef signed __int8 drflac_int8; + typedef unsigned __int8 drflac_uint8; + typedef signed __int16 drflac_int16; + typedef unsigned __int16 drflac_uint16; + typedef signed __int32 drflac_int32; + typedef unsigned __int32 drflac_uint32; + typedef signed __int64 drflac_int64; + typedef unsigned __int64 drflac_uint64; + #if defined(__clang__) + #pragma GCC diagnostic pop + #endif +#else + #include + typedef int8_t drflac_int8; + typedef uint8_t drflac_uint8; + typedef int16_t drflac_int16; + typedef uint16_t drflac_uint16; + typedef int32_t drflac_int32; + typedef uint32_t drflac_uint32; + typedef int64_t drflac_int64; + typedef uint64_t drflac_uint64; +#endif +typedef drflac_uint8 drflac_bool8; +typedef drflac_uint32 drflac_bool32; +#define DRFLAC_TRUE 1 +#define DRFLAC_FALSE 0 + +#if !defined(DRFLAC_API) + #if defined(DRFLAC_DLL) + #if defined(_WIN32) + #define DRFLAC_DLL_IMPORT __declspec(dllimport) + #define DRFLAC_DLL_EXPORT __declspec(dllexport) + #define DRFLAC_DLL_PRIVATE static + #else + #if defined(__GNUC__) && __GNUC__ >= 4 + #define DRFLAC_DLL_IMPORT __attribute__((visibility("default"))) + #define DRFLAC_DLL_EXPORT __attribute__((visibility("default"))) + #define DRFLAC_DLL_PRIVATE __attribute__((visibility("hidden"))) + #else + #define DRFLAC_DLL_IMPORT + #define DRFLAC_DLL_EXPORT + #define DRFLAC_DLL_PRIVATE static + #endif + #endif + + #if defined(DR_FLAC_IMPLEMENTATION) || defined(DRFLAC_IMPLEMENTATION) + #define DRFLAC_API DRFLAC_DLL_EXPORT + #else + #define DRFLAC_API DRFLAC_DLL_IMPORT + #endif + #define DRFLAC_PRIVATE DRFLAC_DLL_PRIVATE + #else + #define DRFLAC_API extern + #define DRFLAC_PRIVATE static + #endif +#endif + +#if defined(_MSC_VER) && _MSC_VER >= 1700 /* Visual Studio 2012 */ + #define DRFLAC_DEPRECATED __declspec(deprecated) +#elif (defined(__GNUC__) && __GNUC__ >= 4) /* GCC 4 */ + #define DRFLAC_DEPRECATED __attribute__((deprecated)) +#elif defined(__has_feature) /* Clang */ + #if __has_feature(attribute_deprecated) + #define DRFLAC_DEPRECATED __attribute__((deprecated)) + #else + #define DRFLAC_DEPRECATED + #endif +#else + #define DRFLAC_DEPRECATED +#endif + +DRFLAC_API void drflac_version(drflac_uint32* pMajor, drflac_uint32* pMinor, drflac_uint32* pRevision); +DRFLAC_API const char* drflac_version_string(); + +/* +As data is read from the client it is placed into an internal buffer for fast access. This controls the size of that buffer. Larger values means more speed, +but also more memory. In my testing there is diminishing returns after about 4KB, but you can fiddle with this to suit your own needs. Must be a multiple of 8. +*/ +#ifndef DR_FLAC_BUFFER_SIZE +#define DR_FLAC_BUFFER_SIZE 4096 +#endif + +/* Check if we can enable 64-bit optimizations. */ +#if defined(_WIN64) || defined(_LP64) || defined(__LP64__) +#define DRFLAC_64BIT +#endif + +#ifdef DRFLAC_64BIT +typedef drflac_uint64 drflac_cache_t; +#else +typedef drflac_uint32 drflac_cache_t; +#endif + +/* The various metadata block types. */ +#define DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO 0 +#define DRFLAC_METADATA_BLOCK_TYPE_PADDING 1 +#define DRFLAC_METADATA_BLOCK_TYPE_APPLICATION 2 +#define DRFLAC_METADATA_BLOCK_TYPE_SEEKTABLE 3 +#define DRFLAC_METADATA_BLOCK_TYPE_VORBIS_COMMENT 4 +#define DRFLAC_METADATA_BLOCK_TYPE_CUESHEET 5 +#define DRFLAC_METADATA_BLOCK_TYPE_PICTURE 6 +#define DRFLAC_METADATA_BLOCK_TYPE_INVALID 127 + +/* The various picture types specified in the PICTURE block. */ +#define DRFLAC_PICTURE_TYPE_OTHER 0 +#define DRFLAC_PICTURE_TYPE_FILE_ICON 1 +#define DRFLAC_PICTURE_TYPE_OTHER_FILE_ICON 2 +#define DRFLAC_PICTURE_TYPE_COVER_FRONT 3 +#define DRFLAC_PICTURE_TYPE_COVER_BACK 4 +#define DRFLAC_PICTURE_TYPE_LEAFLET_PAGE 5 +#define DRFLAC_PICTURE_TYPE_MEDIA 6 +#define DRFLAC_PICTURE_TYPE_LEAD_ARTIST 7 +#define DRFLAC_PICTURE_TYPE_ARTIST 8 +#define DRFLAC_PICTURE_TYPE_CONDUCTOR 9 +#define DRFLAC_PICTURE_TYPE_BAND 10 +#define DRFLAC_PICTURE_TYPE_COMPOSER 11 +#define DRFLAC_PICTURE_TYPE_LYRICIST 12 +#define DRFLAC_PICTURE_TYPE_RECORDING_LOCATION 13 +#define DRFLAC_PICTURE_TYPE_DURING_RECORDING 14 +#define DRFLAC_PICTURE_TYPE_DURING_PERFORMANCE 15 +#define DRFLAC_PICTURE_TYPE_SCREEN_CAPTURE 16 +#define DRFLAC_PICTURE_TYPE_BRIGHT_COLORED_FISH 17 +#define DRFLAC_PICTURE_TYPE_ILLUSTRATION 18 +#define DRFLAC_PICTURE_TYPE_BAND_LOGOTYPE 19 +#define DRFLAC_PICTURE_TYPE_PUBLISHER_LOGOTYPE 20 + +typedef enum +{ + drflac_container_native, + drflac_container_ogg, + drflac_container_unknown +} drflac_container; + +typedef enum +{ + drflac_seek_origin_start, + drflac_seek_origin_current +} drflac_seek_origin; + +/* Packing is important on this structure because we map this directly to the raw data within the SEEKTABLE metadata block. */ +#pragma pack(2) +typedef struct +{ + drflac_uint64 firstPCMFrame; + drflac_uint64 flacFrameOffset; /* The offset from the first byte of the header of the first frame. */ + drflac_uint16 pcmFrameCount; +} drflac_seekpoint; +#pragma pack() + +typedef struct +{ + drflac_uint16 minBlockSizeInPCMFrames; + drflac_uint16 maxBlockSizeInPCMFrames; + drflac_uint32 minFrameSizeInPCMFrames; + drflac_uint32 maxFrameSizeInPCMFrames; + drflac_uint32 sampleRate; + drflac_uint8 channels; + drflac_uint8 bitsPerSample; + drflac_uint64 totalPCMFrameCount; + drflac_uint8 md5[16]; +} drflac_streaminfo; + +typedef struct +{ + /* The metadata type. Use this to know how to interpret the data below. */ + drflac_uint32 type; + + /* + A pointer to the raw data. This points to a temporary buffer so don't hold on to it. It's best to + not modify the contents of this buffer. Use the structures below for more meaningful and structured + information about the metadata. It's possible for this to be null. + */ + const void* pRawData; + + /* The size in bytes of the block and the buffer pointed to by pRawData if it's non-NULL. */ + drflac_uint32 rawDataSize; + + union + { + drflac_streaminfo streaminfo; + + struct + { + int unused; + } padding; + + struct + { + drflac_uint32 id; + const void* pData; + drflac_uint32 dataSize; + } application; + + struct + { + drflac_uint32 seekpointCount; + const drflac_seekpoint* pSeekpoints; + } seektable; + + struct + { + drflac_uint32 vendorLength; + const char* vendor; + drflac_uint32 commentCount; + const void* pComments; + } vorbis_comment; + + struct + { + char catalog[128]; + drflac_uint64 leadInSampleCount; + drflac_bool32 isCD; + drflac_uint8 trackCount; + const void* pTrackData; + } cuesheet; + + struct + { + drflac_uint32 type; + drflac_uint32 mimeLength; + const char* mime; + drflac_uint32 descriptionLength; + const char* description; + drflac_uint32 width; + drflac_uint32 height; + drflac_uint32 colorDepth; + drflac_uint32 indexColorCount; + drflac_uint32 pictureDataSize; + const drflac_uint8* pPictureData; + } picture; + } data; +} drflac_metadata; + + +/* +Callback for when data needs to be read from the client. + + +Parameters +---------- +pUserData (in) + The user data that was passed to drflac_open() and family. + +pBufferOut (out) + The output buffer. + +bytesToRead (in) + The number of bytes to read. + + +Return Value +------------ +The number of bytes actually read. + + +Remarks +------- +A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until either the entire bytesToRead is filled or +you have reached the end of the stream. +*/ +typedef size_t (* drflac_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead); + +/* +Callback for when data needs to be seeked. + + +Parameters +---------- +pUserData (in) + The user data that was passed to drflac_open() and family. + +offset (in) + The number of bytes to move, relative to the origin. Will never be negative. + +origin (in) + The origin of the seek - the current position or the start of the stream. + + +Return Value +------------ +Whether or not the seek was successful. + + +Remarks +------- +The offset will never be negative. Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which will be +either drflac_seek_origin_start or drflac_seek_origin_current. + +When seeking to a PCM frame using drflac_seek_to_pcm_frame(), dr_flac may call this with an offset beyond the end of the FLAC stream. This needs to be detected +and handled by returning DRFLAC_FALSE. +*/ +typedef drflac_bool32 (* drflac_seek_proc)(void* pUserData, int offset, drflac_seek_origin origin); + +/* +Callback for when a metadata block is read. + + +Parameters +---------- +pUserData (in) + The user data that was passed to drflac_open() and family. + +pMetadata (in) + A pointer to a structure containing the data of the metadata block. + + +Remarks +------- +Use pMetadata->type to determine which metadata block is being handled and how to read the data. +*/ +typedef void (* drflac_meta_proc)(void* pUserData, drflac_metadata* pMetadata); + + +typedef struct +{ + void* pUserData; + void* (* onMalloc)(size_t sz, void* pUserData); + void* (* onRealloc)(void* p, size_t sz, void* pUserData); + void (* onFree)(void* p, void* pUserData); +} drflac_allocation_callbacks; + +/* Structure for internal use. Only used for decoders opened with drflac_open_memory. */ +typedef struct +{ + const drflac_uint8* data; + size_t dataSize; + size_t currentReadPos; +} drflac__memory_stream; + +/* Structure for internal use. Used for bit streaming. */ +typedef struct +{ + /* The function to call when more data needs to be read. */ + drflac_read_proc onRead; + + /* The function to call when the current read position needs to be moved. */ + drflac_seek_proc onSeek; + + /* The user data to pass around to onRead and onSeek. */ + void* pUserData; + + + /* + The number of unaligned bytes in the L2 cache. This will always be 0 until the end of the stream is hit. At the end of the + stream there will be a number of bytes that don't cleanly fit in an L1 cache line, so we use this variable to know whether + or not the bistreamer needs to run on a slower path to read those last bytes. This will never be more than sizeof(drflac_cache_t). + */ + size_t unalignedByteCount; + + /* The content of the unaligned bytes. */ + drflac_cache_t unalignedCache; + + /* The index of the next valid cache line in the "L2" cache. */ + drflac_uint32 nextL2Line; + + /* The number of bits that have been consumed by the cache. This is used to determine how many valid bits are remaining. */ + drflac_uint32 consumedBits; + + /* + The cached data which was most recently read from the client. There are two levels of cache. Data flows as such: + Client -> L2 -> L1. The L2 -> L1 movement is aligned and runs on a fast path in just a few instructions. + */ + drflac_cache_t cacheL2[DR_FLAC_BUFFER_SIZE/sizeof(drflac_cache_t)]; + drflac_cache_t cache; + + /* + CRC-16. This is updated whenever bits are read from the bit stream. Manually set this to 0 to reset the CRC. For FLAC, this + is reset to 0 at the beginning of each frame. + */ + drflac_uint16 crc16; + drflac_cache_t crc16Cache; /* A cache for optimizing CRC calculations. This is filled when when the L1 cache is reloaded. */ + drflac_uint32 crc16CacheIgnoredBytes; /* The number of bytes to ignore when updating the CRC-16 from the CRC-16 cache. */ +} drflac_bs; + +typedef struct +{ + /* The type of the subframe: SUBFRAME_CONSTANT, SUBFRAME_VERBATIM, SUBFRAME_FIXED or SUBFRAME_LPC. */ + drflac_uint8 subframeType; + + /* The number of wasted bits per sample as specified by the sub-frame header. */ + drflac_uint8 wastedBitsPerSample; + + /* The order to use for the prediction stage for SUBFRAME_FIXED and SUBFRAME_LPC. */ + drflac_uint8 lpcOrder; + + /* A pointer to the buffer containing the decoded samples in the subframe. This pointer is an offset from drflac::pExtraData. */ + drflac_int32* pSamplesS32; +} drflac_subframe; + +typedef struct +{ + /* + If the stream uses variable block sizes, this will be set to the index of the first PCM frame. If fixed block sizes are used, this will + always be set to 0. This is 64-bit because the decoded PCM frame number will be 36 bits. + */ + drflac_uint64 pcmFrameNumber; + + /* + If the stream uses fixed block sizes, this will be set to the frame number. If variable block sizes are used, this will always be 0. This + is 32-bit because in fixed block sizes, the maximum frame number will be 31 bits. + */ + drflac_uint32 flacFrameNumber; + + /* The sample rate of this frame. */ + drflac_uint32 sampleRate; + + /* The number of PCM frames in each sub-frame within this frame. */ + drflac_uint16 blockSizeInPCMFrames; + + /* + The channel assignment of this frame. This is not always set to the channel count. If interchannel decorrelation is being used this + will be set to DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE, DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE or DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE. + */ + drflac_uint8 channelAssignment; + + /* The number of bits per sample within this frame. */ + drflac_uint8 bitsPerSample; + + /* The frame's CRC. */ + drflac_uint8 crc8; +} drflac_frame_header; + +typedef struct +{ + /* The header. */ + drflac_frame_header header; + + /* + The number of PCM frames left to be read in this FLAC frame. This is initially set to the block size. As PCM frames are read, + this will be decremented. When it reaches 0, the decoder will see this frame as fully consumed and load the next frame. + */ + drflac_uint32 pcmFramesRemaining; + + /* The list of sub-frames within the frame. There is one sub-frame for each channel, and there's a maximum of 8 channels. */ + drflac_subframe subframes[8]; +} drflac_frame; + +typedef struct +{ + /* The function to call when a metadata block is read. */ + drflac_meta_proc onMeta; + + /* The user data posted to the metadata callback function. */ + void* pUserDataMD; + + /* Memory allocation callbacks. */ + drflac_allocation_callbacks allocationCallbacks; + + + /* The sample rate. Will be set to something like 44100. */ + drflac_uint32 sampleRate; + + /* + The number of channels. This will be set to 1 for monaural streams, 2 for stereo, etc. Maximum 8. This is set based on the + value specified in the STREAMINFO block. + */ + drflac_uint8 channels; + + /* The bits per sample. Will be set to something like 16, 24, etc. */ + drflac_uint8 bitsPerSample; + + /* The maximum block size, in samples. This number represents the number of samples in each channel (not combined). */ + drflac_uint16 maxBlockSizeInPCMFrames; + + /* + The total number of PCM Frames making up the stream. Can be 0 in which case it's still a valid stream, but just means + the total PCM frame count is unknown. Likely the case with streams like internet radio. + */ + drflac_uint64 totalPCMFrameCount; + + + /* The container type. This is set based on whether or not the decoder was opened from a native or Ogg stream. */ + drflac_container container; + + /* The number of seekpoints in the seektable. */ + drflac_uint32 seekpointCount; + + + /* Information about the frame the decoder is currently sitting on. */ + drflac_frame currentFLACFrame; + + + /* The index of the PCM frame the decoder is currently sitting on. This is only used for seeking. */ + drflac_uint64 currentPCMFrame; + + /* The position of the first FLAC frame in the stream. This is only ever used for seeking. */ + drflac_uint64 firstFLACFramePosInBytes; + + + /* A hack to avoid a malloc() when opening a decoder with drflac_open_memory(). */ + drflac__memory_stream memoryStream; + + + /* A pointer to the decoded sample data. This is an offset of pExtraData. */ + drflac_int32* pDecodedSamples; + + /* A pointer to the seek table. This is an offset of pExtraData, or NULL if there is no seek table. */ + drflac_seekpoint* pSeekpoints; + + /* Internal use only. Only used with Ogg containers. Points to a drflac_oggbs object. This is an offset of pExtraData. */ + void* _oggbs; + + /* Internal use only. Used for profiling and testing different seeking modes. */ + drflac_bool32 _noSeekTableSeek : 1; + drflac_bool32 _noBinarySearchSeek : 1; + drflac_bool32 _noBruteForceSeek : 1; + + /* The bit streamer. The raw FLAC data is fed through this object. */ + drflac_bs bs; + + /* Variable length extra data. We attach this to the end of the object so we can avoid unnecessary mallocs. */ + drflac_uint8 pExtraData[1]; +} drflac; + + +/* +Opens a FLAC decoder. + + +Parameters +---------- +onRead (in) + The function to call when data needs to be read from the client. + +onSeek (in) + The function to call when the read position of the client data needs to move. + +pUserData (in, optional) + A pointer to application defined data that will be passed to onRead and onSeek. + +pAllocationCallbacks (in, optional) + A pointer to application defined callbacks for managing memory allocations. + + +Return Value +------------ +Returns a pointer to an object representing the decoder. + + +Remarks +------- +Close the decoder with `drflac_close()`. + +`pAllocationCallbacks` can be NULL in which case it will use `DRFLAC_MALLOC`, `DRFLAC_REALLOC` and `DRFLAC_FREE`. + +This function will automatically detect whether or not you are attempting to open a native or Ogg encapsulated FLAC, both of which should work seamlessly +without any manual intervention. Ogg encapsulation also works with multiplexed streams which basically means it can play FLAC encoded audio tracks in videos. + +This is the lowest level function for opening a FLAC stream. You can also use `drflac_open_file()` and `drflac_open_memory()` to open the stream from a file or +from a block of memory respectively. + +The STREAMINFO block must be present for this to succeed. Use `drflac_open_relaxed()` to open a FLAC stream where the header may not be present. + + +Seek Also +--------- +drflac_open_file() +drflac_open_memory() +drflac_open_with_metadata() +drflac_close() +*/ +DRFLAC_API drflac* drflac_open(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* +Opens a FLAC stream with relaxed validation of the header block. + + +Parameters +---------- +onRead (in) + The function to call when data needs to be read from the client. + +onSeek (in) + The function to call when the read position of the client data needs to move. + +container (in) + Whether or not the FLAC stream is encapsulated using standard FLAC encapsulation or Ogg encapsulation. + +pUserData (in, optional) + A pointer to application defined data that will be passed to onRead and onSeek. + +pAllocationCallbacks (in, optional) + A pointer to application defined callbacks for managing memory allocations. + + +Return Value +------------ +A pointer to an object representing the decoder. + + +Remarks +------- +The same as drflac_open(), except attempts to open the stream even when a header block is not present. + +Because the header is not necessarily available, the caller must explicitly define the container (Native or Ogg). Do not set this to `drflac_container_unknown` +as that is for internal use only. + +Opening in relaxed mode will continue reading data from onRead until it finds a valid frame. If a frame is never found it will continue forever. To abort, +force your `onRead` callback to return 0, which dr_flac will use as an indicator that the end of the stream was found. +*/ +DRFLAC_API drflac* drflac_open_relaxed(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_container container, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* +Opens a FLAC decoder and notifies the caller of the metadata chunks (album art, etc.). + + +Parameters +---------- +onRead (in) + The function to call when data needs to be read from the client. + +onSeek (in) + The function to call when the read position of the client data needs to move. + +onMeta (in) + The function to call for every metadata block. + +pUserData (in, optional) + A pointer to application defined data that will be passed to onRead, onSeek and onMeta. + +pAllocationCallbacks (in, optional) + A pointer to application defined callbacks for managing memory allocations. + + +Return Value +------------ +A pointer to an object representing the decoder. + + +Remarks +------- +Close the decoder with `drflac_close()`. + +`pAllocationCallbacks` can be NULL in which case it will use `DRFLAC_MALLOC`, `DRFLAC_REALLOC` and `DRFLAC_FREE`. + +This is slower than `drflac_open()`, so avoid this one if you don't need metadata. Internally, this will allocate and free memory on the heap for every +metadata block except for STREAMINFO and PADDING blocks. + +The caller is notified of the metadata via the `onMeta` callback. All metadata blocks will be handled before the function returns. + +The STREAMINFO block must be present for this to succeed. Use `drflac_open_with_metadata_relaxed()` to open a FLAC stream where the header may not be present. + +Note that this will behave inconsistently with `drflac_open()` if the stream is an Ogg encapsulated stream and a metadata block is corrupted. This is due to +the way the Ogg stream recovers from corrupted pages. When `drflac_open_with_metadata()` is being used, the open routine will try to read the contents of the +metadata block, whereas `drflac_open()` will simply seek past it (for the sake of efficiency). This inconsistency can result in different samples being +returned depending on whether or not the stream is being opened with metadata. + + +Seek Also +--------- +drflac_open_file_with_metadata() +drflac_open_memory_with_metadata() +drflac_open() +drflac_close() +*/ +DRFLAC_API drflac* drflac_open_with_metadata(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* +The same as drflac_open_with_metadata(), except attempts to open the stream even when a header block is not present. + +See Also +-------- +drflac_open_with_metadata() +drflac_open_relaxed() +*/ +DRFLAC_API drflac* drflac_open_with_metadata_relaxed(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, drflac_container container, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* +Closes the given FLAC decoder. + + +Parameters +---------- +pFlac (in) + The decoder to close. + + +Remarks +------- +This will destroy the decoder object. + + +See Also +-------- +drflac_open() +drflac_open_with_metadata() +drflac_open_file() +drflac_open_file_w() +drflac_open_file_with_metadata() +drflac_open_file_with_metadata_w() +drflac_open_memory() +drflac_open_memory_with_metadata() +*/ +DRFLAC_API void drflac_close(drflac* pFlac); + + +/* +Reads sample data from the given FLAC decoder, output as interleaved signed 32-bit PCM. + + +Parameters +---------- +pFlac (in) + The decoder. + +framesToRead (in) + The number of PCM frames to read. + +pBufferOut (out, optional) + A pointer to the buffer that will receive the decoded samples. + + +Return Value +------------ +Returns the number of PCM frames actually read. If the return value is less than `framesToRead` it has reached the end. + + +Remarks +------- +pBufferOut can be null, in which case the call will act as a seek, and the return value will be the number of frames seeked. +*/ +DRFLAC_API drflac_uint64 drflac_read_pcm_frames_s32(drflac* pFlac, drflac_uint64 framesToRead, drflac_int32* pBufferOut); + + +/* +Reads sample data from the given FLAC decoder, output as interleaved signed 16-bit PCM. + + +Parameters +---------- +pFlac (in) + The decoder. + +framesToRead (in) + The number of PCM frames to read. + +pBufferOut (out, optional) + A pointer to the buffer that will receive the decoded samples. + + +Return Value +------------ +Returns the number of PCM frames actually read. If the return value is less than `framesToRead` it has reached the end. + + +Remarks +------- +pBufferOut can be null, in which case the call will act as a seek, and the return value will be the number of frames seeked. + +Note that this is lossy for streams where the bits per sample is larger than 16. +*/ +DRFLAC_API drflac_uint64 drflac_read_pcm_frames_s16(drflac* pFlac, drflac_uint64 framesToRead, drflac_int16* pBufferOut); + +/* +Reads sample data from the given FLAC decoder, output as interleaved 32-bit floating point PCM. + + +Parameters +---------- +pFlac (in) + The decoder. + +framesToRead (in) + The number of PCM frames to read. + +pBufferOut (out, optional) + A pointer to the buffer that will receive the decoded samples. + + +Return Value +------------ +Returns the number of PCM frames actually read. If the return value is less than `framesToRead` it has reached the end. + + +Remarks +------- +pBufferOut can be null, in which case the call will act as a seek, and the return value will be the number of frames seeked. + +Note that this should be considered lossy due to the nature of floating point numbers not being able to exactly represent every possible number. +*/ +DRFLAC_API drflac_uint64 drflac_read_pcm_frames_f32(drflac* pFlac, drflac_uint64 framesToRead, float* pBufferOut); + +/* +Seeks to the PCM frame at the given index. + + +Parameters +---------- +pFlac (in) + The decoder. + +pcmFrameIndex (in) + The index of the PCM frame to seek to. See notes below. + + +Return Value +------------- +`DRFLAC_TRUE` if successful; `DRFLAC_FALSE` otherwise. +*/ +DRFLAC_API drflac_bool32 drflac_seek_to_pcm_frame(drflac* pFlac, drflac_uint64 pcmFrameIndex); + + + +#ifndef DR_FLAC_NO_STDIO +/* +Opens a FLAC decoder from the file at the given path. + + +Parameters +---------- +pFileName (in) + The path of the file to open, either absolute or relative to the current directory. + +pAllocationCallbacks (in, optional) + A pointer to application defined callbacks for managing memory allocations. + + +Return Value +------------ +A pointer to an object representing the decoder. + + +Remarks +------- +Close the decoder with drflac_close(). + + +Remarks +------- +This will hold a handle to the file until the decoder is closed with drflac_close(). Some platforms will restrict the number of files a process can have open +at any given time, so keep this mind if you have many decoders open at the same time. + + +See Also +-------- +drflac_open_file_with_metadata() +drflac_open() +drflac_close() +*/ +DRFLAC_API drflac* drflac_open_file(const char* pFileName, const drflac_allocation_callbacks* pAllocationCallbacks); +DRFLAC_API drflac* drflac_open_file_w(const wchar_t* pFileName, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* +Opens a FLAC decoder from the file at the given path and notifies the caller of the metadata chunks (album art, etc.) + + +Parameters +---------- +pFileName (in) + The path of the file to open, either absolute or relative to the current directory. + +pAllocationCallbacks (in, optional) + A pointer to application defined callbacks for managing memory allocations. + +onMeta (in) + The callback to fire for each metadata block. + +pUserData (in) + A pointer to the user data to pass to the metadata callback. + +pAllocationCallbacks (in) + A pointer to application defined callbacks for managing memory allocations. + + +Remarks +------- +Look at the documentation for drflac_open_with_metadata() for more information on how metadata is handled. + + +See Also +-------- +drflac_open_with_metadata() +drflac_open() +drflac_close() +*/ +DRFLAC_API drflac* drflac_open_file_with_metadata(const char* pFileName, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks); +DRFLAC_API drflac* drflac_open_file_with_metadata_w(const wchar_t* pFileName, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks); +#endif + +/* +Opens a FLAC decoder from a pre-allocated block of memory + + +Parameters +---------- +pData (in) + A pointer to the raw encoded FLAC data. + +dataSize (in) + The size in bytes of `data`. + +pAllocationCallbacks (in) + A pointer to application defined callbacks for managing memory allocations. + + +Return Value +------------ +A pointer to an object representing the decoder. + + +Remarks +------- +This does not create a copy of the data. It is up to the application to ensure the buffer remains valid for the lifetime of the decoder. + + +See Also +-------- +drflac_open() +drflac_close() +*/ +DRFLAC_API drflac* drflac_open_memory(const void* pData, size_t dataSize, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* +Opens a FLAC decoder from a pre-allocated block of memory and notifies the caller of the metadata chunks (album art, etc.) + + +Parameters +---------- +pData (in) + A pointer to the raw encoded FLAC data. + +dataSize (in) + The size in bytes of `data`. + +onMeta (in) + The callback to fire for each metadata block. + +pUserData (in) + A pointer to the user data to pass to the metadata callback. + +pAllocationCallbacks (in) + A pointer to application defined callbacks for managing memory allocations. + + +Remarks +------- +Look at the documentation for drflac_open_with_metadata() for more information on how metadata is handled. + + +See Also +------- +drflac_open_with_metadata() +drflac_open() +drflac_close() +*/ +DRFLAC_API drflac* drflac_open_memory_with_metadata(const void* pData, size_t dataSize, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks); + + + +/* High Level APIs */ + +/* +Opens a FLAC stream from the given callbacks and fully decodes it in a single operation. The return value is a +pointer to the sample data as interleaved signed 32-bit PCM. The returned data must be freed with drflac_free(). + +You can pass in custom memory allocation callbacks via the pAllocationCallbacks parameter. This can be NULL in which +case it will use DRFLAC_MALLOC, DRFLAC_REALLOC and DRFLAC_FREE. + +Sometimes a FLAC file won't keep track of the total sample count. In this situation the function will continuously +read samples into a dynamically sized buffer on the heap until no samples are left. + +Do not call this function on a broadcast type of stream (like internet radio streams and whatnot). +*/ +DRFLAC_API drflac_int32* drflac_open_and_read_pcm_frames_s32(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* Same as drflac_open_and_read_pcm_frames_s32(), except returns signed 16-bit integer samples. */ +DRFLAC_API drflac_int16* drflac_open_and_read_pcm_frames_s16(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* Same as drflac_open_and_read_pcm_frames_s32(), except returns 32-bit floating-point samples. */ +DRFLAC_API float* drflac_open_and_read_pcm_frames_f32(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks); + +#ifndef DR_FLAC_NO_STDIO +/* Same as drflac_open_and_read_pcm_frames_s32() except opens the decoder from a file. */ +DRFLAC_API drflac_int32* drflac_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* Same as drflac_open_file_and_read_pcm_frames_s32(), except returns signed 16-bit integer samples. */ +DRFLAC_API drflac_int16* drflac_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* Same as drflac_open_file_and_read_pcm_frames_s32(), except returns 32-bit floating-point samples. */ +DRFLAC_API float* drflac_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks); +#endif + +/* Same as drflac_open_and_read_pcm_frames_s32() except opens the decoder from a block of memory. */ +DRFLAC_API drflac_int32* drflac_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* Same as drflac_open_memory_and_read_pcm_frames_s32(), except returns signed 16-bit integer samples. */ +DRFLAC_API drflac_int16* drflac_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* Same as drflac_open_memory_and_read_pcm_frames_s32(), except returns 32-bit floating-point samples. */ +DRFLAC_API float* drflac_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks); + +/* +Frees memory that was allocated internally by dr_flac. + +Set pAllocationCallbacks to the same object that was passed to drflac_open_*_and_read_pcm_frames_*(). If you originally passed in NULL, pass in NULL for this. +*/ +DRFLAC_API void drflac_free(void* p, const drflac_allocation_callbacks* pAllocationCallbacks); + + +/* Structure representing an iterator for vorbis comments in a VORBIS_COMMENT metadata block. */ +typedef struct +{ + drflac_uint32 countRemaining; + const char* pRunningData; +} drflac_vorbis_comment_iterator; + +/* +Initializes a vorbis comment iterator. This can be used for iterating over the vorbis comments in a VORBIS_COMMENT +metadata block. +*/ +DRFLAC_API void drflac_init_vorbis_comment_iterator(drflac_vorbis_comment_iterator* pIter, drflac_uint32 commentCount, const void* pComments); + +/* +Goes to the next vorbis comment in the given iterator. If null is returned it means there are no more comments. The +returned string is NOT null terminated. +*/ +DRFLAC_API const char* drflac_next_vorbis_comment(drflac_vorbis_comment_iterator* pIter, drflac_uint32* pCommentLengthOut); + + +/* Structure representing an iterator for cuesheet tracks in a CUESHEET metadata block. */ +typedef struct +{ + drflac_uint32 countRemaining; + const char* pRunningData; +} drflac_cuesheet_track_iterator; + +/* Packing is important on this structure because we map this directly to the raw data within the CUESHEET metadata block. */ +#pragma pack(4) +typedef struct +{ + drflac_uint64 offset; + drflac_uint8 index; + drflac_uint8 reserved[3]; +} drflac_cuesheet_track_index; +#pragma pack() + +typedef struct +{ + drflac_uint64 offset; + drflac_uint8 trackNumber; + char ISRC[12]; + drflac_bool8 isAudio; + drflac_bool8 preEmphasis; + drflac_uint8 indexCount; + const drflac_cuesheet_track_index* pIndexPoints; +} drflac_cuesheet_track; + +/* +Initializes a cuesheet track iterator. This can be used for iterating over the cuesheet tracks in a CUESHEET metadata +block. +*/ +DRFLAC_API void drflac_init_cuesheet_track_iterator(drflac_cuesheet_track_iterator* pIter, drflac_uint32 trackCount, const void* pTrackData); + +/* Goes to the next cuesheet track in the given iterator. If DRFLAC_FALSE is returned it means there are no more comments. */ +DRFLAC_API drflac_bool32 drflac_next_cuesheet_track(drflac_cuesheet_track_iterator* pIter, drflac_cuesheet_track* pCuesheetTrack); + + +#ifdef __cplusplus +} +#endif +#endif /* dr_flac_h */ + + +/************************************************************************************************************************************************************ + ************************************************************************************************************************************************************ + + IMPLEMENTATION + + ************************************************************************************************************************************************************ + ************************************************************************************************************************************************************/ +#if defined(DR_FLAC_IMPLEMENTATION) || defined(DRFLAC_IMPLEMENTATION) +#ifndef dr_flac_c +#define dr_flac_c + +/* Disable some annoying warnings. */ +#if defined(__GNUC__) + #pragma GCC diagnostic push + #if __GNUC__ >= 7 + #pragma GCC diagnostic ignored "-Wimplicit-fallthrough" + #endif +#endif + +#ifdef __linux__ + #ifndef _BSD_SOURCE + #define _BSD_SOURCE + #endif + #ifndef __USE_BSD + #define __USE_BSD + #endif + #include +#endif + +#include +#include + +#ifdef _MSC_VER + #define DRFLAC_INLINE __forceinline +#elif defined(__GNUC__) + /* + I've had a bug report where GCC is emitting warnings about functions possibly not being inlineable. This warning happens when + the __attribute__((always_inline)) attribute is defined without an "inline" statement. I think therefore there must be some + case where "__inline__" is not always defined, thus the compiler emitting these warnings. When using -std=c89 or -ansi on the + command line, we cannot use the "inline" keyword and instead need to use "__inline__". In an attempt to work around this issue + I am using "__inline__" only when we're compiling in strict ANSI mode. + */ + #if defined(__STRICT_ANSI__) + #define DRFLAC_INLINE __inline__ __attribute__((always_inline)) + #else + #define DRFLAC_INLINE inline __attribute__((always_inline)) + #endif +#else + #define DRFLAC_INLINE +#endif + +/* CPU architecture. */ +#if defined(__x86_64__) || defined(_M_X64) + #define DRFLAC_X64 +#elif defined(__i386) || defined(_M_IX86) + #define DRFLAC_X86 +#elif defined(__arm__) || defined(_M_ARM) + #define DRFLAC_ARM +#endif + +/* Intrinsics Support */ +#if !defined(DR_FLAC_NO_SIMD) + #if defined(DRFLAC_X64) || defined(DRFLAC_X86) + #if defined(_MSC_VER) && !defined(__clang__) + /* MSVC. */ + #if _MSC_VER >= 1400 && !defined(DRFLAC_NO_SSE2) /* 2005 */ + #define DRFLAC_SUPPORT_SSE2 + #endif + #if _MSC_VER >= 1600 && !defined(DRFLAC_NO_SSE41) /* 2010 */ + #define DRFLAC_SUPPORT_SSE41 + #endif + #else + /* Assume GNUC-style. */ + #if defined(__SSE2__) && !defined(DRFLAC_NO_SSE2) + #define DRFLAC_SUPPORT_SSE2 + #endif + #if defined(__SSE4_1__) && !defined(DRFLAC_NO_SSE41) + #define DRFLAC_SUPPORT_SSE41 + #endif + #endif + + /* If at this point we still haven't determined compiler support for the intrinsics just fall back to __has_include. */ + #if !defined(__GNUC__) && !defined(__clang__) && defined(__has_include) + #if !defined(DRFLAC_SUPPORT_SSE2) && !defined(DRFLAC_NO_SSE2) && __has_include() + #define DRFLAC_SUPPORT_SSE2 + #endif + #if !defined(DRFLAC_SUPPORT_SSE41) && !defined(DRFLAC_NO_SSE41) && __has_include() + #define DRFLAC_SUPPORT_SSE41 + #endif + #endif + + #if defined(DRFLAC_SUPPORT_SSE41) + #include + #elif defined(DRFLAC_SUPPORT_SSE2) + #include + #endif + #endif + + #if defined(DRFLAC_ARM) + #if !defined(DRFLAC_NO_NEON) && (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64)) + #define DRFLAC_SUPPORT_NEON + #endif + + /* Fall back to looking for the #include file. */ + #if !defined(__GNUC__) && !defined(__clang__) && defined(__has_include) + #if !defined(DRFLAC_SUPPORT_NEON) && !defined(DRFLAC_NO_NEON) && __has_include() + #define DRFLAC_SUPPORT_NEON + #endif + #endif + + #if defined(DRFLAC_SUPPORT_NEON) + #include + #endif + #endif +#endif + +/* Compile-time CPU feature support. */ +#if !defined(DR_FLAC_NO_SIMD) && (defined(DRFLAC_X86) || defined(DRFLAC_X64)) + #if defined(_MSC_VER) && !defined(__clang__) + #if _MSC_VER >= 1400 + #include + static void drflac__cpuid(int info[4], int fid) + { + __cpuid(info, fid); + } + #else + #define DRFLAC_NO_CPUID + #endif + #else + #if defined(__GNUC__) || defined(__clang__) + static void drflac__cpuid(int info[4], int fid) + { + /* + It looks like the -fPIC option uses the ebx register which GCC complains about. We can work around this by just using a different register, the + specific register of which I'm letting the compiler decide on. The "k" prefix is used to specify a 32-bit register. The {...} syntax is for + supporting different assembly dialects. + + What's basically happening is that we're saving and restoring the ebx register manually. + */ + #if defined(DRFLAC_X86) && defined(__PIC__) + __asm__ __volatile__ ( + "xchg{l} {%%}ebx, %k1;" + "cpuid;" + "xchg{l} {%%}ebx, %k1;" + : "=a"(info[0]), "=&r"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0) + ); + #else + __asm__ __volatile__ ( + "cpuid" : "=a"(info[0]), "=b"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0) + ); + #endif + } + #else + #define DRFLAC_NO_CPUID + #endif + #endif +#else + #define DRFLAC_NO_CPUID +#endif + +static DRFLAC_INLINE drflac_bool32 drflac_has_sse2(void) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + #if (defined(DRFLAC_X64) || defined(DRFLAC_X86)) && !defined(DRFLAC_NO_SSE2) + #if defined(DRFLAC_X64) + return DRFLAC_TRUE; /* 64-bit targets always support SSE2. */ + #elif (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE2__) + return DRFLAC_TRUE; /* If the compiler is allowed to freely generate SSE2 code we can assume support. */ + #else + #if defined(DRFLAC_NO_CPUID) + return DRFLAC_FALSE; + #else + int info[4]; + drflac__cpuid(info, 1); + return (info[3] & (1 << 26)) != 0; + #endif + #endif + #else + return DRFLAC_FALSE; /* SSE2 is only supported on x86 and x64 architectures. */ + #endif +#else + return DRFLAC_FALSE; /* No compiler support. */ +#endif +} + +static DRFLAC_INLINE drflac_bool32 drflac_has_sse41(void) +{ +#if defined(DRFLAC_SUPPORT_SSE41) + #if (defined(DRFLAC_X64) || defined(DRFLAC_X86)) && !defined(DRFLAC_NO_SSE41) + #if defined(DRFLAC_X64) + return DRFLAC_TRUE; /* 64-bit targets always support SSE4.1. */ + #elif (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE4_1__) + return DRFLAC_TRUE; /* If the compiler is allowed to freely generate SSE41 code we can assume support. */ + #else + #if defined(DRFLAC_NO_CPUID) + return DRFLAC_FALSE; + #else + int info[4]; + drflac__cpuid(info, 1); + return (info[2] & (1 << 19)) != 0; + #endif + #endif + #else + return DRFLAC_FALSE; /* SSE41 is only supported on x86 and x64 architectures. */ + #endif +#else + return DRFLAC_FALSE; /* No compiler support. */ +#endif +} + + +#if defined(_MSC_VER) && _MSC_VER >= 1500 && (defined(DRFLAC_X86) || defined(DRFLAC_X64)) + #define DRFLAC_HAS_LZCNT_INTRINSIC +#elif (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))) + #define DRFLAC_HAS_LZCNT_INTRINSIC +#elif defined(__clang__) + #if defined(__has_builtin) + #if __has_builtin(__builtin_clzll) || __has_builtin(__builtin_clzl) + #define DRFLAC_HAS_LZCNT_INTRINSIC + #endif + #endif +#endif + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + #define DRFLAC_HAS_BYTESWAP16_INTRINSIC + #define DRFLAC_HAS_BYTESWAP32_INTRINSIC + #define DRFLAC_HAS_BYTESWAP64_INTRINSIC +#elif defined(__clang__) + #if defined(__has_builtin) + #if __has_builtin(__builtin_bswap16) + #define DRFLAC_HAS_BYTESWAP16_INTRINSIC + #endif + #if __has_builtin(__builtin_bswap32) + #define DRFLAC_HAS_BYTESWAP32_INTRINSIC + #endif + #if __has_builtin(__builtin_bswap64) + #define DRFLAC_HAS_BYTESWAP64_INTRINSIC + #endif + #endif +#elif defined(__GNUC__) + #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define DRFLAC_HAS_BYTESWAP32_INTRINSIC + #define DRFLAC_HAS_BYTESWAP64_INTRINSIC + #endif + #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) + #define DRFLAC_HAS_BYTESWAP16_INTRINSIC + #endif +#endif + + +/* Standard library stuff. */ +#ifndef DRFLAC_ASSERT +#include +#define DRFLAC_ASSERT(expression) assert(expression) +#endif +#ifndef DRFLAC_MALLOC +#define DRFLAC_MALLOC(sz) malloc((sz)) +#endif +#ifndef DRFLAC_REALLOC +#define DRFLAC_REALLOC(p, sz) realloc((p), (sz)) +#endif +#ifndef DRFLAC_FREE +#define DRFLAC_FREE(p) free((p)) +#endif +#ifndef DRFLAC_COPY_MEMORY +#define DRFLAC_COPY_MEMORY(dst, src, sz) memcpy((dst), (src), (sz)) +#endif +#ifndef DRFLAC_ZERO_MEMORY +#define DRFLAC_ZERO_MEMORY(p, sz) memset((p), 0, (sz)) +#endif +#ifndef DRFLAC_ZERO_OBJECT +#define DRFLAC_ZERO_OBJECT(p) DRFLAC_ZERO_MEMORY((p), sizeof(*(p))) +#endif + +#define DRFLAC_MAX_SIMD_VECTOR_SIZE 64 /* 64 for AVX-512 in the future. */ + +typedef drflac_int32 drflac_result; +#define DRFLAC_SUCCESS 0 +#define DRFLAC_ERROR -1 /* A generic error. */ +#define DRFLAC_INVALID_ARGS -2 +#define DRFLAC_INVALID_OPERATION -3 +#define DRFLAC_OUT_OF_MEMORY -4 +#define DRFLAC_OUT_OF_RANGE -5 +#define DRFLAC_ACCESS_DENIED -6 +#define DRFLAC_DOES_NOT_EXIST -7 +#define DRFLAC_ALREADY_EXISTS -8 +#define DRFLAC_TOO_MANY_OPEN_FILES -9 +#define DRFLAC_INVALID_FILE -10 +#define DRFLAC_TOO_BIG -11 +#define DRFLAC_PATH_TOO_LONG -12 +#define DRFLAC_NAME_TOO_LONG -13 +#define DRFLAC_NOT_DIRECTORY -14 +#define DRFLAC_IS_DIRECTORY -15 +#define DRFLAC_DIRECTORY_NOT_EMPTY -16 +#define DRFLAC_END_OF_FILE -17 +#define DRFLAC_NO_SPACE -18 +#define DRFLAC_BUSY -19 +#define DRFLAC_IO_ERROR -20 +#define DRFLAC_INTERRUPT -21 +#define DRFLAC_UNAVAILABLE -22 +#define DRFLAC_ALREADY_IN_USE -23 +#define DRFLAC_BAD_ADDRESS -24 +#define DRFLAC_BAD_SEEK -25 +#define DRFLAC_BAD_PIPE -26 +#define DRFLAC_DEADLOCK -27 +#define DRFLAC_TOO_MANY_LINKS -28 +#define DRFLAC_NOT_IMPLEMENTED -29 +#define DRFLAC_NO_MESSAGE -30 +#define DRFLAC_BAD_MESSAGE -31 +#define DRFLAC_NO_DATA_AVAILABLE -32 +#define DRFLAC_INVALID_DATA -33 +#define DRFLAC_TIMEOUT -34 +#define DRFLAC_NO_NETWORK -35 +#define DRFLAC_NOT_UNIQUE -36 +#define DRFLAC_NOT_SOCKET -37 +#define DRFLAC_NO_ADDRESS -38 +#define DRFLAC_BAD_PROTOCOL -39 +#define DRFLAC_PROTOCOL_UNAVAILABLE -40 +#define DRFLAC_PROTOCOL_NOT_SUPPORTED -41 +#define DRFLAC_PROTOCOL_FAMILY_NOT_SUPPORTED -42 +#define DRFLAC_ADDRESS_FAMILY_NOT_SUPPORTED -43 +#define DRFLAC_SOCKET_NOT_SUPPORTED -44 +#define DRFLAC_CONNECTION_RESET -45 +#define DRFLAC_ALREADY_CONNECTED -46 +#define DRFLAC_NOT_CONNECTED -47 +#define DRFLAC_CONNECTION_REFUSED -48 +#define DRFLAC_NO_HOST -49 +#define DRFLAC_IN_PROGRESS -50 +#define DRFLAC_CANCELLED -51 +#define DRFLAC_MEMORY_ALREADY_MAPPED -52 +#define DRFLAC_AT_END -53 +#define DRFLAC_CRC_MISMATCH -128 + +#define DRFLAC_SUBFRAME_CONSTANT 0 +#define DRFLAC_SUBFRAME_VERBATIM 1 +#define DRFLAC_SUBFRAME_FIXED 8 +#define DRFLAC_SUBFRAME_LPC 32 +#define DRFLAC_SUBFRAME_RESERVED 255 + +#define DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE 0 +#define DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2 1 + +#define DRFLAC_CHANNEL_ASSIGNMENT_INDEPENDENT 0 +#define DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE 8 +#define DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE 9 +#define DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE 10 + +#define drflac_align(x, a) ((((x) + (a) - 1) / (a)) * (a)) + + +DRFLAC_API void drflac_version(drflac_uint32* pMajor, drflac_uint32* pMinor, drflac_uint32* pRevision) +{ + if (pMajor) { + *pMajor = DRFLAC_VERSION_MAJOR; + } + + if (pMinor) { + *pMinor = DRFLAC_VERSION_MINOR; + } + + if (pRevision) { + *pRevision = DRFLAC_VERSION_REVISION; + } +} + +DRFLAC_API const char* drflac_version_string() +{ + return DRFLAC_VERSION_STRING; +} + + +/* CPU caps. */ +#if defined(__has_feature) + #if __has_feature(thread_sanitizer) + #define DRFLAC_NO_THREAD_SANITIZE __attribute__((no_sanitize("thread"))) + #else + #define DRFLAC_NO_THREAD_SANITIZE + #endif +#else + #define DRFLAC_NO_THREAD_SANITIZE +#endif + +#if defined(DRFLAC_HAS_LZCNT_INTRINSIC) +static drflac_bool32 drflac__gIsLZCNTSupported = DRFLAC_FALSE; +#endif + +#ifndef DRFLAC_NO_CPUID +static drflac_bool32 drflac__gIsSSE2Supported = DRFLAC_FALSE; +static drflac_bool32 drflac__gIsSSE41Supported = DRFLAC_FALSE; + +/* +I've had a bug report that Clang's ThreadSanitizer presents a warning in this function. Having reviewed this, this does +actually make sense. However, since CPU caps should never differ for a running process, I don't think the trade off of +complicating internal API's by passing around CPU caps versus just disabling the warnings is worthwhile. I'm therefore +just going to disable these warnings. This is disabled via the DRFLAC_NO_THREAD_SANITIZE attribute. +*/ +DRFLAC_NO_THREAD_SANITIZE static void drflac__init_cpu_caps(void) +{ + static drflac_bool32 isCPUCapsInitialized = DRFLAC_FALSE; + + if (!isCPUCapsInitialized) { + /* LZCNT */ +#if defined(DRFLAC_HAS_LZCNT_INTRINSIC) + int info[4] = {0}; + drflac__cpuid(info, 0x80000001); + drflac__gIsLZCNTSupported = (info[2] & (1 << 5)) != 0; +#endif + + /* SSE2 */ + drflac__gIsSSE2Supported = drflac_has_sse2(); + + /* SSE4.1 */ + drflac__gIsSSE41Supported = drflac_has_sse41(); + + /* Initialized. */ + isCPUCapsInitialized = DRFLAC_TRUE; + } +} +#else +static drflac_bool32 drflac__gIsNEONSupported = DRFLAC_FALSE; + +static DRFLAC_INLINE drflac_bool32 drflac__has_neon(void) +{ +#if defined(DRFLAC_SUPPORT_NEON) + #if defined(DRFLAC_ARM) && !defined(DRFLAC_NO_NEON) + #if (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64)) + return DRFLAC_TRUE; /* If the compiler is allowed to freely generate NEON code we can assume support. */ + #else + /* TODO: Runtime check. */ + return DRFLAC_FALSE; + #endif + #else + return DRFLAC_FALSE; /* NEON is only supported on ARM architectures. */ + #endif +#else + return DRFLAC_FALSE; /* No compiler support. */ +#endif +} + +DRFLAC_NO_THREAD_SANITIZE static void drflac__init_cpu_caps(void) +{ + drflac__gIsNEONSupported = drflac__has_neon(); + +#if defined(DRFLAC_HAS_LZCNT_INTRINSIC) && defined(DRFLAC_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5) + drflac__gIsLZCNTSupported = DRFLAC_TRUE; +#endif +} +#endif + + +/* Endian Management */ +static DRFLAC_INLINE drflac_bool32 drflac__is_little_endian(void) +{ +#if defined(DRFLAC_X86) || defined(DRFLAC_X64) + return DRFLAC_TRUE; +#elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN + return DRFLAC_TRUE; +#else + int n = 1; + return (*(char*)&n) == 1; +#endif +} + +static DRFLAC_INLINE drflac_uint16 drflac__swap_endian_uint16(drflac_uint16 n) +{ +#ifdef DRFLAC_HAS_BYTESWAP16_INTRINSIC + #if defined(_MSC_VER) + return _byteswap_ushort(n); + #elif defined(__GNUC__) || defined(__clang__) + return __builtin_bswap16(n); + #else + #error "This compiler does not support the byte swap intrinsic." + #endif +#else + return ((n & 0xFF00) >> 8) | + ((n & 0x00FF) << 8); +#endif +} + +static DRFLAC_INLINE drflac_uint32 drflac__swap_endian_uint32(drflac_uint32 n) +{ +#ifdef DRFLAC_HAS_BYTESWAP32_INTRINSIC + #if defined(_MSC_VER) + return _byteswap_ulong(n); + #elif defined(__GNUC__) || defined(__clang__) + #if defined(DRFLAC_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(DRFLAC_64BIT) /* <-- 64-bit inline assembly has not been tested, so disabling for now. */ + /* Inline assembly optimized implementation for ARM. In my testing, GCC does not generate optimized code with __builtin_bswap32(). */ + drflac_uint32 r; + __asm__ __volatile__ ( + #if defined(DRFLAC_64BIT) + "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n) /* <-- This is untested. If someone in the community could test this, that would be appreciated! */ + #else + "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n) + #endif + ); + return r; + #else + return __builtin_bswap32(n); + #endif + #else + #error "This compiler does not support the byte swap intrinsic." + #endif +#else + return ((n & 0xFF000000) >> 24) | + ((n & 0x00FF0000) >> 8) | + ((n & 0x0000FF00) << 8) | + ((n & 0x000000FF) << 24); +#endif +} + +static DRFLAC_INLINE drflac_uint64 drflac__swap_endian_uint64(drflac_uint64 n) +{ +#ifdef DRFLAC_HAS_BYTESWAP64_INTRINSIC + #if defined(_MSC_VER) + return _byteswap_uint64(n); + #elif defined(__GNUC__) || defined(__clang__) + return __builtin_bswap64(n); + #else + #error "This compiler does not support the byte swap intrinsic." + #endif +#else + return ((n & (drflac_uint64)0xFF00000000000000) >> 56) | + ((n & (drflac_uint64)0x00FF000000000000) >> 40) | + ((n & (drflac_uint64)0x0000FF0000000000) >> 24) | + ((n & (drflac_uint64)0x000000FF00000000) >> 8) | + ((n & (drflac_uint64)0x00000000FF000000) << 8) | + ((n & (drflac_uint64)0x0000000000FF0000) << 24) | + ((n & (drflac_uint64)0x000000000000FF00) << 40) | + ((n & (drflac_uint64)0x00000000000000FF) << 56); +#endif +} + + +static DRFLAC_INLINE drflac_uint16 drflac__be2host_16(drflac_uint16 n) +{ + if (drflac__is_little_endian()) { + return drflac__swap_endian_uint16(n); + } + + return n; +} + +static DRFLAC_INLINE drflac_uint32 drflac__be2host_32(drflac_uint32 n) +{ + if (drflac__is_little_endian()) { + return drflac__swap_endian_uint32(n); + } + + return n; +} + +static DRFLAC_INLINE drflac_uint64 drflac__be2host_64(drflac_uint64 n) +{ + if (drflac__is_little_endian()) { + return drflac__swap_endian_uint64(n); + } + + return n; +} + + +static DRFLAC_INLINE drflac_uint32 drflac__le2host_32(drflac_uint32 n) +{ + if (!drflac__is_little_endian()) { + return drflac__swap_endian_uint32(n); + } + + return n; +} + + +static DRFLAC_INLINE drflac_uint32 drflac__unsynchsafe_32(drflac_uint32 n) +{ + drflac_uint32 result = 0; + result |= (n & 0x7F000000) >> 3; + result |= (n & 0x007F0000) >> 2; + result |= (n & 0x00007F00) >> 1; + result |= (n & 0x0000007F) >> 0; + + return result; +} + + + +/* The CRC code below is based on this document: http://zlib.net/crc_v3.txt */ +static drflac_uint8 drflac__crc8_table[] = { + 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D, + 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D, + 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD, + 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD, + 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2, 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA, + 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2, 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A, + 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32, 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A, + 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42, 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A, + 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4, + 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC, 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4, + 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C, 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44, + 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34, + 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B, 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63, + 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B, 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13, + 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83, + 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3 +}; + +static drflac_uint16 drflac__crc16_table[] = { + 0x0000, 0x8005, 0x800F, 0x000A, 0x801B, 0x001E, 0x0014, 0x8011, + 0x8033, 0x0036, 0x003C, 0x8039, 0x0028, 0x802D, 0x8027, 0x0022, + 0x8063, 0x0066, 0x006C, 0x8069, 0x0078, 0x807D, 0x8077, 0x0072, + 0x0050, 0x8055, 0x805F, 0x005A, 0x804B, 0x004E, 0x0044, 0x8041, + 0x80C3, 0x00C6, 0x00CC, 0x80C9, 0x00D8, 0x80DD, 0x80D7, 0x00D2, + 0x00F0, 0x80F5, 0x80FF, 0x00FA, 0x80EB, 0x00EE, 0x00E4, 0x80E1, + 0x00A0, 0x80A5, 0x80AF, 0x00AA, 0x80BB, 0x00BE, 0x00B4, 0x80B1, + 0x8093, 0x0096, 0x009C, 0x8099, 0x0088, 0x808D, 0x8087, 0x0082, + 0x8183, 0x0186, 0x018C, 0x8189, 0x0198, 0x819D, 0x8197, 0x0192, + 0x01B0, 0x81B5, 0x81BF, 0x01BA, 0x81AB, 0x01AE, 0x01A4, 0x81A1, + 0x01E0, 0x81E5, 0x81EF, 0x01EA, 0x81FB, 0x01FE, 0x01F4, 0x81F1, + 0x81D3, 0x01D6, 0x01DC, 0x81D9, 0x01C8, 0x81CD, 0x81C7, 0x01C2, + 0x0140, 0x8145, 0x814F, 0x014A, 0x815B, 0x015E, 0x0154, 0x8151, + 0x8173, 0x0176, 0x017C, 0x8179, 0x0168, 0x816D, 0x8167, 0x0162, + 0x8123, 0x0126, 0x012C, 0x8129, 0x0138, 0x813D, 0x8137, 0x0132, + 0x0110, 0x8115, 0x811F, 0x011A, 0x810B, 0x010E, 0x0104, 0x8101, + 0x8303, 0x0306, 0x030C, 0x8309, 0x0318, 0x831D, 0x8317, 0x0312, + 0x0330, 0x8335, 0x833F, 0x033A, 0x832B, 0x032E, 0x0324, 0x8321, + 0x0360, 0x8365, 0x836F, 0x036A, 0x837B, 0x037E, 0x0374, 0x8371, + 0x8353, 0x0356, 0x035C, 0x8359, 0x0348, 0x834D, 0x8347, 0x0342, + 0x03C0, 0x83C5, 0x83CF, 0x03CA, 0x83DB, 0x03DE, 0x03D4, 0x83D1, + 0x83F3, 0x03F6, 0x03FC, 0x83F9, 0x03E8, 0x83ED, 0x83E7, 0x03E2, + 0x83A3, 0x03A6, 0x03AC, 0x83A9, 0x03B8, 0x83BD, 0x83B7, 0x03B2, + 0x0390, 0x8395, 0x839F, 0x039A, 0x838B, 0x038E, 0x0384, 0x8381, + 0x0280, 0x8285, 0x828F, 0x028A, 0x829B, 0x029E, 0x0294, 0x8291, + 0x82B3, 0x02B6, 0x02BC, 0x82B9, 0x02A8, 0x82AD, 0x82A7, 0x02A2, + 0x82E3, 0x02E6, 0x02EC, 0x82E9, 0x02F8, 0x82FD, 0x82F7, 0x02F2, + 0x02D0, 0x82D5, 0x82DF, 0x02DA, 0x82CB, 0x02CE, 0x02C4, 0x82C1, + 0x8243, 0x0246, 0x024C, 0x8249, 0x0258, 0x825D, 0x8257, 0x0252, + 0x0270, 0x8275, 0x827F, 0x027A, 0x826B, 0x026E, 0x0264, 0x8261, + 0x0220, 0x8225, 0x822F, 0x022A, 0x823B, 0x023E, 0x0234, 0x8231, + 0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202 +}; + +static DRFLAC_INLINE drflac_uint8 drflac_crc8_byte(drflac_uint8 crc, drflac_uint8 data) +{ + return drflac__crc8_table[crc ^ data]; +} + +static DRFLAC_INLINE drflac_uint8 drflac_crc8(drflac_uint8 crc, drflac_uint32 data, drflac_uint32 count) +{ +#ifdef DR_FLAC_NO_CRC + (void)crc; + (void)data; + (void)count; + return 0; +#else +#if 0 + /* REFERENCE (use of this implementation requires an explicit flush by doing "drflac_crc8(crc, 0, 8);") */ + drflac_uint8 p = 0x07; + for (int i = count-1; i >= 0; --i) { + drflac_uint8 bit = (data & (1 << i)) >> i; + if (crc & 0x80) { + crc = ((crc << 1) | bit) ^ p; + } else { + crc = ((crc << 1) | bit); + } + } + return crc; +#else + drflac_uint32 wholeBytes; + drflac_uint32 leftoverBits; + drflac_uint64 leftoverDataMask; + + static drflac_uint64 leftoverDataMaskTable[8] = { + 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F + }; + + DRFLAC_ASSERT(count <= 32); + + wholeBytes = count >> 3; + leftoverBits = count - (wholeBytes*8); + leftoverDataMask = leftoverDataMaskTable[leftoverBits]; + + switch (wholeBytes) { + case 4: crc = drflac_crc8_byte(crc, (drflac_uint8)((data & (0xFF000000UL << leftoverBits)) >> (24 + leftoverBits))); + case 3: crc = drflac_crc8_byte(crc, (drflac_uint8)((data & (0x00FF0000UL << leftoverBits)) >> (16 + leftoverBits))); + case 2: crc = drflac_crc8_byte(crc, (drflac_uint8)((data & (0x0000FF00UL << leftoverBits)) >> ( 8 + leftoverBits))); + case 1: crc = drflac_crc8_byte(crc, (drflac_uint8)((data & (0x000000FFUL << leftoverBits)) >> ( 0 + leftoverBits))); + case 0: if (leftoverBits > 0) crc = (drflac_uint8)((crc << leftoverBits) ^ drflac__crc8_table[(crc >> (8 - leftoverBits)) ^ (data & leftoverDataMask)]); + } + return crc; +#endif +#endif +} + +static DRFLAC_INLINE drflac_uint16 drflac_crc16_byte(drflac_uint16 crc, drflac_uint8 data) +{ + return (crc << 8) ^ drflac__crc16_table[(drflac_uint8)(crc >> 8) ^ data]; +} + +static DRFLAC_INLINE drflac_uint16 drflac_crc16_cache(drflac_uint16 crc, drflac_cache_t data) +{ +#ifdef DRFLAC_64BIT + crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 56) & 0xFF)); + crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 48) & 0xFF)); + crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 40) & 0xFF)); + crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 32) & 0xFF)); +#endif + crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 24) & 0xFF)); + crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 16) & 0xFF)); + crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 8) & 0xFF)); + crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 0) & 0xFF)); + + return crc; +} + +static DRFLAC_INLINE drflac_uint16 drflac_crc16_bytes(drflac_uint16 crc, drflac_cache_t data, drflac_uint32 byteCount) +{ + switch (byteCount) + { +#ifdef DRFLAC_64BIT + case 8: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 56) & 0xFF)); + case 7: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 48) & 0xFF)); + case 6: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 40) & 0xFF)); + case 5: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 32) & 0xFF)); +#endif + case 4: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 24) & 0xFF)); + case 3: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 16) & 0xFF)); + case 2: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 8) & 0xFF)); + case 1: crc = drflac_crc16_byte(crc, (drflac_uint8)((data >> 0) & 0xFF)); + } + + return crc; +} + +#if 0 +static DRFLAC_INLINE drflac_uint16 drflac_crc16__32bit(drflac_uint16 crc, drflac_uint32 data, drflac_uint32 count) +{ +#ifdef DR_FLAC_NO_CRC + (void)crc; + (void)data; + (void)count; + return 0; +#else +#if 0 + /* REFERENCE (use of this implementation requires an explicit flush by doing "drflac_crc16(crc, 0, 16);") */ + drflac_uint16 p = 0x8005; + for (int i = count-1; i >= 0; --i) { + drflac_uint16 bit = (data & (1ULL << i)) >> i; + if (r & 0x8000) { + r = ((r << 1) | bit) ^ p; + } else { + r = ((r << 1) | bit); + } + } + + return crc; +#else + drflac_uint32 wholeBytes; + drflac_uint32 leftoverBits; + drflac_uint64 leftoverDataMask; + + static drflac_uint64 leftoverDataMaskTable[8] = { + 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F + }; + + DRFLAC_ASSERT(count <= 64); + + wholeBytes = count >> 3; + leftoverBits = count & 7; + leftoverDataMask = leftoverDataMaskTable[leftoverBits]; + + switch (wholeBytes) { + default: + case 4: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (0xFF000000UL << leftoverBits)) >> (24 + leftoverBits))); + case 3: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (0x00FF0000UL << leftoverBits)) >> (16 + leftoverBits))); + case 2: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (0x0000FF00UL << leftoverBits)) >> ( 8 + leftoverBits))); + case 1: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (0x000000FFUL << leftoverBits)) >> ( 0 + leftoverBits))); + case 0: if (leftoverBits > 0) crc = (crc << leftoverBits) ^ drflac__crc16_table[(crc >> (16 - leftoverBits)) ^ (data & leftoverDataMask)]; + } + return crc; +#endif +#endif +} + +static DRFLAC_INLINE drflac_uint16 drflac_crc16__64bit(drflac_uint16 crc, drflac_uint64 data, drflac_uint32 count) +{ +#ifdef DR_FLAC_NO_CRC + (void)crc; + (void)data; + (void)count; + return 0; +#else + drflac_uint32 wholeBytes; + drflac_uint32 leftoverBits; + drflac_uint64 leftoverDataMask; + + static drflac_uint64 leftoverDataMaskTable[8] = { + 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F + }; + + DRFLAC_ASSERT(count <= 64); + + wholeBytes = count >> 3; + leftoverBits = count & 7; + leftoverDataMask = leftoverDataMaskTable[leftoverBits]; + + switch (wholeBytes) { + default: + case 8: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0xFF000000 << 32) << leftoverBits)) >> (56 + leftoverBits))); /* Weird "<< 32" bitshift is required for C89 because it doesn't support 64-bit constants. Should be optimized out by a good compiler. */ + case 7: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x00FF0000 << 32) << leftoverBits)) >> (48 + leftoverBits))); + case 6: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x0000FF00 << 32) << leftoverBits)) >> (40 + leftoverBits))); + case 5: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x000000FF << 32) << leftoverBits)) >> (32 + leftoverBits))); + case 4: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0xFF000000 ) << leftoverBits)) >> (24 + leftoverBits))); + case 3: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x00FF0000 ) << leftoverBits)) >> (16 + leftoverBits))); + case 2: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x0000FF00 ) << leftoverBits)) >> ( 8 + leftoverBits))); + case 1: crc = drflac_crc16_byte(crc, (drflac_uint8)((data & (((drflac_uint64)0x000000FF ) << leftoverBits)) >> ( 0 + leftoverBits))); + case 0: if (leftoverBits > 0) crc = (crc << leftoverBits) ^ drflac__crc16_table[(crc >> (16 - leftoverBits)) ^ (data & leftoverDataMask)]; + } + return crc; +#endif +} + + +static DRFLAC_INLINE drflac_uint16 drflac_crc16(drflac_uint16 crc, drflac_cache_t data, drflac_uint32 count) +{ +#ifdef DRFLAC_64BIT + return drflac_crc16__64bit(crc, data, count); +#else + return drflac_crc16__32bit(crc, data, count); +#endif +} +#endif + + +#ifdef DRFLAC_64BIT +#define drflac__be2host__cache_line drflac__be2host_64 +#else +#define drflac__be2host__cache_line drflac__be2host_32 +#endif + +/* +BIT READING ATTEMPT #2 + +This uses a 32- or 64-bit bit-shifted cache - as bits are read, the cache is shifted such that the first valid bit is sitting +on the most significant bit. It uses the notion of an L1 and L2 cache (borrowed from CPU architecture), where the L1 cache +is a 32- or 64-bit unsigned integer (depending on whether or not a 32- or 64-bit build is being compiled) and the L2 is an +array of "cache lines", with each cache line being the same size as the L1. The L2 is a buffer of about 4KB and is where data +from onRead() is read into. +*/ +#define DRFLAC_CACHE_L1_SIZE_BYTES(bs) (sizeof((bs)->cache)) +#define DRFLAC_CACHE_L1_SIZE_BITS(bs) (sizeof((bs)->cache)*8) +#define DRFLAC_CACHE_L1_BITS_REMAINING(bs) (DRFLAC_CACHE_L1_SIZE_BITS(bs) - (bs)->consumedBits) +#define DRFLAC_CACHE_L1_SELECTION_MASK(_bitCount) (~((~(drflac_cache_t)0) >> (_bitCount))) +#define DRFLAC_CACHE_L1_SELECTION_SHIFT(bs, _bitCount) (DRFLAC_CACHE_L1_SIZE_BITS(bs) - (_bitCount)) +#define DRFLAC_CACHE_L1_SELECT(bs, _bitCount) (((bs)->cache) & DRFLAC_CACHE_L1_SELECTION_MASK(_bitCount)) +#define DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, _bitCount) (DRFLAC_CACHE_L1_SELECT((bs), (_bitCount)) >> DRFLAC_CACHE_L1_SELECTION_SHIFT((bs), (_bitCount))) +#define DRFLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE(bs, _bitCount)(DRFLAC_CACHE_L1_SELECT((bs), (_bitCount)) >> (DRFLAC_CACHE_L1_SELECTION_SHIFT((bs), (_bitCount)) & (DRFLAC_CACHE_L1_SIZE_BITS(bs)-1))) +#define DRFLAC_CACHE_L2_SIZE_BYTES(bs) (sizeof((bs)->cacheL2)) +#define DRFLAC_CACHE_L2_LINE_COUNT(bs) (DRFLAC_CACHE_L2_SIZE_BYTES(bs) / sizeof((bs)->cacheL2[0])) +#define DRFLAC_CACHE_L2_LINES_REMAINING(bs) (DRFLAC_CACHE_L2_LINE_COUNT(bs) - (bs)->nextL2Line) + + +#ifndef DR_FLAC_NO_CRC +static DRFLAC_INLINE void drflac__reset_crc16(drflac_bs* bs) +{ + bs->crc16 = 0; + bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3; +} + +static DRFLAC_INLINE void drflac__update_crc16(drflac_bs* bs) +{ + if (bs->crc16CacheIgnoredBytes == 0) { + bs->crc16 = drflac_crc16_cache(bs->crc16, bs->crc16Cache); + } else { + bs->crc16 = drflac_crc16_bytes(bs->crc16, bs->crc16Cache, DRFLAC_CACHE_L1_SIZE_BYTES(bs) - bs->crc16CacheIgnoredBytes); + bs->crc16CacheIgnoredBytes = 0; + } +} + +static DRFLAC_INLINE drflac_uint16 drflac__flush_crc16(drflac_bs* bs) +{ + /* We should never be flushing in a situation where we are not aligned on a byte boundary. */ + DRFLAC_ASSERT((DRFLAC_CACHE_L1_BITS_REMAINING(bs) & 7) == 0); + + /* + The bits that were read from the L1 cache need to be accumulated. The number of bytes needing to be accumulated is determined + by the number of bits that have been consumed. + */ + if (DRFLAC_CACHE_L1_BITS_REMAINING(bs) == 0) { + drflac__update_crc16(bs); + } else { + /* We only accumulate the consumed bits. */ + bs->crc16 = drflac_crc16_bytes(bs->crc16, bs->crc16Cache >> DRFLAC_CACHE_L1_BITS_REMAINING(bs), (bs->consumedBits >> 3) - bs->crc16CacheIgnoredBytes); + + /* + The bits that we just accumulated should never be accumulated again. We need to keep track of how many bytes were accumulated + so we can handle that later. + */ + bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3; + } + + return bs->crc16; +} +#endif + +static DRFLAC_INLINE drflac_bool32 drflac__reload_l1_cache_from_l2(drflac_bs* bs) +{ + size_t bytesRead; + size_t alignedL1LineCount; + + /* Fast path. Try loading straight from L2. */ + if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) { + bs->cache = bs->cacheL2[bs->nextL2Line++]; + return DRFLAC_TRUE; + } + + /* + If we get here it means we've run out of data in the L2 cache. We'll need to fetch more from the client, if there's + any left. + */ + if (bs->unalignedByteCount > 0) { + return DRFLAC_FALSE; /* If we have any unaligned bytes it means there's no more aligned bytes left in the client. */ + } + + bytesRead = bs->onRead(bs->pUserData, bs->cacheL2, DRFLAC_CACHE_L2_SIZE_BYTES(bs)); + + bs->nextL2Line = 0; + if (bytesRead == DRFLAC_CACHE_L2_SIZE_BYTES(bs)) { + bs->cache = bs->cacheL2[bs->nextL2Line++]; + return DRFLAC_TRUE; + } + + + /* + If we get here it means we were unable to retrieve enough data to fill the entire L2 cache. It probably + means we've just reached the end of the file. We need to move the valid data down to the end of the buffer + and adjust the index of the next line accordingly. Also keep in mind that the L2 cache must be aligned to + the size of the L1 so we'll need to seek backwards by any misaligned bytes. + */ + alignedL1LineCount = bytesRead / DRFLAC_CACHE_L1_SIZE_BYTES(bs); + + /* We need to keep track of any unaligned bytes for later use. */ + bs->unalignedByteCount = bytesRead - (alignedL1LineCount * DRFLAC_CACHE_L1_SIZE_BYTES(bs)); + if (bs->unalignedByteCount > 0) { + bs->unalignedCache = bs->cacheL2[alignedL1LineCount]; + } + + if (alignedL1LineCount > 0) { + size_t offset = DRFLAC_CACHE_L2_LINE_COUNT(bs) - alignedL1LineCount; + size_t i; + for (i = alignedL1LineCount; i > 0; --i) { + bs->cacheL2[i-1 + offset] = bs->cacheL2[i-1]; + } + + bs->nextL2Line = (drflac_uint32)offset; + bs->cache = bs->cacheL2[bs->nextL2Line++]; + return DRFLAC_TRUE; + } else { + /* If we get into this branch it means we weren't able to load any L1-aligned data. */ + bs->nextL2Line = DRFLAC_CACHE_L2_LINE_COUNT(bs); + return DRFLAC_FALSE; + } +} + +static drflac_bool32 drflac__reload_cache(drflac_bs* bs) +{ + size_t bytesRead; + +#ifndef DR_FLAC_NO_CRC + drflac__update_crc16(bs); +#endif + + /* Fast path. Try just moving the next value in the L2 cache to the L1 cache. */ + if (drflac__reload_l1_cache_from_l2(bs)) { + bs->cache = drflac__be2host__cache_line(bs->cache); + bs->consumedBits = 0; +#ifndef DR_FLAC_NO_CRC + bs->crc16Cache = bs->cache; +#endif + return DRFLAC_TRUE; + } + + /* Slow path. */ + + /* + If we get here it means we have failed to load the L1 cache from the L2. Likely we've just reached the end of the stream and the last + few bytes did not meet the alignment requirements for the L2 cache. In this case we need to fall back to a slower path and read the + data from the unaligned cache. + */ + bytesRead = bs->unalignedByteCount; + if (bytesRead == 0) { + bs->consumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs); /* <-- The stream has been exhausted, so marked the bits as consumed. */ + return DRFLAC_FALSE; + } + + DRFLAC_ASSERT(bytesRead < DRFLAC_CACHE_L1_SIZE_BYTES(bs)); + bs->consumedBits = (drflac_uint32)(DRFLAC_CACHE_L1_SIZE_BYTES(bs) - bytesRead) * 8; + + bs->cache = drflac__be2host__cache_line(bs->unalignedCache); + bs->cache &= DRFLAC_CACHE_L1_SELECTION_MASK(DRFLAC_CACHE_L1_BITS_REMAINING(bs)); /* <-- Make sure the consumed bits are always set to zero. Other parts of the library depend on this property. */ + bs->unalignedByteCount = 0; /* <-- At this point the unaligned bytes have been moved into the cache and we thus have no more unaligned bytes. */ + +#ifndef DR_FLAC_NO_CRC + bs->crc16Cache = bs->cache >> bs->consumedBits; + bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3; +#endif + return DRFLAC_TRUE; +} + +static void drflac__reset_cache(drflac_bs* bs) +{ + bs->nextL2Line = DRFLAC_CACHE_L2_LINE_COUNT(bs); /* <-- This clears the L2 cache. */ + bs->consumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs); /* <-- This clears the L1 cache. */ + bs->cache = 0; + bs->unalignedByteCount = 0; /* <-- This clears the trailing unaligned bytes. */ + bs->unalignedCache = 0; + +#ifndef DR_FLAC_NO_CRC + bs->crc16Cache = 0; + bs->crc16CacheIgnoredBytes = 0; +#endif +} + + +static DRFLAC_INLINE drflac_bool32 drflac__read_uint32(drflac_bs* bs, unsigned int bitCount, drflac_uint32* pResultOut) +{ + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(pResultOut != NULL); + DRFLAC_ASSERT(bitCount > 0); + DRFLAC_ASSERT(bitCount <= 32); + + if (bs->consumedBits == DRFLAC_CACHE_L1_SIZE_BITS(bs)) { + if (!drflac__reload_cache(bs)) { + return DRFLAC_FALSE; + } + } + + if (bitCount <= DRFLAC_CACHE_L1_BITS_REMAINING(bs)) { + /* + If we want to load all 32-bits from a 32-bit cache we need to do it slightly differently because we can't do + a 32-bit shift on a 32-bit integer. This will never be the case on 64-bit caches, so we can have a slightly + more optimal solution for this. + */ +#ifdef DRFLAC_64BIT + *pResultOut = (drflac_uint32)DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCount); + bs->consumedBits += bitCount; + bs->cache <<= bitCount; +#else + if (bitCount < DRFLAC_CACHE_L1_SIZE_BITS(bs)) { + *pResultOut = (drflac_uint32)DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCount); + bs->consumedBits += bitCount; + bs->cache <<= bitCount; + } else { + /* Cannot shift by 32-bits, so need to do it differently. */ + *pResultOut = (drflac_uint32)bs->cache; + bs->consumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs); + bs->cache = 0; + } +#endif + + return DRFLAC_TRUE; + } else { + /* It straddles the cached data. It will never cover more than the next chunk. We just read the number in two parts and combine them. */ + drflac_uint32 bitCountHi = DRFLAC_CACHE_L1_BITS_REMAINING(bs); + drflac_uint32 bitCountLo = bitCount - bitCountHi; + drflac_uint32 resultHi; + + DRFLAC_ASSERT(bitCountHi > 0); + DRFLAC_ASSERT(bitCountHi < 32); + resultHi = (drflac_uint32)DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCountHi); + + if (!drflac__reload_cache(bs)) { + return DRFLAC_FALSE; + } + + *pResultOut = (resultHi << bitCountLo) | (drflac_uint32)DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCountLo); + bs->consumedBits += bitCountLo; + bs->cache <<= bitCountLo; + return DRFLAC_TRUE; + } +} + +static drflac_bool32 drflac__read_int32(drflac_bs* bs, unsigned int bitCount, drflac_int32* pResult) +{ + drflac_uint32 result; + drflac_uint32 signbit; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(pResult != NULL); + DRFLAC_ASSERT(bitCount > 0); + DRFLAC_ASSERT(bitCount <= 32); + + if (!drflac__read_uint32(bs, bitCount, &result)) { + return DRFLAC_FALSE; + } + + signbit = ((result >> (bitCount-1)) & 0x01); + result |= (~signbit + 1) << bitCount; + + *pResult = (drflac_int32)result; + return DRFLAC_TRUE; +} + +#ifdef DRFLAC_64BIT +static drflac_bool32 drflac__read_uint64(drflac_bs* bs, unsigned int bitCount, drflac_uint64* pResultOut) +{ + drflac_uint32 resultHi; + drflac_uint32 resultLo; + + DRFLAC_ASSERT(bitCount <= 64); + DRFLAC_ASSERT(bitCount > 32); + + if (!drflac__read_uint32(bs, bitCount - 32, &resultHi)) { + return DRFLAC_FALSE; + } + + if (!drflac__read_uint32(bs, 32, &resultLo)) { + return DRFLAC_FALSE; + } + + *pResultOut = (((drflac_uint64)resultHi) << 32) | ((drflac_uint64)resultLo); + return DRFLAC_TRUE; +} +#endif + +/* Function below is unused, but leaving it here in case I need to quickly add it again. */ +#if 0 +static drflac_bool32 drflac__read_int64(drflac_bs* bs, unsigned int bitCount, drflac_int64* pResultOut) +{ + drflac_uint64 result; + drflac_uint64 signbit; + + DRFLAC_ASSERT(bitCount <= 64); + + if (!drflac__read_uint64(bs, bitCount, &result)) { + return DRFLAC_FALSE; + } + + signbit = ((result >> (bitCount-1)) & 0x01); + result |= (~signbit + 1) << bitCount; + + *pResultOut = (drflac_int64)result; + return DRFLAC_TRUE; +} +#endif + +static drflac_bool32 drflac__read_uint16(drflac_bs* bs, unsigned int bitCount, drflac_uint16* pResult) +{ + drflac_uint32 result; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(pResult != NULL); + DRFLAC_ASSERT(bitCount > 0); + DRFLAC_ASSERT(bitCount <= 16); + + if (!drflac__read_uint32(bs, bitCount, &result)) { + return DRFLAC_FALSE; + } + + *pResult = (drflac_uint16)result; + return DRFLAC_TRUE; +} + +#if 0 +static drflac_bool32 drflac__read_int16(drflac_bs* bs, unsigned int bitCount, drflac_int16* pResult) +{ + drflac_int32 result; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(pResult != NULL); + DRFLAC_ASSERT(bitCount > 0); + DRFLAC_ASSERT(bitCount <= 16); + + if (!drflac__read_int32(bs, bitCount, &result)) { + return DRFLAC_FALSE; + } + + *pResult = (drflac_int16)result; + return DRFLAC_TRUE; +} +#endif + +static drflac_bool32 drflac__read_uint8(drflac_bs* bs, unsigned int bitCount, drflac_uint8* pResult) +{ + drflac_uint32 result; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(pResult != NULL); + DRFLAC_ASSERT(bitCount > 0); + DRFLAC_ASSERT(bitCount <= 8); + + if (!drflac__read_uint32(bs, bitCount, &result)) { + return DRFLAC_FALSE; + } + + *pResult = (drflac_uint8)result; + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__read_int8(drflac_bs* bs, unsigned int bitCount, drflac_int8* pResult) +{ + drflac_int32 result; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(pResult != NULL); + DRFLAC_ASSERT(bitCount > 0); + DRFLAC_ASSERT(bitCount <= 8); + + if (!drflac__read_int32(bs, bitCount, &result)) { + return DRFLAC_FALSE; + } + + *pResult = (drflac_int8)result; + return DRFLAC_TRUE; +} + + +static drflac_bool32 drflac__seek_bits(drflac_bs* bs, size_t bitsToSeek) +{ + if (bitsToSeek <= DRFLAC_CACHE_L1_BITS_REMAINING(bs)) { + bs->consumedBits += (drflac_uint32)bitsToSeek; + bs->cache <<= bitsToSeek; + return DRFLAC_TRUE; + } else { + /* It straddles the cached data. This function isn't called too frequently so I'm favouring simplicity here. */ + bitsToSeek -= DRFLAC_CACHE_L1_BITS_REMAINING(bs); + bs->consumedBits += DRFLAC_CACHE_L1_BITS_REMAINING(bs); + bs->cache = 0; + + /* Simple case. Seek in groups of the same number as bits that fit within a cache line. */ +#ifdef DRFLAC_64BIT + while (bitsToSeek >= DRFLAC_CACHE_L1_SIZE_BITS(bs)) { + drflac_uint64 bin; + if (!drflac__read_uint64(bs, DRFLAC_CACHE_L1_SIZE_BITS(bs), &bin)) { + return DRFLAC_FALSE; + } + bitsToSeek -= DRFLAC_CACHE_L1_SIZE_BITS(bs); + } +#else + while (bitsToSeek >= DRFLAC_CACHE_L1_SIZE_BITS(bs)) { + drflac_uint32 bin; + if (!drflac__read_uint32(bs, DRFLAC_CACHE_L1_SIZE_BITS(bs), &bin)) { + return DRFLAC_FALSE; + } + bitsToSeek -= DRFLAC_CACHE_L1_SIZE_BITS(bs); + } +#endif + + /* Whole leftover bytes. */ + while (bitsToSeek >= 8) { + drflac_uint8 bin; + if (!drflac__read_uint8(bs, 8, &bin)) { + return DRFLAC_FALSE; + } + bitsToSeek -= 8; + } + + /* Leftover bits. */ + if (bitsToSeek > 0) { + drflac_uint8 bin; + if (!drflac__read_uint8(bs, (drflac_uint32)bitsToSeek, &bin)) { + return DRFLAC_FALSE; + } + bitsToSeek = 0; /* <-- Necessary for the assert below. */ + } + + DRFLAC_ASSERT(bitsToSeek == 0); + return DRFLAC_TRUE; + } +} + + +/* This function moves the bit streamer to the first bit after the sync code (bit 15 of the of the frame header). It will also update the CRC-16. */ +static drflac_bool32 drflac__find_and_seek_to_next_sync_code(drflac_bs* bs) +{ + DRFLAC_ASSERT(bs != NULL); + + /* + The sync code is always aligned to 8 bits. This is convenient for us because it means we can do byte-aligned movements. The first + thing to do is align to the next byte. + */ + if (!drflac__seek_bits(bs, DRFLAC_CACHE_L1_BITS_REMAINING(bs) & 7)) { + return DRFLAC_FALSE; + } + + for (;;) { + drflac_uint8 hi; + +#ifndef DR_FLAC_NO_CRC + drflac__reset_crc16(bs); +#endif + + if (!drflac__read_uint8(bs, 8, &hi)) { + return DRFLAC_FALSE; + } + + if (hi == 0xFF) { + drflac_uint8 lo; + if (!drflac__read_uint8(bs, 6, &lo)) { + return DRFLAC_FALSE; + } + + if (lo == 0x3E) { + return DRFLAC_TRUE; + } else { + if (!drflac__seek_bits(bs, DRFLAC_CACHE_L1_BITS_REMAINING(bs) & 7)) { + return DRFLAC_FALSE; + } + } + } + } + + /* Should never get here. */ + /*return DRFLAC_FALSE;*/ +} + + +#if defined(DRFLAC_HAS_LZCNT_INTRINSIC) +#define DRFLAC_IMPLEMENT_CLZ_LZCNT +#endif +#if defined(_MSC_VER) && _MSC_VER >= 1400 && (defined(DRFLAC_X64) || defined(DRFLAC_X86)) +#define DRFLAC_IMPLEMENT_CLZ_MSVC +#endif + +static DRFLAC_INLINE drflac_uint32 drflac__clz_software(drflac_cache_t x) +{ + drflac_uint32 n; + static drflac_uint32 clz_table_4[] = { + 0, + 4, + 3, 3, + 2, 2, 2, 2, + 1, 1, 1, 1, 1, 1, 1, 1 + }; + + if (x == 0) { + return sizeof(x)*8; + } + + n = clz_table_4[x >> (sizeof(x)*8 - 4)]; + if (n == 0) { +#ifdef DRFLAC_64BIT + if ((x & ((drflac_uint64)0xFFFFFFFF << 32)) == 0) { n = 32; x <<= 32; } + if ((x & ((drflac_uint64)0xFFFF0000 << 32)) == 0) { n += 16; x <<= 16; } + if ((x & ((drflac_uint64)0xFF000000 << 32)) == 0) { n += 8; x <<= 8; } + if ((x & ((drflac_uint64)0xF0000000 << 32)) == 0) { n += 4; x <<= 4; } +#else + if ((x & 0xFFFF0000) == 0) { n = 16; x <<= 16; } + if ((x & 0xFF000000) == 0) { n += 8; x <<= 8; } + if ((x & 0xF0000000) == 0) { n += 4; x <<= 4; } +#endif + n += clz_table_4[x >> (sizeof(x)*8 - 4)]; + } + + return n - 1; +} + +#ifdef DRFLAC_IMPLEMENT_CLZ_LZCNT +static DRFLAC_INLINE drflac_bool32 drflac__is_lzcnt_supported(void) +{ + /* Fast compile time check for ARM. */ +#if defined(DRFLAC_HAS_LZCNT_INTRINSIC) && defined(DRFLAC_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5) + return DRFLAC_TRUE; +#else + /* If the compiler itself does not support the intrinsic then we'll need to return false. */ + #ifdef DRFLAC_HAS_LZCNT_INTRINSIC + return drflac__gIsLZCNTSupported; + #else + return DRFLAC_FALSE; + #endif +#endif +} + +static DRFLAC_INLINE drflac_uint32 drflac__clz_lzcnt(drflac_cache_t x) +{ +#if defined(_MSC_VER) && !defined(__clang__) + #ifdef DRFLAC_64BIT + return (drflac_uint32)__lzcnt64(x); + #else + return (drflac_uint32)__lzcnt(x); + #endif +#else + #if defined(__GNUC__) || defined(__clang__) + #if defined(DRFLAC_X64) + { + drflac_uint64 r; + __asm__ __volatile__ ( + "lzcnt{ %1, %0| %0, %1}" : "=r"(r) : "r"(x) + ); + + return (drflac_uint32)r; + } + #elif defined(DRFLAC_X86) + { + drflac_uint32 r; + __asm__ __volatile__ ( + "lzcnt{l %1, %0| %0, %1}" : "=r"(r) : "r"(x) + ); + + return r; + } + #elif defined(DRFLAC_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5) && !defined(DRFLAC_64BIT) /* <-- I haven't tested 64-bit inline assembly, so only enabling this for the 32-bit build for now. */ + { + unsigned int r; + __asm__ __volatile__ ( + #if defined(DRFLAC_64BIT) + "clz %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(x) /* <-- This is untested. If someone in the community could test this, that would be appreciated! */ + #else + "clz %[out], %[in]" : [out]"=r"(r) : [in]"r"(x) + #endif + ); + + return r; + } + #else + if (x == 0) { + return sizeof(x)*8; + } + #ifdef DRFLAC_64BIT + return (drflac_uint32)__builtin_clzll((drflac_uint64)x); + #else + return (drflac_uint32)__builtin_clzl((drflac_uint32)x); + #endif + #endif + #else + /* Unsupported compiler. */ + #error "This compiler does not support the lzcnt intrinsic." + #endif +#endif +} +#endif + +#ifdef DRFLAC_IMPLEMENT_CLZ_MSVC +#include /* For BitScanReverse(). */ + +static DRFLAC_INLINE drflac_uint32 drflac__clz_msvc(drflac_cache_t x) +{ + drflac_uint32 n; + + if (x == 0) { + return sizeof(x)*8; + } + +#ifdef DRFLAC_64BIT + _BitScanReverse64((unsigned long*)&n, x); +#else + _BitScanReverse((unsigned long*)&n, x); +#endif + return sizeof(x)*8 - n - 1; +} +#endif + +static DRFLAC_INLINE drflac_uint32 drflac__clz(drflac_cache_t x) +{ +#ifdef DRFLAC_IMPLEMENT_CLZ_LZCNT + if (drflac__is_lzcnt_supported()) { + return drflac__clz_lzcnt(x); + } else +#endif + { +#ifdef DRFLAC_IMPLEMENT_CLZ_MSVC + return drflac__clz_msvc(x); +#else + return drflac__clz_software(x); +#endif + } +} + + +static DRFLAC_INLINE drflac_bool32 drflac__seek_past_next_set_bit(drflac_bs* bs, unsigned int* pOffsetOut) +{ + drflac_uint32 zeroCounter = 0; + drflac_uint32 setBitOffsetPlus1; + + while (bs->cache == 0) { + zeroCounter += (drflac_uint32)DRFLAC_CACHE_L1_BITS_REMAINING(bs); + if (!drflac__reload_cache(bs)) { + return DRFLAC_FALSE; + } + } + + setBitOffsetPlus1 = drflac__clz(bs->cache); + setBitOffsetPlus1 += 1; + + bs->consumedBits += setBitOffsetPlus1; + bs->cache <<= setBitOffsetPlus1; + + *pOffsetOut = zeroCounter + setBitOffsetPlus1 - 1; + return DRFLAC_TRUE; +} + + + +static drflac_bool32 drflac__seek_to_byte(drflac_bs* bs, drflac_uint64 offsetFromStart) +{ + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(offsetFromStart > 0); + + /* + Seeking from the start is not quite as trivial as it sounds because the onSeek callback takes a signed 32-bit integer (which + is intentional because it simplifies the implementation of the onSeek callbacks), however offsetFromStart is unsigned 64-bit. + To resolve we just need to do an initial seek from the start, and then a series of offset seeks to make up the remainder. + */ + if (offsetFromStart > 0x7FFFFFFF) { + drflac_uint64 bytesRemaining = offsetFromStart; + if (!bs->onSeek(bs->pUserData, 0x7FFFFFFF, drflac_seek_origin_start)) { + return DRFLAC_FALSE; + } + bytesRemaining -= 0x7FFFFFFF; + + while (bytesRemaining > 0x7FFFFFFF) { + if (!bs->onSeek(bs->pUserData, 0x7FFFFFFF, drflac_seek_origin_current)) { + return DRFLAC_FALSE; + } + bytesRemaining -= 0x7FFFFFFF; + } + + if (bytesRemaining > 0) { + if (!bs->onSeek(bs->pUserData, (int)bytesRemaining, drflac_seek_origin_current)) { + return DRFLAC_FALSE; + } + } + } else { + if (!bs->onSeek(bs->pUserData, (int)offsetFromStart, drflac_seek_origin_start)) { + return DRFLAC_FALSE; + } + } + + /* The cache should be reset to force a reload of fresh data from the client. */ + drflac__reset_cache(bs); + return DRFLAC_TRUE; +} + + +static drflac_result drflac__read_utf8_coded_number(drflac_bs* bs, drflac_uint64* pNumberOut, drflac_uint8* pCRCOut) +{ + drflac_uint8 crc; + drflac_uint64 result; + drflac_uint8 utf8[7] = {0}; + int byteCount; + int i; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(pNumberOut != NULL); + DRFLAC_ASSERT(pCRCOut != NULL); + + crc = *pCRCOut; + + if (!drflac__read_uint8(bs, 8, utf8)) { + *pNumberOut = 0; + return DRFLAC_AT_END; + } + crc = drflac_crc8(crc, utf8[0], 8); + + if ((utf8[0] & 0x80) == 0) { + *pNumberOut = utf8[0]; + *pCRCOut = crc; + return DRFLAC_SUCCESS; + } + + /*byteCount = 1;*/ + if ((utf8[0] & 0xE0) == 0xC0) { + byteCount = 2; + } else if ((utf8[0] & 0xF0) == 0xE0) { + byteCount = 3; + } else if ((utf8[0] & 0xF8) == 0xF0) { + byteCount = 4; + } else if ((utf8[0] & 0xFC) == 0xF8) { + byteCount = 5; + } else if ((utf8[0] & 0xFE) == 0xFC) { + byteCount = 6; + } else if ((utf8[0] & 0xFF) == 0xFE) { + byteCount = 7; + } else { + *pNumberOut = 0; + return DRFLAC_CRC_MISMATCH; /* Bad UTF-8 encoding. */ + } + + /* Read extra bytes. */ + DRFLAC_ASSERT(byteCount > 1); + + result = (drflac_uint64)(utf8[0] & (0xFF >> (byteCount + 1))); + for (i = 1; i < byteCount; ++i) { + if (!drflac__read_uint8(bs, 8, utf8 + i)) { + *pNumberOut = 0; + return DRFLAC_AT_END; + } + crc = drflac_crc8(crc, utf8[i], 8); + + result = (result << 6) | (utf8[i] & 0x3F); + } + + *pNumberOut = result; + *pCRCOut = crc; + return DRFLAC_SUCCESS; +} + + + +/* +The next two functions are responsible for calculating the prediction. + +When the bits per sample is >16 we need to use 64-bit integer arithmetic because otherwise we'll run out of precision. It's +safe to assume this will be slower on 32-bit platforms so we use a more optimal solution when the bits per sample is <=16. +*/ +static DRFLAC_INLINE drflac_int32 drflac__calculate_prediction_32(drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pDecodedSamples) +{ + drflac_int32 prediction = 0; + + DRFLAC_ASSERT(order <= 32); + + /* 32-bit version. */ + + /* VC++ optimizes this to a single jmp. I've not yet verified this for other compilers. */ + switch (order) + { + case 32: prediction += coefficients[31] * pDecodedSamples[-32]; + case 31: prediction += coefficients[30] * pDecodedSamples[-31]; + case 30: prediction += coefficients[29] * pDecodedSamples[-30]; + case 29: prediction += coefficients[28] * pDecodedSamples[-29]; + case 28: prediction += coefficients[27] * pDecodedSamples[-28]; + case 27: prediction += coefficients[26] * pDecodedSamples[-27]; + case 26: prediction += coefficients[25] * pDecodedSamples[-26]; + case 25: prediction += coefficients[24] * pDecodedSamples[-25]; + case 24: prediction += coefficients[23] * pDecodedSamples[-24]; + case 23: prediction += coefficients[22] * pDecodedSamples[-23]; + case 22: prediction += coefficients[21] * pDecodedSamples[-22]; + case 21: prediction += coefficients[20] * pDecodedSamples[-21]; + case 20: prediction += coefficients[19] * pDecodedSamples[-20]; + case 19: prediction += coefficients[18] * pDecodedSamples[-19]; + case 18: prediction += coefficients[17] * pDecodedSamples[-18]; + case 17: prediction += coefficients[16] * pDecodedSamples[-17]; + case 16: prediction += coefficients[15] * pDecodedSamples[-16]; + case 15: prediction += coefficients[14] * pDecodedSamples[-15]; + case 14: prediction += coefficients[13] * pDecodedSamples[-14]; + case 13: prediction += coefficients[12] * pDecodedSamples[-13]; + case 12: prediction += coefficients[11] * pDecodedSamples[-12]; + case 11: prediction += coefficients[10] * pDecodedSamples[-11]; + case 10: prediction += coefficients[ 9] * pDecodedSamples[-10]; + case 9: prediction += coefficients[ 8] * pDecodedSamples[- 9]; + case 8: prediction += coefficients[ 7] * pDecodedSamples[- 8]; + case 7: prediction += coefficients[ 6] * pDecodedSamples[- 7]; + case 6: prediction += coefficients[ 5] * pDecodedSamples[- 6]; + case 5: prediction += coefficients[ 4] * pDecodedSamples[- 5]; + case 4: prediction += coefficients[ 3] * pDecodedSamples[- 4]; + case 3: prediction += coefficients[ 2] * pDecodedSamples[- 3]; + case 2: prediction += coefficients[ 1] * pDecodedSamples[- 2]; + case 1: prediction += coefficients[ 0] * pDecodedSamples[- 1]; + } + + return (drflac_int32)(prediction >> shift); +} + +static DRFLAC_INLINE drflac_int32 drflac__calculate_prediction_64(drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pDecodedSamples) +{ + drflac_int64 prediction; + + DRFLAC_ASSERT(order <= 32); + + /* 64-bit version. */ + + /* This method is faster on the 32-bit build when compiling with VC++. See note below. */ +#ifndef DRFLAC_64BIT + if (order == 8) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3]; + prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4]; + prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5]; + prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6]; + prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7]; + prediction += coefficients[7] * (drflac_int64)pDecodedSamples[-8]; + } + else if (order == 7) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3]; + prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4]; + prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5]; + prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6]; + prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7]; + } + else if (order == 3) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3]; + } + else if (order == 6) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3]; + prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4]; + prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5]; + prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6]; + } + else if (order == 5) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3]; + prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4]; + prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5]; + } + else if (order == 4) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3]; + prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4]; + } + else if (order == 12) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3]; + prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4]; + prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5]; + prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6]; + prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7]; + prediction += coefficients[7] * (drflac_int64)pDecodedSamples[-8]; + prediction += coefficients[8] * (drflac_int64)pDecodedSamples[-9]; + prediction += coefficients[9] * (drflac_int64)pDecodedSamples[-10]; + prediction += coefficients[10] * (drflac_int64)pDecodedSamples[-11]; + prediction += coefficients[11] * (drflac_int64)pDecodedSamples[-12]; + } + else if (order == 2) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + } + else if (order == 1) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + } + else if (order == 10) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3]; + prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4]; + prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5]; + prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6]; + prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7]; + prediction += coefficients[7] * (drflac_int64)pDecodedSamples[-8]; + prediction += coefficients[8] * (drflac_int64)pDecodedSamples[-9]; + prediction += coefficients[9] * (drflac_int64)pDecodedSamples[-10]; + } + else if (order == 9) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3]; + prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4]; + prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5]; + prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6]; + prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7]; + prediction += coefficients[7] * (drflac_int64)pDecodedSamples[-8]; + prediction += coefficients[8] * (drflac_int64)pDecodedSamples[-9]; + } + else if (order == 11) + { + prediction = coefficients[0] * (drflac_int64)pDecodedSamples[-1]; + prediction += coefficients[1] * (drflac_int64)pDecodedSamples[-2]; + prediction += coefficients[2] * (drflac_int64)pDecodedSamples[-3]; + prediction += coefficients[3] * (drflac_int64)pDecodedSamples[-4]; + prediction += coefficients[4] * (drflac_int64)pDecodedSamples[-5]; + prediction += coefficients[5] * (drflac_int64)pDecodedSamples[-6]; + prediction += coefficients[6] * (drflac_int64)pDecodedSamples[-7]; + prediction += coefficients[7] * (drflac_int64)pDecodedSamples[-8]; + prediction += coefficients[8] * (drflac_int64)pDecodedSamples[-9]; + prediction += coefficients[9] * (drflac_int64)pDecodedSamples[-10]; + prediction += coefficients[10] * (drflac_int64)pDecodedSamples[-11]; + } + else + { + int j; + + prediction = 0; + for (j = 0; j < (int)order; ++j) { + prediction += coefficients[j] * (drflac_int64)pDecodedSamples[-j-1]; + } + } +#endif + + /* + VC++ optimizes this to a single jmp instruction, but only the 64-bit build. The 32-bit build generates less efficient code for some + reason. The ugly version above is faster so we'll just switch between the two depending on the target platform. + */ +#ifdef DRFLAC_64BIT + prediction = 0; + switch (order) + { + case 32: prediction += coefficients[31] * (drflac_int64)pDecodedSamples[-32]; + case 31: prediction += coefficients[30] * (drflac_int64)pDecodedSamples[-31]; + case 30: prediction += coefficients[29] * (drflac_int64)pDecodedSamples[-30]; + case 29: prediction += coefficients[28] * (drflac_int64)pDecodedSamples[-29]; + case 28: prediction += coefficients[27] * (drflac_int64)pDecodedSamples[-28]; + case 27: prediction += coefficients[26] * (drflac_int64)pDecodedSamples[-27]; + case 26: prediction += coefficients[25] * (drflac_int64)pDecodedSamples[-26]; + case 25: prediction += coefficients[24] * (drflac_int64)pDecodedSamples[-25]; + case 24: prediction += coefficients[23] * (drflac_int64)pDecodedSamples[-24]; + case 23: prediction += coefficients[22] * (drflac_int64)pDecodedSamples[-23]; + case 22: prediction += coefficients[21] * (drflac_int64)pDecodedSamples[-22]; + case 21: prediction += coefficients[20] * (drflac_int64)pDecodedSamples[-21]; + case 20: prediction += coefficients[19] * (drflac_int64)pDecodedSamples[-20]; + case 19: prediction += coefficients[18] * (drflac_int64)pDecodedSamples[-19]; + case 18: prediction += coefficients[17] * (drflac_int64)pDecodedSamples[-18]; + case 17: prediction += coefficients[16] * (drflac_int64)pDecodedSamples[-17]; + case 16: prediction += coefficients[15] * (drflac_int64)pDecodedSamples[-16]; + case 15: prediction += coefficients[14] * (drflac_int64)pDecodedSamples[-15]; + case 14: prediction += coefficients[13] * (drflac_int64)pDecodedSamples[-14]; + case 13: prediction += coefficients[12] * (drflac_int64)pDecodedSamples[-13]; + case 12: prediction += coefficients[11] * (drflac_int64)pDecodedSamples[-12]; + case 11: prediction += coefficients[10] * (drflac_int64)pDecodedSamples[-11]; + case 10: prediction += coefficients[ 9] * (drflac_int64)pDecodedSamples[-10]; + case 9: prediction += coefficients[ 8] * (drflac_int64)pDecodedSamples[- 9]; + case 8: prediction += coefficients[ 7] * (drflac_int64)pDecodedSamples[- 8]; + case 7: prediction += coefficients[ 6] * (drflac_int64)pDecodedSamples[- 7]; + case 6: prediction += coefficients[ 5] * (drflac_int64)pDecodedSamples[- 6]; + case 5: prediction += coefficients[ 4] * (drflac_int64)pDecodedSamples[- 5]; + case 4: prediction += coefficients[ 3] * (drflac_int64)pDecodedSamples[- 4]; + case 3: prediction += coefficients[ 2] * (drflac_int64)pDecodedSamples[- 3]; + case 2: prediction += coefficients[ 1] * (drflac_int64)pDecodedSamples[- 2]; + case 1: prediction += coefficients[ 0] * (drflac_int64)pDecodedSamples[- 1]; + } +#endif + + return (drflac_int32)(prediction >> shift); +} + + +#if 0 +/* +Reference implementation for reading and decoding samples with residual. This is intentionally left unoptimized for the +sake of readability and should only be used as a reference. +*/ +static drflac_bool32 drflac__decode_samples_with_residual__rice__reference(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ + drflac_uint32 i; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(count > 0); + DRFLAC_ASSERT(pSamplesOut != NULL); + + for (i = 0; i < count; ++i) { + drflac_uint32 zeroCounter = 0; + for (;;) { + drflac_uint8 bit; + if (!drflac__read_uint8(bs, 1, &bit)) { + return DRFLAC_FALSE; + } + + if (bit == 0) { + zeroCounter += 1; + } else { + break; + } + } + + drflac_uint32 decodedRice; + if (riceParam > 0) { + if (!drflac__read_uint32(bs, riceParam, &decodedRice)) { + return DRFLAC_FALSE; + } + } else { + decodedRice = 0; + } + + decodedRice |= (zeroCounter << riceParam); + if ((decodedRice & 0x01)) { + decodedRice = ~(decodedRice >> 1); + } else { + decodedRice = (decodedRice >> 1); + } + + + if (bitsPerSample+shift >= 32) { + pSamplesOut[i] = decodedRice + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + i); + } else { + pSamplesOut[i] = decodedRice + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + i); + } + } + + return DRFLAC_TRUE; +} +#endif + +#if 0 +static drflac_bool32 drflac__read_rice_parts__reference(drflac_bs* bs, drflac_uint8 riceParam, drflac_uint32* pZeroCounterOut, drflac_uint32* pRiceParamPartOut) +{ + drflac_uint32 zeroCounter = 0; + drflac_uint32 decodedRice; + + for (;;) { + drflac_uint8 bit; + if (!drflac__read_uint8(bs, 1, &bit)) { + return DRFLAC_FALSE; + } + + if (bit == 0) { + zeroCounter += 1; + } else { + break; + } + } + + if (riceParam > 0) { + if (!drflac__read_uint32(bs, riceParam, &decodedRice)) { + return DRFLAC_FALSE; + } + } else { + decodedRice = 0; + } + + *pZeroCounterOut = zeroCounter; + *pRiceParamPartOut = decodedRice; + return DRFLAC_TRUE; +} +#endif + +#if 0 +static DRFLAC_INLINE drflac_bool32 drflac__read_rice_parts(drflac_bs* bs, drflac_uint8 riceParam, drflac_uint32* pZeroCounterOut, drflac_uint32* pRiceParamPartOut) +{ + drflac_cache_t riceParamMask; + drflac_uint32 zeroCounter; + drflac_uint32 setBitOffsetPlus1; + drflac_uint32 riceParamPart; + drflac_uint32 riceLength; + + DRFLAC_ASSERT(riceParam > 0); /* <-- riceParam should never be 0. drflac__read_rice_parts__param_equals_zero() should be used instead for this case. */ + + riceParamMask = DRFLAC_CACHE_L1_SELECTION_MASK(riceParam); + + zeroCounter = 0; + while (bs->cache == 0) { + zeroCounter += (drflac_uint32)DRFLAC_CACHE_L1_BITS_REMAINING(bs); + if (!drflac__reload_cache(bs)) { + return DRFLAC_FALSE; + } + } + + setBitOffsetPlus1 = drflac__clz(bs->cache); + zeroCounter += setBitOffsetPlus1; + setBitOffsetPlus1 += 1; + + riceLength = setBitOffsetPlus1 + riceParam; + if (riceLength < DRFLAC_CACHE_L1_BITS_REMAINING(bs)) { + riceParamPart = (drflac_uint32)((bs->cache & (riceParamMask >> setBitOffsetPlus1)) >> DRFLAC_CACHE_L1_SELECTION_SHIFT(bs, riceLength)); + + bs->consumedBits += riceLength; + bs->cache <<= riceLength; + } else { + drflac_uint32 bitCountLo; + drflac_cache_t resultHi; + + bs->consumedBits += riceLength; + bs->cache <<= setBitOffsetPlus1 & (DRFLAC_CACHE_L1_SIZE_BITS(bs)-1); /* <-- Equivalent to "if (setBitOffsetPlus1 < DRFLAC_CACHE_L1_SIZE_BITS(bs)) { bs->cache <<= setBitOffsetPlus1; }" */ + + /* It straddles the cached data. It will never cover more than the next chunk. We just read the number in two parts and combine them. */ + bitCountLo = bs->consumedBits - DRFLAC_CACHE_L1_SIZE_BITS(bs); + resultHi = DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, riceParam); /* <-- Use DRFLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE() if ever this function allows riceParam=0. */ + + if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) { +#ifndef DR_FLAC_NO_CRC + drflac__update_crc16(bs); +#endif + bs->cache = drflac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]); + bs->consumedBits = 0; +#ifndef DR_FLAC_NO_CRC + bs->crc16Cache = bs->cache; +#endif + } else { + /* Slow path. We need to fetch more data from the client. */ + if (!drflac__reload_cache(bs)) { + return DRFLAC_FALSE; + } + } + + riceParamPart = (drflac_uint32)(resultHi | DRFLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE(bs, bitCountLo)); + + bs->consumedBits += bitCountLo; + bs->cache <<= bitCountLo; + } + + pZeroCounterOut[0] = zeroCounter; + pRiceParamPartOut[0] = riceParamPart; + + return DRFLAC_TRUE; +} +#endif + +static DRFLAC_INLINE drflac_bool32 drflac__read_rice_parts_x1(drflac_bs* bs, drflac_uint8 riceParam, drflac_uint32* pZeroCounterOut, drflac_uint32* pRiceParamPartOut) +{ + drflac_uint32 riceParamPlus1 = riceParam + 1; + /*drflac_cache_t riceParamPlus1Mask = DRFLAC_CACHE_L1_SELECTION_MASK(riceParamPlus1);*/ + drflac_uint32 riceParamPlus1Shift = DRFLAC_CACHE_L1_SELECTION_SHIFT(bs, riceParamPlus1); + drflac_uint32 riceParamPlus1MaxConsumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs) - riceParamPlus1; + + /* + The idea here is to use local variables for the cache in an attempt to encourage the compiler to store them in registers. I have + no idea how this will work in practice... + */ + drflac_cache_t bs_cache = bs->cache; + drflac_uint32 bs_consumedBits = bs->consumedBits; + + /* The first thing to do is find the first unset bit. Most likely a bit will be set in the current cache line. */ + drflac_uint32 lzcount = drflac__clz(bs_cache); + if (lzcount < sizeof(bs_cache)*8) { + pZeroCounterOut[0] = lzcount; + + /* + It is most likely that the riceParam part (which comes after the zero counter) is also on this cache line. When extracting + this, we include the set bit from the unary coded part because it simplifies cache management. This bit will be handled + outside of this function at a higher level. + */ + extract_rice_param_part: + bs_cache <<= lzcount; + bs_consumedBits += lzcount; + + if (bs_consumedBits <= riceParamPlus1MaxConsumedBits) { + /* Getting here means the rice parameter part is wholly contained within the current cache line. */ + pRiceParamPartOut[0] = (drflac_uint32)(bs_cache >> riceParamPlus1Shift); + bs_cache <<= riceParamPlus1; + bs_consumedBits += riceParamPlus1; + } else { + drflac_uint32 riceParamPartHi; + drflac_uint32 riceParamPartLo; + drflac_uint32 riceParamPartLoBitCount; + + /* + Getting here means the rice parameter part straddles the cache line. We need to read from the tail of the current cache + line, reload the cache, and then combine it with the head of the next cache line. + */ + + /* Grab the high part of the rice parameter part. */ + riceParamPartHi = (drflac_uint32)(bs_cache >> riceParamPlus1Shift); + + /* Before reloading the cache we need to grab the size in bits of the low part. */ + riceParamPartLoBitCount = bs_consumedBits - riceParamPlus1MaxConsumedBits; + DRFLAC_ASSERT(riceParamPartLoBitCount > 0 && riceParamPartLoBitCount < 32); + + /* Now reload the cache. */ + if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) { + #ifndef DR_FLAC_NO_CRC + drflac__update_crc16(bs); + #endif + bs_cache = drflac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]); + bs_consumedBits = riceParamPartLoBitCount; + #ifndef DR_FLAC_NO_CRC + bs->crc16Cache = bs_cache; + #endif + } else { + /* Slow path. We need to fetch more data from the client. */ + if (!drflac__reload_cache(bs)) { + return DRFLAC_FALSE; + } + + bs_cache = bs->cache; + bs_consumedBits = bs->consumedBits + riceParamPartLoBitCount; + } + + /* We should now have enough information to construct the rice parameter part. */ + riceParamPartLo = (drflac_uint32)(bs_cache >> (DRFLAC_CACHE_L1_SELECTION_SHIFT(bs, riceParamPartLoBitCount))); + pRiceParamPartOut[0] = riceParamPartHi | riceParamPartLo; + + bs_cache <<= riceParamPartLoBitCount; + } + } else { + /* + Getting here means there are no bits set on the cache line. This is a less optimal case because we just wasted a call + to drflac__clz() and we need to reload the cache. + */ + drflac_uint32 zeroCounter = (drflac_uint32)(DRFLAC_CACHE_L1_SIZE_BITS(bs) - bs_consumedBits); + for (;;) { + if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) { + #ifndef DR_FLAC_NO_CRC + drflac__update_crc16(bs); + #endif + bs_cache = drflac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]); + bs_consumedBits = 0; + #ifndef DR_FLAC_NO_CRC + bs->crc16Cache = bs_cache; + #endif + } else { + /* Slow path. We need to fetch more data from the client. */ + if (!drflac__reload_cache(bs)) { + return DRFLAC_FALSE; + } + + bs_cache = bs->cache; + bs_consumedBits = bs->consumedBits; + } + + lzcount = drflac__clz(bs_cache); + zeroCounter += lzcount; + + if (lzcount < sizeof(bs_cache)*8) { + break; + } + } + + pZeroCounterOut[0] = zeroCounter; + goto extract_rice_param_part; + } + + /* Make sure the cache is restored at the end of it all. */ + bs->cache = bs_cache; + bs->consumedBits = bs_consumedBits; + + return DRFLAC_TRUE; +} + +static DRFLAC_INLINE drflac_bool32 drflac__seek_rice_parts(drflac_bs* bs, drflac_uint8 riceParam) +{ + drflac_uint32 riceParamPlus1 = riceParam + 1; + drflac_uint32 riceParamPlus1MaxConsumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs) - riceParamPlus1; + + /* + The idea here is to use local variables for the cache in an attempt to encourage the compiler to store them in registers. I have + no idea how this will work in practice... + */ + drflac_cache_t bs_cache = bs->cache; + drflac_uint32 bs_consumedBits = bs->consumedBits; + + /* The first thing to do is find the first unset bit. Most likely a bit will be set in the current cache line. */ + drflac_uint32 lzcount = drflac__clz(bs_cache); + if (lzcount < sizeof(bs_cache)*8) { + /* + It is most likely that the riceParam part (which comes after the zero counter) is also on this cache line. When extracting + this, we include the set bit from the unary coded part because it simplifies cache management. This bit will be handled + outside of this function at a higher level. + */ + extract_rice_param_part: + bs_cache <<= lzcount; + bs_consumedBits += lzcount; + + if (bs_consumedBits <= riceParamPlus1MaxConsumedBits) { + /* Getting here means the rice parameter part is wholly contained within the current cache line. */ + bs_cache <<= riceParamPlus1; + bs_consumedBits += riceParamPlus1; + } else { + /* + Getting here means the rice parameter part straddles the cache line. We need to read from the tail of the current cache + line, reload the cache, and then combine it with the head of the next cache line. + */ + + /* Before reloading the cache we need to grab the size in bits of the low part. */ + drflac_uint32 riceParamPartLoBitCount = bs_consumedBits - riceParamPlus1MaxConsumedBits; + DRFLAC_ASSERT(riceParamPartLoBitCount > 0 && riceParamPartLoBitCount < 32); + + /* Now reload the cache. */ + if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) { + #ifndef DR_FLAC_NO_CRC + drflac__update_crc16(bs); + #endif + bs_cache = drflac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]); + bs_consumedBits = riceParamPartLoBitCount; + #ifndef DR_FLAC_NO_CRC + bs->crc16Cache = bs_cache; + #endif + } else { + /* Slow path. We need to fetch more data from the client. */ + if (!drflac__reload_cache(bs)) { + return DRFLAC_FALSE; + } + + bs_cache = bs->cache; + bs_consumedBits = bs->consumedBits + riceParamPartLoBitCount; + } + + bs_cache <<= riceParamPartLoBitCount; + } + } else { + /* + Getting here means there are no bits set on the cache line. This is a less optimal case because we just wasted a call + to drflac__clz() and we need to reload the cache. + */ + for (;;) { + if (bs->nextL2Line < DRFLAC_CACHE_L2_LINE_COUNT(bs)) { + #ifndef DR_FLAC_NO_CRC + drflac__update_crc16(bs); + #endif + bs_cache = drflac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]); + bs_consumedBits = 0; + #ifndef DR_FLAC_NO_CRC + bs->crc16Cache = bs_cache; + #endif + } else { + /* Slow path. We need to fetch more data from the client. */ + if (!drflac__reload_cache(bs)) { + return DRFLAC_FALSE; + } + + bs_cache = bs->cache; + bs_consumedBits = bs->consumedBits; + } + + lzcount = drflac__clz(bs_cache); + if (lzcount < sizeof(bs_cache)*8) { + break; + } + } + + goto extract_rice_param_part; + } + + /* Make sure the cache is restored at the end of it all. */ + bs->cache = bs_cache; + bs->consumedBits = bs_consumedBits; + + return DRFLAC_TRUE; +} + + +static drflac_bool32 drflac__decode_samples_with_residual__rice__scalar_zeroorder(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ + drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF}; + drflac_uint32 zeroCountPart0; + drflac_uint32 riceParamPart0; + drflac_uint32 riceParamMask; + drflac_uint32 i; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(count > 0); + DRFLAC_ASSERT(pSamplesOut != NULL); + + (void)bitsPerSample; + (void)order; + (void)shift; + (void)coefficients; + + riceParamMask = (drflac_uint32)~((~0UL) << riceParam); + + i = 0; + while (i < count) { + /* Rice extraction. */ + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0)) { + return DRFLAC_FALSE; + } + + /* Rice reconstruction. */ + riceParamPart0 &= riceParamMask; + riceParamPart0 |= (zeroCountPart0 << riceParam); + riceParamPart0 = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01]; + + pSamplesOut[i] = riceParamPart0; + + i += 1; + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_samples_with_residual__rice__scalar(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ + drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF}; + drflac_uint32 zeroCountPart0 = 0; + drflac_uint32 zeroCountPart1 = 0; + drflac_uint32 zeroCountPart2 = 0; + drflac_uint32 zeroCountPart3 = 0; + drflac_uint32 riceParamPart0 = 0; + drflac_uint32 riceParamPart1 = 0; + drflac_uint32 riceParamPart2 = 0; + drflac_uint32 riceParamPart3 = 0; + drflac_uint32 riceParamMask; + const drflac_int32* pSamplesOutEnd; + drflac_uint32 i; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(count > 0); + DRFLAC_ASSERT(pSamplesOut != NULL); + + if (order == 0) { + return drflac__decode_samples_with_residual__rice__scalar_zeroorder(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut); + } + + riceParamMask = (drflac_uint32)~((~0UL) << riceParam); + pSamplesOutEnd = pSamplesOut + (count & ~3); + + if (bitsPerSample+shift > 32) { + while (pSamplesOut < pSamplesOutEnd) { + /* + Rice extraction. It's faster to do this one at a time against local variables than it is to use the x4 version + against an array. Not sure why, but perhaps it's making more efficient use of registers? + */ + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart1, &riceParamPart1) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart2, &riceParamPart2) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart3, &riceParamPart3)) { + return DRFLAC_FALSE; + } + + riceParamPart0 &= riceParamMask; + riceParamPart1 &= riceParamMask; + riceParamPart2 &= riceParamMask; + riceParamPart3 &= riceParamMask; + + riceParamPart0 |= (zeroCountPart0 << riceParam); + riceParamPart1 |= (zeroCountPart1 << riceParam); + riceParamPart2 |= (zeroCountPart2 << riceParam); + riceParamPart3 |= (zeroCountPart3 << riceParam); + + riceParamPart0 = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01]; + riceParamPart1 = (riceParamPart1 >> 1) ^ t[riceParamPart1 & 0x01]; + riceParamPart2 = (riceParamPart2 >> 1) ^ t[riceParamPart2 & 0x01]; + riceParamPart3 = (riceParamPart3 >> 1) ^ t[riceParamPart3 & 0x01]; + + pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + 0); + pSamplesOut[1] = riceParamPart1 + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + 1); + pSamplesOut[2] = riceParamPart2 + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + 2); + pSamplesOut[3] = riceParamPart3 + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + 3); + + pSamplesOut += 4; + } + } else { + while (pSamplesOut < pSamplesOutEnd) { + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart1, &riceParamPart1) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart2, &riceParamPart2) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart3, &riceParamPart3)) { + return DRFLAC_FALSE; + } + + riceParamPart0 &= riceParamMask; + riceParamPart1 &= riceParamMask; + riceParamPart2 &= riceParamMask; + riceParamPart3 &= riceParamMask; + + riceParamPart0 |= (zeroCountPart0 << riceParam); + riceParamPart1 |= (zeroCountPart1 << riceParam); + riceParamPart2 |= (zeroCountPart2 << riceParam); + riceParamPart3 |= (zeroCountPart3 << riceParam); + + riceParamPart0 = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01]; + riceParamPart1 = (riceParamPart1 >> 1) ^ t[riceParamPart1 & 0x01]; + riceParamPart2 = (riceParamPart2 >> 1) ^ t[riceParamPart2 & 0x01]; + riceParamPart3 = (riceParamPart3 >> 1) ^ t[riceParamPart3 & 0x01]; + + pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + 0); + pSamplesOut[1] = riceParamPart1 + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + 1); + pSamplesOut[2] = riceParamPart2 + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + 2); + pSamplesOut[3] = riceParamPart3 + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + 3); + + pSamplesOut += 4; + } + } + + i = (count & ~3); + while (i < count) { + /* Rice extraction. */ + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0)) { + return DRFLAC_FALSE; + } + + /* Rice reconstruction. */ + riceParamPart0 &= riceParamMask; + riceParamPart0 |= (zeroCountPart0 << riceParam); + riceParamPart0 = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01]; + /*riceParamPart0 = (riceParamPart0 >> 1) ^ (~(riceParamPart0 & 0x01) + 1);*/ + + /* Sample reconstruction. */ + if (bitsPerSample+shift > 32) { + pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + 0); + } else { + pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + 0); + } + + i += 1; + pSamplesOut += 1; + } + + return DRFLAC_TRUE; +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE __m128i drflac__mm_packs_interleaved_epi32(__m128i a, __m128i b) +{ + __m128i r; + + /* Pack. */ + r = _mm_packs_epi32(a, b); + + /* a3a2 a1a0 b3b2 b1b0 -> a3a2 b3b2 a1a0 b1b0 */ + r = _mm_shuffle_epi32(r, _MM_SHUFFLE(3, 1, 2, 0)); + + /* a3a2 b3b2 a1a0 b1b0 -> a3b3 a2b2 a1b1 a0b0 */ + r = _mm_shufflehi_epi16(r, _MM_SHUFFLE(3, 1, 2, 0)); + r = _mm_shufflelo_epi16(r, _MM_SHUFFLE(3, 1, 2, 0)); + + return r; +} +#endif + +#if defined(DRFLAC_SUPPORT_SSE41) +static DRFLAC_INLINE __m128i drflac__mm_not_si128(__m128i a) +{ + return _mm_xor_si128(a, _mm_cmpeq_epi32(_mm_setzero_si128(), _mm_setzero_si128())); +} + +static DRFLAC_INLINE __m128i drflac__mm_hadd_epi32(__m128i x) +{ + __m128i x64 = _mm_add_epi32(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2))); + __m128i x32 = _mm_shufflelo_epi16(x64, _MM_SHUFFLE(1, 0, 3, 2)); + return _mm_add_epi32(x64, x32); +} + +static DRFLAC_INLINE __m128i drflac__mm_hadd_epi64(__m128i x) +{ + return _mm_add_epi64(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2))); +} + +static DRFLAC_INLINE __m128i drflac__mm_srai_epi64(__m128i x, int count) +{ + /* + To simplify this we are assuming count < 32. This restriction allows us to work on a low side and a high side. The low side + is shifted with zero bits, whereas the right side is shifted with sign bits. + */ + __m128i lo = _mm_srli_epi64(x, count); + __m128i hi = _mm_srai_epi32(x, count); + + hi = _mm_and_si128(hi, _mm_set_epi32(0xFFFFFFFF, 0, 0xFFFFFFFF, 0)); /* The high part needs to have the low part cleared. */ + + return _mm_or_si128(lo, hi); +} + +static drflac_bool32 drflac__decode_samples_with_residual__rice__sse41_32(drflac_bs* bs, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ + int i; + drflac_uint32 riceParamMask; + drflac_int32* pDecodedSamples = pSamplesOut; + drflac_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3); + drflac_uint32 zeroCountParts0 = 0; + drflac_uint32 zeroCountParts1 = 0; + drflac_uint32 zeroCountParts2 = 0; + drflac_uint32 zeroCountParts3 = 0; + drflac_uint32 riceParamParts0 = 0; + drflac_uint32 riceParamParts1 = 0; + drflac_uint32 riceParamParts2 = 0; + drflac_uint32 riceParamParts3 = 0; + __m128i coefficients128_0; + __m128i coefficients128_4; + __m128i coefficients128_8; + __m128i samples128_0; + __m128i samples128_4; + __m128i samples128_8; + __m128i riceParamMask128; + + const drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF}; + + riceParamMask = (drflac_uint32)~((~0UL) << riceParam); + riceParamMask128 = _mm_set1_epi32(riceParamMask); + + /* Pre-load. */ + coefficients128_0 = _mm_setzero_si128(); + coefficients128_4 = _mm_setzero_si128(); + coefficients128_8 = _mm_setzero_si128(); + + samples128_0 = _mm_setzero_si128(); + samples128_4 = _mm_setzero_si128(); + samples128_8 = _mm_setzero_si128(); + + /* + Pre-loading the coefficients and prior samples is annoying because we need to ensure we don't try reading more than + what's available in the input buffers. It would be convenient to use a fall-through switch to do this, but this results + in strict aliasing warnings with GCC. To work around this I'm just doing something hacky. This feels a bit convoluted + so I think there's opportunity for this to be simplified. + */ +#if 1 + { + int runningOrder = order; + + /* 0 - 3. */ + if (runningOrder >= 4) { + coefficients128_0 = _mm_loadu_si128((const __m128i*)(coefficients + 0)); + samples128_0 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 4)); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: coefficients128_0 = _mm_set_epi32(0, coefficients[2], coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], pSamplesOut[-3], 0); break; + case 2: coefficients128_0 = _mm_set_epi32(0, 0, coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], 0, 0); break; + case 1: coefficients128_0 = _mm_set_epi32(0, 0, 0, coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], 0, 0, 0); break; + } + runningOrder = 0; + } + + /* 4 - 7 */ + if (runningOrder >= 4) { + coefficients128_4 = _mm_loadu_si128((const __m128i*)(coefficients + 4)); + samples128_4 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 8)); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: coefficients128_4 = _mm_set_epi32(0, coefficients[6], coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], pSamplesOut[-7], 0); break; + case 2: coefficients128_4 = _mm_set_epi32(0, 0, coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], 0, 0); break; + case 1: coefficients128_4 = _mm_set_epi32(0, 0, 0, coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], 0, 0, 0); break; + } + runningOrder = 0; + } + + /* 8 - 11 */ + if (runningOrder == 4) { + coefficients128_8 = _mm_loadu_si128((const __m128i*)(coefficients + 8)); + samples128_8 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 12)); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: coefficients128_8 = _mm_set_epi32(0, coefficients[10], coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], pSamplesOut[-11], 0); break; + case 2: coefficients128_8 = _mm_set_epi32(0, 0, coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], 0, 0); break; + case 1: coefficients128_8 = _mm_set_epi32(0, 0, 0, coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], 0, 0, 0); break; + } + runningOrder = 0; + } + + /* Coefficients need to be shuffled for our streaming algorithm below to work. Samples are already in the correct order from the loading routine above. */ + coefficients128_0 = _mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(0, 1, 2, 3)); + coefficients128_4 = _mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(0, 1, 2, 3)); + coefficients128_8 = _mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(0, 1, 2, 3)); + } +#else + /* This causes strict-aliasing warnings with GCC. */ + switch (order) + { + case 12: ((drflac_int32*)&coefficients128_8)[0] = coefficients[11]; ((drflac_int32*)&samples128_8)[0] = pDecodedSamples[-12]; + case 11: ((drflac_int32*)&coefficients128_8)[1] = coefficients[10]; ((drflac_int32*)&samples128_8)[1] = pDecodedSamples[-11]; + case 10: ((drflac_int32*)&coefficients128_8)[2] = coefficients[ 9]; ((drflac_int32*)&samples128_8)[2] = pDecodedSamples[-10]; + case 9: ((drflac_int32*)&coefficients128_8)[3] = coefficients[ 8]; ((drflac_int32*)&samples128_8)[3] = pDecodedSamples[- 9]; + case 8: ((drflac_int32*)&coefficients128_4)[0] = coefficients[ 7]; ((drflac_int32*)&samples128_4)[0] = pDecodedSamples[- 8]; + case 7: ((drflac_int32*)&coefficients128_4)[1] = coefficients[ 6]; ((drflac_int32*)&samples128_4)[1] = pDecodedSamples[- 7]; + case 6: ((drflac_int32*)&coefficients128_4)[2] = coefficients[ 5]; ((drflac_int32*)&samples128_4)[2] = pDecodedSamples[- 6]; + case 5: ((drflac_int32*)&coefficients128_4)[3] = coefficients[ 4]; ((drflac_int32*)&samples128_4)[3] = pDecodedSamples[- 5]; + case 4: ((drflac_int32*)&coefficients128_0)[0] = coefficients[ 3]; ((drflac_int32*)&samples128_0)[0] = pDecodedSamples[- 4]; + case 3: ((drflac_int32*)&coefficients128_0)[1] = coefficients[ 2]; ((drflac_int32*)&samples128_0)[1] = pDecodedSamples[- 3]; + case 2: ((drflac_int32*)&coefficients128_0)[2] = coefficients[ 1]; ((drflac_int32*)&samples128_0)[2] = pDecodedSamples[- 2]; + case 1: ((drflac_int32*)&coefficients128_0)[3] = coefficients[ 0]; ((drflac_int32*)&samples128_0)[3] = pDecodedSamples[- 1]; + } +#endif + + /* For this version we are doing one sample at a time. */ + while (pDecodedSamples < pDecodedSamplesEnd) { + __m128i prediction128; + __m128i zeroCountPart128; + __m128i riceParamPart128; + + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts1, &riceParamParts1) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts2, &riceParamParts2) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts3, &riceParamParts3)) { + return DRFLAC_FALSE; + } + + zeroCountPart128 = _mm_set_epi32(zeroCountParts3, zeroCountParts2, zeroCountParts1, zeroCountParts0); + riceParamPart128 = _mm_set_epi32(riceParamParts3, riceParamParts2, riceParamParts1, riceParamParts0); + + riceParamPart128 = _mm_and_si128(riceParamPart128, riceParamMask128); + riceParamPart128 = _mm_or_si128(riceParamPart128, _mm_slli_epi32(zeroCountPart128, riceParam)); + riceParamPart128 = _mm_xor_si128(_mm_srli_epi32(riceParamPart128, 1), _mm_add_epi32(drflac__mm_not_si128(_mm_and_si128(riceParamPart128, _mm_set1_epi32(0x01))), _mm_set1_epi32(0x01))); /* <-- SSE2 compatible */ + /*riceParamPart128 = _mm_xor_si128(_mm_srli_epi32(riceParamPart128, 1), _mm_mullo_epi32(_mm_and_si128(riceParamPart128, _mm_set1_epi32(0x01)), _mm_set1_epi32(0xFFFFFFFF)));*/ /* <-- Only supported from SSE4.1 and is slower in my testing... */ + + if (order <= 4) { + for (i = 0; i < 4; i += 1) { + prediction128 = _mm_mullo_epi32(coefficients128_0, samples128_0); + + /* Horizontal add and shift. */ + prediction128 = drflac__mm_hadd_epi32(prediction128); + prediction128 = _mm_srai_epi32(prediction128, shift); + prediction128 = _mm_add_epi32(riceParamPart128, prediction128); + + samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4); + riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4); + } + } else if (order <= 8) { + for (i = 0; i < 4; i += 1) { + prediction128 = _mm_mullo_epi32(coefficients128_4, samples128_4); + prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_0, samples128_0)); + + /* Horizontal add and shift. */ + prediction128 = drflac__mm_hadd_epi32(prediction128); + prediction128 = _mm_srai_epi32(prediction128, shift); + prediction128 = _mm_add_epi32(riceParamPart128, prediction128); + + samples128_4 = _mm_alignr_epi8(samples128_0, samples128_4, 4); + samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4); + riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4); + } + } else { + for (i = 0; i < 4; i += 1) { + prediction128 = _mm_mullo_epi32(coefficients128_8, samples128_8); + prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_4, samples128_4)); + prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_0, samples128_0)); + + /* Horizontal add and shift. */ + prediction128 = drflac__mm_hadd_epi32(prediction128); + prediction128 = _mm_srai_epi32(prediction128, shift); + prediction128 = _mm_add_epi32(riceParamPart128, prediction128); + + samples128_8 = _mm_alignr_epi8(samples128_4, samples128_8, 4); + samples128_4 = _mm_alignr_epi8(samples128_0, samples128_4, 4); + samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4); + riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4); + } + } + + /* We store samples in groups of 4. */ + _mm_storeu_si128((__m128i*)pDecodedSamples, samples128_0); + pDecodedSamples += 4; + } + + /* Make sure we process the last few samples. */ + i = (count & ~3); + while (i < (int)count) { + /* Rice extraction. */ + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0)) { + return DRFLAC_FALSE; + } + + /* Rice reconstruction. */ + riceParamParts0 &= riceParamMask; + riceParamParts0 |= (zeroCountParts0 << riceParam); + riceParamParts0 = (riceParamParts0 >> 1) ^ t[riceParamParts0 & 0x01]; + + /* Sample reconstruction. */ + pDecodedSamples[0] = riceParamParts0 + drflac__calculate_prediction_32(order, shift, coefficients, pDecodedSamples); + + i += 1; + pDecodedSamples += 1; + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_samples_with_residual__rice__sse41_64(drflac_bs* bs, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ + int i; + drflac_uint32 riceParamMask; + drflac_int32* pDecodedSamples = pSamplesOut; + drflac_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3); + drflac_uint32 zeroCountParts0 = 0; + drflac_uint32 zeroCountParts1 = 0; + drflac_uint32 zeroCountParts2 = 0; + drflac_uint32 zeroCountParts3 = 0; + drflac_uint32 riceParamParts0 = 0; + drflac_uint32 riceParamParts1 = 0; + drflac_uint32 riceParamParts2 = 0; + drflac_uint32 riceParamParts3 = 0; + __m128i coefficients128_0; + __m128i coefficients128_4; + __m128i coefficients128_8; + __m128i samples128_0; + __m128i samples128_4; + __m128i samples128_8; + __m128i prediction128; + __m128i riceParamMask128; + + const drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF}; + + DRFLAC_ASSERT(order <= 12); + + riceParamMask = (drflac_uint32)~((~0UL) << riceParam); + riceParamMask128 = _mm_set1_epi32(riceParamMask); + + prediction128 = _mm_setzero_si128(); + + /* Pre-load. */ + coefficients128_0 = _mm_setzero_si128(); + coefficients128_4 = _mm_setzero_si128(); + coefficients128_8 = _mm_setzero_si128(); + + samples128_0 = _mm_setzero_si128(); + samples128_4 = _mm_setzero_si128(); + samples128_8 = _mm_setzero_si128(); + +#if 1 + { + int runningOrder = order; + + /* 0 - 3. */ + if (runningOrder >= 4) { + coefficients128_0 = _mm_loadu_si128((const __m128i*)(coefficients + 0)); + samples128_0 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 4)); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: coefficients128_0 = _mm_set_epi32(0, coefficients[2], coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], pSamplesOut[-3], 0); break; + case 2: coefficients128_0 = _mm_set_epi32(0, 0, coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], 0, 0); break; + case 1: coefficients128_0 = _mm_set_epi32(0, 0, 0, coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], 0, 0, 0); break; + } + runningOrder = 0; + } + + /* 4 - 7 */ + if (runningOrder >= 4) { + coefficients128_4 = _mm_loadu_si128((const __m128i*)(coefficients + 4)); + samples128_4 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 8)); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: coefficients128_4 = _mm_set_epi32(0, coefficients[6], coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], pSamplesOut[-7], 0); break; + case 2: coefficients128_4 = _mm_set_epi32(0, 0, coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], 0, 0); break; + case 1: coefficients128_4 = _mm_set_epi32(0, 0, 0, coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], 0, 0, 0); break; + } + runningOrder = 0; + } + + /* 8 - 11 */ + if (runningOrder == 4) { + coefficients128_8 = _mm_loadu_si128((const __m128i*)(coefficients + 8)); + samples128_8 = _mm_loadu_si128((const __m128i*)(pSamplesOut - 12)); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: coefficients128_8 = _mm_set_epi32(0, coefficients[10], coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], pSamplesOut[-11], 0); break; + case 2: coefficients128_8 = _mm_set_epi32(0, 0, coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], 0, 0); break; + case 1: coefficients128_8 = _mm_set_epi32(0, 0, 0, coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], 0, 0, 0); break; + } + runningOrder = 0; + } + + /* Coefficients need to be shuffled for our streaming algorithm below to work. Samples are already in the correct order from the loading routine above. */ + coefficients128_0 = _mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(0, 1, 2, 3)); + coefficients128_4 = _mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(0, 1, 2, 3)); + coefficients128_8 = _mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(0, 1, 2, 3)); + } +#else + switch (order) + { + case 12: ((drflac_int32*)&coefficients128_8)[0] = coefficients[11]; ((drflac_int32*)&samples128_8)[0] = pDecodedSamples[-12]; + case 11: ((drflac_int32*)&coefficients128_8)[1] = coefficients[10]; ((drflac_int32*)&samples128_8)[1] = pDecodedSamples[-11]; + case 10: ((drflac_int32*)&coefficients128_8)[2] = coefficients[ 9]; ((drflac_int32*)&samples128_8)[2] = pDecodedSamples[-10]; + case 9: ((drflac_int32*)&coefficients128_8)[3] = coefficients[ 8]; ((drflac_int32*)&samples128_8)[3] = pDecodedSamples[- 9]; + case 8: ((drflac_int32*)&coefficients128_4)[0] = coefficients[ 7]; ((drflac_int32*)&samples128_4)[0] = pDecodedSamples[- 8]; + case 7: ((drflac_int32*)&coefficients128_4)[1] = coefficients[ 6]; ((drflac_int32*)&samples128_4)[1] = pDecodedSamples[- 7]; + case 6: ((drflac_int32*)&coefficients128_4)[2] = coefficients[ 5]; ((drflac_int32*)&samples128_4)[2] = pDecodedSamples[- 6]; + case 5: ((drflac_int32*)&coefficients128_4)[3] = coefficients[ 4]; ((drflac_int32*)&samples128_4)[3] = pDecodedSamples[- 5]; + case 4: ((drflac_int32*)&coefficients128_0)[0] = coefficients[ 3]; ((drflac_int32*)&samples128_0)[0] = pDecodedSamples[- 4]; + case 3: ((drflac_int32*)&coefficients128_0)[1] = coefficients[ 2]; ((drflac_int32*)&samples128_0)[1] = pDecodedSamples[- 3]; + case 2: ((drflac_int32*)&coefficients128_0)[2] = coefficients[ 1]; ((drflac_int32*)&samples128_0)[2] = pDecodedSamples[- 2]; + case 1: ((drflac_int32*)&coefficients128_0)[3] = coefficients[ 0]; ((drflac_int32*)&samples128_0)[3] = pDecodedSamples[- 1]; + } +#endif + + /* For this version we are doing one sample at a time. */ + while (pDecodedSamples < pDecodedSamplesEnd) { + __m128i zeroCountPart128; + __m128i riceParamPart128; + + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts1, &riceParamParts1) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts2, &riceParamParts2) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts3, &riceParamParts3)) { + return DRFLAC_FALSE; + } + + zeroCountPart128 = _mm_set_epi32(zeroCountParts3, zeroCountParts2, zeroCountParts1, zeroCountParts0); + riceParamPart128 = _mm_set_epi32(riceParamParts3, riceParamParts2, riceParamParts1, riceParamParts0); + + riceParamPart128 = _mm_and_si128(riceParamPart128, riceParamMask128); + riceParamPart128 = _mm_or_si128(riceParamPart128, _mm_slli_epi32(zeroCountPart128, riceParam)); + riceParamPart128 = _mm_xor_si128(_mm_srli_epi32(riceParamPart128, 1), _mm_add_epi32(drflac__mm_not_si128(_mm_and_si128(riceParamPart128, _mm_set1_epi32(1))), _mm_set1_epi32(1))); + + for (i = 0; i < 4; i += 1) { + prediction128 = _mm_xor_si128(prediction128, prediction128); /* Reset to 0. */ + + switch (order) + { + case 12: + case 11: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_8, _MM_SHUFFLE(1, 1, 0, 0)))); + case 10: + case 9: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_8, _MM_SHUFFLE(3, 3, 2, 2)))); + case 8: + case 7: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_4, _MM_SHUFFLE(1, 1, 0, 0)))); + case 6: + case 5: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_4, _MM_SHUFFLE(3, 3, 2, 2)))); + case 4: + case 3: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_0, _MM_SHUFFLE(1, 1, 0, 0)))); + case 2: + case 1: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_0, _MM_SHUFFLE(3, 3, 2, 2)))); + } + + /* Horizontal add and shift. */ + prediction128 = drflac__mm_hadd_epi64(prediction128); + prediction128 = drflac__mm_srai_epi64(prediction128, shift); + prediction128 = _mm_add_epi32(riceParamPart128, prediction128); + + /* Our value should be sitting in prediction128[0]. We need to combine this with our SSE samples. */ + samples128_8 = _mm_alignr_epi8(samples128_4, samples128_8, 4); + samples128_4 = _mm_alignr_epi8(samples128_0, samples128_4, 4); + samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4); + + /* Slide our rice parameter down so that the value in position 0 contains the next one to process. */ + riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4); + } + + /* We store samples in groups of 4. */ + _mm_storeu_si128((__m128i*)pDecodedSamples, samples128_0); + pDecodedSamples += 4; + } + + /* Make sure we process the last few samples. */ + i = (count & ~3); + while (i < (int)count) { + /* Rice extraction. */ + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0)) { + return DRFLAC_FALSE; + } + + /* Rice reconstruction. */ + riceParamParts0 &= riceParamMask; + riceParamParts0 |= (zeroCountParts0 << riceParam); + riceParamParts0 = (riceParamParts0 >> 1) ^ t[riceParamParts0 & 0x01]; + + /* Sample reconstruction. */ + pDecodedSamples[0] = riceParamParts0 + drflac__calculate_prediction_64(order, shift, coefficients, pDecodedSamples); + + i += 1; + pDecodedSamples += 1; + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_samples_with_residual__rice__sse41(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(count > 0); + DRFLAC_ASSERT(pSamplesOut != NULL); + + /* In my testing the order is rarely > 12, so in this case I'm going to simplify the SSE implementation by only handling order <= 12. */ + if (order > 0 && order <= 12) { + if (bitsPerSample+shift > 32) { + return drflac__decode_samples_with_residual__rice__sse41_64(bs, count, riceParam, order, shift, coefficients, pSamplesOut); + } else { + return drflac__decode_samples_with_residual__rice__sse41_32(bs, count, riceParam, order, shift, coefficients, pSamplesOut); + } + } else { + return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut); + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac__vst2q_s32(drflac_int32* p, int32x4x2_t x) +{ + vst1q_s32(p+0, x.val[0]); + vst1q_s32(p+4, x.val[1]); +} + +static DRFLAC_INLINE void drflac__vst2q_u32(drflac_uint32* p, uint32x4x2_t x) +{ + vst1q_u32(p+0, x.val[0]); + vst1q_u32(p+4, x.val[1]); +} + +static DRFLAC_INLINE void drflac__vst2q_f32(float* p, float32x4x2_t x) +{ + vst1q_f32(p+0, x.val[0]); + vst1q_f32(p+4, x.val[1]); +} + +static DRFLAC_INLINE void drflac__vst2q_s16(drflac_int16* p, int16x4x2_t x) +{ + vst1q_s16(p, vcombine_s16(x.val[0], x.val[1])); +} + +static DRFLAC_INLINE void drflac__vst2q_u16(drflac_uint16* p, uint16x4x2_t x) +{ + vst1q_u16(p, vcombine_u16(x.val[0], x.val[1])); +} + +static DRFLAC_INLINE int32x4_t drflac__vdupq_n_s32x4(drflac_int32 x3, drflac_int32 x2, drflac_int32 x1, drflac_int32 x0) +{ + drflac_int32 x[4]; + x[3] = x3; + x[2] = x2; + x[1] = x1; + x[0] = x0; + return vld1q_s32(x); +} + +static DRFLAC_INLINE int32x4_t drflac__valignrq_s32_1(int32x4_t a, int32x4_t b) +{ + /* Equivalent to SSE's _mm_alignr_epi8(a, b, 4) */ + + /* Reference */ + /*return drflac__vdupq_n_s32x4( + vgetq_lane_s32(a, 0), + vgetq_lane_s32(b, 3), + vgetq_lane_s32(b, 2), + vgetq_lane_s32(b, 1) + );*/ + + return vextq_s32(b, a, 1); +} + +static DRFLAC_INLINE uint32x4_t drflac__valignrq_u32_1(uint32x4_t a, uint32x4_t b) +{ + /* Equivalent to SSE's _mm_alignr_epi8(a, b, 4) */ + + /* Reference */ + /*return drflac__vdupq_n_s32x4( + vgetq_lane_s32(a, 0), + vgetq_lane_s32(b, 3), + vgetq_lane_s32(b, 2), + vgetq_lane_s32(b, 1) + );*/ + + return vextq_u32(b, a, 1); +} + +static DRFLAC_INLINE int32x2_t drflac__vhaddq_s32(int32x4_t x) +{ + /* The sum must end up in position 0. */ + + /* Reference */ + /*return vdupq_n_s32( + vgetq_lane_s32(x, 3) + + vgetq_lane_s32(x, 2) + + vgetq_lane_s32(x, 1) + + vgetq_lane_s32(x, 0) + );*/ + + int32x2_t r = vadd_s32(vget_high_s32(x), vget_low_s32(x)); + return vpadd_s32(r, r); +} + +static DRFLAC_INLINE int64x1_t drflac__vhaddq_s64(int64x2_t x) +{ + return vadd_s64(vget_high_s64(x), vget_low_s64(x)); +} + +static DRFLAC_INLINE int32x4_t drflac__vrevq_s32(int32x4_t x) +{ + /* Reference */ + /*return drflac__vdupq_n_s32x4( + vgetq_lane_s32(x, 0), + vgetq_lane_s32(x, 1), + vgetq_lane_s32(x, 2), + vgetq_lane_s32(x, 3) + );*/ + + return vrev64q_s32(vcombine_s32(vget_high_s32(x), vget_low_s32(x))); +} + +static DRFLAC_INLINE int32x4_t drflac__vnotq_s32(int32x4_t x) +{ + return veorq_s32(x, vdupq_n_s32(0xFFFFFFFF)); +} + +static DRFLAC_INLINE uint32x4_t drflac__vnotq_u32(uint32x4_t x) +{ + return veorq_u32(x, vdupq_n_u32(0xFFFFFFFF)); +} + +static drflac_bool32 drflac__decode_samples_with_residual__rice__neon_32(drflac_bs* bs, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ + int i; + drflac_uint32 riceParamMask; + drflac_int32* pDecodedSamples = pSamplesOut; + drflac_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3); + drflac_uint32 zeroCountParts[4]; + drflac_uint32 riceParamParts[4]; + int32x4_t coefficients128_0; + int32x4_t coefficients128_4; + int32x4_t coefficients128_8; + int32x4_t samples128_0; + int32x4_t samples128_4; + int32x4_t samples128_8; + uint32x4_t riceParamMask128; + int32x4_t riceParam128; + int32x2_t shift64; + uint32x4_t one128; + + const drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF}; + + riceParamMask = ~((~0UL) << riceParam); + riceParamMask128 = vdupq_n_u32(riceParamMask); + + riceParam128 = vdupq_n_s32(riceParam); + shift64 = vdup_n_s32(-shift); /* Negate the shift because we'll be doing a variable shift using vshlq_s32(). */ + one128 = vdupq_n_u32(1); + + /* + Pre-loading the coefficients and prior samples is annoying because we need to ensure we don't try reading more than + what's available in the input buffers. It would be conenient to use a fall-through switch to do this, but this results + in strict aliasing warnings with GCC. To work around this I'm just doing something hacky. This feels a bit convoluted + so I think there's opportunity for this to be simplified. + */ + { + int runningOrder = order; + drflac_int32 tempC[4] = {0, 0, 0, 0}; + drflac_int32 tempS[4] = {0, 0, 0, 0}; + + /* 0 - 3. */ + if (runningOrder >= 4) { + coefficients128_0 = vld1q_s32(coefficients + 0); + samples128_0 = vld1q_s32(pSamplesOut - 4); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: tempC[2] = coefficients[2]; tempS[1] = pSamplesOut[-3]; /* fallthrough */ + case 2: tempC[1] = coefficients[1]; tempS[2] = pSamplesOut[-2]; /* fallthrough */ + case 1: tempC[0] = coefficients[0]; tempS[3] = pSamplesOut[-1]; /* fallthrough */ + } + + coefficients128_0 = vld1q_s32(tempC); + samples128_0 = vld1q_s32(tempS); + runningOrder = 0; + } + + /* 4 - 7 */ + if (runningOrder >= 4) { + coefficients128_4 = vld1q_s32(coefficients + 4); + samples128_4 = vld1q_s32(pSamplesOut - 8); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: tempC[2] = coefficients[6]; tempS[1] = pSamplesOut[-7]; /* fallthrough */ + case 2: tempC[1] = coefficients[5]; tempS[2] = pSamplesOut[-6]; /* fallthrough */ + case 1: tempC[0] = coefficients[4]; tempS[3] = pSamplesOut[-5]; /* fallthrough */ + } + + coefficients128_4 = vld1q_s32(tempC); + samples128_4 = vld1q_s32(tempS); + runningOrder = 0; + } + + /* 8 - 11 */ + if (runningOrder == 4) { + coefficients128_8 = vld1q_s32(coefficients + 8); + samples128_8 = vld1q_s32(pSamplesOut - 12); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: tempC[2] = coefficients[10]; tempS[1] = pSamplesOut[-11]; /* fallthrough */ + case 2: tempC[1] = coefficients[ 9]; tempS[2] = pSamplesOut[-10]; /* fallthrough */ + case 1: tempC[0] = coefficients[ 8]; tempS[3] = pSamplesOut[- 9]; /* fallthrough */ + } + + coefficients128_8 = vld1q_s32(tempC); + samples128_8 = vld1q_s32(tempS); + runningOrder = 0; + } + + /* Coefficients need to be shuffled for our streaming algorithm below to work. Samples are already in the correct order from the loading routine above. */ + coefficients128_0 = drflac__vrevq_s32(coefficients128_0); + coefficients128_4 = drflac__vrevq_s32(coefficients128_4); + coefficients128_8 = drflac__vrevq_s32(coefficients128_8); + } + + /* For this version we are doing one sample at a time. */ + while (pDecodedSamples < pDecodedSamplesEnd) { + int32x4_t prediction128; + int32x2_t prediction64; + uint32x4_t zeroCountPart128; + uint32x4_t riceParamPart128; + + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0]) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[1], &riceParamParts[1]) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[2], &riceParamParts[2]) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[3], &riceParamParts[3])) { + return DRFLAC_FALSE; + } + + zeroCountPart128 = vld1q_u32(zeroCountParts); + riceParamPart128 = vld1q_u32(riceParamParts); + + riceParamPart128 = vandq_u32(riceParamPart128, riceParamMask128); + riceParamPart128 = vorrq_u32(riceParamPart128, vshlq_u32(zeroCountPart128, riceParam128)); + riceParamPart128 = veorq_u32(vshrq_n_u32(riceParamPart128, 1), vaddq_u32(drflac__vnotq_u32(vandq_u32(riceParamPart128, one128)), one128)); + + if (order <= 4) { + for (i = 0; i < 4; i += 1) { + prediction128 = vmulq_s32(coefficients128_0, samples128_0); + + /* Horizontal add and shift. */ + prediction64 = drflac__vhaddq_s32(prediction128); + prediction64 = vshl_s32(prediction64, shift64); + prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128))); + + samples128_0 = drflac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0); + riceParamPart128 = drflac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128); + } + } else if (order <= 8) { + for (i = 0; i < 4; i += 1) { + prediction128 = vmulq_s32(coefficients128_4, samples128_4); + prediction128 = vmlaq_s32(prediction128, coefficients128_0, samples128_0); + + /* Horizontal add and shift. */ + prediction64 = drflac__vhaddq_s32(prediction128); + prediction64 = vshl_s32(prediction64, shift64); + prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128))); + + samples128_4 = drflac__valignrq_s32_1(samples128_0, samples128_4); + samples128_0 = drflac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0); + riceParamPart128 = drflac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128); + } + } else { + for (i = 0; i < 4; i += 1) { + prediction128 = vmulq_s32(coefficients128_8, samples128_8); + prediction128 = vmlaq_s32(prediction128, coefficients128_4, samples128_4); + prediction128 = vmlaq_s32(prediction128, coefficients128_0, samples128_0); + + /* Horizontal add and shift. */ + prediction64 = drflac__vhaddq_s32(prediction128); + prediction64 = vshl_s32(prediction64, shift64); + prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128))); + + samples128_8 = drflac__valignrq_s32_1(samples128_4, samples128_8); + samples128_4 = drflac__valignrq_s32_1(samples128_0, samples128_4); + samples128_0 = drflac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0); + riceParamPart128 = drflac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128); + } + } + + /* We store samples in groups of 4. */ + vst1q_s32(pDecodedSamples, samples128_0); + pDecodedSamples += 4; + } + + /* Make sure we process the last few samples. */ + i = (count & ~3); + while (i < (int)count) { + /* Rice extraction. */ + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0])) { + return DRFLAC_FALSE; + } + + /* Rice reconstruction. */ + riceParamParts[0] &= riceParamMask; + riceParamParts[0] |= (zeroCountParts[0] << riceParam); + riceParamParts[0] = (riceParamParts[0] >> 1) ^ t[riceParamParts[0] & 0x01]; + + /* Sample reconstruction. */ + pDecodedSamples[0] = riceParamParts[0] + drflac__calculate_prediction_32(order, shift, coefficients, pDecodedSamples); + + i += 1; + pDecodedSamples += 1; + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_samples_with_residual__rice__neon_64(drflac_bs* bs, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ + int i; + drflac_uint32 riceParamMask; + drflac_int32* pDecodedSamples = pSamplesOut; + drflac_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3); + drflac_uint32 zeroCountParts[4]; + drflac_uint32 riceParamParts[4]; + int32x4_t coefficients128_0; + int32x4_t coefficients128_4; + int32x4_t coefficients128_8; + int32x4_t samples128_0; + int32x4_t samples128_4; + int32x4_t samples128_8; + uint32x4_t riceParamMask128; + int32x4_t riceParam128; + int64x1_t shift64; + uint32x4_t one128; + + const drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF}; + + riceParamMask = ~((~0UL) << riceParam); + riceParamMask128 = vdupq_n_u32(riceParamMask); + + riceParam128 = vdupq_n_s32(riceParam); + shift64 = vdup_n_s64(-shift); /* Negate the shift because we'll be doing a variable shift using vshlq_s32(). */ + one128 = vdupq_n_u32(1); + + /* + Pre-loading the coefficients and prior samples is annoying because we need to ensure we don't try reading more than + what's available in the input buffers. It would be conenient to use a fall-through switch to do this, but this results + in strict aliasing warnings with GCC. To work around this I'm just doing something hacky. This feels a bit convoluted + so I think there's opportunity for this to be simplified. + */ + { + int runningOrder = order; + drflac_int32 tempC[4] = {0, 0, 0, 0}; + drflac_int32 tempS[4] = {0, 0, 0, 0}; + + /* 0 - 3. */ + if (runningOrder >= 4) { + coefficients128_0 = vld1q_s32(coefficients + 0); + samples128_0 = vld1q_s32(pSamplesOut - 4); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: tempC[2] = coefficients[2]; tempS[1] = pSamplesOut[-3]; /* fallthrough */ + case 2: tempC[1] = coefficients[1]; tempS[2] = pSamplesOut[-2]; /* fallthrough */ + case 1: tempC[0] = coefficients[0]; tempS[3] = pSamplesOut[-1]; /* fallthrough */ + } + + coefficients128_0 = vld1q_s32(tempC); + samples128_0 = vld1q_s32(tempS); + runningOrder = 0; + } + + /* 4 - 7 */ + if (runningOrder >= 4) { + coefficients128_4 = vld1q_s32(coefficients + 4); + samples128_4 = vld1q_s32(pSamplesOut - 8); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: tempC[2] = coefficients[6]; tempS[1] = pSamplesOut[-7]; /* fallthrough */ + case 2: tempC[1] = coefficients[5]; tempS[2] = pSamplesOut[-6]; /* fallthrough */ + case 1: tempC[0] = coefficients[4]; tempS[3] = pSamplesOut[-5]; /* fallthrough */ + } + + coefficients128_4 = vld1q_s32(tempC); + samples128_4 = vld1q_s32(tempS); + runningOrder = 0; + } + + /* 8 - 11 */ + if (runningOrder == 4) { + coefficients128_8 = vld1q_s32(coefficients + 8); + samples128_8 = vld1q_s32(pSamplesOut - 12); + runningOrder -= 4; + } else { + switch (runningOrder) { + case 3: tempC[2] = coefficients[10]; tempS[1] = pSamplesOut[-11]; /* fallthrough */ + case 2: tempC[1] = coefficients[ 9]; tempS[2] = pSamplesOut[-10]; /* fallthrough */ + case 1: tempC[0] = coefficients[ 8]; tempS[3] = pSamplesOut[- 9]; /* fallthrough */ + } + + coefficients128_8 = vld1q_s32(tempC); + samples128_8 = vld1q_s32(tempS); + runningOrder = 0; + } + + /* Coefficients need to be shuffled for our streaming algorithm below to work. Samples are already in the correct order from the loading routine above. */ + coefficients128_0 = drflac__vrevq_s32(coefficients128_0); + coefficients128_4 = drflac__vrevq_s32(coefficients128_4); + coefficients128_8 = drflac__vrevq_s32(coefficients128_8); + } + + /* For this version we are doing one sample at a time. */ + while (pDecodedSamples < pDecodedSamplesEnd) { + int64x2_t prediction128; + uint32x4_t zeroCountPart128; + uint32x4_t riceParamPart128; + + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0]) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[1], &riceParamParts[1]) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[2], &riceParamParts[2]) || + !drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[3], &riceParamParts[3])) { + return DRFLAC_FALSE; + } + + zeroCountPart128 = vld1q_u32(zeroCountParts); + riceParamPart128 = vld1q_u32(riceParamParts); + + riceParamPart128 = vandq_u32(riceParamPart128, riceParamMask128); + riceParamPart128 = vorrq_u32(riceParamPart128, vshlq_u32(zeroCountPart128, riceParam128)); + riceParamPart128 = veorq_u32(vshrq_n_u32(riceParamPart128, 1), vaddq_u32(drflac__vnotq_u32(vandq_u32(riceParamPart128, one128)), one128)); + + for (i = 0; i < 4; i += 1) { + int64x1_t prediction64; + + prediction128 = veorq_s64(prediction128, prediction128); /* Reset to 0. */ + switch (order) + { + case 12: + case 11: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_8), vget_low_s32(samples128_8))); + case 10: + case 9: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_8), vget_high_s32(samples128_8))); + case 8: + case 7: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_4), vget_low_s32(samples128_4))); + case 6: + case 5: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_4), vget_high_s32(samples128_4))); + case 4: + case 3: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_0), vget_low_s32(samples128_0))); + case 2: + case 1: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_0), vget_high_s32(samples128_0))); + } + + /* Horizontal add and shift. */ + prediction64 = drflac__vhaddq_s64(prediction128); + prediction64 = vshl_s64(prediction64, shift64); + prediction64 = vadd_s64(prediction64, vdup_n_s64(vgetq_lane_u32(riceParamPart128, 0))); + + /* Our value should be sitting in prediction64[0]. We need to combine this with our SSE samples. */ + samples128_8 = drflac__valignrq_s32_1(samples128_4, samples128_8); + samples128_4 = drflac__valignrq_s32_1(samples128_0, samples128_4); + samples128_0 = drflac__valignrq_s32_1(vcombine_s32(vreinterpret_s32_s64(prediction64), vdup_n_s32(0)), samples128_0); + + /* Slide our rice parameter down so that the value in position 0 contains the next one to process. */ + riceParamPart128 = drflac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128); + } + + /* We store samples in groups of 4. */ + vst1q_s32(pDecodedSamples, samples128_0); + pDecodedSamples += 4; + } + + /* Make sure we process the last few samples. */ + i = (count & ~3); + while (i < (int)count) { + /* Rice extraction. */ + if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0])) { + return DRFLAC_FALSE; + } + + /* Rice reconstruction. */ + riceParamParts[0] &= riceParamMask; + riceParamParts[0] |= (zeroCountParts[0] << riceParam); + riceParamParts[0] = (riceParamParts[0] >> 1) ^ t[riceParamParts[0] & 0x01]; + + /* Sample reconstruction. */ + pDecodedSamples[0] = riceParamParts[0] + drflac__calculate_prediction_64(order, shift, coefficients, pDecodedSamples); + + i += 1; + pDecodedSamples += 1; + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_samples_with_residual__rice__neon(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(count > 0); + DRFLAC_ASSERT(pSamplesOut != NULL); + + /* In my testing the order is rarely > 12, so in this case I'm going to simplify the NEON implementation by only handling order <= 12. */ + if (order > 0 && order <= 12) { + if (bitsPerSample+shift > 32) { + return drflac__decode_samples_with_residual__rice__neon_64(bs, count, riceParam, order, shift, coefficients, pSamplesOut); + } else { + return drflac__decode_samples_with_residual__rice__neon_32(bs, count, riceParam, order, shift, coefficients, pSamplesOut); + } + } else { + return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut); + } +} +#endif + +static drflac_bool32 drflac__decode_samples_with_residual__rice(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ +#if defined(DRFLAC_SUPPORT_SSE41) + if (drflac__gIsSSE41Supported) { + return drflac__decode_samples_with_residual__rice__sse41(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported) { + return drflac__decode_samples_with_residual__rice__neon(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut); + } else +#endif + { + /* Scalar fallback. */ + #if 0 + return drflac__decode_samples_with_residual__rice__reference(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut); + #else + return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut); + #endif + } +} + +/* Reads and seeks past a string of residual values as Rice codes. The decoder should be sitting on the first bit of the Rice codes. */ +static drflac_bool32 drflac__read_and_seek_residual__rice(drflac_bs* bs, drflac_uint32 count, drflac_uint8 riceParam) +{ + drflac_uint32 i; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(count > 0); + + for (i = 0; i < count; ++i) { + if (!drflac__seek_rice_parts(bs, riceParam)) { + return DRFLAC_FALSE; + } + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_samples_with_residual__unencoded(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 unencodedBitsPerSample, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut) +{ + drflac_uint32 i; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(count > 0); + DRFLAC_ASSERT(unencodedBitsPerSample <= 31); /* <-- unencodedBitsPerSample is a 5 bit number, so cannot exceed 31. */ + DRFLAC_ASSERT(pSamplesOut != NULL); + + for (i = 0; i < count; ++i) { + if (unencodedBitsPerSample > 0) { + if (!drflac__read_int32(bs, unencodedBitsPerSample, pSamplesOut + i)) { + return DRFLAC_FALSE; + } + } else { + pSamplesOut[i] = 0; + } + + if (bitsPerSample >= 24) { + pSamplesOut[i] += drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + i); + } else { + pSamplesOut[i] += drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + i); + } + } + + return DRFLAC_TRUE; +} + + +/* +Reads and decodes the residual for the sub-frame the decoder is currently sitting on. This function should be called +when the decoder is sitting at the very start of the RESIDUAL block. The first residuals will be ignored. The + and parameters are used to determine how many residual values need to be decoded. +*/ +static drflac_bool32 drflac__decode_samples_with_residual(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 blockSize, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pDecodedSamples) +{ + drflac_uint8 residualMethod; + drflac_uint8 partitionOrder; + drflac_uint32 samplesInPartition; + drflac_uint32 partitionsRemaining; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(blockSize != 0); + DRFLAC_ASSERT(pDecodedSamples != NULL); /* <-- Should we allow NULL, in which case we just seek past the residual rather than do a full decode? */ + + if (!drflac__read_uint8(bs, 2, &residualMethod)) { + return DRFLAC_FALSE; + } + + if (residualMethod != DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE && residualMethod != DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) { + return DRFLAC_FALSE; /* Unknown or unsupported residual coding method. */ + } + + /* Ignore the first values. */ + pDecodedSamples += order; + + if (!drflac__read_uint8(bs, 4, &partitionOrder)) { + return DRFLAC_FALSE; + } + + /* + From the FLAC spec: + The Rice partition order in a Rice-coded residual section must be less than or equal to 8. + */ + if (partitionOrder > 8) { + return DRFLAC_FALSE; + } + + /* Validation check. */ + if ((blockSize / (1 << partitionOrder)) <= order) { + return DRFLAC_FALSE; + } + + samplesInPartition = (blockSize / (1 << partitionOrder)) - order; + partitionsRemaining = (1 << partitionOrder); + for (;;) { + drflac_uint8 riceParam = 0; + if (residualMethod == DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE) { + if (!drflac__read_uint8(bs, 4, &riceParam)) { + return DRFLAC_FALSE; + } + if (riceParam == 15) { + riceParam = 0xFF; + } + } else if (residualMethod == DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) { + if (!drflac__read_uint8(bs, 5, &riceParam)) { + return DRFLAC_FALSE; + } + if (riceParam == 31) { + riceParam = 0xFF; + } + } + + if (riceParam != 0xFF) { + if (!drflac__decode_samples_with_residual__rice(bs, bitsPerSample, samplesInPartition, riceParam, order, shift, coefficients, pDecodedSamples)) { + return DRFLAC_FALSE; + } + } else { + drflac_uint8 unencodedBitsPerSample = 0; + if (!drflac__read_uint8(bs, 5, &unencodedBitsPerSample)) { + return DRFLAC_FALSE; + } + + if (!drflac__decode_samples_with_residual__unencoded(bs, bitsPerSample, samplesInPartition, unencodedBitsPerSample, order, shift, coefficients, pDecodedSamples)) { + return DRFLAC_FALSE; + } + } + + pDecodedSamples += samplesInPartition; + + if (partitionsRemaining == 1) { + break; + } + + partitionsRemaining -= 1; + + if (partitionOrder != 0) { + samplesInPartition = blockSize / (1 << partitionOrder); + } + } + + return DRFLAC_TRUE; +} + +/* +Reads and seeks past the residual for the sub-frame the decoder is currently sitting on. This function should be called +when the decoder is sitting at the very start of the RESIDUAL block. The first residuals will be set to 0. The + and parameters are used to determine how many residual values need to be decoded. +*/ +static drflac_bool32 drflac__read_and_seek_residual(drflac_bs* bs, drflac_uint32 blockSize, drflac_uint32 order) +{ + drflac_uint8 residualMethod; + drflac_uint8 partitionOrder; + drflac_uint32 samplesInPartition; + drflac_uint32 partitionsRemaining; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(blockSize != 0); + + if (!drflac__read_uint8(bs, 2, &residualMethod)) { + return DRFLAC_FALSE; + } + + if (residualMethod != DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE && residualMethod != DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) { + return DRFLAC_FALSE; /* Unknown or unsupported residual coding method. */ + } + + if (!drflac__read_uint8(bs, 4, &partitionOrder)) { + return DRFLAC_FALSE; + } + + /* + From the FLAC spec: + The Rice partition order in a Rice-coded residual section must be less than or equal to 8. + */ + if (partitionOrder > 8) { + return DRFLAC_FALSE; + } + + /* Validation check. */ + if ((blockSize / (1 << partitionOrder)) <= order) { + return DRFLAC_FALSE; + } + + samplesInPartition = (blockSize / (1 << partitionOrder)) - order; + partitionsRemaining = (1 << partitionOrder); + for (;;) + { + drflac_uint8 riceParam = 0; + if (residualMethod == DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE) { + if (!drflac__read_uint8(bs, 4, &riceParam)) { + return DRFLAC_FALSE; + } + if (riceParam == 15) { + riceParam = 0xFF; + } + } else if (residualMethod == DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) { + if (!drflac__read_uint8(bs, 5, &riceParam)) { + return DRFLAC_FALSE; + } + if (riceParam == 31) { + riceParam = 0xFF; + } + } + + if (riceParam != 0xFF) { + if (!drflac__read_and_seek_residual__rice(bs, samplesInPartition, riceParam)) { + return DRFLAC_FALSE; + } + } else { + drflac_uint8 unencodedBitsPerSample = 0; + if (!drflac__read_uint8(bs, 5, &unencodedBitsPerSample)) { + return DRFLAC_FALSE; + } + + if (!drflac__seek_bits(bs, unencodedBitsPerSample * samplesInPartition)) { + return DRFLAC_FALSE; + } + } + + + if (partitionsRemaining == 1) { + break; + } + + partitionsRemaining -= 1; + samplesInPartition = blockSize / (1 << partitionOrder); + } + + return DRFLAC_TRUE; +} + + +static drflac_bool32 drflac__decode_samples__constant(drflac_bs* bs, drflac_uint32 blockSize, drflac_uint32 subframeBitsPerSample, drflac_int32* pDecodedSamples) +{ + drflac_uint32 i; + + /* Only a single sample needs to be decoded here. */ + drflac_int32 sample; + if (!drflac__read_int32(bs, subframeBitsPerSample, &sample)) { + return DRFLAC_FALSE; + } + + /* + We don't really need to expand this, but it does simplify the process of reading samples. If this becomes a performance issue (unlikely) + we'll want to look at a more efficient way. + */ + for (i = 0; i < blockSize; ++i) { + pDecodedSamples[i] = sample; + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_samples__verbatim(drflac_bs* bs, drflac_uint32 blockSize, drflac_uint32 subframeBitsPerSample, drflac_int32* pDecodedSamples) +{ + drflac_uint32 i; + + for (i = 0; i < blockSize; ++i) { + drflac_int32 sample; + if (!drflac__read_int32(bs, subframeBitsPerSample, &sample)) { + return DRFLAC_FALSE; + } + + pDecodedSamples[i] = sample; + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_samples__fixed(drflac_bs* bs, drflac_uint32 blockSize, drflac_uint32 subframeBitsPerSample, drflac_uint8 lpcOrder, drflac_int32* pDecodedSamples) +{ + drflac_uint32 i; + + static drflac_int32 lpcCoefficientsTable[5][4] = { + {0, 0, 0, 0}, + {1, 0, 0, 0}, + {2, -1, 0, 0}, + {3, -3, 1, 0}, + {4, -6, 4, -1} + }; + + /* Warm up samples and coefficients. */ + for (i = 0; i < lpcOrder; ++i) { + drflac_int32 sample; + if (!drflac__read_int32(bs, subframeBitsPerSample, &sample)) { + return DRFLAC_FALSE; + } + + pDecodedSamples[i] = sample; + } + + if (!drflac__decode_samples_with_residual(bs, subframeBitsPerSample, blockSize, lpcOrder, 0, lpcCoefficientsTable[lpcOrder], pDecodedSamples)) { + return DRFLAC_FALSE; + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_samples__lpc(drflac_bs* bs, drflac_uint32 blockSize, drflac_uint32 bitsPerSample, drflac_uint8 lpcOrder, drflac_int32* pDecodedSamples) +{ + drflac_uint8 i; + drflac_uint8 lpcPrecision; + drflac_int8 lpcShift; + drflac_int32 coefficients[32]; + + /* Warm up samples. */ + for (i = 0; i < lpcOrder; ++i) { + drflac_int32 sample; + if (!drflac__read_int32(bs, bitsPerSample, &sample)) { + return DRFLAC_FALSE; + } + + pDecodedSamples[i] = sample; + } + + if (!drflac__read_uint8(bs, 4, &lpcPrecision)) { + return DRFLAC_FALSE; + } + if (lpcPrecision == 15) { + return DRFLAC_FALSE; /* Invalid. */ + } + lpcPrecision += 1; + + if (!drflac__read_int8(bs, 5, &lpcShift)) { + return DRFLAC_FALSE; + } + + /* + From the FLAC specification: + + Quantized linear predictor coefficient shift needed in bits (NOTE: this number is signed two's-complement) + + Emphasis on the "signed two's-complement". In practice there does not seem to be any encoders nor decoders supporting negative shifts. For now dr_flac is + not going to support negative shifts as I don't have any reference files. However, when a reference file comes through I will consider adding support. + */ + if (lpcShift < 0) { + return DRFLAC_FALSE; + } + + DRFLAC_ZERO_MEMORY(coefficients, sizeof(coefficients)); + for (i = 0; i < lpcOrder; ++i) { + if (!drflac__read_int32(bs, lpcPrecision, coefficients + i)) { + return DRFLAC_FALSE; + } + } + + if (!drflac__decode_samples_with_residual(bs, bitsPerSample, blockSize, lpcOrder, lpcShift, coefficients, pDecodedSamples)) { + return DRFLAC_FALSE; + } + + return DRFLAC_TRUE; +} + + +static drflac_bool32 drflac__read_next_flac_frame_header(drflac_bs* bs, drflac_uint8 streaminfoBitsPerSample, drflac_frame_header* header) +{ + const drflac_uint32 sampleRateTable[12] = {0, 88200, 176400, 192000, 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000}; + const drflac_uint8 bitsPerSampleTable[8] = {0, 8, 12, (drflac_uint8)-1, 16, 20, 24, (drflac_uint8)-1}; /* -1 = reserved. */ + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(header != NULL); + + /* Keep looping until we find a valid sync code. */ + for (;;) { + drflac_uint8 crc8 = 0xCE; /* 0xCE = drflac_crc8(0, 0x3FFE, 14); */ + drflac_uint8 reserved = 0; + drflac_uint8 blockingStrategy = 0; + drflac_uint8 blockSize = 0; + drflac_uint8 sampleRate = 0; + drflac_uint8 channelAssignment = 0; + drflac_uint8 bitsPerSample = 0; + drflac_bool32 isVariableBlockSize; + + if (!drflac__find_and_seek_to_next_sync_code(bs)) { + return DRFLAC_FALSE; + } + + if (!drflac__read_uint8(bs, 1, &reserved)) { + return DRFLAC_FALSE; + } + if (reserved == 1) { + continue; + } + crc8 = drflac_crc8(crc8, reserved, 1); + + if (!drflac__read_uint8(bs, 1, &blockingStrategy)) { + return DRFLAC_FALSE; + } + crc8 = drflac_crc8(crc8, blockingStrategy, 1); + + if (!drflac__read_uint8(bs, 4, &blockSize)) { + return DRFLAC_FALSE; + } + if (blockSize == 0) { + continue; + } + crc8 = drflac_crc8(crc8, blockSize, 4); + + if (!drflac__read_uint8(bs, 4, &sampleRate)) { + return DRFLAC_FALSE; + } + crc8 = drflac_crc8(crc8, sampleRate, 4); + + if (!drflac__read_uint8(bs, 4, &channelAssignment)) { + return DRFLAC_FALSE; + } + if (channelAssignment > 10) { + continue; + } + crc8 = drflac_crc8(crc8, channelAssignment, 4); + + if (!drflac__read_uint8(bs, 3, &bitsPerSample)) { + return DRFLAC_FALSE; + } + if (bitsPerSample == 3 || bitsPerSample == 7) { + continue; + } + crc8 = drflac_crc8(crc8, bitsPerSample, 3); + + + if (!drflac__read_uint8(bs, 1, &reserved)) { + return DRFLAC_FALSE; + } + if (reserved == 1) { + continue; + } + crc8 = drflac_crc8(crc8, reserved, 1); + + + isVariableBlockSize = blockingStrategy == 1; + if (isVariableBlockSize) { + drflac_uint64 pcmFrameNumber; + drflac_result result = drflac__read_utf8_coded_number(bs, &pcmFrameNumber, &crc8); + if (result != DRFLAC_SUCCESS) { + if (result == DRFLAC_AT_END) { + return DRFLAC_FALSE; + } else { + continue; + } + } + header->flacFrameNumber = 0; + header->pcmFrameNumber = pcmFrameNumber; + } else { + drflac_uint64 flacFrameNumber = 0; + drflac_result result = drflac__read_utf8_coded_number(bs, &flacFrameNumber, &crc8); + if (result != DRFLAC_SUCCESS) { + if (result == DRFLAC_AT_END) { + return DRFLAC_FALSE; + } else { + continue; + } + } + header->flacFrameNumber = (drflac_uint32)flacFrameNumber; /* <-- Safe cast. */ + header->pcmFrameNumber = 0; + } + + + DRFLAC_ASSERT(blockSize > 0); + if (blockSize == 1) { + header->blockSizeInPCMFrames = 192; + } else if (blockSize >= 2 && blockSize <= 5) { + header->blockSizeInPCMFrames = 576 * (1 << (blockSize - 2)); + } else if (blockSize == 6) { + if (!drflac__read_uint16(bs, 8, &header->blockSizeInPCMFrames)) { + return DRFLAC_FALSE; + } + crc8 = drflac_crc8(crc8, header->blockSizeInPCMFrames, 8); + header->blockSizeInPCMFrames += 1; + } else if (blockSize == 7) { + if (!drflac__read_uint16(bs, 16, &header->blockSizeInPCMFrames)) { + return DRFLAC_FALSE; + } + crc8 = drflac_crc8(crc8, header->blockSizeInPCMFrames, 16); + header->blockSizeInPCMFrames += 1; + } else { + DRFLAC_ASSERT(blockSize >= 8); + header->blockSizeInPCMFrames = 256 * (1 << (blockSize - 8)); + } + + + if (sampleRate <= 11) { + header->sampleRate = sampleRateTable[sampleRate]; + } else if (sampleRate == 12) { + if (!drflac__read_uint32(bs, 8, &header->sampleRate)) { + return DRFLAC_FALSE; + } + crc8 = drflac_crc8(crc8, header->sampleRate, 8); + header->sampleRate *= 1000; + } else if (sampleRate == 13) { + if (!drflac__read_uint32(bs, 16, &header->sampleRate)) { + return DRFLAC_FALSE; + } + crc8 = drflac_crc8(crc8, header->sampleRate, 16); + } else if (sampleRate == 14) { + if (!drflac__read_uint32(bs, 16, &header->sampleRate)) { + return DRFLAC_FALSE; + } + crc8 = drflac_crc8(crc8, header->sampleRate, 16); + header->sampleRate *= 10; + } else { + continue; /* Invalid. Assume an invalid block. */ + } + + + header->channelAssignment = channelAssignment; + + header->bitsPerSample = bitsPerSampleTable[bitsPerSample]; + if (header->bitsPerSample == 0) { + header->bitsPerSample = streaminfoBitsPerSample; + } + + if (!drflac__read_uint8(bs, 8, &header->crc8)) { + return DRFLAC_FALSE; + } + +#ifndef DR_FLAC_NO_CRC + if (header->crc8 != crc8) { + continue; /* CRC mismatch. Loop back to the top and find the next sync code. */ + } +#endif + return DRFLAC_TRUE; + } +} + +static drflac_bool32 drflac__read_subframe_header(drflac_bs* bs, drflac_subframe* pSubframe) +{ + drflac_uint8 header; + int type; + + if (!drflac__read_uint8(bs, 8, &header)) { + return DRFLAC_FALSE; + } + + /* First bit should always be 0. */ + if ((header & 0x80) != 0) { + return DRFLAC_FALSE; + } + + type = (header & 0x7E) >> 1; + if (type == 0) { + pSubframe->subframeType = DRFLAC_SUBFRAME_CONSTANT; + } else if (type == 1) { + pSubframe->subframeType = DRFLAC_SUBFRAME_VERBATIM; + } else { + if ((type & 0x20) != 0) { + pSubframe->subframeType = DRFLAC_SUBFRAME_LPC; + pSubframe->lpcOrder = (drflac_uint8)(type & 0x1F) + 1; + } else if ((type & 0x08) != 0) { + pSubframe->subframeType = DRFLAC_SUBFRAME_FIXED; + pSubframe->lpcOrder = (drflac_uint8)(type & 0x07); + if (pSubframe->lpcOrder > 4) { + pSubframe->subframeType = DRFLAC_SUBFRAME_RESERVED; + pSubframe->lpcOrder = 0; + } + } else { + pSubframe->subframeType = DRFLAC_SUBFRAME_RESERVED; + } + } + + if (pSubframe->subframeType == DRFLAC_SUBFRAME_RESERVED) { + return DRFLAC_FALSE; + } + + /* Wasted bits per sample. */ + pSubframe->wastedBitsPerSample = 0; + if ((header & 0x01) == 1) { + unsigned int wastedBitsPerSample; + if (!drflac__seek_past_next_set_bit(bs, &wastedBitsPerSample)) { + return DRFLAC_FALSE; + } + pSubframe->wastedBitsPerSample = (drflac_uint8)wastedBitsPerSample + 1; + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_subframe(drflac_bs* bs, drflac_frame* frame, int subframeIndex, drflac_int32* pDecodedSamplesOut) +{ + drflac_subframe* pSubframe; + drflac_uint32 subframeBitsPerSample; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(frame != NULL); + + pSubframe = frame->subframes + subframeIndex; + if (!drflac__read_subframe_header(bs, pSubframe)) { + return DRFLAC_FALSE; + } + + /* Side channels require an extra bit per sample. Took a while to figure that one out... */ + subframeBitsPerSample = frame->header.bitsPerSample; + if ((frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE || frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE) && subframeIndex == 1) { + subframeBitsPerSample += 1; + } else if (frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE && subframeIndex == 0) { + subframeBitsPerSample += 1; + } + + /* Need to handle wasted bits per sample. */ + if (pSubframe->wastedBitsPerSample >= subframeBitsPerSample) { + return DRFLAC_FALSE; + } + subframeBitsPerSample -= pSubframe->wastedBitsPerSample; + + pSubframe->pSamplesS32 = pDecodedSamplesOut; + + switch (pSubframe->subframeType) + { + case DRFLAC_SUBFRAME_CONSTANT: + { + drflac__decode_samples__constant(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->pSamplesS32); + } break; + + case DRFLAC_SUBFRAME_VERBATIM: + { + drflac__decode_samples__verbatim(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->pSamplesS32); + } break; + + case DRFLAC_SUBFRAME_FIXED: + { + drflac__decode_samples__fixed(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->lpcOrder, pSubframe->pSamplesS32); + } break; + + case DRFLAC_SUBFRAME_LPC: + { + drflac__decode_samples__lpc(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->lpcOrder, pSubframe->pSamplesS32); + } break; + + default: return DRFLAC_FALSE; + } + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__seek_subframe(drflac_bs* bs, drflac_frame* frame, int subframeIndex) +{ + drflac_subframe* pSubframe; + drflac_uint32 subframeBitsPerSample; + + DRFLAC_ASSERT(bs != NULL); + DRFLAC_ASSERT(frame != NULL); + + pSubframe = frame->subframes + subframeIndex; + if (!drflac__read_subframe_header(bs, pSubframe)) { + return DRFLAC_FALSE; + } + + /* Side channels require an extra bit per sample. Took a while to figure that one out... */ + subframeBitsPerSample = frame->header.bitsPerSample; + if ((frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE || frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE) && subframeIndex == 1) { + subframeBitsPerSample += 1; + } else if (frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE && subframeIndex == 0) { + subframeBitsPerSample += 1; + } + + /* Need to handle wasted bits per sample. */ + if (pSubframe->wastedBitsPerSample >= subframeBitsPerSample) { + return DRFLAC_FALSE; + } + subframeBitsPerSample -= pSubframe->wastedBitsPerSample; + + pSubframe->pSamplesS32 = NULL; + + switch (pSubframe->subframeType) + { + case DRFLAC_SUBFRAME_CONSTANT: + { + if (!drflac__seek_bits(bs, subframeBitsPerSample)) { + return DRFLAC_FALSE; + } + } break; + + case DRFLAC_SUBFRAME_VERBATIM: + { + unsigned int bitsToSeek = frame->header.blockSizeInPCMFrames * subframeBitsPerSample; + if (!drflac__seek_bits(bs, bitsToSeek)) { + return DRFLAC_FALSE; + } + } break; + + case DRFLAC_SUBFRAME_FIXED: + { + unsigned int bitsToSeek = pSubframe->lpcOrder * subframeBitsPerSample; + if (!drflac__seek_bits(bs, bitsToSeek)) { + return DRFLAC_FALSE; + } + + if (!drflac__read_and_seek_residual(bs, frame->header.blockSizeInPCMFrames, pSubframe->lpcOrder)) { + return DRFLAC_FALSE; + } + } break; + + case DRFLAC_SUBFRAME_LPC: + { + drflac_uint8 lpcPrecision; + + unsigned int bitsToSeek = pSubframe->lpcOrder * subframeBitsPerSample; + if (!drflac__seek_bits(bs, bitsToSeek)) { + return DRFLAC_FALSE; + } + + if (!drflac__read_uint8(bs, 4, &lpcPrecision)) { + return DRFLAC_FALSE; + } + if (lpcPrecision == 15) { + return DRFLAC_FALSE; /* Invalid. */ + } + lpcPrecision += 1; + + + bitsToSeek = (pSubframe->lpcOrder * lpcPrecision) + 5; /* +5 for shift. */ + if (!drflac__seek_bits(bs, bitsToSeek)) { + return DRFLAC_FALSE; + } + + if (!drflac__read_and_seek_residual(bs, frame->header.blockSizeInPCMFrames, pSubframe->lpcOrder)) { + return DRFLAC_FALSE; + } + } break; + + default: return DRFLAC_FALSE; + } + + return DRFLAC_TRUE; +} + + +static DRFLAC_INLINE drflac_uint8 drflac__get_channel_count_from_channel_assignment(drflac_int8 channelAssignment) +{ + drflac_uint8 lookup[] = {1, 2, 3, 4, 5, 6, 7, 8, 2, 2, 2}; + + DRFLAC_ASSERT(channelAssignment <= 10); + return lookup[channelAssignment]; +} + +static drflac_result drflac__decode_flac_frame(drflac* pFlac) +{ + int channelCount; + int i; + drflac_uint8 paddingSizeInBits; + drflac_uint16 desiredCRC16; +#ifndef DR_FLAC_NO_CRC + drflac_uint16 actualCRC16; +#endif + + /* This function should be called while the stream is sitting on the first byte after the frame header. */ + DRFLAC_ZERO_MEMORY(pFlac->currentFLACFrame.subframes, sizeof(pFlac->currentFLACFrame.subframes)); + + /* The frame block size must never be larger than the maximum block size defined by the FLAC stream. */ + if (pFlac->currentFLACFrame.header.blockSizeInPCMFrames > pFlac->maxBlockSizeInPCMFrames) { + return DRFLAC_ERROR; + } + + /* The number of channels in the frame must match the channel count from the STREAMINFO block. */ + channelCount = drflac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment); + if (channelCount != (int)pFlac->channels) { + return DRFLAC_ERROR; + } + + for (i = 0; i < channelCount; ++i) { + if (!drflac__decode_subframe(&pFlac->bs, &pFlac->currentFLACFrame, i, pFlac->pDecodedSamples + (pFlac->currentFLACFrame.header.blockSizeInPCMFrames * i))) { + return DRFLAC_ERROR; + } + } + + paddingSizeInBits = (drflac_uint8)(DRFLAC_CACHE_L1_BITS_REMAINING(&pFlac->bs) & 7); + if (paddingSizeInBits > 0) { + drflac_uint8 padding = 0; + if (!drflac__read_uint8(&pFlac->bs, paddingSizeInBits, &padding)) { + return DRFLAC_AT_END; + } + } + +#ifndef DR_FLAC_NO_CRC + actualCRC16 = drflac__flush_crc16(&pFlac->bs); +#endif + if (!drflac__read_uint16(&pFlac->bs, 16, &desiredCRC16)) { + return DRFLAC_AT_END; + } + +#ifndef DR_FLAC_NO_CRC + if (actualCRC16 != desiredCRC16) { + return DRFLAC_CRC_MISMATCH; /* CRC mismatch. */ + } +#endif + + pFlac->currentFLACFrame.pcmFramesRemaining = pFlac->currentFLACFrame.header.blockSizeInPCMFrames; + + return DRFLAC_SUCCESS; +} + +static drflac_result drflac__seek_flac_frame(drflac* pFlac) +{ + int channelCount; + int i; + drflac_uint16 desiredCRC16; +#ifndef DR_FLAC_NO_CRC + drflac_uint16 actualCRC16; +#endif + + channelCount = drflac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment); + for (i = 0; i < channelCount; ++i) { + if (!drflac__seek_subframe(&pFlac->bs, &pFlac->currentFLACFrame, i)) { + return DRFLAC_ERROR; + } + } + + /* Padding. */ + if (!drflac__seek_bits(&pFlac->bs, DRFLAC_CACHE_L1_BITS_REMAINING(&pFlac->bs) & 7)) { + return DRFLAC_ERROR; + } + + /* CRC. */ +#ifndef DR_FLAC_NO_CRC + actualCRC16 = drflac__flush_crc16(&pFlac->bs); +#endif + if (!drflac__read_uint16(&pFlac->bs, 16, &desiredCRC16)) { + return DRFLAC_AT_END; + } + +#ifndef DR_FLAC_NO_CRC + if (actualCRC16 != desiredCRC16) { + return DRFLAC_CRC_MISMATCH; /* CRC mismatch. */ + } +#endif + + return DRFLAC_SUCCESS; +} + +static drflac_bool32 drflac__read_and_decode_next_flac_frame(drflac* pFlac) +{ + DRFLAC_ASSERT(pFlac != NULL); + + for (;;) { + drflac_result result; + + if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + return DRFLAC_FALSE; + } + + result = drflac__decode_flac_frame(pFlac); + if (result != DRFLAC_SUCCESS) { + if (result == DRFLAC_CRC_MISMATCH) { + continue; /* CRC mismatch. Skip to the next frame. */ + } else { + return DRFLAC_FALSE; + } + } + + return DRFLAC_TRUE; + } +} + +static void drflac__get_pcm_frame_range_of_current_flac_frame(drflac* pFlac, drflac_uint64* pFirstPCMFrame, drflac_uint64* pLastPCMFrame) +{ + drflac_uint64 firstPCMFrame; + drflac_uint64 lastPCMFrame; + + DRFLAC_ASSERT(pFlac != NULL); + + firstPCMFrame = pFlac->currentFLACFrame.header.pcmFrameNumber; + if (firstPCMFrame == 0) { + firstPCMFrame = ((drflac_uint64)pFlac->currentFLACFrame.header.flacFrameNumber) * pFlac->maxBlockSizeInPCMFrames; + } + + lastPCMFrame = firstPCMFrame + pFlac->currentFLACFrame.header.blockSizeInPCMFrames; + if (lastPCMFrame > 0) { + lastPCMFrame -= 1; /* Needs to be zero based. */ + } + + if (pFirstPCMFrame) { + *pFirstPCMFrame = firstPCMFrame; + } + if (pLastPCMFrame) { + *pLastPCMFrame = lastPCMFrame; + } +} + +static drflac_bool32 drflac__seek_to_first_frame(drflac* pFlac) +{ + drflac_bool32 result; + + DRFLAC_ASSERT(pFlac != NULL); + + result = drflac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes); + + DRFLAC_ZERO_MEMORY(&pFlac->currentFLACFrame, sizeof(pFlac->currentFLACFrame)); + pFlac->currentPCMFrame = 0; + + return result; +} + +static DRFLAC_INLINE drflac_result drflac__seek_to_next_flac_frame(drflac* pFlac) +{ + /* This function should only ever be called while the decoder is sitting on the first byte past the FRAME_HEADER section. */ + DRFLAC_ASSERT(pFlac != NULL); + return drflac__seek_flac_frame(pFlac); +} + + +static drflac_uint64 drflac__seek_forward_by_pcm_frames(drflac* pFlac, drflac_uint64 pcmFramesToSeek) +{ + drflac_uint64 pcmFramesRead = 0; + while (pcmFramesToSeek > 0) { + if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) { + if (!drflac__read_and_decode_next_flac_frame(pFlac)) { + break; /* Couldn't read the next frame, so just break from the loop and return. */ + } + } else { + if (pFlac->currentFLACFrame.pcmFramesRemaining > pcmFramesToSeek) { + pcmFramesRead += pcmFramesToSeek; + pFlac->currentFLACFrame.pcmFramesRemaining -= (drflac_uint32)pcmFramesToSeek; /* <-- Safe cast. Will always be < currentFrame.pcmFramesRemaining < 65536. */ + pcmFramesToSeek = 0; + } else { + pcmFramesRead += pFlac->currentFLACFrame.pcmFramesRemaining; + pcmFramesToSeek -= pFlac->currentFLACFrame.pcmFramesRemaining; + pFlac->currentFLACFrame.pcmFramesRemaining = 0; + } + } + } + + pFlac->currentPCMFrame += pcmFramesRead; + return pcmFramesRead; +} + + +static drflac_bool32 drflac__seek_to_pcm_frame__brute_force(drflac* pFlac, drflac_uint64 pcmFrameIndex) +{ + drflac_bool32 isMidFrame = DRFLAC_FALSE; + drflac_uint64 runningPCMFrameCount; + + DRFLAC_ASSERT(pFlac != NULL); + + /* If we are seeking forward we start from the current position. Otherwise we need to start all the way from the start of the file. */ + if (pcmFrameIndex >= pFlac->currentPCMFrame) { + /* Seeking forward. Need to seek from the current position. */ + runningPCMFrameCount = pFlac->currentPCMFrame; + + /* The frame header for the first frame may not yet have been read. We need to do that if necessary. */ + if (pFlac->currentPCMFrame == 0 && pFlac->currentFLACFrame.pcmFramesRemaining == 0) { + if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + return DRFLAC_FALSE; + } + } else { + isMidFrame = DRFLAC_TRUE; + } + } else { + /* Seeking backwards. Need to seek from the start of the file. */ + runningPCMFrameCount = 0; + + /* Move back to the start. */ + if (!drflac__seek_to_first_frame(pFlac)) { + return DRFLAC_FALSE; + } + + /* Decode the first frame in preparation for sample-exact seeking below. */ + if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + return DRFLAC_FALSE; + } + } + + /* + We need to as quickly as possible find the frame that contains the target sample. To do this, we iterate over each frame and inspect its + header. If based on the header we can determine that the frame contains the sample, we do a full decode of that frame. + */ + for (;;) { + drflac_uint64 pcmFrameCountInThisFLACFrame; + drflac_uint64 firstPCMFrameInFLACFrame = 0; + drflac_uint64 lastPCMFrameInFLACFrame = 0; + + drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame); + + pcmFrameCountInThisFLACFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1; + if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFLACFrame)) { + /* + The sample should be in this frame. We need to fully decode it, however if it's an invalid frame (a CRC mismatch), we need to pretend + it never existed and keep iterating. + */ + drflac_uint64 pcmFramesToDecode = pcmFrameIndex - runningPCMFrameCount; + + if (!isMidFrame) { + drflac_result result = drflac__decode_flac_frame(pFlac); + if (result == DRFLAC_SUCCESS) { + /* The frame is valid. We just need to skip over some samples to ensure it's sample-exact. */ + return drflac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode; /* <-- If this fails, something bad has happened (it should never fail). */ + } else { + if (result == DRFLAC_CRC_MISMATCH) { + goto next_iteration; /* CRC mismatch. Pretend this frame never existed. */ + } else { + return DRFLAC_FALSE; + } + } + } else { + /* We started seeking mid-frame which means we need to skip the frame decoding part. */ + return drflac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode; + } + } else { + /* + It's not in this frame. We need to seek past the frame, but check if there was a CRC mismatch. If so, we pretend this + frame never existed and leave the running sample count untouched. + */ + if (!isMidFrame) { + drflac_result result = drflac__seek_to_next_flac_frame(pFlac); + if (result == DRFLAC_SUCCESS) { + runningPCMFrameCount += pcmFrameCountInThisFLACFrame; + } else { + if (result == DRFLAC_CRC_MISMATCH) { + goto next_iteration; /* CRC mismatch. Pretend this frame never existed. */ + } else { + return DRFLAC_FALSE; + } + } + } else { + /* + We started seeking mid-frame which means we need to seek by reading to the end of the frame instead of with + drflac__seek_to_next_flac_frame() which only works if the decoder is sitting on the byte just after the frame header. + */ + runningPCMFrameCount += pFlac->currentFLACFrame.pcmFramesRemaining; + pFlac->currentFLACFrame.pcmFramesRemaining = 0; + isMidFrame = DRFLAC_FALSE; + } + + /* If we are seeking to the end of the file and we've just hit it, we're done. */ + if (pcmFrameIndex == pFlac->totalPCMFrameCount && runningPCMFrameCount == pFlac->totalPCMFrameCount) { + return DRFLAC_TRUE; + } + } + + next_iteration: + /* Grab the next frame in preparation for the next iteration. */ + if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + return DRFLAC_FALSE; + } + } +} + + +#if !defined(DR_FLAC_NO_CRC) +/* +We use an average compression ratio to determine our approximate start location. FLAC files are generally about 50%-70% the size of their +uncompressed counterparts so we'll use this as a basis. I'm going to split the middle and use a factor of 0.6 to determine the starting +location. +*/ +#define DRFLAC_BINARY_SEARCH_APPROX_COMPRESSION_RATIO 0.6f + +static drflac_bool32 drflac__seek_to_approximate_flac_frame_to_byte(drflac* pFlac, drflac_uint64 targetByte, drflac_uint64 rangeLo, drflac_uint64 rangeHi, drflac_uint64* pLastSuccessfulSeekOffset) +{ + DRFLAC_ASSERT(pFlac != NULL); + DRFLAC_ASSERT(pLastSuccessfulSeekOffset != NULL); + DRFLAC_ASSERT(targetByte >= rangeLo); + DRFLAC_ASSERT(targetByte <= rangeHi); + + *pLastSuccessfulSeekOffset = pFlac->firstFLACFramePosInBytes; + + for (;;) { + /* When seeking to a byte, failure probably means we've attempted to seek beyond the end of the stream. To counter this we just halve it each attempt. */ + if (!drflac__seek_to_byte(&pFlac->bs, targetByte)) { + /* If we couldn't even seek to the first byte in the stream we have a problem. Just abandon the whole thing. */ + if (targetByte == 0) { + drflac__seek_to_first_frame(pFlac); /* Try to recover. */ + return DRFLAC_FALSE; + } + + /* Halve the byte location and continue. */ + targetByte = rangeLo + ((rangeHi - rangeLo)/2); + rangeHi = targetByte; + } else { + /* Getting here should mean that we have seeked to an appropriate byte. */ + + /* Clear the details of the FLAC frame so we don't misreport data. */ + DRFLAC_ZERO_MEMORY(&pFlac->currentFLACFrame, sizeof(pFlac->currentFLACFrame)); + + /* + Now seek to the next FLAC frame. We need to decode the entire frame (not just the header) because it's possible for the header to incorrectly pass the + CRC check and return bad data. We need to decode the entire frame to be more certain. Although this seems unlikely, this has happened to me in testing + so it needs to stay this way for now. + */ +#if 1 + if (!drflac__read_and_decode_next_flac_frame(pFlac)) { + /* Halve the byte location and continue. */ + targetByte = rangeLo + ((rangeHi - rangeLo)/2); + rangeHi = targetByte; + } else { + break; + } +#else + if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + /* Halve the byte location and continue. */ + targetByte = rangeLo + ((rangeHi - rangeLo)/2); + rangeHi = targetByte; + } else { + break; + } +#endif + } + } + + /* The current PCM frame needs to be updated based on the frame we just seeked to. */ + drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &pFlac->currentPCMFrame, NULL); + + DRFLAC_ASSERT(targetByte <= rangeHi); + + *pLastSuccessfulSeekOffset = targetByte; + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__decode_flac_frame_and_seek_forward_by_pcm_frames(drflac* pFlac, drflac_uint64 offset) +{ + /* This section of code would be used if we were only decoding the FLAC frame header when calling drflac__seek_to_approximate_flac_frame_to_byte(). */ +#if 0 + if (drflac__decode_flac_frame(pFlac) != DRFLAC_SUCCESS) { + /* We failed to decode this frame which may be due to it being corrupt. We'll just use the next valid FLAC frame. */ + if (drflac__read_and_decode_next_flac_frame(pFlac) == DRFLAC_FALSE) { + return DRFLAC_FALSE; + } + } +#endif + + return drflac__seek_forward_by_pcm_frames(pFlac, offset) == offset; +} + + +static drflac_bool32 drflac__seek_to_pcm_frame__binary_search_internal(drflac* pFlac, drflac_uint64 pcmFrameIndex, drflac_uint64 byteRangeLo, drflac_uint64 byteRangeHi) +{ + /* This assumes pFlac->currentPCMFrame is sitting on byteRangeLo upon entry. */ + + drflac_uint64 targetByte; + drflac_uint64 pcmRangeLo = pFlac->totalPCMFrameCount; + drflac_uint64 pcmRangeHi = 0; + drflac_uint64 lastSuccessfulSeekOffset = (drflac_uint64)-1; + drflac_uint64 closestSeekOffsetBeforeTargetPCMFrame = byteRangeLo; + drflac_uint32 seekForwardThreshold = (pFlac->maxBlockSizeInPCMFrames != 0) ? pFlac->maxBlockSizeInPCMFrames*2 : 4096; + + targetByte = byteRangeLo + (drflac_uint64)(((drflac_int64)((pcmFrameIndex - pFlac->currentPCMFrame) * pFlac->channels * pFlac->bitsPerSample)/8.0f) * DRFLAC_BINARY_SEARCH_APPROX_COMPRESSION_RATIO); + if (targetByte > byteRangeHi) { + targetByte = byteRangeHi; + } + + for (;;) { + if (drflac__seek_to_approximate_flac_frame_to_byte(pFlac, targetByte, byteRangeLo, byteRangeHi, &lastSuccessfulSeekOffset)) { + /* We found a FLAC frame. We need to check if it contains the sample we're looking for. */ + drflac_uint64 newPCMRangeLo; + drflac_uint64 newPCMRangeHi; + drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &newPCMRangeLo, &newPCMRangeHi); + + /* If we selected the same frame, it means we should be pretty close. Just decode the rest. */ + if (pcmRangeLo == newPCMRangeLo) { + if (!drflac__seek_to_approximate_flac_frame_to_byte(pFlac, closestSeekOffsetBeforeTargetPCMFrame, closestSeekOffsetBeforeTargetPCMFrame, byteRangeHi, &lastSuccessfulSeekOffset)) { + break; /* Failed to seek to closest frame. */ + } + + if (drflac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame)) { + return DRFLAC_TRUE; + } else { + break; /* Failed to seek forward. */ + } + } + + pcmRangeLo = newPCMRangeLo; + pcmRangeHi = newPCMRangeHi; + + if (pcmRangeLo <= pcmFrameIndex && pcmRangeHi >= pcmFrameIndex) { + /* The target PCM frame is in this FLAC frame. */ + if (drflac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame) ) { + return DRFLAC_TRUE; + } else { + break; /* Failed to seek to FLAC frame. */ + } + } else { + const float approxCompressionRatio = (drflac_int64)(lastSuccessfulSeekOffset - pFlac->firstFLACFramePosInBytes) / ((drflac_int64)(pcmRangeLo * pFlac->channels * pFlac->bitsPerSample)/8.0f); + + if (pcmRangeLo > pcmFrameIndex) { + /* We seeked too far forward. We need to move our target byte backward and try again. */ + byteRangeHi = lastSuccessfulSeekOffset; + if (byteRangeLo > byteRangeHi) { + byteRangeLo = byteRangeHi; + } + + targetByte = byteRangeLo + ((byteRangeHi - byteRangeLo) / 2); + if (targetByte < byteRangeLo) { + targetByte = byteRangeLo; + } + } else /*if (pcmRangeHi < pcmFrameIndex)*/ { + /* We didn't seek far enough. We need to move our target byte forward and try again. */ + + /* If we're close enough we can just seek forward. */ + if ((pcmFrameIndex - pcmRangeLo) < seekForwardThreshold) { + if (drflac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame)) { + return DRFLAC_TRUE; + } else { + break; /* Failed to seek to FLAC frame. */ + } + } else { + byteRangeLo = lastSuccessfulSeekOffset; + if (byteRangeHi < byteRangeLo) { + byteRangeHi = byteRangeLo; + } + + targetByte = lastSuccessfulSeekOffset + (drflac_uint64)(((drflac_int64)((pcmFrameIndex-pcmRangeLo) * pFlac->channels * pFlac->bitsPerSample)/8.0f) * approxCompressionRatio); + if (targetByte > byteRangeHi) { + targetByte = byteRangeHi; + } + + if (closestSeekOffsetBeforeTargetPCMFrame < lastSuccessfulSeekOffset) { + closestSeekOffsetBeforeTargetPCMFrame = lastSuccessfulSeekOffset; + } + } + } + } + } else { + /* Getting here is really bad. We just recover as best we can, but moving to the first frame in the stream, and then abort. */ + break; + } + } + + drflac__seek_to_first_frame(pFlac); /* <-- Try to recover. */ + return DRFLAC_FALSE; +} + +static drflac_bool32 drflac__seek_to_pcm_frame__binary_search(drflac* pFlac, drflac_uint64 pcmFrameIndex) +{ + drflac_uint64 byteRangeLo; + drflac_uint64 byteRangeHi; + drflac_uint32 seekForwardThreshold = (pFlac->maxBlockSizeInPCMFrames != 0) ? pFlac->maxBlockSizeInPCMFrames*2 : 4096; + + /* Our algorithm currently assumes the FLAC stream is currently sitting at the start. */ + if (drflac__seek_to_first_frame(pFlac) == DRFLAC_FALSE) { + return DRFLAC_FALSE; + } + + /* If we're close enough to the start, just move to the start and seek forward. */ + if (pcmFrameIndex < seekForwardThreshold) { + return drflac__seek_forward_by_pcm_frames(pFlac, pcmFrameIndex) == pcmFrameIndex; + } + + /* + Our starting byte range is the byte position of the first FLAC frame and the approximate end of the file as if it were completely uncompressed. This ensures + the entire file is included, even though most of the time it'll exceed the end of the actual stream. This is OK as the frame searching logic will handle it. + */ + byteRangeLo = pFlac->firstFLACFramePosInBytes; + byteRangeHi = pFlac->firstFLACFramePosInBytes + (drflac_uint64)((drflac_int64)(pFlac->totalPCMFrameCount * pFlac->channels * pFlac->bitsPerSample)/8.0f); + + return drflac__seek_to_pcm_frame__binary_search_internal(pFlac, pcmFrameIndex, byteRangeLo, byteRangeHi); +} +#endif /* !DR_FLAC_NO_CRC */ + +static drflac_bool32 drflac__seek_to_pcm_frame__seek_table(drflac* pFlac, drflac_uint64 pcmFrameIndex) +{ + drflac_uint32 iClosestSeekpoint = 0; + drflac_bool32 isMidFrame = DRFLAC_FALSE; + drflac_uint64 runningPCMFrameCount; + drflac_uint32 iSeekpoint; + + + DRFLAC_ASSERT(pFlac != NULL); + + if (pFlac->pSeekpoints == NULL || pFlac->seekpointCount == 0) { + return DRFLAC_FALSE; + } + + for (iSeekpoint = 0; iSeekpoint < pFlac->seekpointCount; ++iSeekpoint) { + if (pFlac->pSeekpoints[iSeekpoint].firstPCMFrame >= pcmFrameIndex) { + break; + } + + iClosestSeekpoint = iSeekpoint; + } + + /* There's been cases where the seek table contains only zeros. We need to do some basic validation on the closest seekpoint. */ + if (pFlac->pSeekpoints[iClosestSeekpoint].pcmFrameCount == 0 || pFlac->pSeekpoints[iClosestSeekpoint].pcmFrameCount > pFlac->maxBlockSizeInPCMFrames) { + return DRFLAC_FALSE; + } + if (pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame > pFlac->totalPCMFrameCount && pFlac->totalPCMFrameCount > 0) { + return DRFLAC_FALSE; + } + +#if !defined(DR_FLAC_NO_CRC) + /* At this point we should know the closest seek point. We can use a binary search for this. We need to know the total sample count for this. */ + if (pFlac->totalPCMFrameCount > 0) { + drflac_uint64 byteRangeLo; + drflac_uint64 byteRangeHi; + + byteRangeHi = pFlac->firstFLACFramePosInBytes + (drflac_uint64)((drflac_int64)(pFlac->totalPCMFrameCount * pFlac->channels * pFlac->bitsPerSample)/8.0f); + byteRangeLo = pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset; + + /* + If our closest seek point is not the last one, we only need to search between it and the next one. The section below calculates an appropriate starting + value for byteRangeHi which will clamp it appropriately. + + Note that the next seekpoint must have an offset greater than the closest seekpoint because otherwise our binary search algorithm will break down. There + have been cases where a seektable consists of seek points where every byte offset is set to 0 which causes problems. If this happens we need to abort. + */ + if (iClosestSeekpoint < pFlac->seekpointCount-1) { + drflac_uint32 iNextSeekpoint = iClosestSeekpoint + 1; + + /* Basic validation on the seekpoints to ensure they're usable. */ + if (pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset >= pFlac->pSeekpoints[iNextSeekpoint].flacFrameOffset || pFlac->pSeekpoints[iNextSeekpoint].pcmFrameCount == 0) { + return DRFLAC_FALSE; /* The next seekpoint doesn't look right. The seek table cannot be trusted from here. Abort. */ + } + + if (pFlac->pSeekpoints[iNextSeekpoint].firstPCMFrame != (((drflac_uint64)0xFFFFFFFF << 32) | 0xFFFFFFFF)) { /* Make sure it's not a placeholder seekpoint. */ + byteRangeHi = pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iNextSeekpoint].flacFrameOffset - 1; /* byteRangeHi must be zero based. */ + } + } + + if (drflac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset)) { + if (drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &pFlac->currentPCMFrame, NULL); + + if (drflac__seek_to_pcm_frame__binary_search_internal(pFlac, pcmFrameIndex, byteRangeLo, byteRangeHi)) { + return DRFLAC_TRUE; + } + } + } + } +#endif /* !DR_FLAC_NO_CRC */ + + /* Getting here means we need to use a slower algorithm because the binary search method failed or cannot be used. */ + + /* + If we are seeking forward and the closest seekpoint is _before_ the current sample, we just seek forward from where we are. Otherwise we start seeking + from the seekpoint's first sample. + */ + if (pcmFrameIndex >= pFlac->currentPCMFrame && pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame <= pFlac->currentPCMFrame) { + /* Optimized case. Just seek forward from where we are. */ + runningPCMFrameCount = pFlac->currentPCMFrame; + + /* The frame header for the first frame may not yet have been read. We need to do that if necessary. */ + if (pFlac->currentPCMFrame == 0 && pFlac->currentFLACFrame.pcmFramesRemaining == 0) { + if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + return DRFLAC_FALSE; + } + } else { + isMidFrame = DRFLAC_TRUE; + } + } else { + /* Slower case. Seek to the start of the seekpoint and then seek forward from there. */ + runningPCMFrameCount = pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame; + + if (!drflac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset)) { + return DRFLAC_FALSE; + } + + /* Grab the frame the seekpoint is sitting on in preparation for the sample-exact seeking below. */ + if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + return DRFLAC_FALSE; + } + } + + for (;;) { + drflac_uint64 pcmFrameCountInThisFLACFrame; + drflac_uint64 firstPCMFrameInFLACFrame = 0; + drflac_uint64 lastPCMFrameInFLACFrame = 0; + + drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame); + + pcmFrameCountInThisFLACFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1; + if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFLACFrame)) { + /* + The sample should be in this frame. We need to fully decode it, but if it's an invalid frame (a CRC mismatch) we need to pretend + it never existed and keep iterating. + */ + drflac_uint64 pcmFramesToDecode = pcmFrameIndex - runningPCMFrameCount; + + if (!isMidFrame) { + drflac_result result = drflac__decode_flac_frame(pFlac); + if (result == DRFLAC_SUCCESS) { + /* The frame is valid. We just need to skip over some samples to ensure it's sample-exact. */ + return drflac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode; /* <-- If this fails, something bad has happened (it should never fail). */ + } else { + if (result == DRFLAC_CRC_MISMATCH) { + goto next_iteration; /* CRC mismatch. Pretend this frame never existed. */ + } else { + return DRFLAC_FALSE; + } + } + } else { + /* We started seeking mid-frame which means we need to skip the frame decoding part. */ + return drflac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode; + } + } else { + /* + It's not in this frame. We need to seek past the frame, but check if there was a CRC mismatch. If so, we pretend this + frame never existed and leave the running sample count untouched. + */ + if (!isMidFrame) { + drflac_result result = drflac__seek_to_next_flac_frame(pFlac); + if (result == DRFLAC_SUCCESS) { + runningPCMFrameCount += pcmFrameCountInThisFLACFrame; + } else { + if (result == DRFLAC_CRC_MISMATCH) { + goto next_iteration; /* CRC mismatch. Pretend this frame never existed. */ + } else { + return DRFLAC_FALSE; + } + } + } else { + /* + We started seeking mid-frame which means we need to seek by reading to the end of the frame instead of with + drflac__seek_to_next_flac_frame() which only works if the decoder is sitting on the byte just after the frame header. + */ + runningPCMFrameCount += pFlac->currentFLACFrame.pcmFramesRemaining; + pFlac->currentFLACFrame.pcmFramesRemaining = 0; + isMidFrame = DRFLAC_FALSE; + } + + /* If we are seeking to the end of the file and we've just hit it, we're done. */ + if (pcmFrameIndex == pFlac->totalPCMFrameCount && runningPCMFrameCount == pFlac->totalPCMFrameCount) { + return DRFLAC_TRUE; + } + } + + next_iteration: + /* Grab the next frame in preparation for the next iteration. */ + if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + return DRFLAC_FALSE; + } + } +} + + +#ifndef DR_FLAC_NO_OGG +typedef struct +{ + drflac_uint8 capturePattern[4]; /* Should be "OggS" */ + drflac_uint8 structureVersion; /* Always 0. */ + drflac_uint8 headerType; + drflac_uint64 granulePosition; + drflac_uint32 serialNumber; + drflac_uint32 sequenceNumber; + drflac_uint32 checksum; + drflac_uint8 segmentCount; + drflac_uint8 segmentTable[255]; +} drflac_ogg_page_header; +#endif + +typedef struct +{ + drflac_read_proc onRead; + drflac_seek_proc onSeek; + drflac_meta_proc onMeta; + drflac_container container; + void* pUserData; + void* pUserDataMD; + drflac_uint32 sampleRate; + drflac_uint8 channels; + drflac_uint8 bitsPerSample; + drflac_uint64 totalPCMFrameCount; + drflac_uint16 maxBlockSizeInPCMFrames; + drflac_uint64 runningFilePos; + drflac_bool32 hasStreamInfoBlock; + drflac_bool32 hasMetadataBlocks; + drflac_bs bs; /* <-- A bit streamer is required for loading data during initialization. */ + drflac_frame_header firstFrameHeader; /* <-- The header of the first frame that was read during relaxed initalization. Only set if there is no STREAMINFO block. */ + +#ifndef DR_FLAC_NO_OGG + drflac_uint32 oggSerial; + drflac_uint64 oggFirstBytePos; + drflac_ogg_page_header oggBosHeader; +#endif +} drflac_init_info; + +static DRFLAC_INLINE void drflac__decode_block_header(drflac_uint32 blockHeader, drflac_uint8* isLastBlock, drflac_uint8* blockType, drflac_uint32* blockSize) +{ + blockHeader = drflac__be2host_32(blockHeader); + *isLastBlock = (drflac_uint8)((blockHeader & 0x80000000UL) >> 31); + *blockType = (drflac_uint8)((blockHeader & 0x7F000000UL) >> 24); + *blockSize = (blockHeader & 0x00FFFFFFUL); +} + +static DRFLAC_INLINE drflac_bool32 drflac__read_and_decode_block_header(drflac_read_proc onRead, void* pUserData, drflac_uint8* isLastBlock, drflac_uint8* blockType, drflac_uint32* blockSize) +{ + drflac_uint32 blockHeader; + + *blockSize = 0; + if (onRead(pUserData, &blockHeader, 4) != 4) { + return DRFLAC_FALSE; + } + + drflac__decode_block_header(blockHeader, isLastBlock, blockType, blockSize); + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__read_streaminfo(drflac_read_proc onRead, void* pUserData, drflac_streaminfo* pStreamInfo) +{ + drflac_uint32 blockSizes; + drflac_uint64 frameSizes = 0; + drflac_uint64 importantProps; + drflac_uint8 md5[16]; + + /* min/max block size. */ + if (onRead(pUserData, &blockSizes, 4) != 4) { + return DRFLAC_FALSE; + } + + /* min/max frame size. */ + if (onRead(pUserData, &frameSizes, 6) != 6) { + return DRFLAC_FALSE; + } + + /* Sample rate, channels, bits per sample and total sample count. */ + if (onRead(pUserData, &importantProps, 8) != 8) { + return DRFLAC_FALSE; + } + + /* MD5 */ + if (onRead(pUserData, md5, sizeof(md5)) != sizeof(md5)) { + return DRFLAC_FALSE; + } + + blockSizes = drflac__be2host_32(blockSizes); + frameSizes = drflac__be2host_64(frameSizes); + importantProps = drflac__be2host_64(importantProps); + + pStreamInfo->minBlockSizeInPCMFrames = (drflac_uint16)((blockSizes & 0xFFFF0000) >> 16); + pStreamInfo->maxBlockSizeInPCMFrames = (drflac_uint16) (blockSizes & 0x0000FFFF); + pStreamInfo->minFrameSizeInPCMFrames = (drflac_uint32)((frameSizes & (((drflac_uint64)0x00FFFFFF << 16) << 24)) >> 40); + pStreamInfo->maxFrameSizeInPCMFrames = (drflac_uint32)((frameSizes & (((drflac_uint64)0x00FFFFFF << 16) << 0)) >> 16); + pStreamInfo->sampleRate = (drflac_uint32)((importantProps & (((drflac_uint64)0x000FFFFF << 16) << 28)) >> 44); + pStreamInfo->channels = (drflac_uint8 )((importantProps & (((drflac_uint64)0x0000000E << 16) << 24)) >> 41) + 1; + pStreamInfo->bitsPerSample = (drflac_uint8 )((importantProps & (((drflac_uint64)0x0000001F << 16) << 20)) >> 36) + 1; + pStreamInfo->totalPCMFrameCount = ((importantProps & ((((drflac_uint64)0x0000000F << 16) << 16) | 0xFFFFFFFF))); + DRFLAC_COPY_MEMORY(pStreamInfo->md5, md5, sizeof(md5)); + + return DRFLAC_TRUE; +} + + +static void* drflac__malloc_default(size_t sz, void* pUserData) +{ + (void)pUserData; + return DRFLAC_MALLOC(sz); +} + +static void* drflac__realloc_default(void* p, size_t sz, void* pUserData) +{ + (void)pUserData; + return DRFLAC_REALLOC(p, sz); +} + +static void drflac__free_default(void* p, void* pUserData) +{ + (void)pUserData; + DRFLAC_FREE(p); +} + + +static void* drflac__malloc_from_callbacks(size_t sz, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + if (pAllocationCallbacks == NULL) { + return NULL; + } + + if (pAllocationCallbacks->onMalloc != NULL) { + return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData); + } + + /* Try using realloc(). */ + if (pAllocationCallbacks->onRealloc != NULL) { + return pAllocationCallbacks->onRealloc(NULL, sz, pAllocationCallbacks->pUserData); + } + + return NULL; +} + +static void* drflac__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + if (pAllocationCallbacks == NULL) { + return NULL; + } + + if (pAllocationCallbacks->onRealloc != NULL) { + return pAllocationCallbacks->onRealloc(p, szNew, pAllocationCallbacks->pUserData); + } + + /* Try emulating realloc() in terms of malloc()/free(). */ + if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) { + void* p2; + + p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData); + if (p2 == NULL) { + return NULL; + } + + if (p != NULL) { + DRFLAC_COPY_MEMORY(p2, p, szOld); + pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData); + } + + return p2; + } + + return NULL; +} + +static void drflac__free_from_callbacks(void* p, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + if (p == NULL || pAllocationCallbacks == NULL) { + return; + } + + if (pAllocationCallbacks->onFree != NULL) { + pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData); + } +} + + +static drflac_bool32 drflac__read_and_decode_metadata(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, void* pUserData, void* pUserDataMD, drflac_uint64* pFirstFramePos, drflac_uint64* pSeektablePos, drflac_uint32* pSeektableSize, drflac_allocation_callbacks* pAllocationCallbacks) +{ + /* + We want to keep track of the byte position in the stream of the seektable. At the time of calling this function we know that + we'll be sitting on byte 42. + */ + drflac_uint64 runningFilePos = 42; + drflac_uint64 seektablePos = 0; + drflac_uint32 seektableSize = 0; + + for (;;) { + drflac_metadata metadata; + drflac_uint8 isLastBlock = 0; + drflac_uint8 blockType; + drflac_uint32 blockSize; + if (drflac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize) == DRFLAC_FALSE) { + return DRFLAC_FALSE; + } + runningFilePos += 4; + + metadata.type = blockType; + metadata.pRawData = NULL; + metadata.rawDataSize = 0; + + switch (blockType) + { + case DRFLAC_METADATA_BLOCK_TYPE_APPLICATION: + { + if (blockSize < 4) { + return DRFLAC_FALSE; + } + + if (onMeta) { + void* pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks); + if (pRawData == NULL) { + return DRFLAC_FALSE; + } + + if (onRead(pUserData, pRawData, blockSize) != blockSize) { + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + + metadata.pRawData = pRawData; + metadata.rawDataSize = blockSize; + metadata.data.application.id = drflac__be2host_32(*(drflac_uint32*)pRawData); + metadata.data.application.pData = (const void*)((drflac_uint8*)pRawData + sizeof(drflac_uint32)); + metadata.data.application.dataSize = blockSize - sizeof(drflac_uint32); + onMeta(pUserDataMD, &metadata); + + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + } + } break; + + case DRFLAC_METADATA_BLOCK_TYPE_SEEKTABLE: + { + seektablePos = runningFilePos; + seektableSize = blockSize; + + if (onMeta) { + drflac_uint32 iSeekpoint; + void* pRawData; + + pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks); + if (pRawData == NULL) { + return DRFLAC_FALSE; + } + + if (onRead(pUserData, pRawData, blockSize) != blockSize) { + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + + metadata.pRawData = pRawData; + metadata.rawDataSize = blockSize; + metadata.data.seektable.seekpointCount = blockSize/sizeof(drflac_seekpoint); + metadata.data.seektable.pSeekpoints = (const drflac_seekpoint*)pRawData; + + /* Endian swap. */ + for (iSeekpoint = 0; iSeekpoint < metadata.data.seektable.seekpointCount; ++iSeekpoint) { + drflac_seekpoint* pSeekpoint = (drflac_seekpoint*)pRawData + iSeekpoint; + pSeekpoint->firstPCMFrame = drflac__be2host_64(pSeekpoint->firstPCMFrame); + pSeekpoint->flacFrameOffset = drflac__be2host_64(pSeekpoint->flacFrameOffset); + pSeekpoint->pcmFrameCount = drflac__be2host_16(pSeekpoint->pcmFrameCount); + } + + onMeta(pUserDataMD, &metadata); + + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + } + } break; + + case DRFLAC_METADATA_BLOCK_TYPE_VORBIS_COMMENT: + { + if (blockSize < 8) { + return DRFLAC_FALSE; + } + + if (onMeta) { + void* pRawData; + const char* pRunningData; + const char* pRunningDataEnd; + drflac_uint32 i; + + pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks); + if (pRawData == NULL) { + return DRFLAC_FALSE; + } + + if (onRead(pUserData, pRawData, blockSize) != blockSize) { + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + + metadata.pRawData = pRawData; + metadata.rawDataSize = blockSize; + + pRunningData = (const char*)pRawData; + pRunningDataEnd = (const char*)pRawData + blockSize; + + metadata.data.vorbis_comment.vendorLength = drflac__le2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + + /* Need space for the rest of the block */ + if ((pRunningDataEnd - pRunningData) - 4 < (drflac_int64)metadata.data.vorbis_comment.vendorLength) { /* <-- Note the order of operations to avoid overflow to a valid value */ + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + metadata.data.vorbis_comment.vendor = pRunningData; pRunningData += metadata.data.vorbis_comment.vendorLength; + metadata.data.vorbis_comment.commentCount = drflac__le2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + + /* Need space for 'commentCount' comments after the block, which at minimum is a drflac_uint32 per comment */ + if ((pRunningDataEnd - pRunningData) / sizeof(drflac_uint32) < metadata.data.vorbis_comment.commentCount) { /* <-- Note the order of operations to avoid overflow to a valid value */ + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + metadata.data.vorbis_comment.pComments = pRunningData; + + /* Check that the comments section is valid before passing it to the callback */ + for (i = 0; i < metadata.data.vorbis_comment.commentCount; ++i) { + drflac_uint32 commentLength; + + if (pRunningDataEnd - pRunningData < 4) { + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + + commentLength = drflac__le2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + if (pRunningDataEnd - pRunningData < (drflac_int64)commentLength) { /* <-- Note the order of operations to avoid overflow to a valid value */ + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + pRunningData += commentLength; + } + + onMeta(pUserDataMD, &metadata); + + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + } + } break; + + case DRFLAC_METADATA_BLOCK_TYPE_CUESHEET: + { + if (blockSize < 396) { + return DRFLAC_FALSE; + } + + if (onMeta) { + void* pRawData; + const char* pRunningData; + const char* pRunningDataEnd; + drflac_uint8 iTrack; + drflac_uint8 iIndex; + + pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks); + if (pRawData == NULL) { + return DRFLAC_FALSE; + } + + if (onRead(pUserData, pRawData, blockSize) != blockSize) { + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + + metadata.pRawData = pRawData; + metadata.rawDataSize = blockSize; + + pRunningData = (const char*)pRawData; + pRunningDataEnd = (const char*)pRawData + blockSize; + + DRFLAC_COPY_MEMORY(metadata.data.cuesheet.catalog, pRunningData, 128); pRunningData += 128; + metadata.data.cuesheet.leadInSampleCount = drflac__be2host_64(*(const drflac_uint64*)pRunningData); pRunningData += 8; + metadata.data.cuesheet.isCD = (pRunningData[0] & 0x80) != 0; pRunningData += 259; + metadata.data.cuesheet.trackCount = pRunningData[0]; pRunningData += 1; + metadata.data.cuesheet.pTrackData = pRunningData; + + /* Check that the cuesheet tracks are valid before passing it to the callback */ + for (iTrack = 0; iTrack < metadata.data.cuesheet.trackCount; ++iTrack) { + drflac_uint8 indexCount; + drflac_uint32 indexPointSize; + + if (pRunningDataEnd - pRunningData < 36) { + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + + /* Skip to the index point count */ + pRunningData += 35; + indexCount = pRunningData[0]; pRunningData += 1; + indexPointSize = indexCount * sizeof(drflac_cuesheet_track_index); + if (pRunningDataEnd - pRunningData < (drflac_int64)indexPointSize) { + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + + /* Endian swap. */ + for (iIndex = 0; iIndex < indexCount; ++iIndex) { + drflac_cuesheet_track_index* pTrack = (drflac_cuesheet_track_index*)pRunningData; + pRunningData += sizeof(drflac_cuesheet_track_index); + pTrack->offset = drflac__be2host_64(pTrack->offset); + } + } + + onMeta(pUserDataMD, &metadata); + + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + } + } break; + + case DRFLAC_METADATA_BLOCK_TYPE_PICTURE: + { + if (blockSize < 32) { + return DRFLAC_FALSE; + } + + if (onMeta) { + void* pRawData; + const char* pRunningData; + const char* pRunningDataEnd; + + pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks); + if (pRawData == NULL) { + return DRFLAC_FALSE; + } + + if (onRead(pUserData, pRawData, blockSize) != blockSize) { + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + + metadata.pRawData = pRawData; + metadata.rawDataSize = blockSize; + + pRunningData = (const char*)pRawData; + pRunningDataEnd = (const char*)pRawData + blockSize; + + metadata.data.picture.type = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + metadata.data.picture.mimeLength = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + + /* Need space for the rest of the block */ + if ((pRunningDataEnd - pRunningData) - 24 < (drflac_int64)metadata.data.picture.mimeLength) { /* <-- Note the order of operations to avoid overflow to a valid value */ + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + metadata.data.picture.mime = pRunningData; pRunningData += metadata.data.picture.mimeLength; + metadata.data.picture.descriptionLength = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + + /* Need space for the rest of the block */ + if ((pRunningDataEnd - pRunningData) - 20 < (drflac_int64)metadata.data.picture.descriptionLength) { /* <-- Note the order of operations to avoid overflow to a valid value */ + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + metadata.data.picture.description = pRunningData; pRunningData += metadata.data.picture.descriptionLength; + metadata.data.picture.width = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + metadata.data.picture.height = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + metadata.data.picture.colorDepth = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + metadata.data.picture.indexColorCount = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + metadata.data.picture.pictureDataSize = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + metadata.data.picture.pPictureData = (const drflac_uint8*)pRunningData; + + /* Need space for the picture after the block */ + if (pRunningDataEnd - pRunningData < (drflac_int64)metadata.data.picture.pictureDataSize) { /* <-- Note the order of operations to avoid overflow to a valid value */ + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + + onMeta(pUserDataMD, &metadata); + + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + } + } break; + + case DRFLAC_METADATA_BLOCK_TYPE_PADDING: + { + if (onMeta) { + metadata.data.padding.unused = 0; + + /* Padding doesn't have anything meaningful in it, so just skip over it, but make sure the caller is aware of it by firing the callback. */ + if (!onSeek(pUserData, blockSize, drflac_seek_origin_current)) { + isLastBlock = DRFLAC_TRUE; /* An error occurred while seeking. Attempt to recover by treating this as the last block which will in turn terminate the loop. */ + } else { + onMeta(pUserDataMD, &metadata); + } + } + } break; + + case DRFLAC_METADATA_BLOCK_TYPE_INVALID: + { + /* Invalid chunk. Just skip over this one. */ + if (onMeta) { + if (!onSeek(pUserData, blockSize, drflac_seek_origin_current)) { + isLastBlock = DRFLAC_TRUE; /* An error occurred while seeking. Attempt to recover by treating this as the last block which will in turn terminate the loop. */ + } + } + } break; + + default: + { + /* + It's an unknown chunk, but not necessarily invalid. There's a chance more metadata blocks might be defined later on, so we + can at the very least report the chunk to the application and let it look at the raw data. + */ + if (onMeta) { + void* pRawData = drflac__malloc_from_callbacks(blockSize, pAllocationCallbacks); + if (pRawData == NULL) { + return DRFLAC_FALSE; + } + + if (onRead(pUserData, pRawData, blockSize) != blockSize) { + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + return DRFLAC_FALSE; + } + + metadata.pRawData = pRawData; + metadata.rawDataSize = blockSize; + onMeta(pUserDataMD, &metadata); + + drflac__free_from_callbacks(pRawData, pAllocationCallbacks); + } + } break; + } + + /* If we're not handling metadata, just skip over the block. If we are, it will have been handled earlier in the switch statement above. */ + if (onMeta == NULL && blockSize > 0) { + if (!onSeek(pUserData, blockSize, drflac_seek_origin_current)) { + isLastBlock = DRFLAC_TRUE; + } + } + + runningFilePos += blockSize; + if (isLastBlock) { + break; + } + } + + *pSeektablePos = seektablePos; + *pSeektableSize = seektableSize; + *pFirstFramePos = runningFilePos; + + return DRFLAC_TRUE; +} + +static drflac_bool32 drflac__init_private__native(drflac_init_info* pInit, drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, void* pUserData, void* pUserDataMD, drflac_bool32 relaxed) +{ + /* Pre Condition: The bit stream should be sitting just past the 4-byte id header. */ + + drflac_uint8 isLastBlock; + drflac_uint8 blockType; + drflac_uint32 blockSize; + + (void)onSeek; + + pInit->container = drflac_container_native; + + /* The first metadata block should be the STREAMINFO block. */ + if (!drflac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize)) { + return DRFLAC_FALSE; + } + + if (blockType != DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO || blockSize != 34) { + if (!relaxed) { + /* We're opening in strict mode and the first block is not the STREAMINFO block. Error. */ + return DRFLAC_FALSE; + } else { + /* + Relaxed mode. To open from here we need to just find the first frame and set the sample rate, etc. to whatever is defined + for that frame. + */ + pInit->hasStreamInfoBlock = DRFLAC_FALSE; + pInit->hasMetadataBlocks = DRFLAC_FALSE; + + if (!drflac__read_next_flac_frame_header(&pInit->bs, 0, &pInit->firstFrameHeader)) { + return DRFLAC_FALSE; /* Couldn't find a frame. */ + } + + if (pInit->firstFrameHeader.bitsPerSample == 0) { + return DRFLAC_FALSE; /* Failed to initialize because the first frame depends on the STREAMINFO block, which does not exist. */ + } + + pInit->sampleRate = pInit->firstFrameHeader.sampleRate; + pInit->channels = drflac__get_channel_count_from_channel_assignment(pInit->firstFrameHeader.channelAssignment); + pInit->bitsPerSample = pInit->firstFrameHeader.bitsPerSample; + pInit->maxBlockSizeInPCMFrames = 65535; /* <-- See notes here: https://xiph.org/flac/format.html#metadata_block_streaminfo */ + return DRFLAC_TRUE; + } + } else { + drflac_streaminfo streaminfo; + if (!drflac__read_streaminfo(onRead, pUserData, &streaminfo)) { + return DRFLAC_FALSE; + } + + pInit->hasStreamInfoBlock = DRFLAC_TRUE; + pInit->sampleRate = streaminfo.sampleRate; + pInit->channels = streaminfo.channels; + pInit->bitsPerSample = streaminfo.bitsPerSample; + pInit->totalPCMFrameCount = streaminfo.totalPCMFrameCount; + pInit->maxBlockSizeInPCMFrames = streaminfo.maxBlockSizeInPCMFrames; /* Don't care about the min block size - only the max (used for determining the size of the memory allocation). */ + pInit->hasMetadataBlocks = !isLastBlock; + + if (onMeta) { + drflac_metadata metadata; + metadata.type = DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO; + metadata.pRawData = NULL; + metadata.rawDataSize = 0; + metadata.data.streaminfo = streaminfo; + onMeta(pUserDataMD, &metadata); + } + + return DRFLAC_TRUE; + } +} + +#ifndef DR_FLAC_NO_OGG +#define DRFLAC_OGG_MAX_PAGE_SIZE 65307 +#define DRFLAC_OGG_CAPTURE_PATTERN_CRC32 1605413199 /* CRC-32 of "OggS". */ + +typedef enum +{ + drflac_ogg_recover_on_crc_mismatch, + drflac_ogg_fail_on_crc_mismatch +} drflac_ogg_crc_mismatch_recovery; + +#ifndef DR_FLAC_NO_CRC +static drflac_uint32 drflac__crc32_table[] = { + 0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L, + 0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L, + 0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L, + 0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL, + 0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L, + 0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L, + 0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L, + 0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL, + 0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L, + 0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L, + 0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L, + 0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL, + 0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L, + 0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L, + 0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L, + 0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL, + 0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL, + 0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L, + 0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L, + 0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL, + 0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL, + 0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L, + 0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L, + 0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL, + 0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL, + 0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L, + 0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L, + 0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL, + 0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL, + 0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L, + 0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L, + 0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL, + 0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L, + 0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL, + 0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL, + 0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L, + 0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L, + 0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL, + 0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL, + 0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L, + 0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L, + 0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL, + 0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL, + 0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L, + 0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L, + 0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL, + 0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL, + 0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L, + 0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L, + 0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL, + 0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L, + 0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L, + 0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L, + 0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL, + 0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L, + 0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L, + 0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L, + 0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL, + 0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L, + 0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L, + 0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L, + 0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL, + 0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L, + 0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L +}; +#endif + +static DRFLAC_INLINE drflac_uint32 drflac_crc32_byte(drflac_uint32 crc32, drflac_uint8 data) +{ +#ifndef DR_FLAC_NO_CRC + return (crc32 << 8) ^ drflac__crc32_table[(drflac_uint8)((crc32 >> 24) & 0xFF) ^ data]; +#else + (void)data; + return crc32; +#endif +} + +#if 0 +static DRFLAC_INLINE drflac_uint32 drflac_crc32_uint32(drflac_uint32 crc32, drflac_uint32 data) +{ + crc32 = drflac_crc32_byte(crc32, (drflac_uint8)((data >> 24) & 0xFF)); + crc32 = drflac_crc32_byte(crc32, (drflac_uint8)((data >> 16) & 0xFF)); + crc32 = drflac_crc32_byte(crc32, (drflac_uint8)((data >> 8) & 0xFF)); + crc32 = drflac_crc32_byte(crc32, (drflac_uint8)((data >> 0) & 0xFF)); + return crc32; +} + +static DRFLAC_INLINE drflac_uint32 drflac_crc32_uint64(drflac_uint32 crc32, drflac_uint64 data) +{ + crc32 = drflac_crc32_uint32(crc32, (drflac_uint32)((data >> 32) & 0xFFFFFFFF)); + crc32 = drflac_crc32_uint32(crc32, (drflac_uint32)((data >> 0) & 0xFFFFFFFF)); + return crc32; +} +#endif + +static DRFLAC_INLINE drflac_uint32 drflac_crc32_buffer(drflac_uint32 crc32, drflac_uint8* pData, drflac_uint32 dataSize) +{ + /* This can be optimized. */ + drflac_uint32 i; + for (i = 0; i < dataSize; ++i) { + crc32 = drflac_crc32_byte(crc32, pData[i]); + } + return crc32; +} + + +static DRFLAC_INLINE drflac_bool32 drflac_ogg__is_capture_pattern(drflac_uint8 pattern[4]) +{ + return pattern[0] == 'O' && pattern[1] == 'g' && pattern[2] == 'g' && pattern[3] == 'S'; +} + +static DRFLAC_INLINE drflac_uint32 drflac_ogg__get_page_header_size(drflac_ogg_page_header* pHeader) +{ + return 27 + pHeader->segmentCount; +} + +static DRFLAC_INLINE drflac_uint32 drflac_ogg__get_page_body_size(drflac_ogg_page_header* pHeader) +{ + drflac_uint32 pageBodySize = 0; + int i; + + for (i = 0; i < pHeader->segmentCount; ++i) { + pageBodySize += pHeader->segmentTable[i]; + } + + return pageBodySize; +} + +static drflac_result drflac_ogg__read_page_header_after_capture_pattern(drflac_read_proc onRead, void* pUserData, drflac_ogg_page_header* pHeader, drflac_uint32* pBytesRead, drflac_uint32* pCRC32) +{ + drflac_uint8 data[23]; + drflac_uint32 i; + + DRFLAC_ASSERT(*pCRC32 == DRFLAC_OGG_CAPTURE_PATTERN_CRC32); + + if (onRead(pUserData, data, 23) != 23) { + return DRFLAC_AT_END; + } + *pBytesRead += 23; + + /* + It's not actually used, but set the capture pattern to 'OggS' for completeness. Not doing this will cause static analysers to complain about + us trying to access uninitialized data. We could alternatively just comment out this member of the drflac_ogg_page_header structure, but I + like to have it map to the structure of the underlying data. + */ + pHeader->capturePattern[0] = 'O'; + pHeader->capturePattern[1] = 'g'; + pHeader->capturePattern[2] = 'g'; + pHeader->capturePattern[3] = 'S'; + + pHeader->structureVersion = data[0]; + pHeader->headerType = data[1]; + DRFLAC_COPY_MEMORY(&pHeader->granulePosition, &data[ 2], 8); + DRFLAC_COPY_MEMORY(&pHeader->serialNumber, &data[10], 4); + DRFLAC_COPY_MEMORY(&pHeader->sequenceNumber, &data[14], 4); + DRFLAC_COPY_MEMORY(&pHeader->checksum, &data[18], 4); + pHeader->segmentCount = data[22]; + + /* Calculate the CRC. Note that for the calculation the checksum part of the page needs to be set to 0. */ + data[18] = 0; + data[19] = 0; + data[20] = 0; + data[21] = 0; + + for (i = 0; i < 23; ++i) { + *pCRC32 = drflac_crc32_byte(*pCRC32, data[i]); + } + + + if (onRead(pUserData, pHeader->segmentTable, pHeader->segmentCount) != pHeader->segmentCount) { + return DRFLAC_AT_END; + } + *pBytesRead += pHeader->segmentCount; + + for (i = 0; i < pHeader->segmentCount; ++i) { + *pCRC32 = drflac_crc32_byte(*pCRC32, pHeader->segmentTable[i]); + } + + return DRFLAC_SUCCESS; +} + +static drflac_result drflac_ogg__read_page_header(drflac_read_proc onRead, void* pUserData, drflac_ogg_page_header* pHeader, drflac_uint32* pBytesRead, drflac_uint32* pCRC32) +{ + drflac_uint8 id[4]; + + *pBytesRead = 0; + + if (onRead(pUserData, id, 4) != 4) { + return DRFLAC_AT_END; + } + *pBytesRead += 4; + + /* We need to read byte-by-byte until we find the OggS capture pattern. */ + for (;;) { + if (drflac_ogg__is_capture_pattern(id)) { + drflac_result result; + + *pCRC32 = DRFLAC_OGG_CAPTURE_PATTERN_CRC32; + + result = drflac_ogg__read_page_header_after_capture_pattern(onRead, pUserData, pHeader, pBytesRead, pCRC32); + if (result == DRFLAC_SUCCESS) { + return DRFLAC_SUCCESS; + } else { + if (result == DRFLAC_CRC_MISMATCH) { + continue; + } else { + return result; + } + } + } else { + /* The first 4 bytes did not equal the capture pattern. Read the next byte and try again. */ + id[0] = id[1]; + id[1] = id[2]; + id[2] = id[3]; + if (onRead(pUserData, &id[3], 1) != 1) { + return DRFLAC_AT_END; + } + *pBytesRead += 1; + } + } +} + + +/* +The main part of the Ogg encapsulation is the conversion from the physical Ogg bitstream to the native FLAC bitstream. It works +in three general stages: Ogg Physical Bitstream -> Ogg/FLAC Logical Bitstream -> FLAC Native Bitstream. dr_flac is designed +in such a way that the core sections assume everything is delivered in native format. Therefore, for each encapsulation type +dr_flac is supporting there needs to be a layer sitting on top of the onRead and onSeek callbacks that ensures the bits read from +the physical Ogg bitstream are converted and delivered in native FLAC format. +*/ +typedef struct +{ + drflac_read_proc onRead; /* The original onRead callback from drflac_open() and family. */ + drflac_seek_proc onSeek; /* The original onSeek callback from drflac_open() and family. */ + void* pUserData; /* The user data passed on onRead and onSeek. This is the user data that was passed on drflac_open() and family. */ + drflac_uint64 currentBytePos; /* The position of the byte we are sitting on in the physical byte stream. Used for efficient seeking. */ + drflac_uint64 firstBytePos; /* The position of the first byte in the physical bitstream. Points to the start of the "OggS" identifier of the FLAC bos page. */ + drflac_uint32 serialNumber; /* The serial number of the FLAC audio pages. This is determined by the initial header page that was read during initialization. */ + drflac_ogg_page_header bosPageHeader; /* Used for seeking. */ + drflac_ogg_page_header currentPageHeader; + drflac_uint32 bytesRemainingInPage; + drflac_uint32 pageDataSize; + drflac_uint8 pageData[DRFLAC_OGG_MAX_PAGE_SIZE]; +} drflac_oggbs; /* oggbs = Ogg Bitstream */ + +static size_t drflac_oggbs__read_physical(drflac_oggbs* oggbs, void* bufferOut, size_t bytesToRead) +{ + size_t bytesActuallyRead = oggbs->onRead(oggbs->pUserData, bufferOut, bytesToRead); + oggbs->currentBytePos += bytesActuallyRead; + + return bytesActuallyRead; +} + +static drflac_bool32 drflac_oggbs__seek_physical(drflac_oggbs* oggbs, drflac_uint64 offset, drflac_seek_origin origin) +{ + if (origin == drflac_seek_origin_start) { + if (offset <= 0x7FFFFFFF) { + if (!oggbs->onSeek(oggbs->pUserData, (int)offset, drflac_seek_origin_start)) { + return DRFLAC_FALSE; + } + oggbs->currentBytePos = offset; + + return DRFLAC_TRUE; + } else { + if (!oggbs->onSeek(oggbs->pUserData, 0x7FFFFFFF, drflac_seek_origin_start)) { + return DRFLAC_FALSE; + } + oggbs->currentBytePos = offset; + + return drflac_oggbs__seek_physical(oggbs, offset - 0x7FFFFFFF, drflac_seek_origin_current); + } + } else { + while (offset > 0x7FFFFFFF) { + if (!oggbs->onSeek(oggbs->pUserData, 0x7FFFFFFF, drflac_seek_origin_current)) { + return DRFLAC_FALSE; + } + oggbs->currentBytePos += 0x7FFFFFFF; + offset -= 0x7FFFFFFF; + } + + if (!oggbs->onSeek(oggbs->pUserData, (int)offset, drflac_seek_origin_current)) { /* <-- Safe cast thanks to the loop above. */ + return DRFLAC_FALSE; + } + oggbs->currentBytePos += offset; + + return DRFLAC_TRUE; + } +} + +static drflac_bool32 drflac_oggbs__goto_next_page(drflac_oggbs* oggbs, drflac_ogg_crc_mismatch_recovery recoveryMethod) +{ + drflac_ogg_page_header header; + for (;;) { + drflac_uint32 crc32 = 0; + drflac_uint32 bytesRead; + drflac_uint32 pageBodySize; +#ifndef DR_FLAC_NO_CRC + drflac_uint32 actualCRC32; +#endif + + if (drflac_ogg__read_page_header(oggbs->onRead, oggbs->pUserData, &header, &bytesRead, &crc32) != DRFLAC_SUCCESS) { + return DRFLAC_FALSE; + } + oggbs->currentBytePos += bytesRead; + + pageBodySize = drflac_ogg__get_page_body_size(&header); + if (pageBodySize > DRFLAC_OGG_MAX_PAGE_SIZE) { + continue; /* Invalid page size. Assume it's corrupted and just move to the next page. */ + } + + if (header.serialNumber != oggbs->serialNumber) { + /* It's not a FLAC page. Skip it. */ + if (pageBodySize > 0 && !drflac_oggbs__seek_physical(oggbs, pageBodySize, drflac_seek_origin_current)) { + return DRFLAC_FALSE; + } + continue; + } + + + /* We need to read the entire page and then do a CRC check on it. If there's a CRC mismatch we need to skip this page. */ + if (drflac_oggbs__read_physical(oggbs, oggbs->pageData, pageBodySize) != pageBodySize) { + return DRFLAC_FALSE; + } + oggbs->pageDataSize = pageBodySize; + +#ifndef DR_FLAC_NO_CRC + actualCRC32 = drflac_crc32_buffer(crc32, oggbs->pageData, oggbs->pageDataSize); + if (actualCRC32 != header.checksum) { + if (recoveryMethod == drflac_ogg_recover_on_crc_mismatch) { + continue; /* CRC mismatch. Skip this page. */ + } else { + /* + Even though we are failing on a CRC mismatch, we still want our stream to be in a good state. Therefore we + go to the next valid page to ensure we're in a good state, but return false to let the caller know that the + seek did not fully complete. + */ + drflac_oggbs__goto_next_page(oggbs, drflac_ogg_recover_on_crc_mismatch); + return DRFLAC_FALSE; + } + } +#else + (void)recoveryMethod; /* <-- Silence a warning. */ +#endif + + oggbs->currentPageHeader = header; + oggbs->bytesRemainingInPage = pageBodySize; + return DRFLAC_TRUE; + } +} + +/* Function below is unused at the moment, but I might be re-adding it later. */ +#if 0 +static drflac_uint8 drflac_oggbs__get_current_segment_index(drflac_oggbs* oggbs, drflac_uint8* pBytesRemainingInSeg) +{ + drflac_uint32 bytesConsumedInPage = drflac_ogg__get_page_body_size(&oggbs->currentPageHeader) - oggbs->bytesRemainingInPage; + drflac_uint8 iSeg = 0; + drflac_uint32 iByte = 0; + while (iByte < bytesConsumedInPage) { + drflac_uint8 segmentSize = oggbs->currentPageHeader.segmentTable[iSeg]; + if (iByte + segmentSize > bytesConsumedInPage) { + break; + } else { + iSeg += 1; + iByte += segmentSize; + } + } + + *pBytesRemainingInSeg = oggbs->currentPageHeader.segmentTable[iSeg] - (drflac_uint8)(bytesConsumedInPage - iByte); + return iSeg; +} + +static drflac_bool32 drflac_oggbs__seek_to_next_packet(drflac_oggbs* oggbs) +{ + /* The current packet ends when we get to the segment with a lacing value of < 255 which is not at the end of a page. */ + for (;;) { + drflac_bool32 atEndOfPage = DRFLAC_FALSE; + + drflac_uint8 bytesRemainingInSeg; + drflac_uint8 iFirstSeg = drflac_oggbs__get_current_segment_index(oggbs, &bytesRemainingInSeg); + + drflac_uint32 bytesToEndOfPacketOrPage = bytesRemainingInSeg; + for (drflac_uint8 iSeg = iFirstSeg; iSeg < oggbs->currentPageHeader.segmentCount; ++iSeg) { + drflac_uint8 segmentSize = oggbs->currentPageHeader.segmentTable[iSeg]; + if (segmentSize < 255) { + if (iSeg == oggbs->currentPageHeader.segmentCount-1) { + atEndOfPage = DRFLAC_TRUE; + } + + break; + } + + bytesToEndOfPacketOrPage += segmentSize; + } + + /* + At this point we will have found either the packet or the end of the page. If were at the end of the page we'll + want to load the next page and keep searching for the end of the packet. + */ + drflac_oggbs__seek_physical(oggbs, bytesToEndOfPacketOrPage, drflac_seek_origin_current); + oggbs->bytesRemainingInPage -= bytesToEndOfPacketOrPage; + + if (atEndOfPage) { + /* + We're potentially at the next packet, but we need to check the next page first to be sure because the packet may + straddle pages. + */ + if (!drflac_oggbs__goto_next_page(oggbs)) { + return DRFLAC_FALSE; + } + + /* If it's a fresh packet it most likely means we're at the next packet. */ + if ((oggbs->currentPageHeader.headerType & 0x01) == 0) { + return DRFLAC_TRUE; + } + } else { + /* We're at the next packet. */ + return DRFLAC_TRUE; + } + } +} + +static drflac_bool32 drflac_oggbs__seek_to_next_frame(drflac_oggbs* oggbs) +{ + /* The bitstream should be sitting on the first byte just after the header of the frame. */ + + /* What we're actually doing here is seeking to the start of the next packet. */ + return drflac_oggbs__seek_to_next_packet(oggbs); +} +#endif + +static size_t drflac__on_read_ogg(void* pUserData, void* bufferOut, size_t bytesToRead) +{ + drflac_oggbs* oggbs = (drflac_oggbs*)pUserData; + drflac_uint8* pRunningBufferOut = (drflac_uint8*)bufferOut; + size_t bytesRead = 0; + + DRFLAC_ASSERT(oggbs != NULL); + DRFLAC_ASSERT(pRunningBufferOut != NULL); + + /* Reading is done page-by-page. If we've run out of bytes in the page we need to move to the next one. */ + while (bytesRead < bytesToRead) { + size_t bytesRemainingToRead = bytesToRead - bytesRead; + + if (oggbs->bytesRemainingInPage >= bytesRemainingToRead) { + DRFLAC_COPY_MEMORY(pRunningBufferOut, oggbs->pageData + (oggbs->pageDataSize - oggbs->bytesRemainingInPage), bytesRemainingToRead); + bytesRead += bytesRemainingToRead; + oggbs->bytesRemainingInPage -= (drflac_uint32)bytesRemainingToRead; + break; + } + + /* If we get here it means some of the requested data is contained in the next pages. */ + if (oggbs->bytesRemainingInPage > 0) { + DRFLAC_COPY_MEMORY(pRunningBufferOut, oggbs->pageData + (oggbs->pageDataSize - oggbs->bytesRemainingInPage), oggbs->bytesRemainingInPage); + bytesRead += oggbs->bytesRemainingInPage; + pRunningBufferOut += oggbs->bytesRemainingInPage; + oggbs->bytesRemainingInPage = 0; + } + + DRFLAC_ASSERT(bytesRemainingToRead > 0); + if (!drflac_oggbs__goto_next_page(oggbs, drflac_ogg_recover_on_crc_mismatch)) { + break; /* Failed to go to the next page. Might have simply hit the end of the stream. */ + } + } + + return bytesRead; +} + +static drflac_bool32 drflac__on_seek_ogg(void* pUserData, int offset, drflac_seek_origin origin) +{ + drflac_oggbs* oggbs = (drflac_oggbs*)pUserData; + int bytesSeeked = 0; + + DRFLAC_ASSERT(oggbs != NULL); + DRFLAC_ASSERT(offset >= 0); /* <-- Never seek backwards. */ + + /* Seeking is always forward which makes things a lot simpler. */ + if (origin == drflac_seek_origin_start) { + if (!drflac_oggbs__seek_physical(oggbs, (int)oggbs->firstBytePos, drflac_seek_origin_start)) { + return DRFLAC_FALSE; + } + + if (!drflac_oggbs__goto_next_page(oggbs, drflac_ogg_fail_on_crc_mismatch)) { + return DRFLAC_FALSE; + } + + return drflac__on_seek_ogg(pUserData, offset, drflac_seek_origin_current); + } + + DRFLAC_ASSERT(origin == drflac_seek_origin_current); + + while (bytesSeeked < offset) { + int bytesRemainingToSeek = offset - bytesSeeked; + DRFLAC_ASSERT(bytesRemainingToSeek >= 0); + + if (oggbs->bytesRemainingInPage >= (size_t)bytesRemainingToSeek) { + bytesSeeked += bytesRemainingToSeek; + (void)bytesSeeked; /* <-- Silence a dead store warning emitted by Clang Static Analyzer. */ + oggbs->bytesRemainingInPage -= bytesRemainingToSeek; + break; + } + + /* If we get here it means some of the requested data is contained in the next pages. */ + if (oggbs->bytesRemainingInPage > 0) { + bytesSeeked += (int)oggbs->bytesRemainingInPage; + oggbs->bytesRemainingInPage = 0; + } + + DRFLAC_ASSERT(bytesRemainingToSeek > 0); + if (!drflac_oggbs__goto_next_page(oggbs, drflac_ogg_fail_on_crc_mismatch)) { + /* Failed to go to the next page. We either hit the end of the stream or had a CRC mismatch. */ + return DRFLAC_FALSE; + } + } + + return DRFLAC_TRUE; +} + + +static drflac_bool32 drflac_ogg__seek_to_pcm_frame(drflac* pFlac, drflac_uint64 pcmFrameIndex) +{ + drflac_oggbs* oggbs = (drflac_oggbs*)pFlac->_oggbs; + drflac_uint64 originalBytePos; + drflac_uint64 runningGranulePosition; + drflac_uint64 runningFrameBytePos; + drflac_uint64 runningPCMFrameCount; + + DRFLAC_ASSERT(oggbs != NULL); + + originalBytePos = oggbs->currentBytePos; /* For recovery. Points to the OggS identifier. */ + + /* First seek to the first frame. */ + if (!drflac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes)) { + return DRFLAC_FALSE; + } + oggbs->bytesRemainingInPage = 0; + + runningGranulePosition = 0; + for (;;) { + if (!drflac_oggbs__goto_next_page(oggbs, drflac_ogg_recover_on_crc_mismatch)) { + drflac_oggbs__seek_physical(oggbs, originalBytePos, drflac_seek_origin_start); + return DRFLAC_FALSE; /* Never did find that sample... */ + } + + runningFrameBytePos = oggbs->currentBytePos - drflac_ogg__get_page_header_size(&oggbs->currentPageHeader) - oggbs->pageDataSize; + if (oggbs->currentPageHeader.granulePosition >= pcmFrameIndex) { + break; /* The sample is somewhere in the previous page. */ + } + + /* + At this point we know the sample is not in the previous page. It could possibly be in this page. For simplicity we + disregard any pages that do not begin a fresh packet. + */ + if ((oggbs->currentPageHeader.headerType & 0x01) == 0) { /* <-- Is it a fresh page? */ + if (oggbs->currentPageHeader.segmentTable[0] >= 2) { + drflac_uint8 firstBytesInPage[2]; + firstBytesInPage[0] = oggbs->pageData[0]; + firstBytesInPage[1] = oggbs->pageData[1]; + + if ((firstBytesInPage[0] == 0xFF) && (firstBytesInPage[1] & 0xFC) == 0xF8) { /* <-- Does the page begin with a frame's sync code? */ + runningGranulePosition = oggbs->currentPageHeader.granulePosition; + } + + continue; + } + } + } + + /* + We found the page that that is closest to the sample, so now we need to find it. The first thing to do is seek to the + start of that page. In the loop above we checked that it was a fresh page which means this page is also the start of + a new frame. This property means that after we've seeked to the page we can immediately start looping over frames until + we find the one containing the target sample. + */ + if (!drflac_oggbs__seek_physical(oggbs, runningFrameBytePos, drflac_seek_origin_start)) { + return DRFLAC_FALSE; + } + if (!drflac_oggbs__goto_next_page(oggbs, drflac_ogg_recover_on_crc_mismatch)) { + return DRFLAC_FALSE; + } + + /* + At this point we'll be sitting on the first byte of the frame header of the first frame in the page. We just keep + looping over these frames until we find the one containing the sample we're after. + */ + runningPCMFrameCount = runningGranulePosition; + for (;;) { + /* + There are two ways to find the sample and seek past irrelevant frames: + 1) Use the native FLAC decoder. + 2) Use Ogg's framing system. + + Both of these options have their own pros and cons. Using the native FLAC decoder is slower because it needs to + do a full decode of the frame. Using Ogg's framing system is faster, but more complicated and involves some code + duplication for the decoding of frame headers. + + Another thing to consider is that using the Ogg framing system will perform direct seeking of the physical Ogg + bitstream. This is important to consider because it means we cannot read data from the drflac_bs object using the + standard drflac__*() APIs because that will read in extra data for its own internal caching which in turn breaks + the positioning of the read pointer of the physical Ogg bitstream. Therefore, anything that would normally be read + using the native FLAC decoding APIs, such as drflac__read_next_flac_frame_header(), need to be re-implemented so as to + avoid the use of the drflac_bs object. + + Considering these issues, I have decided to use the slower native FLAC decoding method for the following reasons: + 1) Seeking is already partially accelerated using Ogg's paging system in the code block above. + 2) Seeking in an Ogg encapsulated FLAC stream is probably quite uncommon. + 3) Simplicity. + */ + drflac_uint64 firstPCMFrameInFLACFrame = 0; + drflac_uint64 lastPCMFrameInFLACFrame = 0; + drflac_uint64 pcmFrameCountInThisFrame; + + if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + return DRFLAC_FALSE; + } + + drflac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame); + + pcmFrameCountInThisFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1; + + /* If we are seeking to the end of the file and we've just hit it, we're done. */ + if (pcmFrameIndex == pFlac->totalPCMFrameCount && (runningPCMFrameCount + pcmFrameCountInThisFrame) == pFlac->totalPCMFrameCount) { + drflac_result result = drflac__decode_flac_frame(pFlac); + if (result == DRFLAC_SUCCESS) { + pFlac->currentPCMFrame = pcmFrameIndex; + pFlac->currentFLACFrame.pcmFramesRemaining = 0; + return DRFLAC_TRUE; + } else { + return DRFLAC_FALSE; + } + } + + if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFrame)) { + /* + The sample should be in this FLAC frame. We need to fully decode it, however if it's an invalid frame (a CRC mismatch), we need to pretend + it never existed and keep iterating. + */ + drflac_result result = drflac__decode_flac_frame(pFlac); + if (result == DRFLAC_SUCCESS) { + /* The frame is valid. We just need to skip over some samples to ensure it's sample-exact. */ + drflac_uint64 pcmFramesToDecode = (size_t)(pcmFrameIndex - runningPCMFrameCount); /* <-- Safe cast because the maximum number of samples in a frame is 65535. */ + if (pcmFramesToDecode == 0) { + return DRFLAC_TRUE; + } + + pFlac->currentPCMFrame = runningPCMFrameCount; + + return drflac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode; /* <-- If this fails, something bad has happened (it should never fail). */ + } else { + if (result == DRFLAC_CRC_MISMATCH) { + continue; /* CRC mismatch. Pretend this frame never existed. */ + } else { + return DRFLAC_FALSE; + } + } + } else { + /* + It's not in this frame. We need to seek past the frame, but check if there was a CRC mismatch. If so, we pretend this + frame never existed and leave the running sample count untouched. + */ + drflac_result result = drflac__seek_to_next_flac_frame(pFlac); + if (result == DRFLAC_SUCCESS) { + runningPCMFrameCount += pcmFrameCountInThisFrame; + } else { + if (result == DRFLAC_CRC_MISMATCH) { + continue; /* CRC mismatch. Pretend this frame never existed. */ + } else { + return DRFLAC_FALSE; + } + } + } + } +} + + + +static drflac_bool32 drflac__init_private__ogg(drflac_init_info* pInit, drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, void* pUserData, void* pUserDataMD, drflac_bool32 relaxed) +{ + drflac_ogg_page_header header; + drflac_uint32 crc32 = DRFLAC_OGG_CAPTURE_PATTERN_CRC32; + drflac_uint32 bytesRead = 0; + + /* Pre Condition: The bit stream should be sitting just past the 4-byte OggS capture pattern. */ + (void)relaxed; + + pInit->container = drflac_container_ogg; + pInit->oggFirstBytePos = 0; + + /* + We'll get here if the first 4 bytes of the stream were the OggS capture pattern, however it doesn't necessarily mean the + stream includes FLAC encoded audio. To check for this we need to scan the beginning-of-stream page markers and check if + any match the FLAC specification. Important to keep in mind that the stream may be multiplexed. + */ + if (drflac_ogg__read_page_header_after_capture_pattern(onRead, pUserData, &header, &bytesRead, &crc32) != DRFLAC_SUCCESS) { + return DRFLAC_FALSE; + } + pInit->runningFilePos += bytesRead; + + for (;;) { + int pageBodySize; + + /* Break if we're past the beginning of stream page. */ + if ((header.headerType & 0x02) == 0) { + return DRFLAC_FALSE; + } + + /* Check if it's a FLAC header. */ + pageBodySize = drflac_ogg__get_page_body_size(&header); + if (pageBodySize == 51) { /* 51 = the lacing value of the FLAC header packet. */ + /* It could be a FLAC page... */ + drflac_uint32 bytesRemainingInPage = pageBodySize; + drflac_uint8 packetType; + + if (onRead(pUserData, &packetType, 1) != 1) { + return DRFLAC_FALSE; + } + + bytesRemainingInPage -= 1; + if (packetType == 0x7F) { + /* Increasingly more likely to be a FLAC page... */ + drflac_uint8 sig[4]; + if (onRead(pUserData, sig, 4) != 4) { + return DRFLAC_FALSE; + } + + bytesRemainingInPage -= 4; + if (sig[0] == 'F' && sig[1] == 'L' && sig[2] == 'A' && sig[3] == 'C') { + /* Almost certainly a FLAC page... */ + drflac_uint8 mappingVersion[2]; + if (onRead(pUserData, mappingVersion, 2) != 2) { + return DRFLAC_FALSE; + } + + if (mappingVersion[0] != 1) { + return DRFLAC_FALSE; /* Only supporting version 1.x of the Ogg mapping. */ + } + + /* + The next 2 bytes are the non-audio packets, not including this one. We don't care about this because we're going to + be handling it in a generic way based on the serial number and packet types. + */ + if (!onSeek(pUserData, 2, drflac_seek_origin_current)) { + return DRFLAC_FALSE; + } + + /* Expecting the native FLAC signature "fLaC". */ + if (onRead(pUserData, sig, 4) != 4) { + return DRFLAC_FALSE; + } + + if (sig[0] == 'f' && sig[1] == 'L' && sig[2] == 'a' && sig[3] == 'C') { + /* The remaining data in the page should be the STREAMINFO block. */ + drflac_streaminfo streaminfo; + drflac_uint8 isLastBlock; + drflac_uint8 blockType; + drflac_uint32 blockSize; + if (!drflac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize)) { + return DRFLAC_FALSE; + } + + if (blockType != DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO || blockSize != 34) { + return DRFLAC_FALSE; /* Invalid block type. First block must be the STREAMINFO block. */ + } + + if (drflac__read_streaminfo(onRead, pUserData, &streaminfo)) { + /* Success! */ + pInit->hasStreamInfoBlock = DRFLAC_TRUE; + pInit->sampleRate = streaminfo.sampleRate; + pInit->channels = streaminfo.channels; + pInit->bitsPerSample = streaminfo.bitsPerSample; + pInit->totalPCMFrameCount = streaminfo.totalPCMFrameCount; + pInit->maxBlockSizeInPCMFrames = streaminfo.maxBlockSizeInPCMFrames; + pInit->hasMetadataBlocks = !isLastBlock; + + if (onMeta) { + drflac_metadata metadata; + metadata.type = DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO; + metadata.pRawData = NULL; + metadata.rawDataSize = 0; + metadata.data.streaminfo = streaminfo; + onMeta(pUserDataMD, &metadata); + } + + pInit->runningFilePos += pageBodySize; + pInit->oggFirstBytePos = pInit->runningFilePos - 79; /* Subtracting 79 will place us right on top of the "OggS" identifier of the FLAC bos page. */ + pInit->oggSerial = header.serialNumber; + pInit->oggBosHeader = header; + break; + } else { + /* Failed to read STREAMINFO block. Aww, so close... */ + return DRFLAC_FALSE; + } + } else { + /* Invalid file. */ + return DRFLAC_FALSE; + } + } else { + /* Not a FLAC header. Skip it. */ + if (!onSeek(pUserData, bytesRemainingInPage, drflac_seek_origin_current)) { + return DRFLAC_FALSE; + } + } + } else { + /* Not a FLAC header. Seek past the entire page and move on to the next. */ + if (!onSeek(pUserData, bytesRemainingInPage, drflac_seek_origin_current)) { + return DRFLAC_FALSE; + } + } + } else { + if (!onSeek(pUserData, pageBodySize, drflac_seek_origin_current)) { + return DRFLAC_FALSE; + } + } + + pInit->runningFilePos += pageBodySize; + + + /* Read the header of the next page. */ + if (drflac_ogg__read_page_header(onRead, pUserData, &header, &bytesRead, &crc32) != DRFLAC_SUCCESS) { + return DRFLAC_FALSE; + } + pInit->runningFilePos += bytesRead; + } + + /* + If we get here it means we found a FLAC audio stream. We should be sitting on the first byte of the header of the next page. The next + packets in the FLAC logical stream contain the metadata. The only thing left to do in the initialization phase for Ogg is to create the + Ogg bistream object. + */ + pInit->hasMetadataBlocks = DRFLAC_TRUE; /* <-- Always have at least VORBIS_COMMENT metadata block. */ + return DRFLAC_TRUE; +} +#endif + +static drflac_bool32 drflac__init_private(drflac_init_info* pInit, drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, drflac_container container, void* pUserData, void* pUserDataMD) +{ + drflac_bool32 relaxed; + drflac_uint8 id[4]; + + if (pInit == NULL || onRead == NULL || onSeek == NULL) { + return DRFLAC_FALSE; + } + + DRFLAC_ZERO_MEMORY(pInit, sizeof(*pInit)); + pInit->onRead = onRead; + pInit->onSeek = onSeek; + pInit->onMeta = onMeta; + pInit->container = container; + pInit->pUserData = pUserData; + pInit->pUserDataMD = pUserDataMD; + + pInit->bs.onRead = onRead; + pInit->bs.onSeek = onSeek; + pInit->bs.pUserData = pUserData; + drflac__reset_cache(&pInit->bs); + + + /* If the container is explicitly defined then we can try opening in relaxed mode. */ + relaxed = container != drflac_container_unknown; + + /* Skip over any ID3 tags. */ + for (;;) { + if (onRead(pUserData, id, 4) != 4) { + return DRFLAC_FALSE; /* Ran out of data. */ + } + pInit->runningFilePos += 4; + + if (id[0] == 'I' && id[1] == 'D' && id[2] == '3') { + drflac_uint8 header[6]; + drflac_uint8 flags; + drflac_uint32 headerSize; + + if (onRead(pUserData, header, 6) != 6) { + return DRFLAC_FALSE; /* Ran out of data. */ + } + pInit->runningFilePos += 6; + + flags = header[1]; + + DRFLAC_COPY_MEMORY(&headerSize, header+2, 4); + headerSize = drflac__unsynchsafe_32(drflac__be2host_32(headerSize)); + if (flags & 0x10) { + headerSize += 10; + } + + if (!onSeek(pUserData, headerSize, drflac_seek_origin_current)) { + return DRFLAC_FALSE; /* Failed to seek past the tag. */ + } + pInit->runningFilePos += headerSize; + } else { + break; + } + } + + if (id[0] == 'f' && id[1] == 'L' && id[2] == 'a' && id[3] == 'C') { + return drflac__init_private__native(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed); + } +#ifndef DR_FLAC_NO_OGG + if (id[0] == 'O' && id[1] == 'g' && id[2] == 'g' && id[3] == 'S') { + return drflac__init_private__ogg(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed); + } +#endif + + /* If we get here it means we likely don't have a header. Try opening in relaxed mode, if applicable. */ + if (relaxed) { + if (container == drflac_container_native) { + return drflac__init_private__native(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed); + } +#ifndef DR_FLAC_NO_OGG + if (container == drflac_container_ogg) { + return drflac__init_private__ogg(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed); + } +#endif + } + + /* Unsupported container. */ + return DRFLAC_FALSE; +} + +static void drflac__init_from_info(drflac* pFlac, const drflac_init_info* pInit) +{ + DRFLAC_ASSERT(pFlac != NULL); + DRFLAC_ASSERT(pInit != NULL); + + DRFLAC_ZERO_MEMORY(pFlac, sizeof(*pFlac)); + pFlac->bs = pInit->bs; + pFlac->onMeta = pInit->onMeta; + pFlac->pUserDataMD = pInit->pUserDataMD; + pFlac->maxBlockSizeInPCMFrames = pInit->maxBlockSizeInPCMFrames; + pFlac->sampleRate = pInit->sampleRate; + pFlac->channels = (drflac_uint8)pInit->channels; + pFlac->bitsPerSample = (drflac_uint8)pInit->bitsPerSample; + pFlac->totalPCMFrameCount = pInit->totalPCMFrameCount; + pFlac->container = pInit->container; +} + + +static drflac* drflac_open_with_metadata_private(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, drflac_container container, void* pUserData, void* pUserDataMD, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac_init_info init; + drflac_uint32 allocationSize; + drflac_uint32 wholeSIMDVectorCountPerChannel; + drflac_uint32 decodedSamplesAllocationSize; +#ifndef DR_FLAC_NO_OGG + drflac_oggbs oggbs; +#endif + drflac_uint64 firstFramePos; + drflac_uint64 seektablePos; + drflac_uint32 seektableSize; + drflac_allocation_callbacks allocationCallbacks; + drflac* pFlac; + + /* CPU support first. */ + drflac__init_cpu_caps(); + + if (!drflac__init_private(&init, onRead, onSeek, onMeta, container, pUserData, pUserDataMD)) { + return NULL; + } + + if (pAllocationCallbacks != NULL) { + allocationCallbacks = *pAllocationCallbacks; + if (allocationCallbacks.onFree == NULL || (allocationCallbacks.onMalloc == NULL && allocationCallbacks.onRealloc == NULL)) { + return NULL; /* Invalid allocation callbacks. */ + } + } else { + allocationCallbacks.pUserData = NULL; + allocationCallbacks.onMalloc = drflac__malloc_default; + allocationCallbacks.onRealloc = drflac__realloc_default; + allocationCallbacks.onFree = drflac__free_default; + } + + + /* + The size of the allocation for the drflac object needs to be large enough to fit the following: + 1) The main members of the drflac structure + 2) A block of memory large enough to store the decoded samples of the largest frame in the stream + 3) If the container is Ogg, a drflac_oggbs object + + The complicated part of the allocation is making sure there's enough room the decoded samples, taking into consideration + the different SIMD instruction sets. + */ + allocationSize = sizeof(drflac); + + /* + The allocation size for decoded frames depends on the number of 32-bit integers that fit inside the largest SIMD vector + we are supporting. + */ + if ((init.maxBlockSizeInPCMFrames % (DRFLAC_MAX_SIMD_VECTOR_SIZE / sizeof(drflac_int32))) == 0) { + wholeSIMDVectorCountPerChannel = (init.maxBlockSizeInPCMFrames / (DRFLAC_MAX_SIMD_VECTOR_SIZE / sizeof(drflac_int32))); + } else { + wholeSIMDVectorCountPerChannel = (init.maxBlockSizeInPCMFrames / (DRFLAC_MAX_SIMD_VECTOR_SIZE / sizeof(drflac_int32))) + 1; + } + + decodedSamplesAllocationSize = wholeSIMDVectorCountPerChannel * DRFLAC_MAX_SIMD_VECTOR_SIZE * init.channels; + + allocationSize += decodedSamplesAllocationSize; + allocationSize += DRFLAC_MAX_SIMD_VECTOR_SIZE; /* Allocate extra bytes to ensure we have enough for alignment. */ + +#ifndef DR_FLAC_NO_OGG + /* There's additional data required for Ogg streams. */ + if (init.container == drflac_container_ogg) { + allocationSize += sizeof(drflac_oggbs); + } + + DRFLAC_ZERO_MEMORY(&oggbs, sizeof(oggbs)); + if (init.container == drflac_container_ogg) { + oggbs.onRead = onRead; + oggbs.onSeek = onSeek; + oggbs.pUserData = pUserData; + oggbs.currentBytePos = init.oggFirstBytePos; + oggbs.firstBytePos = init.oggFirstBytePos; + oggbs.serialNumber = init.oggSerial; + oggbs.bosPageHeader = init.oggBosHeader; + oggbs.bytesRemainingInPage = 0; + } +#endif + + /* + This part is a bit awkward. We need to load the seektable so that it can be referenced in-memory, but I want the drflac object to + consist of only a single heap allocation. To this, the size of the seek table needs to be known, which we determine when reading + and decoding the metadata. + */ + firstFramePos = 42; /* <-- We know we are at byte 42 at this point. */ + seektablePos = 0; + seektableSize = 0; + if (init.hasMetadataBlocks) { + drflac_read_proc onReadOverride = onRead; + drflac_seek_proc onSeekOverride = onSeek; + void* pUserDataOverride = pUserData; + +#ifndef DR_FLAC_NO_OGG + if (init.container == drflac_container_ogg) { + onReadOverride = drflac__on_read_ogg; + onSeekOverride = drflac__on_seek_ogg; + pUserDataOverride = (void*)&oggbs; + } +#endif + + if (!drflac__read_and_decode_metadata(onReadOverride, onSeekOverride, onMeta, pUserDataOverride, pUserDataMD, &firstFramePos, &seektablePos, &seektableSize, &allocationCallbacks)) { + return NULL; + } + + allocationSize += seektableSize; + } + + + pFlac = (drflac*)drflac__malloc_from_callbacks(allocationSize, &allocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + drflac__init_from_info(pFlac, &init); + pFlac->allocationCallbacks = allocationCallbacks; + pFlac->pDecodedSamples = (drflac_int32*)drflac_align((size_t)pFlac->pExtraData, DRFLAC_MAX_SIMD_VECTOR_SIZE); + +#ifndef DR_FLAC_NO_OGG + if (init.container == drflac_container_ogg) { + drflac_oggbs* pInternalOggbs = (drflac_oggbs*)((drflac_uint8*)pFlac->pDecodedSamples + decodedSamplesAllocationSize + seektableSize); + *pInternalOggbs = oggbs; + + /* The Ogg bistream needs to be layered on top of the original bitstream. */ + pFlac->bs.onRead = drflac__on_read_ogg; + pFlac->bs.onSeek = drflac__on_seek_ogg; + pFlac->bs.pUserData = (void*)pInternalOggbs; + pFlac->_oggbs = (void*)pInternalOggbs; + } +#endif + + pFlac->firstFLACFramePosInBytes = firstFramePos; + + /* NOTE: Seektables are not currently compatible with Ogg encapsulation (Ogg has its own accelerated seeking system). I may change this later, so I'm leaving this here for now. */ +#ifndef DR_FLAC_NO_OGG + if (init.container == drflac_container_ogg) + { + pFlac->pSeekpoints = NULL; + pFlac->seekpointCount = 0; + } + else +#endif + { + /* If we have a seektable we need to load it now, making sure we move back to where we were previously. */ + if (seektablePos != 0) { + pFlac->seekpointCount = seektableSize / sizeof(*pFlac->pSeekpoints); + pFlac->pSeekpoints = (drflac_seekpoint*)((drflac_uint8*)pFlac->pDecodedSamples + decodedSamplesAllocationSize); + + DRFLAC_ASSERT(pFlac->bs.onSeek != NULL); + DRFLAC_ASSERT(pFlac->bs.onRead != NULL); + + /* Seek to the seektable, then just read directly into our seektable buffer. */ + if (pFlac->bs.onSeek(pFlac->bs.pUserData, (int)seektablePos, drflac_seek_origin_start)) { + if (pFlac->bs.onRead(pFlac->bs.pUserData, pFlac->pSeekpoints, seektableSize) == seektableSize) { + /* Endian swap. */ + drflac_uint32 iSeekpoint; + for (iSeekpoint = 0; iSeekpoint < pFlac->seekpointCount; ++iSeekpoint) { + pFlac->pSeekpoints[iSeekpoint].firstPCMFrame = drflac__be2host_64(pFlac->pSeekpoints[iSeekpoint].firstPCMFrame); + pFlac->pSeekpoints[iSeekpoint].flacFrameOffset = drflac__be2host_64(pFlac->pSeekpoints[iSeekpoint].flacFrameOffset); + pFlac->pSeekpoints[iSeekpoint].pcmFrameCount = drflac__be2host_16(pFlac->pSeekpoints[iSeekpoint].pcmFrameCount); + } + } else { + /* Failed to read the seektable. Pretend we don't have one. */ + pFlac->pSeekpoints = NULL; + pFlac->seekpointCount = 0; + } + + /* We need to seek back to where we were. If this fails it's a critical error. */ + if (!pFlac->bs.onSeek(pFlac->bs.pUserData, (int)pFlac->firstFLACFramePosInBytes, drflac_seek_origin_start)) { + drflac__free_from_callbacks(pFlac, &allocationCallbacks); + return NULL; + } + } else { + /* Failed to seek to the seektable. Ominous sign, but for now we can just pretend we don't have one. */ + pFlac->pSeekpoints = NULL; + pFlac->seekpointCount = 0; + } + } + } + + + /* + If we get here, but don't have a STREAMINFO block, it means we've opened the stream in relaxed mode and need to decode + the first frame. + */ + if (!init.hasStreamInfoBlock) { + pFlac->currentFLACFrame.header = init.firstFrameHeader; + for (;;) { + drflac_result result = drflac__decode_flac_frame(pFlac); + if (result == DRFLAC_SUCCESS) { + break; + } else { + if (result == DRFLAC_CRC_MISMATCH) { + if (!drflac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) { + drflac__free_from_callbacks(pFlac, &allocationCallbacks); + return NULL; + } + continue; + } else { + drflac__free_from_callbacks(pFlac, &allocationCallbacks); + return NULL; + } + } + } + } + + return pFlac; +} + + + +#ifndef DR_FLAC_NO_STDIO +#include +#include /* For wcslen(), wcsrtombs() */ + +/* drflac_result_from_errno() is only used for fopen() and wfopen() so putting it inside DR_WAV_NO_STDIO for now. If something else needs this later we can move it out. */ +#include +static drflac_result drflac_result_from_errno(int e) +{ + switch (e) + { + case 0: return DRFLAC_SUCCESS; + #ifdef EPERM + case EPERM: return DRFLAC_INVALID_OPERATION; + #endif + #ifdef ENOENT + case ENOENT: return DRFLAC_DOES_NOT_EXIST; + #endif + #ifdef ESRCH + case ESRCH: return DRFLAC_DOES_NOT_EXIST; + #endif + #ifdef EINTR + case EINTR: return DRFLAC_INTERRUPT; + #endif + #ifdef EIO + case EIO: return DRFLAC_IO_ERROR; + #endif + #ifdef ENXIO + case ENXIO: return DRFLAC_DOES_NOT_EXIST; + #endif + #ifdef E2BIG + case E2BIG: return DRFLAC_INVALID_ARGS; + #endif + #ifdef ENOEXEC + case ENOEXEC: return DRFLAC_INVALID_FILE; + #endif + #ifdef EBADF + case EBADF: return DRFLAC_INVALID_FILE; + #endif + #ifdef ECHILD + case ECHILD: return DRFLAC_ERROR; + #endif + #ifdef EAGAIN + case EAGAIN: return DRFLAC_UNAVAILABLE; + #endif + #ifdef ENOMEM + case ENOMEM: return DRFLAC_OUT_OF_MEMORY; + #endif + #ifdef EACCES + case EACCES: return DRFLAC_ACCESS_DENIED; + #endif + #ifdef EFAULT + case EFAULT: return DRFLAC_BAD_ADDRESS; + #endif + #ifdef ENOTBLK + case ENOTBLK: return DRFLAC_ERROR; + #endif + #ifdef EBUSY + case EBUSY: return DRFLAC_BUSY; + #endif + #ifdef EEXIST + case EEXIST: return DRFLAC_ALREADY_EXISTS; + #endif + #ifdef EXDEV + case EXDEV: return DRFLAC_ERROR; + #endif + #ifdef ENODEV + case ENODEV: return DRFLAC_DOES_NOT_EXIST; + #endif + #ifdef ENOTDIR + case ENOTDIR: return DRFLAC_NOT_DIRECTORY; + #endif + #ifdef EISDIR + case EISDIR: return DRFLAC_IS_DIRECTORY; + #endif + #ifdef EINVAL + case EINVAL: return DRFLAC_INVALID_ARGS; + #endif + #ifdef ENFILE + case ENFILE: return DRFLAC_TOO_MANY_OPEN_FILES; + #endif + #ifdef EMFILE + case EMFILE: return DRFLAC_TOO_MANY_OPEN_FILES; + #endif + #ifdef ENOTTY + case ENOTTY: return DRFLAC_INVALID_OPERATION; + #endif + #ifdef ETXTBSY + case ETXTBSY: return DRFLAC_BUSY; + #endif + #ifdef EFBIG + case EFBIG: return DRFLAC_TOO_BIG; + #endif + #ifdef ENOSPC + case ENOSPC: return DRFLAC_NO_SPACE; + #endif + #ifdef ESPIPE + case ESPIPE: return DRFLAC_BAD_SEEK; + #endif + #ifdef EROFS + case EROFS: return DRFLAC_ACCESS_DENIED; + #endif + #ifdef EMLINK + case EMLINK: return DRFLAC_TOO_MANY_LINKS; + #endif + #ifdef EPIPE + case EPIPE: return DRFLAC_BAD_PIPE; + #endif + #ifdef EDOM + case EDOM: return DRFLAC_OUT_OF_RANGE; + #endif + #ifdef ERANGE + case ERANGE: return DRFLAC_OUT_OF_RANGE; + #endif + #ifdef EDEADLK + case EDEADLK: return DRFLAC_DEADLOCK; + #endif + #ifdef ENAMETOOLONG + case ENAMETOOLONG: return DRFLAC_PATH_TOO_LONG; + #endif + #ifdef ENOLCK + case ENOLCK: return DRFLAC_ERROR; + #endif + #ifdef ENOSYS + case ENOSYS: return DRFLAC_NOT_IMPLEMENTED; + #endif + #ifdef ENOTEMPTY + case ENOTEMPTY: return DRFLAC_DIRECTORY_NOT_EMPTY; + #endif + #ifdef ELOOP + case ELOOP: return DRFLAC_TOO_MANY_LINKS; + #endif + #ifdef ENOMSG + case ENOMSG: return DRFLAC_NO_MESSAGE; + #endif + #ifdef EIDRM + case EIDRM: return DRFLAC_ERROR; + #endif + #ifdef ECHRNG + case ECHRNG: return DRFLAC_ERROR; + #endif + #ifdef EL2NSYNC + case EL2NSYNC: return DRFLAC_ERROR; + #endif + #ifdef EL3HLT + case EL3HLT: return DRFLAC_ERROR; + #endif + #ifdef EL3RST + case EL3RST: return DRFLAC_ERROR; + #endif + #ifdef ELNRNG + case ELNRNG: return DRFLAC_OUT_OF_RANGE; + #endif + #ifdef EUNATCH + case EUNATCH: return DRFLAC_ERROR; + #endif + #ifdef ENOCSI + case ENOCSI: return DRFLAC_ERROR; + #endif + #ifdef EL2HLT + case EL2HLT: return DRFLAC_ERROR; + #endif + #ifdef EBADE + case EBADE: return DRFLAC_ERROR; + #endif + #ifdef EBADR + case EBADR: return DRFLAC_ERROR; + #endif + #ifdef EXFULL + case EXFULL: return DRFLAC_ERROR; + #endif + #ifdef ENOANO + case ENOANO: return DRFLAC_ERROR; + #endif + #ifdef EBADRQC + case EBADRQC: return DRFLAC_ERROR; + #endif + #ifdef EBADSLT + case EBADSLT: return DRFLAC_ERROR; + #endif + #ifdef EBFONT + case EBFONT: return DRFLAC_INVALID_FILE; + #endif + #ifdef ENOSTR + case ENOSTR: return DRFLAC_ERROR; + #endif + #ifdef ENODATA + case ENODATA: return DRFLAC_NO_DATA_AVAILABLE; + #endif + #ifdef ETIME + case ETIME: return DRFLAC_TIMEOUT; + #endif + #ifdef ENOSR + case ENOSR: return DRFLAC_NO_DATA_AVAILABLE; + #endif + #ifdef ENONET + case ENONET: return DRFLAC_NO_NETWORK; + #endif + #ifdef ENOPKG + case ENOPKG: return DRFLAC_ERROR; + #endif + #ifdef EREMOTE + case EREMOTE: return DRFLAC_ERROR; + #endif + #ifdef ENOLINK + case ENOLINK: return DRFLAC_ERROR; + #endif + #ifdef EADV + case EADV: return DRFLAC_ERROR; + #endif + #ifdef ESRMNT + case ESRMNT: return DRFLAC_ERROR; + #endif + #ifdef ECOMM + case ECOMM: return DRFLAC_ERROR; + #endif + #ifdef EPROTO + case EPROTO: return DRFLAC_ERROR; + #endif + #ifdef EMULTIHOP + case EMULTIHOP: return DRFLAC_ERROR; + #endif + #ifdef EDOTDOT + case EDOTDOT: return DRFLAC_ERROR; + #endif + #ifdef EBADMSG + case EBADMSG: return DRFLAC_BAD_MESSAGE; + #endif + #ifdef EOVERFLOW + case EOVERFLOW: return DRFLAC_TOO_BIG; + #endif + #ifdef ENOTUNIQ + case ENOTUNIQ: return DRFLAC_NOT_UNIQUE; + #endif + #ifdef EBADFD + case EBADFD: return DRFLAC_ERROR; + #endif + #ifdef EREMCHG + case EREMCHG: return DRFLAC_ERROR; + #endif + #ifdef ELIBACC + case ELIBACC: return DRFLAC_ACCESS_DENIED; + #endif + #ifdef ELIBBAD + case ELIBBAD: return DRFLAC_INVALID_FILE; + #endif + #ifdef ELIBSCN + case ELIBSCN: return DRFLAC_INVALID_FILE; + #endif + #ifdef ELIBMAX + case ELIBMAX: return DRFLAC_ERROR; + #endif + #ifdef ELIBEXEC + case ELIBEXEC: return DRFLAC_ERROR; + #endif + #ifdef EILSEQ + case EILSEQ: return DRFLAC_INVALID_DATA; + #endif + #ifdef ERESTART + case ERESTART: return DRFLAC_ERROR; + #endif + #ifdef ESTRPIPE + case ESTRPIPE: return DRFLAC_ERROR; + #endif + #ifdef EUSERS + case EUSERS: return DRFLAC_ERROR; + #endif + #ifdef ENOTSOCK + case ENOTSOCK: return DRFLAC_NOT_SOCKET; + #endif + #ifdef EDESTADDRREQ + case EDESTADDRREQ: return DRFLAC_NO_ADDRESS; + #endif + #ifdef EMSGSIZE + case EMSGSIZE: return DRFLAC_TOO_BIG; + #endif + #ifdef EPROTOTYPE + case EPROTOTYPE: return DRFLAC_BAD_PROTOCOL; + #endif + #ifdef ENOPROTOOPT + case ENOPROTOOPT: return DRFLAC_PROTOCOL_UNAVAILABLE; + #endif + #ifdef EPROTONOSUPPORT + case EPROTONOSUPPORT: return DRFLAC_PROTOCOL_NOT_SUPPORTED; + #endif + #ifdef ESOCKTNOSUPPORT + case ESOCKTNOSUPPORT: return DRFLAC_SOCKET_NOT_SUPPORTED; + #endif + #ifdef EOPNOTSUPP + case EOPNOTSUPP: return DRFLAC_INVALID_OPERATION; + #endif + #ifdef EPFNOSUPPORT + case EPFNOSUPPORT: return DRFLAC_PROTOCOL_FAMILY_NOT_SUPPORTED; + #endif + #ifdef EAFNOSUPPORT + case EAFNOSUPPORT: return DRFLAC_ADDRESS_FAMILY_NOT_SUPPORTED; + #endif + #ifdef EADDRINUSE + case EADDRINUSE: return DRFLAC_ALREADY_IN_USE; + #endif + #ifdef EADDRNOTAVAIL + case EADDRNOTAVAIL: return DRFLAC_ERROR; + #endif + #ifdef ENETDOWN + case ENETDOWN: return DRFLAC_NO_NETWORK; + #endif + #ifdef ENETUNREACH + case ENETUNREACH: return DRFLAC_NO_NETWORK; + #endif + #ifdef ENETRESET + case ENETRESET: return DRFLAC_NO_NETWORK; + #endif + #ifdef ECONNABORTED + case ECONNABORTED: return DRFLAC_NO_NETWORK; + #endif + #ifdef ECONNRESET + case ECONNRESET: return DRFLAC_CONNECTION_RESET; + #endif + #ifdef ENOBUFS + case ENOBUFS: return DRFLAC_NO_SPACE; + #endif + #ifdef EISCONN + case EISCONN: return DRFLAC_ALREADY_CONNECTED; + #endif + #ifdef ENOTCONN + case ENOTCONN: return DRFLAC_NOT_CONNECTED; + #endif + #ifdef ESHUTDOWN + case ESHUTDOWN: return DRFLAC_ERROR; + #endif + #ifdef ETOOMANYREFS + case ETOOMANYREFS: return DRFLAC_ERROR; + #endif + #ifdef ETIMEDOUT + case ETIMEDOUT: return DRFLAC_TIMEOUT; + #endif + #ifdef ECONNREFUSED + case ECONNREFUSED: return DRFLAC_CONNECTION_REFUSED; + #endif + #ifdef EHOSTDOWN + case EHOSTDOWN: return DRFLAC_NO_HOST; + #endif + #ifdef EHOSTUNREACH + case EHOSTUNREACH: return DRFLAC_NO_HOST; + #endif + #ifdef EALREADY + case EALREADY: return DRFLAC_IN_PROGRESS; + #endif + #ifdef EINPROGRESS + case EINPROGRESS: return DRFLAC_IN_PROGRESS; + #endif + #ifdef ESTALE + case ESTALE: return DRFLAC_INVALID_FILE; + #endif + #ifdef EUCLEAN + case EUCLEAN: return DRFLAC_ERROR; + #endif + #ifdef ENOTNAM + case ENOTNAM: return DRFLAC_ERROR; + #endif + #ifdef ENAVAIL + case ENAVAIL: return DRFLAC_ERROR; + #endif + #ifdef EISNAM + case EISNAM: return DRFLAC_ERROR; + #endif + #ifdef EREMOTEIO + case EREMOTEIO: return DRFLAC_IO_ERROR; + #endif + #ifdef EDQUOT + case EDQUOT: return DRFLAC_NO_SPACE; + #endif + #ifdef ENOMEDIUM + case ENOMEDIUM: return DRFLAC_DOES_NOT_EXIST; + #endif + #ifdef EMEDIUMTYPE + case EMEDIUMTYPE: return DRFLAC_ERROR; + #endif + #ifdef ECANCELED + case ECANCELED: return DRFLAC_CANCELLED; + #endif + #ifdef ENOKEY + case ENOKEY: return DRFLAC_ERROR; + #endif + #ifdef EKEYEXPIRED + case EKEYEXPIRED: return DRFLAC_ERROR; + #endif + #ifdef EKEYREVOKED + case EKEYREVOKED: return DRFLAC_ERROR; + #endif + #ifdef EKEYREJECTED + case EKEYREJECTED: return DRFLAC_ERROR; + #endif + #ifdef EOWNERDEAD + case EOWNERDEAD: return DRFLAC_ERROR; + #endif + #ifdef ENOTRECOVERABLE + case ENOTRECOVERABLE: return DRFLAC_ERROR; + #endif + #ifdef ERFKILL + case ERFKILL: return DRFLAC_ERROR; + #endif + #ifdef EHWPOISON + case EHWPOISON: return DRFLAC_ERROR; + #endif + default: return DRFLAC_ERROR; + } +} + +static drflac_result drflac_fopen(FILE** ppFile, const char* pFilePath, const char* pOpenMode) +{ +#if _MSC_VER && _MSC_VER >= 1400 + errno_t err; +#endif + + if (ppFile != NULL) { + *ppFile = NULL; /* Safety. */ + } + + if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) { + return DRFLAC_INVALID_ARGS; + } + +#if _MSC_VER && _MSC_VER >= 1400 + err = fopen_s(ppFile, pFilePath, pOpenMode); + if (err != 0) { + return drflac_result_from_errno(err); + } +#else +#if defined(_WIN32) || defined(__APPLE__) + *ppFile = fopen(pFilePath, pOpenMode); +#else + #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64 && defined(_LARGEFILE64_SOURCE) + *ppFile = fopen64(pFilePath, pOpenMode); + #else + *ppFile = fopen(pFilePath, pOpenMode); + #endif +#endif + if (*ppFile == NULL) { + drflac_result result = drflac_result_from_errno(errno); + if (result == DRFLAC_SUCCESS) { + result = DRFLAC_ERROR; /* Just a safety check to make sure we never ever return success when pFile == NULL. */ + } + + return result; + } +#endif + + return DRFLAC_SUCCESS; +} + +/* +_wfopen() isn't always available in all compilation environments. + + * Windows only. + * MSVC seems to support it universally as far back as VC6 from what I can tell (haven't checked further back). + * MinGW-64 (both 32- and 64-bit) seems to support it. + * MinGW wraps it in !defined(__STRICT_ANSI__). + +This can be reviewed as compatibility issues arise. The preference is to use _wfopen_s() and _wfopen() as opposed to the wcsrtombs() +fallback, so if you notice your compiler not detecting this properly I'm happy to look at adding support. +*/ +#if defined(_WIN32) + #if defined(_MSC_VER) || defined(__MINGW64__) || !defined(__STRICT_ANSI__) + #define DRFLAC_HAS_WFOPEN + #endif +#endif + +static drflac_result drflac_wfopen(FILE** ppFile, const wchar_t* pFilePath, const wchar_t* pOpenMode, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + if (ppFile != NULL) { + *ppFile = NULL; /* Safety. */ + } + + if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) { + return DRFLAC_INVALID_ARGS; + } + +#if defined(DRFLAC_HAS_WFOPEN) + { + /* Use _wfopen() on Windows. */ + #if defined(_MSC_VER) && _MSC_VER >= 1400 + errno_t err = _wfopen_s(ppFile, pFilePath, pOpenMode); + if (err != 0) { + return drflac_result_from_errno(err); + } + #else + *ppFile = _wfopen(pFilePath, pOpenMode); + if (*ppFile == NULL) { + return drflac_result_from_errno(errno); + } + #endif + (void)pAllocationCallbacks; + } +#else + /* + Use fopen() on anything other than Windows. Requires a conversion. This is annoying because fopen() is locale specific. The only real way I can + think of to do this is with wcsrtombs(). Note that wcstombs() is apparently not thread-safe because it uses a static global mbstate_t object for + maintaining state. I've checked this with -std=c89 and it works, but if somebody get's a compiler error I'll look into improving compatibility. + */ + { + mbstate_t mbs; + size_t lenMB; + const wchar_t* pFilePathTemp = pFilePath; + char* pFilePathMB = NULL; + char pOpenModeMB[32] = {0}; + + /* Get the length first. */ + DRFLAC_ZERO_OBJECT(&mbs); + lenMB = wcsrtombs(NULL, &pFilePathTemp, 0, &mbs); + if (lenMB == (size_t)-1) { + return drflac_result_from_errno(errno); + } + + pFilePathMB = (char*)drflac__malloc_from_callbacks(lenMB + 1, pAllocationCallbacks); + if (pFilePathMB == NULL) { + return DRFLAC_OUT_OF_MEMORY; + } + + pFilePathTemp = pFilePath; + DRFLAC_ZERO_OBJECT(&mbs); + wcsrtombs(pFilePathMB, &pFilePathTemp, lenMB + 1, &mbs); + + /* The open mode should always consist of ASCII characters so we should be able to do a trivial conversion. */ + { + size_t i = 0; + for (;;) { + if (pOpenMode[i] == 0) { + pOpenModeMB[i] = '\0'; + break; + } + + pOpenModeMB[i] = (char)pOpenMode[i]; + i += 1; + } + } + + *ppFile = fopen(pFilePathMB, pOpenModeMB); + + drflac__free_from_callbacks(pFilePathMB, pAllocationCallbacks); + } + + if (*ppFile == NULL) { + return DRFLAC_ERROR; + } +#endif + + return DRFLAC_SUCCESS; +} + +static size_t drflac__on_read_stdio(void* pUserData, void* bufferOut, size_t bytesToRead) +{ + return fread(bufferOut, 1, bytesToRead, (FILE*)pUserData); +} + +static drflac_bool32 drflac__on_seek_stdio(void* pUserData, int offset, drflac_seek_origin origin) +{ + DRFLAC_ASSERT(offset >= 0); /* <-- Never seek backwards. */ + + return fseek((FILE*)pUserData, offset, (origin == drflac_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0; +} + + +DRFLAC_API drflac* drflac_open_file(const char* pFileName, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + FILE* pFile; + + if (drflac_fopen(&pFile, pFileName, "rb") != DRFLAC_SUCCESS) { + return NULL; + } + + pFlac = drflac_open(drflac__on_read_stdio, drflac__on_seek_stdio, (void*)pFile, pAllocationCallbacks); + if (pFlac == NULL) { + fclose(pFile); + return NULL; + } + + return pFlac; +} + +DRFLAC_API drflac* drflac_open_file_w(const wchar_t* pFileName, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + FILE* pFile; + + if (drflac_wfopen(&pFile, pFileName, L"rb", pAllocationCallbacks) != DRFLAC_SUCCESS) { + return NULL; + } + + pFlac = drflac_open(drflac__on_read_stdio, drflac__on_seek_stdio, (void*)pFile, pAllocationCallbacks); + if (pFlac == NULL) { + fclose(pFile); + return NULL; + } + + return pFlac; +} + +DRFLAC_API drflac* drflac_open_file_with_metadata(const char* pFileName, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + FILE* pFile; + + if (drflac_fopen(&pFile, pFileName, "rb") != DRFLAC_SUCCESS) { + return NULL; + } + + pFlac = drflac_open_with_metadata_private(drflac__on_read_stdio, drflac__on_seek_stdio, onMeta, drflac_container_unknown, (void*)pFile, pUserData, pAllocationCallbacks); + if (pFlac == NULL) { + fclose(pFile); + return pFlac; + } + + return pFlac; +} + +DRFLAC_API drflac* drflac_open_file_with_metadata_w(const wchar_t* pFileName, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + FILE* pFile; + + if (drflac_wfopen(&pFile, pFileName, L"rb", pAllocationCallbacks) != DRFLAC_SUCCESS) { + return NULL; + } + + pFlac = drflac_open_with_metadata_private(drflac__on_read_stdio, drflac__on_seek_stdio, onMeta, drflac_container_unknown, (void*)pFile, pUserData, pAllocationCallbacks); + if (pFlac == NULL) { + fclose(pFile); + return pFlac; + } + + return pFlac; +} +#endif /* DR_FLAC_NO_STDIO */ + +static size_t drflac__on_read_memory(void* pUserData, void* bufferOut, size_t bytesToRead) +{ + drflac__memory_stream* memoryStream = (drflac__memory_stream*)pUserData; + size_t bytesRemaining; + + DRFLAC_ASSERT(memoryStream != NULL); + DRFLAC_ASSERT(memoryStream->dataSize >= memoryStream->currentReadPos); + + bytesRemaining = memoryStream->dataSize - memoryStream->currentReadPos; + if (bytesToRead > bytesRemaining) { + bytesToRead = bytesRemaining; + } + + if (bytesToRead > 0) { + DRFLAC_COPY_MEMORY(bufferOut, memoryStream->data + memoryStream->currentReadPos, bytesToRead); + memoryStream->currentReadPos += bytesToRead; + } + + return bytesToRead; +} + +static drflac_bool32 drflac__on_seek_memory(void* pUserData, int offset, drflac_seek_origin origin) +{ + drflac__memory_stream* memoryStream = (drflac__memory_stream*)pUserData; + + DRFLAC_ASSERT(memoryStream != NULL); + DRFLAC_ASSERT(offset >= 0); /* <-- Never seek backwards. */ + + if (offset > (drflac_int64)memoryStream->dataSize) { + return DRFLAC_FALSE; + } + + if (origin == drflac_seek_origin_current) { + if (memoryStream->currentReadPos + offset <= memoryStream->dataSize) { + memoryStream->currentReadPos += offset; + } else { + return DRFLAC_FALSE; /* Trying to seek too far forward. */ + } + } else { + if ((drflac_uint32)offset <= memoryStream->dataSize) { + memoryStream->currentReadPos = offset; + } else { + return DRFLAC_FALSE; /* Trying to seek too far forward. */ + } + } + + return DRFLAC_TRUE; +} + +DRFLAC_API drflac* drflac_open_memory(const void* pData, size_t dataSize, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac__memory_stream memoryStream; + drflac* pFlac; + + memoryStream.data = (const drflac_uint8*)pData; + memoryStream.dataSize = dataSize; + memoryStream.currentReadPos = 0; + pFlac = drflac_open(drflac__on_read_memory, drflac__on_seek_memory, &memoryStream, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + pFlac->memoryStream = memoryStream; + + /* This is an awful hack... */ +#ifndef DR_FLAC_NO_OGG + if (pFlac->container == drflac_container_ogg) + { + drflac_oggbs* oggbs = (drflac_oggbs*)pFlac->_oggbs; + oggbs->pUserData = &pFlac->memoryStream; + } + else +#endif + { + pFlac->bs.pUserData = &pFlac->memoryStream; + } + + return pFlac; +} + +DRFLAC_API drflac* drflac_open_memory_with_metadata(const void* pData, size_t dataSize, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac__memory_stream memoryStream; + drflac* pFlac; + + memoryStream.data = (const drflac_uint8*)pData; + memoryStream.dataSize = dataSize; + memoryStream.currentReadPos = 0; + pFlac = drflac_open_with_metadata_private(drflac__on_read_memory, drflac__on_seek_memory, onMeta, drflac_container_unknown, &memoryStream, pUserData, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + pFlac->memoryStream = memoryStream; + + /* This is an awful hack... */ +#ifndef DR_FLAC_NO_OGG + if (pFlac->container == drflac_container_ogg) + { + drflac_oggbs* oggbs = (drflac_oggbs*)pFlac->_oggbs; + oggbs->pUserData = &pFlac->memoryStream; + } + else +#endif + { + pFlac->bs.pUserData = &pFlac->memoryStream; + } + + return pFlac; +} + + + +DRFLAC_API drflac* drflac_open(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + return drflac_open_with_metadata_private(onRead, onSeek, NULL, drflac_container_unknown, pUserData, pUserData, pAllocationCallbacks); +} +DRFLAC_API drflac* drflac_open_relaxed(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_container container, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + return drflac_open_with_metadata_private(onRead, onSeek, NULL, container, pUserData, pUserData, pAllocationCallbacks); +} + +DRFLAC_API drflac* drflac_open_with_metadata(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + return drflac_open_with_metadata_private(onRead, onSeek, onMeta, drflac_container_unknown, pUserData, pUserData, pAllocationCallbacks); +} +DRFLAC_API drflac* drflac_open_with_metadata_relaxed(drflac_read_proc onRead, drflac_seek_proc onSeek, drflac_meta_proc onMeta, drflac_container container, void* pUserData, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + return drflac_open_with_metadata_private(onRead, onSeek, onMeta, container, pUserData, pUserData, pAllocationCallbacks); +} + +DRFLAC_API void drflac_close(drflac* pFlac) +{ + if (pFlac == NULL) { + return; + } + +#ifndef DR_FLAC_NO_STDIO + /* + If we opened the file with drflac_open_file() we will want to close the file handle. We can know whether or not drflac_open_file() + was used by looking at the callbacks. + */ + if (pFlac->bs.onRead == drflac__on_read_stdio) { + fclose((FILE*)pFlac->bs.pUserData); + } + +#ifndef DR_FLAC_NO_OGG + /* Need to clean up Ogg streams a bit differently due to the way the bit streaming is chained. */ + if (pFlac->container == drflac_container_ogg) { + drflac_oggbs* oggbs = (drflac_oggbs*)pFlac->_oggbs; + DRFLAC_ASSERT(pFlac->bs.onRead == drflac__on_read_ogg); + + if (oggbs->onRead == drflac__on_read_stdio) { + fclose((FILE*)oggbs->pUserData); + } + } +#endif +#endif + + drflac__free_from_callbacks(pFlac, &pFlac->allocationCallbacks); +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_left_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + for (i = 0; i < frameCount; ++i) { + drflac_uint32 left = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + drflac_uint32 side = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + drflac_uint32 right = left - side; + + pOutputSamples[i*2+0] = (drflac_int32)left; + pOutputSamples[i*2+1] = (drflac_int32)right; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_left_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 left0 = pInputSamples0U32[i*4+0] << shift0; + drflac_uint32 left1 = pInputSamples0U32[i*4+1] << shift0; + drflac_uint32 left2 = pInputSamples0U32[i*4+2] << shift0; + drflac_uint32 left3 = pInputSamples0U32[i*4+3] << shift0; + + drflac_uint32 side0 = pInputSamples1U32[i*4+0] << shift1; + drflac_uint32 side1 = pInputSamples1U32[i*4+1] << shift1; + drflac_uint32 side2 = pInputSamples1U32[i*4+2] << shift1; + drflac_uint32 side3 = pInputSamples1U32[i*4+3] << shift1; + + drflac_uint32 right0 = left0 - side0; + drflac_uint32 right1 = left1 - side1; + drflac_uint32 right2 = left2 - side2; + drflac_uint32 right3 = left3 - side3; + + pOutputSamples[i*8+0] = (drflac_int32)left0; + pOutputSamples[i*8+1] = (drflac_int32)right0; + pOutputSamples[i*8+2] = (drflac_int32)left1; + pOutputSamples[i*8+3] = (drflac_int32)right1; + pOutputSamples[i*8+4] = (drflac_int32)left2; + pOutputSamples[i*8+5] = (drflac_int32)right2; + pOutputSamples[i*8+6] = (drflac_int32)left3; + pOutputSamples[i*8+7] = (drflac_int32)right3; + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 left = pInputSamples0U32[i] << shift0; + drflac_uint32 side = pInputSamples1U32[i] << shift1; + drflac_uint32 right = left - side; + + pOutputSamples[i*2+0] = (drflac_int32)left; + pOutputSamples[i*2+1] = (drflac_int32)right; + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_left_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + for (i = 0; i < frameCount4; ++i) { + __m128i left = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0); + __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1); + __m128i right = _mm_sub_epi32(left, side); + + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right)); + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 left = pInputSamples0U32[i] << shift0; + drflac_uint32 side = pInputSamples1U32[i] << shift1; + drflac_uint32 right = left - side; + + pOutputSamples[i*2+0] = (drflac_int32)left; + pOutputSamples[i*2+1] = (drflac_int32)right; + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_left_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + int32x4_t shift0_4; + int32x4_t shift1_4; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + shift0_4 = vdupq_n_s32(shift0); + shift1_4 = vdupq_n_s32(shift1); + + for (i = 0; i < frameCount4; ++i) { + uint32x4_t left; + uint32x4_t side; + uint32x4_t right; + + left = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4); + side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4); + right = vsubq_u32(left, side); + + drflac__vst2q_u32((drflac_uint32*)pOutputSamples + i*8, vzipq_u32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 left = pInputSamples0U32[i] << shift0; + drflac_uint32 side = pInputSamples1U32[i] << shift1; + drflac_uint32 right = left - side; + + pOutputSamples[i*2+0] = (drflac_int32)left; + pOutputSamples[i*2+1] = (drflac_int32)right; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_left_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s32__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s32__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_s32__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_s32__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_right_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + for (i = 0; i < frameCount; ++i) { + drflac_uint32 side = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + drflac_uint32 right = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + drflac_uint32 left = right + side; + + pOutputSamples[i*2+0] = (drflac_int32)left; + pOutputSamples[i*2+1] = (drflac_int32)right; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_right_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 side0 = pInputSamples0U32[i*4+0] << shift0; + drflac_uint32 side1 = pInputSamples0U32[i*4+1] << shift0; + drflac_uint32 side2 = pInputSamples0U32[i*4+2] << shift0; + drflac_uint32 side3 = pInputSamples0U32[i*4+3] << shift0; + + drflac_uint32 right0 = pInputSamples1U32[i*4+0] << shift1; + drflac_uint32 right1 = pInputSamples1U32[i*4+1] << shift1; + drflac_uint32 right2 = pInputSamples1U32[i*4+2] << shift1; + drflac_uint32 right3 = pInputSamples1U32[i*4+3] << shift1; + + drflac_uint32 left0 = right0 + side0; + drflac_uint32 left1 = right1 + side1; + drflac_uint32 left2 = right2 + side2; + drflac_uint32 left3 = right3 + side3; + + pOutputSamples[i*8+0] = (drflac_int32)left0; + pOutputSamples[i*8+1] = (drflac_int32)right0; + pOutputSamples[i*8+2] = (drflac_int32)left1; + pOutputSamples[i*8+3] = (drflac_int32)right1; + pOutputSamples[i*8+4] = (drflac_int32)left2; + pOutputSamples[i*8+5] = (drflac_int32)right2; + pOutputSamples[i*8+6] = (drflac_int32)left3; + pOutputSamples[i*8+7] = (drflac_int32)right3; + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 side = pInputSamples0U32[i] << shift0; + drflac_uint32 right = pInputSamples1U32[i] << shift1; + drflac_uint32 left = right + side; + + pOutputSamples[i*2+0] = (drflac_int32)left; + pOutputSamples[i*2+1] = (drflac_int32)right; + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_right_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + for (i = 0; i < frameCount4; ++i) { + __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0); + __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1); + __m128i left = _mm_add_epi32(right, side); + + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right)); + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 side = pInputSamples0U32[i] << shift0; + drflac_uint32 right = pInputSamples1U32[i] << shift1; + drflac_uint32 left = right + side; + + pOutputSamples[i*2+0] = (drflac_int32)left; + pOutputSamples[i*2+1] = (drflac_int32)right; + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_right_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + int32x4_t shift0_4; + int32x4_t shift1_4; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + shift0_4 = vdupq_n_s32(shift0); + shift1_4 = vdupq_n_s32(shift1); + + for (i = 0; i < frameCount4; ++i) { + uint32x4_t side; + uint32x4_t right; + uint32x4_t left; + + side = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4); + right = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4); + left = vaddq_u32(right, side); + + drflac__vst2q_u32((drflac_uint32*)pOutputSamples + i*8, vzipq_u32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 side = pInputSamples0U32[i] << shift0; + drflac_uint32 right = pInputSamples1U32[i] << shift1; + drflac_uint32 left = right + side; + + pOutputSamples[i*2+0] = (drflac_int32)left; + pOutputSamples[i*2+1] = (drflac_int32)right; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_right_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s32__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s32__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_s32__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_s32__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_mid_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + for (drflac_uint64 i = 0; i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid + side) >> 1) << unusedBitsPerSample); + pOutputSamples[i*2+1] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid - side) >> 1) << unusedBitsPerSample); + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_mid_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_int32 shift = unusedBitsPerSample; + + if (shift > 0) { + shift -= 1; + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 temp0L; + drflac_uint32 temp1L; + drflac_uint32 temp2L; + drflac_uint32 temp3L; + drflac_uint32 temp0R; + drflac_uint32 temp1R; + drflac_uint32 temp2R; + drflac_uint32 temp3R; + + drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + + drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid0 = (mid0 << 1) | (side0 & 0x01); + mid1 = (mid1 << 1) | (side1 & 0x01); + mid2 = (mid2 << 1) | (side2 & 0x01); + mid3 = (mid3 << 1) | (side3 & 0x01); + + temp0L = (mid0 + side0) << shift; + temp1L = (mid1 + side1) << shift; + temp2L = (mid2 + side2) << shift; + temp3L = (mid3 + side3) << shift; + + temp0R = (mid0 - side0) << shift; + temp1R = (mid1 - side1) << shift; + temp2R = (mid2 - side2) << shift; + temp3R = (mid3 - side3) << shift; + + pOutputSamples[i*8+0] = (drflac_int32)temp0L; + pOutputSamples[i*8+1] = (drflac_int32)temp0R; + pOutputSamples[i*8+2] = (drflac_int32)temp1L; + pOutputSamples[i*8+3] = (drflac_int32)temp1R; + pOutputSamples[i*8+4] = (drflac_int32)temp2L; + pOutputSamples[i*8+5] = (drflac_int32)temp2R; + pOutputSamples[i*8+6] = (drflac_int32)temp3L; + pOutputSamples[i*8+7] = (drflac_int32)temp3R; + } + } else { + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 temp0L; + drflac_uint32 temp1L; + drflac_uint32 temp2L; + drflac_uint32 temp3L; + drflac_uint32 temp0R; + drflac_uint32 temp1R; + drflac_uint32 temp2R; + drflac_uint32 temp3R; + + drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + + drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid0 = (mid0 << 1) | (side0 & 0x01); + mid1 = (mid1 << 1) | (side1 & 0x01); + mid2 = (mid2 << 1) | (side2 & 0x01); + mid3 = (mid3 << 1) | (side3 & 0x01); + + temp0L = (drflac_uint32)((drflac_int32)(mid0 + side0) >> 1); + temp1L = (drflac_uint32)((drflac_int32)(mid1 + side1) >> 1); + temp2L = (drflac_uint32)((drflac_int32)(mid2 + side2) >> 1); + temp3L = (drflac_uint32)((drflac_int32)(mid3 + side3) >> 1); + + temp0R = (drflac_uint32)((drflac_int32)(mid0 - side0) >> 1); + temp1R = (drflac_uint32)((drflac_int32)(mid1 - side1) >> 1); + temp2R = (drflac_uint32)((drflac_int32)(mid2 - side2) >> 1); + temp3R = (drflac_uint32)((drflac_int32)(mid3 - side3) >> 1); + + pOutputSamples[i*8+0] = (drflac_int32)temp0L; + pOutputSamples[i*8+1] = (drflac_int32)temp0R; + pOutputSamples[i*8+2] = (drflac_int32)temp1L; + pOutputSamples[i*8+3] = (drflac_int32)temp1R; + pOutputSamples[i*8+4] = (drflac_int32)temp2L; + pOutputSamples[i*8+5] = (drflac_int32)temp2R; + pOutputSamples[i*8+6] = (drflac_int32)temp3L; + pOutputSamples[i*8+7] = (drflac_int32)temp3R; + } + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid + side) >> 1) << unusedBitsPerSample); + pOutputSamples[i*2+1] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid - side) >> 1) << unusedBitsPerSample); + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_mid_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_int32 shift = unusedBitsPerSample; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + if (shift == 0) { + for (i = 0; i < frameCount4; ++i) { + __m128i mid; + __m128i side; + __m128i left; + __m128i right; + + mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + + mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01))); + + left = _mm_srai_epi32(_mm_add_epi32(mid, side), 1); + right = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1); + + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right)); + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int32)(mid + side) >> 1; + pOutputSamples[i*2+1] = (drflac_int32)(mid - side) >> 1; + } + } else { + shift -= 1; + for (i = 0; i < frameCount4; ++i) { + __m128i mid; + __m128i side; + __m128i left; + __m128i right; + + mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + + mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01))); + + left = _mm_slli_epi32(_mm_add_epi32(mid, side), shift); + right = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift); + + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right)); + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int32)((mid + side) << shift); + pOutputSamples[i*2+1] = (drflac_int32)((mid - side) << shift); + } + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_mid_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_int32 shift = unusedBitsPerSample; + int32x4_t wbpsShift0_4; /* wbps = Wasted Bits Per Sample */ + int32x4_t wbpsShift1_4; /* wbps = Wasted Bits Per Sample */ + uint32x4_t one4; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + wbpsShift0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + wbpsShift1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + one4 = vdupq_n_u32(1); + + if (shift == 0) { + for (i = 0; i < frameCount4; ++i) { + uint32x4_t mid; + uint32x4_t side; + int32x4_t left; + int32x4_t right; + + mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4); + side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4); + + mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, one4)); + + left = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1); + right = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1); + + drflac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int32)(mid + side) >> 1; + pOutputSamples[i*2+1] = (drflac_int32)(mid - side) >> 1; + } + } else { + int32x4_t shift4; + + shift -= 1; + shift4 = vdupq_n_s32(shift); + + for (i = 0; i < frameCount4; ++i) { + uint32x4_t mid; + uint32x4_t side; + int32x4_t left; + int32x4_t right; + + mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4); + side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4); + + mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, one4)); + + left = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4)); + right = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4)); + + drflac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int32)((mid + side) << shift); + pOutputSamples[i*2+1] = (drflac_int32)((mid - side) << shift); + } + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_mid_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s32__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s32__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_s32__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_s32__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_independent_stereo__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + for (drflac_uint64 i = 0; i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int32)((drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample)); + pOutputSamples[i*2+1] = (drflac_int32)((drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample)); + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_independent_stereo__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0; + drflac_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0; + drflac_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0; + drflac_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0; + + drflac_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1; + drflac_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1; + drflac_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1; + drflac_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1; + + pOutputSamples[i*8+0] = (drflac_int32)tempL0; + pOutputSamples[i*8+1] = (drflac_int32)tempR0; + pOutputSamples[i*8+2] = (drflac_int32)tempL1; + pOutputSamples[i*8+3] = (drflac_int32)tempR1; + pOutputSamples[i*8+4] = (drflac_int32)tempL2; + pOutputSamples[i*8+5] = (drflac_int32)tempR2; + pOutputSamples[i*8+6] = (drflac_int32)tempL3; + pOutputSamples[i*8+7] = (drflac_int32)tempR3; + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0); + pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1); + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_independent_stereo__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + for (i = 0; i < frameCount4; ++i) { + __m128i left = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0); + __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1); + + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right)); + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0); + pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1); + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_independent_stereo__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + int32x4_t shift4_0 = vdupq_n_s32(shift0); + int32x4_t shift4_1 = vdupq_n_s32(shift1); + + for (i = 0; i < frameCount4; ++i) { + int32x4_t left; + int32x4_t right; + + left = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift4_0)); + right = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift4_1)); + + drflac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0); + pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1); + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s32__decode_independent_stereo(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int32* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s32__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s32__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_s32__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_s32__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + + +DRFLAC_API drflac_uint64 drflac_read_pcm_frames_s32(drflac* pFlac, drflac_uint64 framesToRead, drflac_int32* pBufferOut) +{ + drflac_uint64 framesRead; + drflac_uint32 unusedBitsPerSample; + + if (pFlac == NULL || framesToRead == 0) { + return 0; + } + + if (pBufferOut == NULL) { + return drflac__seek_forward_by_pcm_frames(pFlac, framesToRead); + } + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 32); + unusedBitsPerSample = 32 - pFlac->bitsPerSample; + + framesRead = 0; + while (framesToRead > 0) { + /* If we've run out of samples in this frame, go to the next. */ + if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) { + if (!drflac__read_and_decode_next_flac_frame(pFlac)) { + break; /* Couldn't read the next frame, so just break from the loop and return. */ + } + } else { + unsigned int channelCount = drflac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment); + drflac_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining; + drflac_uint64 frameCountThisIteration = framesToRead; + + if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) { + frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining; + } + + if (channelCount == 2) { + const drflac_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame; + const drflac_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame; + + switch (pFlac->currentFLACFrame.header.channelAssignment) + { + case DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE: + { + drflac_read_pcm_frames_s32__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + + case DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE: + { + drflac_read_pcm_frames_s32__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + + case DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE: + { + drflac_read_pcm_frames_s32__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + + case DRFLAC_CHANNEL_ASSIGNMENT_INDEPENDENT: + default: + { + drflac_read_pcm_frames_s32__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + } + } else { + /* Generic interleaving. */ + drflac_uint64 i; + for (i = 0; i < frameCountThisIteration; ++i) { + unsigned int j; + for (j = 0; j < channelCount; ++j) { + pBufferOut[(i*channelCount)+j] = (drflac_int32)((drflac_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample)); + } + } + } + + framesRead += frameCountThisIteration; + pBufferOut += frameCountThisIteration * channelCount; + framesToRead -= frameCountThisIteration; + pFlac->currentPCMFrame += frameCountThisIteration; + pFlac->currentFLACFrame.pcmFramesRemaining -= (drflac_uint32)frameCountThisIteration; + } + } + + return framesRead; +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_left_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + for (i = 0; i < frameCount; ++i) { + drflac_uint32 left = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + drflac_uint32 side = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + drflac_uint32 right = left - side; + + left >>= 16; + right >>= 16; + + pOutputSamples[i*2+0] = (drflac_int16)left; + pOutputSamples[i*2+1] = (drflac_int16)right; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_left_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 left0 = pInputSamples0U32[i*4+0] << shift0; + drflac_uint32 left1 = pInputSamples0U32[i*4+1] << shift0; + drflac_uint32 left2 = pInputSamples0U32[i*4+2] << shift0; + drflac_uint32 left3 = pInputSamples0U32[i*4+3] << shift0; + + drflac_uint32 side0 = pInputSamples1U32[i*4+0] << shift1; + drflac_uint32 side1 = pInputSamples1U32[i*4+1] << shift1; + drflac_uint32 side2 = pInputSamples1U32[i*4+2] << shift1; + drflac_uint32 side3 = pInputSamples1U32[i*4+3] << shift1; + + drflac_uint32 right0 = left0 - side0; + drflac_uint32 right1 = left1 - side1; + drflac_uint32 right2 = left2 - side2; + drflac_uint32 right3 = left3 - side3; + + left0 >>= 16; + left1 >>= 16; + left2 >>= 16; + left3 >>= 16; + + right0 >>= 16; + right1 >>= 16; + right2 >>= 16; + right3 >>= 16; + + pOutputSamples[i*8+0] = (drflac_int16)left0; + pOutputSamples[i*8+1] = (drflac_int16)right0; + pOutputSamples[i*8+2] = (drflac_int16)left1; + pOutputSamples[i*8+3] = (drflac_int16)right1; + pOutputSamples[i*8+4] = (drflac_int16)left2; + pOutputSamples[i*8+5] = (drflac_int16)right2; + pOutputSamples[i*8+6] = (drflac_int16)left3; + pOutputSamples[i*8+7] = (drflac_int16)right3; + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 left = pInputSamples0U32[i] << shift0; + drflac_uint32 side = pInputSamples1U32[i] << shift1; + drflac_uint32 right = left - side; + + left >>= 16; + right >>= 16; + + pOutputSamples[i*2+0] = (drflac_int16)left; + pOutputSamples[i*2+1] = (drflac_int16)right; + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_left_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + for (i = 0; i < frameCount4; ++i) { + __m128i left = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0); + __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1); + __m128i right = _mm_sub_epi32(left, side); + + left = _mm_srai_epi32(left, 16); + right = _mm_srai_epi32(right, 16); + + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), drflac__mm_packs_interleaved_epi32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 left = pInputSamples0U32[i] << shift0; + drflac_uint32 side = pInputSamples1U32[i] << shift1; + drflac_uint32 right = left - side; + + left >>= 16; + right >>= 16; + + pOutputSamples[i*2+0] = (drflac_int16)left; + pOutputSamples[i*2+1] = (drflac_int16)right; + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_left_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + int32x4_t shift0_4; + int32x4_t shift1_4; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + shift0_4 = vdupq_n_s32(shift0); + shift1_4 = vdupq_n_s32(shift1); + + for (i = 0; i < frameCount4; ++i) { + uint32x4_t left; + uint32x4_t side; + uint32x4_t right; + + left = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4); + side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4); + right = vsubq_u32(left, side); + + left = vshrq_n_u32(left, 16); + right = vshrq_n_u32(right, 16); + + drflac__vst2q_u16((drflac_uint16*)pOutputSamples + i*8, vzip_u16(vmovn_u32(left), vmovn_u32(right))); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 left = pInputSamples0U32[i] << shift0; + drflac_uint32 side = pInputSamples1U32[i] << shift1; + drflac_uint32 right = left - side; + + left >>= 16; + right >>= 16; + + pOutputSamples[i*2+0] = (drflac_int16)left; + pOutputSamples[i*2+1] = (drflac_int16)right; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_left_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s16__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s16__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_s16__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_s16__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_right_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + for (i = 0; i < frameCount; ++i) { + drflac_uint32 side = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + drflac_uint32 right = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + drflac_uint32 left = right + side; + + left >>= 16; + right >>= 16; + + pOutputSamples[i*2+0] = (drflac_int16)left; + pOutputSamples[i*2+1] = (drflac_int16)right; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_right_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 side0 = pInputSamples0U32[i*4+0] << shift0; + drflac_uint32 side1 = pInputSamples0U32[i*4+1] << shift0; + drflac_uint32 side2 = pInputSamples0U32[i*4+2] << shift0; + drflac_uint32 side3 = pInputSamples0U32[i*4+3] << shift0; + + drflac_uint32 right0 = pInputSamples1U32[i*4+0] << shift1; + drflac_uint32 right1 = pInputSamples1U32[i*4+1] << shift1; + drflac_uint32 right2 = pInputSamples1U32[i*4+2] << shift1; + drflac_uint32 right3 = pInputSamples1U32[i*4+3] << shift1; + + drflac_uint32 left0 = right0 + side0; + drflac_uint32 left1 = right1 + side1; + drflac_uint32 left2 = right2 + side2; + drflac_uint32 left3 = right3 + side3; + + left0 >>= 16; + left1 >>= 16; + left2 >>= 16; + left3 >>= 16; + + right0 >>= 16; + right1 >>= 16; + right2 >>= 16; + right3 >>= 16; + + pOutputSamples[i*8+0] = (drflac_int16)left0; + pOutputSamples[i*8+1] = (drflac_int16)right0; + pOutputSamples[i*8+2] = (drflac_int16)left1; + pOutputSamples[i*8+3] = (drflac_int16)right1; + pOutputSamples[i*8+4] = (drflac_int16)left2; + pOutputSamples[i*8+5] = (drflac_int16)right2; + pOutputSamples[i*8+6] = (drflac_int16)left3; + pOutputSamples[i*8+7] = (drflac_int16)right3; + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 side = pInputSamples0U32[i] << shift0; + drflac_uint32 right = pInputSamples1U32[i] << shift1; + drflac_uint32 left = right + side; + + left >>= 16; + right >>= 16; + + pOutputSamples[i*2+0] = (drflac_int16)left; + pOutputSamples[i*2+1] = (drflac_int16)right; + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_right_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + for (i = 0; i < frameCount4; ++i) { + __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0); + __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1); + __m128i left = _mm_add_epi32(right, side); + + left = _mm_srai_epi32(left, 16); + right = _mm_srai_epi32(right, 16); + + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), drflac__mm_packs_interleaved_epi32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 side = pInputSamples0U32[i] << shift0; + drflac_uint32 right = pInputSamples1U32[i] << shift1; + drflac_uint32 left = right + side; + + left >>= 16; + right >>= 16; + + pOutputSamples[i*2+0] = (drflac_int16)left; + pOutputSamples[i*2+1] = (drflac_int16)right; + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_right_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + int32x4_t shift0_4; + int32x4_t shift1_4; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + shift0_4 = vdupq_n_s32(shift0); + shift1_4 = vdupq_n_s32(shift1); + + for (i = 0; i < frameCount4; ++i) { + uint32x4_t side; + uint32x4_t right; + uint32x4_t left; + + side = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4); + right = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4); + left = vaddq_u32(right, side); + + left = vshrq_n_u32(left, 16); + right = vshrq_n_u32(right, 16); + + drflac__vst2q_u16((drflac_uint16*)pOutputSamples + i*8, vzip_u16(vmovn_u32(left), vmovn_u32(right))); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 side = pInputSamples0U32[i] << shift0; + drflac_uint32 right = pInputSamples1U32[i] << shift1; + drflac_uint32 left = right + side; + + left >>= 16; + right >>= 16; + + pOutputSamples[i*2+0] = (drflac_int16)left; + pOutputSamples[i*2+1] = (drflac_int16)right; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_right_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s16__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s16__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_s16__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_s16__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_mid_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + for (drflac_uint64 i = 0; i < frameCount; ++i) { + drflac_uint32 mid = (drflac_uint32)pInputSamples0[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = (drflac_uint32)pInputSamples1[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int16)(((drflac_uint32)((drflac_int32)(mid + side) >> 1) << unusedBitsPerSample) >> 16); + pOutputSamples[i*2+1] = (drflac_int16)(((drflac_uint32)((drflac_int32)(mid - side) >> 1) << unusedBitsPerSample) >> 16); + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_mid_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift = unusedBitsPerSample; + + if (shift > 0) { + shift -= 1; + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 temp0L; + drflac_uint32 temp1L; + drflac_uint32 temp2L; + drflac_uint32 temp3L; + drflac_uint32 temp0R; + drflac_uint32 temp1R; + drflac_uint32 temp2R; + drflac_uint32 temp3R; + + drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + + drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid0 = (mid0 << 1) | (side0 & 0x01); + mid1 = (mid1 << 1) | (side1 & 0x01); + mid2 = (mid2 << 1) | (side2 & 0x01); + mid3 = (mid3 << 1) | (side3 & 0x01); + + temp0L = (mid0 + side0) << shift; + temp1L = (mid1 + side1) << shift; + temp2L = (mid2 + side2) << shift; + temp3L = (mid3 + side3) << shift; + + temp0R = (mid0 - side0) << shift; + temp1R = (mid1 - side1) << shift; + temp2R = (mid2 - side2) << shift; + temp3R = (mid3 - side3) << shift; + + temp0L >>= 16; + temp1L >>= 16; + temp2L >>= 16; + temp3L >>= 16; + + temp0R >>= 16; + temp1R >>= 16; + temp2R >>= 16; + temp3R >>= 16; + + pOutputSamples[i*8+0] = (drflac_int16)temp0L; + pOutputSamples[i*8+1] = (drflac_int16)temp0R; + pOutputSamples[i*8+2] = (drflac_int16)temp1L; + pOutputSamples[i*8+3] = (drflac_int16)temp1R; + pOutputSamples[i*8+4] = (drflac_int16)temp2L; + pOutputSamples[i*8+5] = (drflac_int16)temp2R; + pOutputSamples[i*8+6] = (drflac_int16)temp3L; + pOutputSamples[i*8+7] = (drflac_int16)temp3R; + } + } else { + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 temp0L; + drflac_uint32 temp1L; + drflac_uint32 temp2L; + drflac_uint32 temp3L; + drflac_uint32 temp0R; + drflac_uint32 temp1R; + drflac_uint32 temp2R; + drflac_uint32 temp3R; + + drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + + drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid0 = (mid0 << 1) | (side0 & 0x01); + mid1 = (mid1 << 1) | (side1 & 0x01); + mid2 = (mid2 << 1) | (side2 & 0x01); + mid3 = (mid3 << 1) | (side3 & 0x01); + + temp0L = ((drflac_int32)(mid0 + side0) >> 1); + temp1L = ((drflac_int32)(mid1 + side1) >> 1); + temp2L = ((drflac_int32)(mid2 + side2) >> 1); + temp3L = ((drflac_int32)(mid3 + side3) >> 1); + + temp0R = ((drflac_int32)(mid0 - side0) >> 1); + temp1R = ((drflac_int32)(mid1 - side1) >> 1); + temp2R = ((drflac_int32)(mid2 - side2) >> 1); + temp3R = ((drflac_int32)(mid3 - side3) >> 1); + + temp0L >>= 16; + temp1L >>= 16; + temp2L >>= 16; + temp3L >>= 16; + + temp0R >>= 16; + temp1R >>= 16; + temp2R >>= 16; + temp3R >>= 16; + + pOutputSamples[i*8+0] = (drflac_int16)temp0L; + pOutputSamples[i*8+1] = (drflac_int16)temp0R; + pOutputSamples[i*8+2] = (drflac_int16)temp1L; + pOutputSamples[i*8+3] = (drflac_int16)temp1R; + pOutputSamples[i*8+4] = (drflac_int16)temp2L; + pOutputSamples[i*8+5] = (drflac_int16)temp2R; + pOutputSamples[i*8+6] = (drflac_int16)temp3L; + pOutputSamples[i*8+7] = (drflac_int16)temp3R; + } + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int16)(((drflac_uint32)((drflac_int32)(mid + side) >> 1) << unusedBitsPerSample) >> 16); + pOutputSamples[i*2+1] = (drflac_int16)(((drflac_uint32)((drflac_int32)(mid - side) >> 1) << unusedBitsPerSample) >> 16); + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_mid_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift = unusedBitsPerSample; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + if (shift == 0) { + for (i = 0; i < frameCount4; ++i) { + __m128i mid; + __m128i side; + __m128i left; + __m128i right; + + mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + + mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01))); + + left = _mm_srai_epi32(_mm_add_epi32(mid, side), 1); + right = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1); + + left = _mm_srai_epi32(left, 16); + right = _mm_srai_epi32(right, 16); + + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), drflac__mm_packs_interleaved_epi32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int16)(((drflac_int32)(mid + side) >> 1) >> 16); + pOutputSamples[i*2+1] = (drflac_int16)(((drflac_int32)(mid - side) >> 1) >> 16); + } + } else { + shift -= 1; + for (i = 0; i < frameCount4; ++i) { + __m128i mid; + __m128i side; + __m128i left; + __m128i right; + + mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + + mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01))); + + left = _mm_slli_epi32(_mm_add_epi32(mid, side), shift); + right = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift); + + left = _mm_srai_epi32(left, 16); + right = _mm_srai_epi32(right, 16); + + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), drflac__mm_packs_interleaved_epi32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int16)(((mid + side) << shift) >> 16); + pOutputSamples[i*2+1] = (drflac_int16)(((mid - side) << shift) >> 16); + } + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_mid_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift = unusedBitsPerSample; + int32x4_t wbpsShift0_4; /* wbps = Wasted Bits Per Sample */ + int32x4_t wbpsShift1_4; /* wbps = Wasted Bits Per Sample */ + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + wbpsShift0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + wbpsShift1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + + if (shift == 0) { + for (i = 0; i < frameCount4; ++i) { + uint32x4_t mid; + uint32x4_t side; + int32x4_t left; + int32x4_t right; + + mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4); + side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4); + + mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1))); + + left = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1); + right = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1); + + left = vshrq_n_s32(left, 16); + right = vshrq_n_s32(right, 16); + + drflac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right))); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int16)(((drflac_int32)(mid + side) >> 1) >> 16); + pOutputSamples[i*2+1] = (drflac_int16)(((drflac_int32)(mid - side) >> 1) >> 16); + } + } else { + int32x4_t shift4; + + shift -= 1; + shift4 = vdupq_n_s32(shift); + + for (i = 0; i < frameCount4; ++i) { + uint32x4_t mid; + uint32x4_t side; + int32x4_t left; + int32x4_t right; + + mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4); + side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4); + + mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1))); + + left = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4)); + right = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4)); + + left = vshrq_n_s32(left, 16); + right = vshrq_n_s32(right, 16); + + drflac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right))); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int16)(((mid + side) << shift) >> 16); + pOutputSamples[i*2+1] = (drflac_int16)(((mid - side) << shift) >> 16); + } + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_mid_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s16__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s16__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_s16__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_s16__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_independent_stereo__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + for (drflac_uint64 i = 0; i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int16)((drflac_int32)((drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample)) >> 16); + pOutputSamples[i*2+1] = (drflac_int16)((drflac_int32)((drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample)) >> 16); + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_independent_stereo__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0; + drflac_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0; + drflac_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0; + drflac_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0; + + drflac_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1; + drflac_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1; + drflac_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1; + drflac_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1; + + tempL0 >>= 16; + tempL1 >>= 16; + tempL2 >>= 16; + tempL3 >>= 16; + + tempR0 >>= 16; + tempR1 >>= 16; + tempR2 >>= 16; + tempR3 >>= 16; + + pOutputSamples[i*8+0] = (drflac_int16)tempL0; + pOutputSamples[i*8+1] = (drflac_int16)tempR0; + pOutputSamples[i*8+2] = (drflac_int16)tempL1; + pOutputSamples[i*8+3] = (drflac_int16)tempR1; + pOutputSamples[i*8+4] = (drflac_int16)tempL2; + pOutputSamples[i*8+5] = (drflac_int16)tempR2; + pOutputSamples[i*8+6] = (drflac_int16)tempL3; + pOutputSamples[i*8+7] = (drflac_int16)tempR3; + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int16)((pInputSamples0U32[i] << shift0) >> 16); + pOutputSamples[i*2+1] = (drflac_int16)((pInputSamples1U32[i] << shift1) >> 16); + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_independent_stereo__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + for (i = 0; i < frameCount4; ++i) { + __m128i left = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0); + __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1); + + left = _mm_srai_epi32(left, 16); + right = _mm_srai_epi32(right, 16); + + /* At this point we have results. We can now pack and interleave these into a single __m128i object and then store the in the output buffer. */ + _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), drflac__mm_packs_interleaved_epi32(left, right)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int16)((pInputSamples0U32[i] << shift0) >> 16); + pOutputSamples[i*2+1] = (drflac_int16)((pInputSamples1U32[i] << shift1) >> 16); + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_independent_stereo__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + int32x4_t shift0_4 = vdupq_n_s32(shift0); + int32x4_t shift1_4 = vdupq_n_s32(shift1); + + for (i = 0; i < frameCount4; ++i) { + int32x4_t left; + int32x4_t right; + + left = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4)); + right = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4)); + + left = vshrq_n_s32(left, 16); + right = vshrq_n_s32(right, 16); + + drflac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right))); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int16)((pInputSamples0U32[i] << shift0) >> 16); + pOutputSamples[i*2+1] = (drflac_int16)((pInputSamples1U32[i] << shift1) >> 16); + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_s16__decode_independent_stereo(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, drflac_int16* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s16__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_s16__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_s16__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_s16__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + +DRFLAC_API drflac_uint64 drflac_read_pcm_frames_s16(drflac* pFlac, drflac_uint64 framesToRead, drflac_int16* pBufferOut) +{ + drflac_uint64 framesRead; + drflac_uint32 unusedBitsPerSample; + + if (pFlac == NULL || framesToRead == 0) { + return 0; + } + + if (pBufferOut == NULL) { + return drflac__seek_forward_by_pcm_frames(pFlac, framesToRead); + } + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 32); + unusedBitsPerSample = 32 - pFlac->bitsPerSample; + + framesRead = 0; + while (framesToRead > 0) { + /* If we've run out of samples in this frame, go to the next. */ + if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) { + if (!drflac__read_and_decode_next_flac_frame(pFlac)) { + break; /* Couldn't read the next frame, so just break from the loop and return. */ + } + } else { + unsigned int channelCount = drflac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment); + drflac_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining; + drflac_uint64 frameCountThisIteration = framesToRead; + + if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) { + frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining; + } + + if (channelCount == 2) { + const drflac_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame; + const drflac_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame; + + switch (pFlac->currentFLACFrame.header.channelAssignment) + { + case DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE: + { + drflac_read_pcm_frames_s16__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + + case DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE: + { + drflac_read_pcm_frames_s16__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + + case DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE: + { + drflac_read_pcm_frames_s16__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + + case DRFLAC_CHANNEL_ASSIGNMENT_INDEPENDENT: + default: + { + drflac_read_pcm_frames_s16__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + } + } else { + /* Generic interleaving. */ + drflac_uint64 i; + for (i = 0; i < frameCountThisIteration; ++i) { + unsigned int j; + for (j = 0; j < channelCount; ++j) { + drflac_int32 sampleS32 = (drflac_int32)((drflac_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample)); + pBufferOut[(i*channelCount)+j] = (drflac_int16)(sampleS32 >> 16); + } + } + } + + framesRead += frameCountThisIteration; + pBufferOut += frameCountThisIteration * channelCount; + framesToRead -= frameCountThisIteration; + pFlac->currentPCMFrame += frameCountThisIteration; + pFlac->currentFLACFrame.pcmFramesRemaining -= (drflac_uint32)frameCountThisIteration; + } + } + + return framesRead; +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_left_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + for (i = 0; i < frameCount; ++i) { + drflac_uint32 left = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + drflac_uint32 side = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + drflac_uint32 right = left - side; + + pOutputSamples[i*2+0] = (float)((drflac_int32)left / 2147483648.0); + pOutputSamples[i*2+1] = (float)((drflac_int32)right / 2147483648.0); + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_left_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + float factor = 1 / 2147483648.0; + + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 left0 = pInputSamples0U32[i*4+0] << shift0; + drflac_uint32 left1 = pInputSamples0U32[i*4+1] << shift0; + drflac_uint32 left2 = pInputSamples0U32[i*4+2] << shift0; + drflac_uint32 left3 = pInputSamples0U32[i*4+3] << shift0; + + drflac_uint32 side0 = pInputSamples1U32[i*4+0] << shift1; + drflac_uint32 side1 = pInputSamples1U32[i*4+1] << shift1; + drflac_uint32 side2 = pInputSamples1U32[i*4+2] << shift1; + drflac_uint32 side3 = pInputSamples1U32[i*4+3] << shift1; + + drflac_uint32 right0 = left0 - side0; + drflac_uint32 right1 = left1 - side1; + drflac_uint32 right2 = left2 - side2; + drflac_uint32 right3 = left3 - side3; + + pOutputSamples[i*8+0] = (drflac_int32)left0 * factor; + pOutputSamples[i*8+1] = (drflac_int32)right0 * factor; + pOutputSamples[i*8+2] = (drflac_int32)left1 * factor; + pOutputSamples[i*8+3] = (drflac_int32)right1 * factor; + pOutputSamples[i*8+4] = (drflac_int32)left2 * factor; + pOutputSamples[i*8+5] = (drflac_int32)right2 * factor; + pOutputSamples[i*8+6] = (drflac_int32)left3 * factor; + pOutputSamples[i*8+7] = (drflac_int32)right3 * factor; + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 left = pInputSamples0U32[i] << shift0; + drflac_uint32 side = pInputSamples1U32[i] << shift1; + drflac_uint32 right = left - side; + + pOutputSamples[i*2+0] = (drflac_int32)left * factor; + pOutputSamples[i*2+1] = (drflac_int32)right * factor; + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_left_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8; + drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8; + __m128 factor; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + factor = _mm_set1_ps(1.0f / 8388608.0f); + + for (i = 0; i < frameCount4; ++i) { + __m128i left = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0); + __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1); + __m128i right = _mm_sub_epi32(left, side); + __m128 leftf = _mm_mul_ps(_mm_cvtepi32_ps(left), factor); + __m128 rightf = _mm_mul_ps(_mm_cvtepi32_ps(right), factor); + + _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf)); + _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 left = pInputSamples0U32[i] << shift0; + drflac_uint32 side = pInputSamples1U32[i] << shift1; + drflac_uint32 right = left - side; + + pOutputSamples[i*2+0] = (drflac_int32)left / 8388608.0f; + pOutputSamples[i*2+1] = (drflac_int32)right / 8388608.0f; + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_left_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8; + drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8; + float32x4_t factor4; + int32x4_t shift0_4; + int32x4_t shift1_4; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + factor4 = vdupq_n_f32(1.0f / 8388608.0f); + shift0_4 = vdupq_n_s32(shift0); + shift1_4 = vdupq_n_s32(shift1); + + for (i = 0; i < frameCount4; ++i) { + uint32x4_t left; + uint32x4_t side; + uint32x4_t right; + float32x4_t leftf; + float32x4_t rightf; + + left = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4); + side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4); + right = vsubq_u32(left, side); + leftf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(left)), factor4); + rightf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(right)), factor4); + + drflac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 left = pInputSamples0U32[i] << shift0; + drflac_uint32 side = pInputSamples1U32[i] << shift1; + drflac_uint32 right = left - side; + + pOutputSamples[i*2+0] = (drflac_int32)left / 8388608.0f; + pOutputSamples[i*2+1] = (drflac_int32)right / 8388608.0f; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_left_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_f32__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_f32__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_f32__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_f32__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_right_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + for (i = 0; i < frameCount; ++i) { + drflac_uint32 side = (drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + drflac_uint32 right = (drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + drflac_uint32 left = right + side; + + pOutputSamples[i*2+0] = (float)((drflac_int32)left / 2147483648.0); + pOutputSamples[i*2+1] = (float)((drflac_int32)right / 2147483648.0); + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_right_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + float factor = 1 / 2147483648.0; + + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 side0 = pInputSamples0U32[i*4+0] << shift0; + drflac_uint32 side1 = pInputSamples0U32[i*4+1] << shift0; + drflac_uint32 side2 = pInputSamples0U32[i*4+2] << shift0; + drflac_uint32 side3 = pInputSamples0U32[i*4+3] << shift0; + + drflac_uint32 right0 = pInputSamples1U32[i*4+0] << shift1; + drflac_uint32 right1 = pInputSamples1U32[i*4+1] << shift1; + drflac_uint32 right2 = pInputSamples1U32[i*4+2] << shift1; + drflac_uint32 right3 = pInputSamples1U32[i*4+3] << shift1; + + drflac_uint32 left0 = right0 + side0; + drflac_uint32 left1 = right1 + side1; + drflac_uint32 left2 = right2 + side2; + drflac_uint32 left3 = right3 + side3; + + pOutputSamples[i*8+0] = (drflac_int32)left0 * factor; + pOutputSamples[i*8+1] = (drflac_int32)right0 * factor; + pOutputSamples[i*8+2] = (drflac_int32)left1 * factor; + pOutputSamples[i*8+3] = (drflac_int32)right1 * factor; + pOutputSamples[i*8+4] = (drflac_int32)left2 * factor; + pOutputSamples[i*8+5] = (drflac_int32)right2 * factor; + pOutputSamples[i*8+6] = (drflac_int32)left3 * factor; + pOutputSamples[i*8+7] = (drflac_int32)right3 * factor; + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 side = pInputSamples0U32[i] << shift0; + drflac_uint32 right = pInputSamples1U32[i] << shift1; + drflac_uint32 left = right + side; + + pOutputSamples[i*2+0] = (drflac_int32)left * factor; + pOutputSamples[i*2+1] = (drflac_int32)right * factor; + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_right_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8; + drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8; + __m128 factor; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + factor = _mm_set1_ps(1.0f / 8388608.0f); + + for (i = 0; i < frameCount4; ++i) { + __m128i side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0); + __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1); + __m128i left = _mm_add_epi32(right, side); + __m128 leftf = _mm_mul_ps(_mm_cvtepi32_ps(left), factor); + __m128 rightf = _mm_mul_ps(_mm_cvtepi32_ps(right), factor); + + _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf)); + _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 side = pInputSamples0U32[i] << shift0; + drflac_uint32 right = pInputSamples1U32[i] << shift1; + drflac_uint32 left = right + side; + + pOutputSamples[i*2+0] = (drflac_int32)left / 8388608.0f; + pOutputSamples[i*2+1] = (drflac_int32)right / 8388608.0f; + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_right_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8; + drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8; + float32x4_t factor4; + int32x4_t shift0_4; + int32x4_t shift1_4; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + factor4 = vdupq_n_f32(1.0f / 8388608.0f); + shift0_4 = vdupq_n_s32(shift0); + shift1_4 = vdupq_n_s32(shift1); + + for (i = 0; i < frameCount4; ++i) { + uint32x4_t side; + uint32x4_t right; + uint32x4_t left; + float32x4_t leftf; + float32x4_t rightf; + + side = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4); + right = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4); + left = vaddq_u32(right, side); + leftf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(left)), factor4); + rightf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(right)), factor4); + + drflac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 side = pInputSamples0U32[i] << shift0; + drflac_uint32 right = pInputSamples1U32[i] << shift1; + drflac_uint32 left = right + side; + + pOutputSamples[i*2+0] = (drflac_int32)left / 8388608.0f; + pOutputSamples[i*2+1] = (drflac_int32)right / 8388608.0f; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_right_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_f32__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_f32__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_f32__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_f32__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_mid_side__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + for (drflac_uint64 i = 0; i < frameCount; ++i) { + drflac_uint32 mid = (drflac_uint32)pInputSamples0[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = (drflac_uint32)pInputSamples1[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (float)((((drflac_int32)(mid + side) >> 1) << (unusedBitsPerSample)) / 2147483648.0); + pOutputSamples[i*2+1] = (float)((((drflac_int32)(mid - side) >> 1) << (unusedBitsPerSample)) / 2147483648.0); + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_mid_side__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift = unusedBitsPerSample; + float factor = 1 / 2147483648.0; + + if (shift > 0) { + shift -= 1; + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 temp0L; + drflac_uint32 temp1L; + drflac_uint32 temp2L; + drflac_uint32 temp3L; + drflac_uint32 temp0R; + drflac_uint32 temp1R; + drflac_uint32 temp2R; + drflac_uint32 temp3R; + + drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + + drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid0 = (mid0 << 1) | (side0 & 0x01); + mid1 = (mid1 << 1) | (side1 & 0x01); + mid2 = (mid2 << 1) | (side2 & 0x01); + mid3 = (mid3 << 1) | (side3 & 0x01); + + temp0L = (mid0 + side0) << shift; + temp1L = (mid1 + side1) << shift; + temp2L = (mid2 + side2) << shift; + temp3L = (mid3 + side3) << shift; + + temp0R = (mid0 - side0) << shift; + temp1R = (mid1 - side1) << shift; + temp2R = (mid2 - side2) << shift; + temp3R = (mid3 - side3) << shift; + + pOutputSamples[i*8+0] = (drflac_int32)temp0L * factor; + pOutputSamples[i*8+1] = (drflac_int32)temp0R * factor; + pOutputSamples[i*8+2] = (drflac_int32)temp1L * factor; + pOutputSamples[i*8+3] = (drflac_int32)temp1R * factor; + pOutputSamples[i*8+4] = (drflac_int32)temp2L * factor; + pOutputSamples[i*8+5] = (drflac_int32)temp2R * factor; + pOutputSamples[i*8+6] = (drflac_int32)temp3L * factor; + pOutputSamples[i*8+7] = (drflac_int32)temp3R * factor; + } + } else { + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 temp0L; + drflac_uint32 temp1L; + drflac_uint32 temp2L; + drflac_uint32 temp3L; + drflac_uint32 temp0R; + drflac_uint32 temp1R; + drflac_uint32 temp2R; + drflac_uint32 temp3R; + + drflac_uint32 mid0 = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid1 = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid2 = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 mid3 = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + + drflac_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + drflac_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid0 = (mid0 << 1) | (side0 & 0x01); + mid1 = (mid1 << 1) | (side1 & 0x01); + mid2 = (mid2 << 1) | (side2 & 0x01); + mid3 = (mid3 << 1) | (side3 & 0x01); + + temp0L = (drflac_uint32)((drflac_int32)(mid0 + side0) >> 1); + temp1L = (drflac_uint32)((drflac_int32)(mid1 + side1) >> 1); + temp2L = (drflac_uint32)((drflac_int32)(mid2 + side2) >> 1); + temp3L = (drflac_uint32)((drflac_int32)(mid3 + side3) >> 1); + + temp0R = (drflac_uint32)((drflac_int32)(mid0 - side0) >> 1); + temp1R = (drflac_uint32)((drflac_int32)(mid1 - side1) >> 1); + temp2R = (drflac_uint32)((drflac_int32)(mid2 - side2) >> 1); + temp3R = (drflac_uint32)((drflac_int32)(mid3 - side3) >> 1); + + pOutputSamples[i*8+0] = (drflac_int32)temp0L * factor; + pOutputSamples[i*8+1] = (drflac_int32)temp0R * factor; + pOutputSamples[i*8+2] = (drflac_int32)temp1L * factor; + pOutputSamples[i*8+3] = (drflac_int32)temp1R * factor; + pOutputSamples[i*8+4] = (drflac_int32)temp2L * factor; + pOutputSamples[i*8+5] = (drflac_int32)temp2R * factor; + pOutputSamples[i*8+6] = (drflac_int32)temp3L * factor; + pOutputSamples[i*8+7] = (drflac_int32)temp3R * factor; + } + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid + side) >> 1) << unusedBitsPerSample) * factor; + pOutputSamples[i*2+1] = (drflac_int32)((drflac_uint32)((drflac_int32)(mid - side) >> 1) << unusedBitsPerSample) * factor; + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_mid_side__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift = unusedBitsPerSample - 8; + float factor; + __m128 factor128; + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + factor = 1.0f / 8388608.0f; + factor128 = _mm_set1_ps(factor); + + if (shift == 0) { + for (i = 0; i < frameCount4; ++i) { + __m128i mid; + __m128i side; + __m128i tempL; + __m128i tempR; + __m128 leftf; + __m128 rightf; + + mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + + mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01))); + + tempL = _mm_srai_epi32(_mm_add_epi32(mid, side), 1); + tempR = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1); + + leftf = _mm_mul_ps(_mm_cvtepi32_ps(tempL), factor128); + rightf = _mm_mul_ps(_mm_cvtepi32_ps(tempR), factor128); + + _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf)); + _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = ((drflac_int32)(mid + side) >> 1) * factor; + pOutputSamples[i*2+1] = ((drflac_int32)(mid - side) >> 1) * factor; + } + } else { + shift -= 1; + for (i = 0; i < frameCount4; ++i) { + __m128i mid; + __m128i side; + __m128i tempL; + __m128i tempR; + __m128 leftf; + __m128 rightf; + + mid = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + side = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + + mid = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01))); + + tempL = _mm_slli_epi32(_mm_add_epi32(mid, side), shift); + tempR = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift); + + leftf = _mm_mul_ps(_mm_cvtepi32_ps(tempL), factor128); + rightf = _mm_mul_ps(_mm_cvtepi32_ps(tempR), factor128); + + _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf)); + _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int32)((mid + side) << shift) * factor; + pOutputSamples[i*2+1] = (drflac_int32)((mid - side) << shift) * factor; + } + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_mid_side__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift = unusedBitsPerSample - 8; + float factor; + float32x4_t factor4; + int32x4_t shift4; + int32x4_t wbps0_4; /* Wasted Bits Per Sample */ + int32x4_t wbps1_4; /* Wasted Bits Per Sample */ + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 24); + + factor = 1.0f / 8388608.0f; + factor4 = vdupq_n_f32(factor); + wbps0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample); + wbps1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample); + + if (shift == 0) { + for (i = 0; i < frameCount4; ++i) { + int32x4_t lefti; + int32x4_t righti; + float32x4_t leftf; + float32x4_t rightf; + + uint32x4_t mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbps0_4); + uint32x4_t side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbps1_4); + + mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1))); + + lefti = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1); + righti = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1); + + leftf = vmulq_f32(vcvtq_f32_s32(lefti), factor4); + rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4); + + drflac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = ((drflac_int32)(mid + side) >> 1) * factor; + pOutputSamples[i*2+1] = ((drflac_int32)(mid - side) >> 1) * factor; + } + } else { + shift -= 1; + shift4 = vdupq_n_s32(shift); + for (i = 0; i < frameCount4; ++i) { + uint32x4_t mid; + uint32x4_t side; + int32x4_t lefti; + int32x4_t righti; + float32x4_t leftf; + float32x4_t rightf; + + mid = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbps0_4); + side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbps1_4); + + mid = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1))); + + lefti = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4)); + righti = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4)); + + leftf = vmulq_f32(vcvtq_f32_s32(lefti), factor4); + rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4); + + drflac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + drflac_uint32 mid = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + + mid = (mid << 1) | (side & 0x01); + + pOutputSamples[i*2+0] = (drflac_int32)((mid + side) << shift) * factor; + pOutputSamples[i*2+1] = (drflac_int32)((mid - side) << shift) * factor; + } + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_mid_side(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_f32__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_f32__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_f32__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_f32__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + +#if 0 +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_independent_stereo__reference(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + for (drflac_uint64 i = 0; i < frameCount; ++i) { + pOutputSamples[i*2+0] = (float)((drflac_int32)((drflac_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample)) / 2147483648.0); + pOutputSamples[i*2+1] = (float)((drflac_int32)((drflac_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample)) / 2147483648.0); + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_independent_stereo__scalar(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample; + drflac_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample; + float factor = 1 / 2147483648.0; + + for (i = 0; i < frameCount4; ++i) { + drflac_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0; + drflac_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0; + drflac_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0; + drflac_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0; + + drflac_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1; + drflac_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1; + drflac_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1; + drflac_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1; + + pOutputSamples[i*8+0] = (drflac_int32)tempL0 * factor; + pOutputSamples[i*8+1] = (drflac_int32)tempR0 * factor; + pOutputSamples[i*8+2] = (drflac_int32)tempL1 * factor; + pOutputSamples[i*8+3] = (drflac_int32)tempR1 * factor; + pOutputSamples[i*8+4] = (drflac_int32)tempL2 * factor; + pOutputSamples[i*8+5] = (drflac_int32)tempR2 * factor; + pOutputSamples[i*8+6] = (drflac_int32)tempL3 * factor; + pOutputSamples[i*8+7] = (drflac_int32)tempR3 * factor; + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0) * factor; + pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1) * factor; + } +} + +#if defined(DRFLAC_SUPPORT_SSE2) +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_independent_stereo__sse2(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8; + drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8; + + float factor = 1.0f / 8388608.0f; + __m128 factor128 = _mm_set1_ps(factor); + + for (i = 0; i < frameCount4; ++i) { + __m128i lefti; + __m128i righti; + __m128 leftf; + __m128 rightf; + + lefti = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0); + righti = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1); + + leftf = _mm_mul_ps(_mm_cvtepi32_ps(lefti), factor128); + rightf = _mm_mul_ps(_mm_cvtepi32_ps(righti), factor128); + + _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf)); + _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0) * factor; + pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1) * factor; + } +} +#endif + +#if defined(DRFLAC_SUPPORT_NEON) +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_independent_stereo__neon(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ + drflac_uint64 i; + drflac_uint64 frameCount4 = frameCount >> 2; + const drflac_uint32* pInputSamples0U32 = (const drflac_uint32*)pInputSamples0; + const drflac_uint32* pInputSamples1U32 = (const drflac_uint32*)pInputSamples1; + drflac_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8; + drflac_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8; + + float factor = 1.0f / 8388608.0f; + float32x4_t factor4 = vdupq_n_f32(factor); + int32x4_t shift0_4 = vdupq_n_s32(shift0); + int32x4_t shift1_4 = vdupq_n_s32(shift1); + + for (i = 0; i < frameCount4; ++i) { + int32x4_t lefti; + int32x4_t righti; + float32x4_t leftf; + float32x4_t rightf; + + lefti = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4)); + righti = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4)); + + leftf = vmulq_f32(vcvtq_f32_s32(lefti), factor4); + rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4); + + drflac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf)); + } + + for (i = (frameCount4 << 2); i < frameCount; ++i) { + pOutputSamples[i*2+0] = (drflac_int32)(pInputSamples0U32[i] << shift0) * factor; + pOutputSamples[i*2+1] = (drflac_int32)(pInputSamples1U32[i] << shift1) * factor; + } +} +#endif + +static DRFLAC_INLINE void drflac_read_pcm_frames_f32__decode_independent_stereo(drflac* pFlac, drflac_uint64 frameCount, drflac_uint32 unusedBitsPerSample, const drflac_int32* pInputSamples0, const drflac_int32* pInputSamples1, float* pOutputSamples) +{ +#if defined(DRFLAC_SUPPORT_SSE2) + if (drflac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_f32__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#elif defined(DRFLAC_SUPPORT_NEON) + if (drflac__gIsNEONSupported && pFlac->bitsPerSample <= 24) { + drflac_read_pcm_frames_f32__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); + } else +#endif + { + /* Scalar fallback. */ +#if 0 + drflac_read_pcm_frames_f32__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#else + drflac_read_pcm_frames_f32__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples); +#endif + } +} + +DRFLAC_API drflac_uint64 drflac_read_pcm_frames_f32(drflac* pFlac, drflac_uint64 framesToRead, float* pBufferOut) +{ + drflac_uint64 framesRead; + drflac_uint32 unusedBitsPerSample; + + if (pFlac == NULL || framesToRead == 0) { + return 0; + } + + if (pBufferOut == NULL) { + return drflac__seek_forward_by_pcm_frames(pFlac, framesToRead); + } + + DRFLAC_ASSERT(pFlac->bitsPerSample <= 32); + unusedBitsPerSample = 32 - pFlac->bitsPerSample; + + framesRead = 0; + while (framesToRead > 0) { + /* If we've run out of samples in this frame, go to the next. */ + if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) { + if (!drflac__read_and_decode_next_flac_frame(pFlac)) { + break; /* Couldn't read the next frame, so just break from the loop and return. */ + } + } else { + unsigned int channelCount = drflac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment); + drflac_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining; + drflac_uint64 frameCountThisIteration = framesToRead; + + if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) { + frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining; + } + + if (channelCount == 2) { + const drflac_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame; + const drflac_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame; + + switch (pFlac->currentFLACFrame.header.channelAssignment) + { + case DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE: + { + drflac_read_pcm_frames_f32__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + + case DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE: + { + drflac_read_pcm_frames_f32__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + + case DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE: + { + drflac_read_pcm_frames_f32__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + + case DRFLAC_CHANNEL_ASSIGNMENT_INDEPENDENT: + default: + { + drflac_read_pcm_frames_f32__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut); + } break; + } + } else { + /* Generic interleaving. */ + drflac_uint64 i; + for (i = 0; i < frameCountThisIteration; ++i) { + unsigned int j; + for (j = 0; j < channelCount; ++j) { + drflac_int32 sampleS32 = (drflac_int32)((drflac_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample)); + pBufferOut[(i*channelCount)+j] = (float)(sampleS32 / 2147483648.0); + } + } + } + + framesRead += frameCountThisIteration; + pBufferOut += frameCountThisIteration * channelCount; + framesToRead -= frameCountThisIteration; + pFlac->currentPCMFrame += frameCountThisIteration; + pFlac->currentFLACFrame.pcmFramesRemaining -= (unsigned int)frameCountThisIteration; + } + } + + return framesRead; +} + + +DRFLAC_API drflac_bool32 drflac_seek_to_pcm_frame(drflac* pFlac, drflac_uint64 pcmFrameIndex) +{ + if (pFlac == NULL) { + return DRFLAC_FALSE; + } + + /* Don't do anything if we're already on the seek point. */ + if (pFlac->currentPCMFrame == pcmFrameIndex) { + return DRFLAC_TRUE; + } + + /* + If we don't know where the first frame begins then we can't seek. This will happen when the STREAMINFO block was not present + when the decoder was opened. + */ + if (pFlac->firstFLACFramePosInBytes == 0) { + return DRFLAC_FALSE; + } + + if (pcmFrameIndex == 0) { + pFlac->currentPCMFrame = 0; + return drflac__seek_to_first_frame(pFlac); + } else { + drflac_bool32 wasSuccessful = DRFLAC_FALSE; + + /* Clamp the sample to the end. */ + if (pcmFrameIndex > pFlac->totalPCMFrameCount) { + pcmFrameIndex = pFlac->totalPCMFrameCount; + } + + /* If the target sample and the current sample are in the same frame we just move the position forward. */ + if (pcmFrameIndex > pFlac->currentPCMFrame) { + /* Forward. */ + drflac_uint32 offset = (drflac_uint32)(pcmFrameIndex - pFlac->currentPCMFrame); + if (pFlac->currentFLACFrame.pcmFramesRemaining > offset) { + pFlac->currentFLACFrame.pcmFramesRemaining -= offset; + pFlac->currentPCMFrame = pcmFrameIndex; + return DRFLAC_TRUE; + } + } else { + /* Backward. */ + drflac_uint32 offsetAbs = (drflac_uint32)(pFlac->currentPCMFrame - pcmFrameIndex); + drflac_uint32 currentFLACFramePCMFrameCount = pFlac->currentFLACFrame.header.blockSizeInPCMFrames; + drflac_uint32 currentFLACFramePCMFramesConsumed = currentFLACFramePCMFrameCount - pFlac->currentFLACFrame.pcmFramesRemaining; + if (currentFLACFramePCMFramesConsumed > offsetAbs) { + pFlac->currentFLACFrame.pcmFramesRemaining += offsetAbs; + pFlac->currentPCMFrame = pcmFrameIndex; + return DRFLAC_TRUE; + } + } + + /* + Different techniques depending on encapsulation. Using the native FLAC seektable with Ogg encapsulation is a bit awkward so + we'll instead use Ogg's natural seeking facility. + */ +#ifndef DR_FLAC_NO_OGG + if (pFlac->container == drflac_container_ogg) + { + wasSuccessful = drflac_ogg__seek_to_pcm_frame(pFlac, pcmFrameIndex); + } + else +#endif + { + /* First try seeking via the seek table. If this fails, fall back to a brute force seek which is much slower. */ + if (/*!wasSuccessful && */!pFlac->_noSeekTableSeek) { + wasSuccessful = drflac__seek_to_pcm_frame__seek_table(pFlac, pcmFrameIndex); + } + +#if !defined(DR_FLAC_NO_CRC) + /* Fall back to binary search if seek table seeking fails. This requires the length of the stream to be known. */ + if (!wasSuccessful && !pFlac->_noBinarySearchSeek && pFlac->totalPCMFrameCount > 0) { + wasSuccessful = drflac__seek_to_pcm_frame__binary_search(pFlac, pcmFrameIndex); + } +#endif + + /* Fall back to brute force if all else fails. */ + if (!wasSuccessful && !pFlac->_noBruteForceSeek) { + wasSuccessful = drflac__seek_to_pcm_frame__brute_force(pFlac, pcmFrameIndex); + } + } + + pFlac->currentPCMFrame = pcmFrameIndex; + return wasSuccessful; + } +} + + + +/* High Level APIs */ + +#if defined(SIZE_MAX) + #define DRFLAC_SIZE_MAX SIZE_MAX +#else + #if defined(DRFLAC_64BIT) + #define DRFLAC_SIZE_MAX ((drflac_uint64)0xFFFFFFFFFFFFFFFF) + #else + #define DRFLAC_SIZE_MAX 0xFFFFFFFF + #endif +#endif + + +/* Using a macro as the definition of the drflac__full_decode_and_close_*() API family. Sue me. */ +#define DRFLAC_DEFINE_FULL_READ_AND_CLOSE(extension, type) \ +static type* drflac__full_read_and_close_ ## extension (drflac* pFlac, unsigned int* channelsOut, unsigned int* sampleRateOut, drflac_uint64* totalPCMFrameCountOut)\ +{ \ + type* pSampleData = NULL; \ + drflac_uint64 totalPCMFrameCount; \ + \ + DRFLAC_ASSERT(pFlac != NULL); \ + \ + totalPCMFrameCount = pFlac->totalPCMFrameCount; \ + \ + if (totalPCMFrameCount == 0) { \ + type buffer[4096]; \ + drflac_uint64 pcmFramesRead; \ + size_t sampleDataBufferSize = sizeof(buffer); \ + \ + pSampleData = (type*)drflac__malloc_from_callbacks(sampleDataBufferSize, &pFlac->allocationCallbacks); \ + if (pSampleData == NULL) { \ + goto on_error; \ + } \ + \ + while ((pcmFramesRead = (drflac_uint64)drflac_read_pcm_frames_##extension(pFlac, sizeof(buffer)/sizeof(buffer[0])/pFlac->channels, buffer)) > 0) { \ + if (((totalPCMFrameCount + pcmFramesRead) * pFlac->channels * sizeof(type)) > sampleDataBufferSize) { \ + type* pNewSampleData; \ + size_t newSampleDataBufferSize; \ + \ + newSampleDataBufferSize = sampleDataBufferSize * 2; \ + pNewSampleData = (type*)drflac__realloc_from_callbacks(pSampleData, newSampleDataBufferSize, sampleDataBufferSize, &pFlac->allocationCallbacks); \ + if (pNewSampleData == NULL) { \ + drflac__free_from_callbacks(pSampleData, &pFlac->allocationCallbacks); \ + goto on_error; \ + } \ + \ + sampleDataBufferSize = newSampleDataBufferSize; \ + pSampleData = pNewSampleData; \ + } \ + \ + DRFLAC_COPY_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), buffer, (size_t)(pcmFramesRead*pFlac->channels*sizeof(type))); \ + totalPCMFrameCount += pcmFramesRead; \ + } \ + \ + /* At this point everything should be decoded, but we just want to fill the unused part buffer with silence - need to \ + protect those ears from random noise! */ \ + DRFLAC_ZERO_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), (size_t)(sampleDataBufferSize - totalPCMFrameCount*pFlac->channels*sizeof(type))); \ + } else { \ + drflac_uint64 dataSize = totalPCMFrameCount*pFlac->channels*sizeof(type); \ + if (dataSize > DRFLAC_SIZE_MAX) { \ + goto on_error; /* The decoded data is too big. */ \ + } \ + \ + pSampleData = (type*)drflac__malloc_from_callbacks((size_t)dataSize, &pFlac->allocationCallbacks); /* <-- Safe cast as per the check above. */ \ + if (pSampleData == NULL) { \ + goto on_error; \ + } \ + \ + totalPCMFrameCount = drflac_read_pcm_frames_##extension(pFlac, pFlac->totalPCMFrameCount, pSampleData); \ + } \ + \ + if (sampleRateOut) *sampleRateOut = pFlac->sampleRate; \ + if (channelsOut) *channelsOut = pFlac->channels; \ + if (totalPCMFrameCountOut) *totalPCMFrameCountOut = totalPCMFrameCount; \ + \ + drflac_close(pFlac); \ + return pSampleData; \ + \ +on_error: \ + drflac_close(pFlac); \ + return NULL; \ +} + +DRFLAC_DEFINE_FULL_READ_AND_CLOSE(s32, drflac_int32) +DRFLAC_DEFINE_FULL_READ_AND_CLOSE(s16, drflac_int16) +DRFLAC_DEFINE_FULL_READ_AND_CLOSE(f32, float) + +DRFLAC_API drflac_int32* drflac_open_and_read_pcm_frames_s32(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drflac_uint64* totalPCMFrameCountOut, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalPCMFrameCountOut) { + *totalPCMFrameCountOut = 0; + } + + pFlac = drflac_open(onRead, onSeek, pUserData, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + return drflac__full_read_and_close_s32(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut); +} + +DRFLAC_API drflac_int16* drflac_open_and_read_pcm_frames_s16(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drflac_uint64* totalPCMFrameCountOut, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalPCMFrameCountOut) { + *totalPCMFrameCountOut = 0; + } + + pFlac = drflac_open(onRead, onSeek, pUserData, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + return drflac__full_read_and_close_s16(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut); +} + +DRFLAC_API float* drflac_open_and_read_pcm_frames_f32(drflac_read_proc onRead, drflac_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drflac_uint64* totalPCMFrameCountOut, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalPCMFrameCountOut) { + *totalPCMFrameCountOut = 0; + } + + pFlac = drflac_open(onRead, onSeek, pUserData, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + return drflac__full_read_and_close_f32(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut); +} + +#ifndef DR_FLAC_NO_STDIO +DRFLAC_API drflac_int32* drflac_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + + if (sampleRate) { + *sampleRate = 0; + } + if (channels) { + *channels = 0; + } + if (totalPCMFrameCount) { + *totalPCMFrameCount = 0; + } + + pFlac = drflac_open_file(filename, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + return drflac__full_read_and_close_s32(pFlac, channels, sampleRate, totalPCMFrameCount); +} + +DRFLAC_API drflac_int16* drflac_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + + if (sampleRate) { + *sampleRate = 0; + } + if (channels) { + *channels = 0; + } + if (totalPCMFrameCount) { + *totalPCMFrameCount = 0; + } + + pFlac = drflac_open_file(filename, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + return drflac__full_read_and_close_s16(pFlac, channels, sampleRate, totalPCMFrameCount); +} + +DRFLAC_API float* drflac_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + + if (sampleRate) { + *sampleRate = 0; + } + if (channels) { + *channels = 0; + } + if (totalPCMFrameCount) { + *totalPCMFrameCount = 0; + } + + pFlac = drflac_open_file(filename, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + return drflac__full_read_and_close_f32(pFlac, channels, sampleRate, totalPCMFrameCount); +} +#endif + +DRFLAC_API drflac_int32* drflac_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + + if (sampleRate) { + *sampleRate = 0; + } + if (channels) { + *channels = 0; + } + if (totalPCMFrameCount) { + *totalPCMFrameCount = 0; + } + + pFlac = drflac_open_memory(data, dataSize, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + return drflac__full_read_and_close_s32(pFlac, channels, sampleRate, totalPCMFrameCount); +} + +DRFLAC_API drflac_int16* drflac_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + + if (sampleRate) { + *sampleRate = 0; + } + if (channels) { + *channels = 0; + } + if (totalPCMFrameCount) { + *totalPCMFrameCount = 0; + } + + pFlac = drflac_open_memory(data, dataSize, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + return drflac__full_read_and_close_s16(pFlac, channels, sampleRate, totalPCMFrameCount); +} + +DRFLAC_API float* drflac_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drflac_uint64* totalPCMFrameCount, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + drflac* pFlac; + + if (sampleRate) { + *sampleRate = 0; + } + if (channels) { + *channels = 0; + } + if (totalPCMFrameCount) { + *totalPCMFrameCount = 0; + } + + pFlac = drflac_open_memory(data, dataSize, pAllocationCallbacks); + if (pFlac == NULL) { + return NULL; + } + + return drflac__full_read_and_close_f32(pFlac, channels, sampleRate, totalPCMFrameCount); +} + + +DRFLAC_API void drflac_free(void* p, const drflac_allocation_callbacks* pAllocationCallbacks) +{ + if (pAllocationCallbacks != NULL) { + drflac__free_from_callbacks(p, pAllocationCallbacks); + } else { + drflac__free_default(p, NULL); + } +} + + + + +DRFLAC_API void drflac_init_vorbis_comment_iterator(drflac_vorbis_comment_iterator* pIter, drflac_uint32 commentCount, const void* pComments) +{ + if (pIter == NULL) { + return; + } + + pIter->countRemaining = commentCount; + pIter->pRunningData = (const char*)pComments; +} + +DRFLAC_API const char* drflac_next_vorbis_comment(drflac_vorbis_comment_iterator* pIter, drflac_uint32* pCommentLengthOut) +{ + drflac_int32 length; + const char* pComment; + + /* Safety. */ + if (pCommentLengthOut) { + *pCommentLengthOut = 0; + } + + if (pIter == NULL || pIter->countRemaining == 0 || pIter->pRunningData == NULL) { + return NULL; + } + + length = drflac__le2host_32(*(const drflac_uint32*)pIter->pRunningData); + pIter->pRunningData += 4; + + pComment = pIter->pRunningData; + pIter->pRunningData += length; + pIter->countRemaining -= 1; + + if (pCommentLengthOut) { + *pCommentLengthOut = length; + } + + return pComment; +} + + + + +DRFLAC_API void drflac_init_cuesheet_track_iterator(drflac_cuesheet_track_iterator* pIter, drflac_uint32 trackCount, const void* pTrackData) +{ + if (pIter == NULL) { + return; + } + + pIter->countRemaining = trackCount; + pIter->pRunningData = (const char*)pTrackData; +} + +DRFLAC_API drflac_bool32 drflac_next_cuesheet_track(drflac_cuesheet_track_iterator* pIter, drflac_cuesheet_track* pCuesheetTrack) +{ + drflac_cuesheet_track cuesheetTrack; + const char* pRunningData; + drflac_uint64 offsetHi; + drflac_uint64 offsetLo; + + if (pIter == NULL || pIter->countRemaining == 0 || pIter->pRunningData == NULL) { + return DRFLAC_FALSE; + } + + pRunningData = pIter->pRunningData; + + offsetHi = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + offsetLo = drflac__be2host_32(*(const drflac_uint32*)pRunningData); pRunningData += 4; + cuesheetTrack.offset = offsetLo | (offsetHi << 32); + cuesheetTrack.trackNumber = pRunningData[0]; pRunningData += 1; + DRFLAC_COPY_MEMORY(cuesheetTrack.ISRC, pRunningData, sizeof(cuesheetTrack.ISRC)); pRunningData += 12; + cuesheetTrack.isAudio = (pRunningData[0] & 0x80) != 0; + cuesheetTrack.preEmphasis = (pRunningData[0] & 0x40) != 0; pRunningData += 14; + cuesheetTrack.indexCount = pRunningData[0]; pRunningData += 1; + cuesheetTrack.pIndexPoints = (const drflac_cuesheet_track_index*)pRunningData; pRunningData += cuesheetTrack.indexCount * sizeof(drflac_cuesheet_track_index); + + pIter->pRunningData = pRunningData; + pIter->countRemaining -= 1; + + if (pCuesheetTrack) { + *pCuesheetTrack = cuesheetTrack; + } + + return DRFLAC_TRUE; +} + +#if defined(__GNUC__) + #pragma GCC diagnostic pop +#endif +#endif /* dr_flac_c */ +#endif /* DR_FLAC_IMPLEMENTATION */ + + +/* +REVISION HISTORY +================ +v0.12.15 - 2020-07-06 + - Check for negative LPC shifts and return an error. + +v0.12.14 - 2020-06-23 + - Add include guard for the implementation section. + +v0.12.13 - 2020-05-16 + - Add compile-time and run-time version querying. + - DRFLAC_VERSION_MINOR + - DRFLAC_VERSION_MAJOR + - DRFLAC_VERSION_REVISION + - DRFLAC_VERSION_STRING + - drflac_version() + - drflac_version_string() + +v0.12.12 - 2020-04-30 + - Fix compilation errors with VC6. + +v0.12.11 - 2020-04-19 + - Fix some pedantic warnings. + - Fix some undefined behaviour warnings. + +v0.12.10 - 2020-04-10 + - Fix some bugs when trying to seek with an invalid seek table. + +v0.12.9 - 2020-04-05 + - Fix warnings. + +v0.12.8 - 2020-04-04 + - Add drflac_open_file_w() and drflac_open_file_with_metadata_w(). + - Fix some static analysis warnings. + - Minor documentation updates. + +v0.12.7 - 2020-03-14 + - Fix compilation errors with VC6. + +v0.12.6 - 2020-03-07 + - Fix compilation error with Visual Studio .NET 2003. + +v0.12.5 - 2020-01-30 + - Silence some static analysis warnings. + +v0.12.4 - 2020-01-29 + - Silence some static analysis warnings. + +v0.12.3 - 2019-12-02 + - Fix some warnings when compiling with GCC and the -Og flag. + - Fix a crash in out-of-memory situations. + - Fix potential integer overflow bug. + - Fix some static analysis warnings. + - Fix a possible crash when using custom memory allocators without a custom realloc() implementation. + - Fix a bug with binary search seeking where the bits per sample is not a multiple of 8. + +v0.12.2 - 2019-10-07 + - Internal code clean up. + +v0.12.1 - 2019-09-29 + - Fix some Clang Static Analyzer warnings. + - Fix an unused variable warning. + +v0.12.0 - 2019-09-23 + - API CHANGE: Add support for user defined memory allocation routines. This system allows the program to specify their own memory allocation + routines with a user data pointer for client-specific contextual data. This adds an extra parameter to the end of the following APIs: + - drflac_open() + - drflac_open_relaxed() + - drflac_open_with_metadata() + - drflac_open_with_metadata_relaxed() + - drflac_open_file() + - drflac_open_file_with_metadata() + - drflac_open_memory() + - drflac_open_memory_with_metadata() + - drflac_open_and_read_pcm_frames_s32() + - drflac_open_and_read_pcm_frames_s16() + - drflac_open_and_read_pcm_frames_f32() + - drflac_open_file_and_read_pcm_frames_s32() + - drflac_open_file_and_read_pcm_frames_s16() + - drflac_open_file_and_read_pcm_frames_f32() + - drflac_open_memory_and_read_pcm_frames_s32() + - drflac_open_memory_and_read_pcm_frames_s16() + - drflac_open_memory_and_read_pcm_frames_f32() + Set this extra parameter to NULL to use defaults which is the same as the previous behaviour. Setting this NULL will use + DRFLAC_MALLOC, DRFLAC_REALLOC and DRFLAC_FREE. + - Remove deprecated APIs: + - drflac_read_s32() + - drflac_read_s16() + - drflac_read_f32() + - drflac_seek_to_sample() + - drflac_open_and_decode_s32() + - drflac_open_and_decode_s16() + - drflac_open_and_decode_f32() + - drflac_open_and_decode_file_s32() + - drflac_open_and_decode_file_s16() + - drflac_open_and_decode_file_f32() + - drflac_open_and_decode_memory_s32() + - drflac_open_and_decode_memory_s16() + - drflac_open_and_decode_memory_f32() + - Remove drflac.totalSampleCount which is now replaced with drflac.totalPCMFrameCount. You can emulate drflac.totalSampleCount + by doing pFlac->totalPCMFrameCount*pFlac->channels. + - Rename drflac.currentFrame to drflac.currentFLACFrame to remove ambiguity with PCM frames. + - Fix errors when seeking to the end of a stream. + - Optimizations to seeking. + - SSE improvements and optimizations. + - ARM NEON optimizations. + - Optimizations to drflac_read_pcm_frames_s16(). + - Optimizations to drflac_read_pcm_frames_s32(). + +v0.11.10 - 2019-06-26 + - Fix a compiler error. + +v0.11.9 - 2019-06-16 + - Silence some ThreadSanitizer warnings. + +v0.11.8 - 2019-05-21 + - Fix warnings. + +v0.11.7 - 2019-05-06 + - C89 fixes. + +v0.11.6 - 2019-05-05 + - Add support for C89. + - Fix a compiler warning when CRC is disabled. + - Change license to choice of public domain or MIT-0. + +v0.11.5 - 2019-04-19 + - Fix a compiler error with GCC. + +v0.11.4 - 2019-04-17 + - Fix some warnings with GCC when compiling with -std=c99. + +v0.11.3 - 2019-04-07 + - Silence warnings with GCC. + +v0.11.2 - 2019-03-10 + - Fix a warning. + +v0.11.1 - 2019-02-17 + - Fix a potential bug with seeking. + +v0.11.0 - 2018-12-16 + - API CHANGE: Deprecated drflac_read_s32(), drflac_read_s16() and drflac_read_f32() and replaced them with + drflac_read_pcm_frames_s32(), drflac_read_pcm_frames_s16() and drflac_read_pcm_frames_f32(). The new APIs take + and return PCM frame counts instead of sample counts. To upgrade you will need to change the input count by + dividing it by the channel count, and then do the same with the return value. + - API_CHANGE: Deprecated drflac_seek_to_sample() and replaced with drflac_seek_to_pcm_frame(). Same rules as + the changes to drflac_read_*() apply. + - API CHANGE: Deprecated drflac_open_and_decode_*() and replaced with drflac_open_*_and_read_*(). Same rules as + the changes to drflac_read_*() apply. + - Optimizations. + +v0.10.0 - 2018-09-11 + - Remove the DR_FLAC_NO_WIN32_IO option and the Win32 file IO functionality. If you need to use Win32 file IO you + need to do it yourself via the callback API. + - Fix the clang build. + - Fix undefined behavior. + - Fix errors with CUESHEET metdata blocks. + - Add an API for iterating over each cuesheet track in the CUESHEET metadata block. This works the same way as the + Vorbis comment API. + - Other miscellaneous bug fixes, mostly relating to invalid FLAC streams. + - Minor optimizations. + +v0.9.11 - 2018-08-29 + - Fix a bug with sample reconstruction. + +v0.9.10 - 2018-08-07 + - Improve 64-bit detection. + +v0.9.9 - 2018-08-05 + - Fix C++ build on older versions of GCC. + +v0.9.8 - 2018-07-24 + - Fix compilation errors. + +v0.9.7 - 2018-07-05 + - Fix a warning. + +v0.9.6 - 2018-06-29 + - Fix some typos. + +v0.9.5 - 2018-06-23 + - Fix some warnings. + +v0.9.4 - 2018-06-14 + - Optimizations to seeking. + - Clean up. + +v0.9.3 - 2018-05-22 + - Bug fix. + +v0.9.2 - 2018-05-12 + - Fix a compilation error due to a missing break statement. + +v0.9.1 - 2018-04-29 + - Fix compilation error with Clang. + +v0.9 - 2018-04-24 + - Fix Clang build. + - Start using major.minor.revision versioning. + +v0.8g - 2018-04-19 + - Fix build on non-x86/x64 architectures. + +v0.8f - 2018-02-02 + - Stop pretending to support changing rate/channels mid stream. + +v0.8e - 2018-02-01 + - Fix a crash when the block size of a frame is larger than the maximum block size defined by the FLAC stream. + - Fix a crash the the Rice partition order is invalid. + +v0.8d - 2017-09-22 + - Add support for decoding streams with ID3 tags. ID3 tags are just skipped. + +v0.8c - 2017-09-07 + - Fix warning on non-x86/x64 architectures. + +v0.8b - 2017-08-19 + - Fix build on non-x86/x64 architectures. + +v0.8a - 2017-08-13 + - A small optimization for the Clang build. + +v0.8 - 2017-08-12 + - API CHANGE: Rename dr_* types to drflac_*. + - Optimizations. This brings dr_flac back to about the same class of efficiency as the reference implementation. + - Add support for custom implementations of malloc(), realloc(), etc. + - Add CRC checking to Ogg encapsulated streams. + - Fix VC++ 6 build. This is only for the C++ compiler. The C compiler is not currently supported. + - Bug fixes. + +v0.7 - 2017-07-23 + - Add support for opening a stream without a header block. To do this, use drflac_open_relaxed() / drflac_open_with_metadata_relaxed(). + +v0.6 - 2017-07-22 + - Add support for recovering from invalid frames. With this change, dr_flac will simply skip over invalid frames as if they + never existed. Frames are checked against their sync code, the CRC-8 of the frame header and the CRC-16 of the whole frame. + +v0.5 - 2017-07-16 + - Fix typos. + - Change drflac_bool* types to unsigned. + - Add CRC checking. This makes dr_flac slower, but can be disabled with #define DR_FLAC_NO_CRC. + +v0.4f - 2017-03-10 + - Fix a couple of bugs with the bitstreaming code. + +v0.4e - 2017-02-17 + - Fix some warnings. + +v0.4d - 2016-12-26 + - Add support for 32-bit floating-point PCM decoding. + - Use drflac_int* and drflac_uint* sized types to improve compiler support. + - Minor improvements to documentation. + +v0.4c - 2016-12-26 + - Add support for signed 16-bit integer PCM decoding. + +v0.4b - 2016-10-23 + - A minor change to drflac_bool8 and drflac_bool32 types. + +v0.4a - 2016-10-11 + - Rename drBool32 to drflac_bool32 for styling consistency. + +v0.4 - 2016-09-29 + - API/ABI CHANGE: Use fixed size 32-bit booleans instead of the built-in bool type. + - API CHANGE: Rename drflac_open_and_decode*() to drflac_open_and_decode*_s32(). + - API CHANGE: Swap the order of "channels" and "sampleRate" parameters in drflac_open_and_decode*(). Rationale for this is to + keep it consistent with drflac_audio. + +v0.3f - 2016-09-21 + - Fix a warning with GCC. + +v0.3e - 2016-09-18 + - Fixed a bug where GCC 4.3+ was not getting properly identified. + - Fixed a few typos. + - Changed date formats to ISO 8601 (YYYY-MM-DD). + +v0.3d - 2016-06-11 + - Minor clean up. + +v0.3c - 2016-05-28 + - Fixed compilation error. + +v0.3b - 2016-05-16 + - Fixed Linux/GCC build. + - Updated documentation. + +v0.3a - 2016-05-15 + - Minor fixes to documentation. + +v0.3 - 2016-05-11 + - Optimizations. Now at about parity with the reference implementation on 32-bit builds. + - Lots of clean up. + +v0.2b - 2016-05-10 + - Bug fixes. + +v0.2a - 2016-05-10 + - Made drflac_open_and_decode() more robust. + - Removed an unused debugging variable + +v0.2 - 2016-05-09 + - Added support for Ogg encapsulation. + - API CHANGE. Have the onSeek callback take a third argument which specifies whether or not the seek + should be relative to the start or the current position. Also changes the seeking rules such that + seeking offsets will never be negative. + - Have drflac_open_and_decode() fail gracefully if the stream has an unknown total sample count. + +v0.1b - 2016-05-07 + - Properly close the file handle in drflac_open_file() and family when the decoder fails to initialize. + - Removed a stale comment. + +v0.1a - 2016-05-05 + - Minor formatting changes. + - Fixed a warning on the GCC build. + +v0.1 - 2016-05-03 + - Initial versioned release. +*/ + +/* +This software is available as a choice of the following licenses. Choose +whichever you prefer. + +=============================================================================== +ALTERNATIVE 1 - Public Domain (www.unlicense.org) +=============================================================================== +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. + +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to + +=============================================================================== +ALTERNATIVE 2 - MIT No Attribution +=============================================================================== +Copyright 2020 David Reid + +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. + +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. +*/ diff --git a/libs/include/dr_pcx.h b/libs/include/dr_pcx.h new file mode 100644 index 0000000..04f9adc --- /dev/null +++ b/libs/include/dr_pcx.h @@ -0,0 +1,793 @@ +// PCX image loader. Public domain. See "unlicense" statement at the end of this file. +// dr_pcx - v0.3.1 - 2018-09-11 +// +// David Reid - mackron@gmail.com + +// USAGE +// +// dr_pcx is a single-file library. To use it, do something like the following in one .c file. +// #define DR_PCX_IMPLEMENTATION +// #include "dr_pcx.h" +// +// You can then #include this file in other parts of the program as you would with any other header file. Do something like +// the following to load and decode an image: +// +// int width; +// int height; +// int components +// drpcx_uint8* pImageData = drpcx_load_file("my_image.pcx", DRPCX_FALSE, &width, &height, &components, 0); +// if (pImageData == NULL) { +// // Failed to load image. +// } +// +// ... +// +// drpcx_free(pImageData); +// +// The boolean parameter (second argument in the above example) is whether or not the image should be flipped upside down. +// +// +// +// OPTIONS +// #define these options before including this file. +// +// #define DR_PCX_NO_STDIO +// Disable drpcx_load_file(). +// +// +// +// QUICK NOTES +// - 2-bpp/4-plane and 4-bpp/1-plane formats have not been tested. + +#ifndef dr_pcx_h +#define dr_pcx_h + +#include + +#if defined(_MSC_VER) && _MSC_VER < 1600 +typedef signed char drpcx_int8; +typedef unsigned char drpcx_uint8; +typedef signed short drpcx_int16; +typedef unsigned short drpcx_uint16; +typedef signed int drpcx_int32; +typedef unsigned int drpcx_uint32; +typedef signed __int64 drpcx_int64; +typedef unsigned __int64 drpcx_uint64; +#else +#include +typedef int8_t drpcx_int8; +typedef uint8_t drpcx_uint8; +typedef int16_t drpcx_int16; +typedef uint16_t drpcx_uint16; +typedef int32_t drpcx_int32; +typedef uint32_t drpcx_uint32; +typedef int64_t drpcx_int64; +typedef uint64_t drpcx_uint64; +#endif +typedef drpcx_uint8 drpcx_bool8; +typedef drpcx_uint32 drpcx_bool32; +#define DRPCX_TRUE 1 +#define DRPCX_FALSE 0 + +#ifdef __cplusplus +extern "C" { +#endif + +// Callback for when data is read. Return value is the number of bytes actually read. +typedef size_t (* drpcx_read_proc)(void* userData, void* bufferOut, size_t bytesToRead); + + +// Loads a PCX file using the given callbacks. +drpcx_uint8* drpcx_load(drpcx_read_proc onRead, void* pUserData, drpcx_bool32 flipped, int* x, int* y, int* internalComponents, int desiredComponents); + +// Frees memory returned by drpcx_load() and family. +void drpcx_free(void* pReturnValueFromLoad); + + +#ifndef DR_PCX_NO_STDIO +// Loads an PCX file from an actual file. +drpcx_uint8* drpcx_load_file(const char* filename, drpcx_bool32 flipped, int* x, int* y, int* internalComponents, int desiredComponents); +#endif + +// Helper for loading an PCX file from a block of memory. +drpcx_uint8* drpcx_load_memory(const void* data, size_t dataSize, drpcx_bool32 flipped, int* x, int* y, int* internalComponents, int desiredComponents); + + +#ifdef __cplusplus +} +#endif + +#endif // dr_pcx_h + + +/////////////////////////////////////////////////////////////////////////////// +// +// IMPLEMENTATION +// +/////////////////////////////////////////////////////////////////////////////// +#ifdef DR_PCX_IMPLEMENTATION +#include +#include +#include + +#ifndef DR_PCX_NO_STDIO +#include + +static size_t drpcx__on_read_stdio(void* pUserData, void* bufferOut, size_t bytesToRead) +{ + return fread(bufferOut, 1, bytesToRead, (FILE*)pUserData); +} + +drpcx_uint8* drpcx_load_file(const char* filename, drpcx_bool32 flipped, int* x, int* y, int* internalComponents, int desiredComponents) +{ + FILE* pFile; +#ifdef _MSC_VER + if (fopen_s(&pFile, filename, "rb") != 0) { + return NULL; + } +#else + pFile = fopen(filename, "rb"); + if (pFile == NULL) { + return NULL; + } +#endif + + drpcx_uint8* pImageData = drpcx_load(drpcx__on_read_stdio, pFile, flipped, x, y, internalComponents, desiredComponents); + + fclose(pFile); + return pImageData; +} +#endif // DR_PCX_NO_STDIO + + +typedef struct +{ + // A pointer to the beginning of the data. We use a char as the type here for easy offsetting. + const unsigned char* data; + size_t dataSize; + size_t currentReadPos; +} drpcx_memory; + +static size_t drpcx__on_read_memory(void* pUserData, void* bufferOut, size_t bytesToRead) +{ + drpcx_memory* memory = (drpcx_memory*)pUserData; + assert(memory != NULL); + assert(memory->dataSize >= memory->currentReadPos); + + size_t bytesRemaining = memory->dataSize - memory->currentReadPos; + if (bytesToRead > bytesRemaining) { + bytesToRead = bytesRemaining; + } + + if (bytesToRead > 0) { + memcpy(bufferOut, memory->data + memory->currentReadPos, bytesToRead); + memory->currentReadPos += bytesToRead; + } + + return bytesToRead; +} + +drpcx_uint8* drpcx_load_memory(const void* data, size_t dataSize, drpcx_bool32 flipped, int* x, int* y, int* internalComponents, int desiredComponents) +{ + drpcx_memory memory; + memory.data = (const unsigned char*)data; + memory.dataSize = dataSize; + memory.currentReadPos = 0; + return drpcx_load(drpcx__on_read_memory, &memory, flipped, x, y, internalComponents, desiredComponents); +} + + +typedef struct +{ + drpcx_uint8 header; + drpcx_uint8 version; + drpcx_uint8 encoding; + drpcx_uint8 bpp; + drpcx_uint16 left; + drpcx_uint16 top; + drpcx_uint16 right; + drpcx_uint16 bottom; + drpcx_uint16 hres; + drpcx_uint16 vres; + drpcx_uint8 palette16[48]; + drpcx_uint8 reserved1; + drpcx_uint8 bitPlanes; + drpcx_uint16 bytesPerLine; + drpcx_uint16 paletteType; + drpcx_uint16 screenSizeH; + drpcx_uint16 screenSizeV; + drpcx_uint8 reserved2[54]; +} drpcx_header; + +typedef struct +{ + drpcx_read_proc onRead; + void* pUserData; + drpcx_bool32 flipped; + drpcx_header header; + + drpcx_uint32 width; + drpcx_uint32 height; + drpcx_uint32 components; // 3 = RGB; 4 = RGBA. Only 3 and 4 are supported. + drpcx_uint8* pImageData; +} drpcx; + + +static drpcx_uint8 drpcx__read_byte(drpcx* pPCX) +{ + drpcx_uint8 byte = 0; + pPCX->onRead(pPCX->pUserData, &byte, 1); + + return byte; +} + +static drpcx_uint8* drpcx__row_ptr(drpcx* pPCX, drpcx_uint32 row) +{ + drpcx_uint32 stride = pPCX->width * pPCX->components; + + drpcx_uint8* pRow = pPCX->pImageData; + if (pPCX->flipped) { + pRow += (pPCX->height - row - 1) * stride; + } else { + pRow += row * stride; + } + + return pRow; +} + +static drpcx_uint8 drpcx__rle(drpcx* pPCX, drpcx_uint8* pRLEValueOut) +{ + drpcx_uint8 rleCount; + drpcx_uint8 rleValue; + + rleValue = drpcx__read_byte(pPCX); + if ((rleValue & 0xC0) == 0xC0) { + rleCount = rleValue & 0x3F; + rleValue = drpcx__read_byte(pPCX); + } else { + rleCount = 1; + } + + + *pRLEValueOut = rleValue; + return rleCount; +} + + +drpcx_bool32 drpcx__decode_1bit(drpcx* pPCX) +{ + drpcx_uint8 rleCount = 0; + drpcx_uint8 rleValue = 0; + + switch (pPCX->header.bitPlanes) + { + case 1: + { + for (drpcx_uint32 y = 0; y < pPCX->height; ++y) { + drpcx_uint8* pRow = drpcx__row_ptr(pPCX, y); + for (drpcx_uint32 x = 0; x < pPCX->header.bytesPerLine; ++x) { + if (rleCount == 0) { + rleCount = drpcx__rle(pPCX, &rleValue); + } + rleCount -= 1; + + for (int bit = 0; (bit < 8) && ((x*8 + bit) < pPCX->width); ++bit) { + drpcx_uint8 mask = (1 << (7 - bit)); + drpcx_uint8 paletteIndex = (rleValue & mask) >> (7 - bit); + + pRow[0] = paletteIndex * 255; + pRow[1] = paletteIndex * 255; + pRow[2] = paletteIndex * 255; + pRow += 3; + } + } + } + + return DRPCX_TRUE; + + } break; + + case 2: + case 3: + case 4: + { + for (drpcx_uint32 y = 0; y < pPCX->height; ++y) { + for (drpcx_uint32 c = 0; c < pPCX->header.bitPlanes; ++c) { + drpcx_uint8* pRow = drpcx__row_ptr(pPCX, y); + for (drpcx_uint32 x = 0; x < pPCX->header.bytesPerLine; ++x) { + if (rleCount == 0) { + rleCount = drpcx__rle(pPCX, &rleValue); + } + rleCount -= 1; + + for (int bit = 0; (bit < 8) && ((x*8 + bit) < pPCX->width); ++bit) { + drpcx_uint8 mask = (1 << (7 - bit)); + drpcx_uint8 paletteIndex = (rleValue & mask) >> (7 - bit); + + pRow[0] |= ((paletteIndex & 0x01) << c); + pRow += pPCX->components; + } + } + } + + + drpcx_uint8* pRow = drpcx__row_ptr(pPCX, y); + for (drpcx_uint32 x = 0; x < pPCX->width; ++x) { + drpcx_uint8 paletteIndex = pRow[0]; + for (drpcx_uint32 c = 0; c < pPCX->components; ++c) { + pRow[c] = pPCX->header.palette16[paletteIndex*3 + c]; + } + + pRow += pPCX->components; + } + } + + return DRPCX_TRUE; + } + + default: return DRPCX_FALSE; + } +} + +drpcx_bool32 drpcx__decode_2bit(drpcx* pPCX) +{ + drpcx_uint8 rleCount = 0; + drpcx_uint8 rleValue = 0; + + switch (pPCX->header.bitPlanes) + { + case 1: + { + drpcx_uint8 paletteCGA[48]; + paletteCGA[ 0] = 0x00; paletteCGA[ 1] = 0x00; paletteCGA[ 2] = 0x00; // #000000 + paletteCGA[ 3] = 0x00; paletteCGA[ 4] = 0x00; paletteCGA[ 5] = 0xAA; // #0000AA + paletteCGA[ 6] = 0x00; paletteCGA[ 7] = 0xAA; paletteCGA[ 8] = 0x00; // #00AA00 + paletteCGA[ 9] = 0x00; paletteCGA[10] = 0xAA; paletteCGA[11] = 0xAA; // #00AAAA + paletteCGA[12] = 0xAA; paletteCGA[13] = 0x00; paletteCGA[14] = 0x00; // #AA0000 + paletteCGA[15] = 0xAA; paletteCGA[16] = 0x00; paletteCGA[17] = 0xAA; // #AA00AA + paletteCGA[18] = 0xAA; paletteCGA[19] = 0x55; paletteCGA[20] = 0x00; // #AA5500 + paletteCGA[21] = 0xAA; paletteCGA[22] = 0xAA; paletteCGA[23] = 0xAA; // #AAAAAA + paletteCGA[24] = 0x55; paletteCGA[25] = 0x55; paletteCGA[26] = 0x55; // #555555 + paletteCGA[27] = 0x55; paletteCGA[28] = 0x55; paletteCGA[29] = 0xFF; // #5555FF + paletteCGA[30] = 0x55; paletteCGA[31] = 0xFF; paletteCGA[32] = 0x55; // #55FF55 + paletteCGA[33] = 0x55; paletteCGA[34] = 0xFF; paletteCGA[35] = 0xFF; // #55FFFF + paletteCGA[36] = 0xFF; paletteCGA[37] = 0x55; paletteCGA[38] = 0x55; // #FF5555 + paletteCGA[39] = 0xFF; paletteCGA[40] = 0x55; paletteCGA[41] = 0xFF; // #FF55FF + paletteCGA[42] = 0xFF; paletteCGA[43] = 0xFF; paletteCGA[44] = 0x55; // #FFFF55 + paletteCGA[45] = 0xFF; paletteCGA[46] = 0xFF; paletteCGA[47] = 0xFF; // #FFFFFF + + drpcx_uint8 cgaBGColor = pPCX->header.palette16[0] >> 4; + drpcx_uint8 i = (pPCX->header.palette16[3] & 0x20) >> 5; + drpcx_uint8 p = (pPCX->header.palette16[3] & 0x40) >> 6; + //drpcx_uint8 c = (pPCX->header.palette16[3] & 0x80) >> 7; // Color or monochrome. How is monochrome handled? + + for (drpcx_uint32 y = 0; y < pPCX->height; ++y) { + drpcx_uint8* pRow = drpcx__row_ptr(pPCX, y); + for (drpcx_uint32 x = 0; x < pPCX->header.bytesPerLine; ++x) { + if (rleCount == 0) { + rleCount = drpcx__rle(pPCX, &rleValue); + } + rleCount -= 1; + + for (int bit = 0; bit < 4; ++bit) { + if (x*4 + bit < pPCX->width) { + drpcx_uint8 mask = (3 << ((3 - bit) * 2)); + drpcx_uint8 paletteIndex = (rleValue & mask) >> ((3 - bit) * 2); + + drpcx_uint8 cgaIndex; + if (paletteIndex == 0) { // Background. + cgaIndex = cgaBGColor; + } else { // Foreground + cgaIndex = (((paletteIndex << 1) + p) + (i << 3)); + } + + pRow[0] = paletteCGA[cgaIndex*3 + 0]; + pRow[1] = paletteCGA[cgaIndex*3 + 1]; + pRow[2] = paletteCGA[cgaIndex*3 + 2]; + pRow += 3; + } + } + } + } + + // TODO: According to http://www.fysnet.net/pcxfile.htm, we should use the palette at the end of the file + // instead of the standard CGA palette if the version is equal to 5. With my test files the palette + // at the end of the file does not exist. Research this one. + if (pPCX->header.version == 5) { + drpcx_uint8 paletteMarker = drpcx__read_byte(pPCX); + if (paletteMarker == 0x0C) { + // TODO: Implement Me. + } + } + + return DRPCX_TRUE; + }; + + case 4: + { + // NOTE: This is completely untested. If anybody knows where I can get a test file please let me know or send it through to me! + // TODO: Test Me. + + for (drpcx_uint32 y = 0; y < pPCX->height; ++y) { + for (drpcx_uint32 c = 0; c < pPCX->header.bitPlanes; ++c) { + drpcx_uint8* pRow = drpcx__row_ptr(pPCX, y); + for (drpcx_uint32 x = 0; x < pPCX->header.bytesPerLine; ++x) { + if (rleCount == 0) { + rleCount = drpcx__rle(pPCX, &rleValue); + } + rleCount -= 1; + + for (int bitpair = 0; (bitpair < 4) && ((x*4 + bitpair) < pPCX->width); ++bitpair) { + drpcx_uint8 mask = (4 << (3 - bitpair)); + drpcx_uint8 paletteIndex = (rleValue & mask) >> (3 - bitpair); + + pRow[0] |= ((paletteIndex & 0x03) << (c*2)); + pRow += pPCX->components; + } + } + } + + + drpcx_uint8* pRow = drpcx__row_ptr(pPCX, y); + for (drpcx_uint32 x = 0; x < pPCX->width; ++x) { + drpcx_uint8 paletteIndex = pRow[0]; + for (drpcx_uint32 c = 0; c < pPCX->header.bitPlanes; ++c) { + pRow[c] = pPCX->header.palette16[paletteIndex*3 + c]; + } + + pRow += pPCX->components; + } + } + + return DRPCX_TRUE; + }; + + default: return DRPCX_FALSE; + } +} + +drpcx_bool32 drpcx__decode_4bit(drpcx* pPCX) +{ + // NOTE: This is completely untested. If anybody knows where I can get a test file please let me know or send it through to me! + // TODO: Test Me. + + if (pPCX->header.bitPlanes > 1) { + return DRPCX_FALSE; + } + + drpcx_uint8 rleCount = 0; + drpcx_uint8 rleValue = 0; + + for (drpcx_uint32 y = 0; y < pPCX->height; ++y) { + for (drpcx_uint32 c = 0; c < pPCX->header.bitPlanes; ++c) { + drpcx_uint8* pRow = drpcx__row_ptr(pPCX, y); + for (drpcx_uint32 x = 0; x < pPCX->header.bytesPerLine; ++x) { + if (rleCount == 0) { + rleCount = drpcx__rle(pPCX, &rleValue); + } + rleCount -= 1; + + for (int nibble = 0; (nibble < 2) && ((x*2 + nibble) < pPCX->width); ++nibble) + { + drpcx_uint8 mask = (4 << (1 - nibble)); + drpcx_uint8 paletteIndex = (rleValue & mask) >> (1 - nibble); + + pRow[0] |= ((paletteIndex & 0x0F) << (c*4)); + pRow += pPCX->components; + } + } + } + + + drpcx_uint8* pRow = drpcx__row_ptr(pPCX, y); + for (drpcx_uint32 x = 0; x < pPCX->width; ++x) { + drpcx_uint8 paletteIndex = pRow[0]; + for (drpcx_uint32 c = 0; c < pPCX->components; ++c) { + pRow[c] = pPCX->header.palette16[paletteIndex*3 + c]; + } + + pRow += pPCX->components; + } + } + + return DRPCX_TRUE; +} + +drpcx_bool32 drpcx__decode_8bit(drpcx* pPCX) +{ + drpcx_uint8 rleCount = 0; + drpcx_uint8 rleValue = 0; + drpcx_uint32 stride = pPCX->width * pPCX->components; + + switch (pPCX->header.bitPlanes) + { + case 1: + { + for (drpcx_uint32 y = 0; y < pPCX->height; ++y) { + drpcx_uint8* pRow = drpcx__row_ptr(pPCX, y); + for (drpcx_uint32 x = 0; x < pPCX->header.bytesPerLine; ++x) { + if (rleCount == 0) { + rleCount = drpcx__rle(pPCX, &rleValue); + } + rleCount -= 1; + + if (x < pPCX->width) { + pRow[0] = rleValue; + pRow[1] = rleValue; + pRow[2] = rleValue; + pRow += 3; + } + } + } + + // At this point we can know if we are dealing with a palette or a grayscale image by checking the next byte. If it's equal to 0x0C, we + // need to do a simple palette lookup. + drpcx_uint8 paletteMarker = drpcx__read_byte(pPCX); + if (paletteMarker == 0x0C) { + // A palette is present - we need to do a second pass. + drpcx_uint8 palette256[768]; + if (pPCX->onRead(pPCX->pUserData, palette256, sizeof(palette256)) != sizeof(palette256)) { + return DRPCX_FALSE; + } + + for (drpcx_uint32 y = 0; y < pPCX->height; ++y) { + drpcx_uint8* pRow = pPCX->pImageData + (y * stride); + for (drpcx_uint32 x = 0; x < pPCX->width; ++x) { + drpcx_uint8 index = pRow[0]; + pRow[0] = palette256[index*3 + 0]; + pRow[1] = palette256[index*3 + 1]; + pRow[2] = palette256[index*3 + 2]; + pRow += 3; + } + } + } + + return DRPCX_TRUE; + } + + case 3: + case 4: + { + for (drpcx_uint32 y = 0; y < pPCX->height; ++y) { + for (drpcx_uint32 c = 0; c < pPCX->components; ++c) { + drpcx_uint8* pRow = drpcx__row_ptr(pPCX, y); + for (drpcx_uint32 x = 0; x < pPCX->header.bytesPerLine; ++x) { + if (rleCount == 0) { + rleCount = drpcx__rle(pPCX, &rleValue); + } + rleCount -= 1; + + if (x < pPCX->width) { + pRow[c] = rleValue; + pRow += pPCX->components; + } + } + } + } + + return DRPCX_TRUE; + } + } + + return DRPCX_TRUE; +} + +drpcx_uint8* drpcx_load(drpcx_read_proc onRead, void* pUserData, drpcx_bool32 flipped, int* x, int* y, int* internalComponents, int desiredComponents) +{ + if (onRead == NULL) return NULL; + if (desiredComponents > 4) return NULL; + + drpcx pcx; + pcx.onRead = onRead; + pcx.pUserData = pUserData; + pcx.flipped = flipped; + if (onRead(pUserData, &pcx.header, sizeof(pcx.header)) != sizeof(pcx.header)) { + return NULL; // Failed to read the header. + } + + if (pcx.header.header != 10) { + return NULL; // Not a PCX file. + } + + if (pcx.header.encoding != 1) { + return NULL; // Not supporting non-RLE encoding. Would assume a value of 0 indicates raw, unencoded, but that is apparently never used. + } + + if (pcx.header.bpp != 1 && pcx.header.bpp != 2 && pcx.header.bpp != 4 && pcx.header.bpp != 8) { + return NULL; // Unsupported pixel format. + } + + + if (pcx.header.left > pcx.header.right) { + drpcx_uint16 temp = pcx.header.left; + pcx.header.left = pcx.header.right; + pcx.header.right = temp; + } + if (pcx.header.top > pcx.header.bottom) { + drpcx_uint16 temp = pcx.header.top; + pcx.header.top = pcx.header.bottom; + pcx.header.bottom = temp; + } + + pcx.width = pcx.header.right - pcx.header.left + 1; + pcx.height = pcx.header.bottom - pcx.header.top + 1; + pcx.components = (pcx.header.bpp == 8 && pcx.header.bitPlanes == 4) ? 4 : 3; + + size_t dataSize = pcx.width * pcx.height * pcx.components; + pcx.pImageData = (drpcx_uint8*)calloc(1, dataSize); // <-- Clearing to zero is important! Required for proper decoding. + if (pcx.pImageData == NULL) { + return NULL; // Failed to allocate memory. + } + + drpcx_bool32 result = DRPCX_FALSE; + switch (pcx.header.bpp) + { + case 1: + { + result = drpcx__decode_1bit(&pcx); + } break; + + case 2: + { + result = drpcx__decode_2bit(&pcx); + } break; + + case 4: + { + result = drpcx__decode_4bit(&pcx); + } break; + + case 8: + { + result = drpcx__decode_8bit(&pcx); + } break; + } + + if (!result) { + free(pcx.pImageData); + return NULL; + } + + // There's an annoying amount of branching when loading PCX files so for simplicity I'm doing the component conversion as + // a second pass. + if (desiredComponents == 0) desiredComponents = pcx.components; + if (desiredComponents != (int)pcx.components) { + drpcx_uint8* pNewImageData = (drpcx_uint8*)malloc(pcx.width * pcx.height * desiredComponents); + if (pNewImageData == NULL) { + free(pcx.pImageData); + return NULL; + } + + drpcx_uint8* pSrcData = pcx.pImageData; + drpcx_uint8* pDstData = pNewImageData; + if (desiredComponents < (int)pcx.components) { + // We're reducing the number of components. Just drop the excess. + for (drpcx_uint32 i = 0; i < pcx.width*pcx.height; ++i) { + for (int c = 0; c < desiredComponents; ++c) { + pDstData[c] = pSrcData[c]; + } + + pSrcData += pcx.components; + pDstData += desiredComponents; + } + } else { + // We're increasing the number of components. Always ensure the alpha channel is set to 0xFF. + if (pcx.components == 1) { + for (drpcx_uint32 i = 0; i < pcx.width*pcx.height; ++i) { + for (int c = 0; c < desiredComponents; ++c) { + pDstData[c] = pSrcData[0]; + } + + pSrcData += pcx.components; + pDstData += desiredComponents; + } + } else if (pcx.components == 2) { + for (drpcx_uint32 i = 0; i < pcx.width*pcx.height; ++i) { + pDstData[0] = pSrcData[0]; + pDstData[1] = pSrcData[1]; + pDstData[2] = 0x00; + if (desiredComponents == 4) pDstData[3] = 0xFF; + + pSrcData += pcx.components; + pDstData += desiredComponents; + } + } else { + assert(pcx.components == 3); + assert(desiredComponents == 4); + for (drpcx_uint32 i = 0; i < pcx.width*pcx.height; ++i) { + pDstData[0] = pSrcData[0]; + pDstData[1] = pSrcData[1]; + pDstData[2] = pSrcData[2]; + pDstData[3] = 0xFF; + + pSrcData += pcx.components; + pDstData += desiredComponents; + } + } + } + + free(pcx.pImageData); + pcx.pImageData = pNewImageData; + } + + if (x) *x = pcx.width; + if (y) *y = pcx.height; + if (internalComponents) *internalComponents = pcx.components; + return pcx.pImageData; +} + +void drpcx_free(void* pReturnValueFromLoad) +{ + free(pReturnValueFromLoad); +} + +#endif // DR_PCX_IMPLEMENTATION + + +// REVISION HISTORY +// +// v0.3.1 - 2018-09-11 +// - Styling fixes. +// - Fix a typo. +// +// v0.3 - 2018-02-08 +// - API CHANGE: Rename dr_* types to drpcx_*. +// +// v0.2c - 2018-02-07 +// - Fix a crash. +// +// v0.2b - 2018-02-02 +// - Fix compilation error. +// +// v0.2a - 2017-07-16 +// - Change underlying type for booleans to unsigned. +// +// v0.2 - 2016-10-28 +// - API CHANGE: Add a parameter to drpcx_load() and family to control the number of output components. +// - Use custom sized types rather than built-in ones to improve support for older MSVC compilers. +// +// v0.1c - 2016-10-23 +// - A minor change to drpcx_bool8 and drpcx_bool32 types. +// +// v0.1b - 2016-10-11 +// - Use drpcx_bool32 instead of the built-in "bool" type. The reason for this change is that it helps maintain API/ABI consistency +// between C and C++ builds. +// +// v0.1a - 2016-09-18 +// - Change date format to ISO 8601 (YYYY-MM-DD) +// +// v0.1 - 2016-05-04 +// - Initial versioned release. + + +// TODO +// - Test 2-bpp/4-plane and 4-bpp/1-plane formats. + + +/* +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to +*/ + diff --git a/libs/include/dr_wav.h b/libs/include/dr_wav.h new file mode 100644 index 0000000..2fb30a4 --- /dev/null +++ b/libs/include/dr_wav.h @@ -0,0 +1,6279 @@ +/* +WAV audio loader and writer. Choice of public domain or MIT-0. See license statements at the end of this file. +dr_wav - v0.12.7 - 2020-07-15 + +David Reid - mackron@gmail.com + +GitHub: https://github.com/mackron/dr_libs +*/ + +/* +RELEASE NOTES - VERSION 0.12 +============================ +Version 0.12 includes breaking changes to custom chunk handling. + + +Changes to Chunk Callback +------------------------- +dr_wav supports the ability to fire a callback when a chunk is encounted (except for WAVE and FMT chunks). The callback has been updated to include both the +container (RIFF or Wave64) and the FMT chunk which contains information about the format of the data in the wave file. + +Previously, there was no direct way to determine the container, and therefore no way discriminate against the different IDs in the chunk header (RIFF and +Wave64 containers encode chunk ID's differently). The `container` parameter can be used to know which ID to use. + +Sometimes it can be useful to know the data format at the time the chunk callback is fired. A pointer to a `drwav_fmt` object is now passed into the chunk +callback which will give you information about the data format. To determine the sample format, use `drwav_fmt_get_format()`. This will return one of the +`DR_WAVE_FORMAT_*` tokens. +*/ + +/* +Introduction +============ +This is a single file library. To use it, do something like the following in one .c file. + + ```c + #define DR_WAV_IMPLEMENTATION + #include "dr_wav.h" + ``` + +You can then #include this file in other parts of the program as you would with any other header file. Do something like the following to read audio data: + + ```c + drwav wav; + if (!drwav_init_file(&wav, "my_song.wav", NULL)) { + // Error opening WAV file. + } + + drwav_int32* pDecodedInterleavedPCMFrames = malloc(wav.totalPCMFrameCount * wav.channels * sizeof(drwav_int32)); + size_t numberOfSamplesActuallyDecoded = drwav_read_pcm_frames_s32(&wav, wav.totalPCMFrameCount, pDecodedInterleavedPCMFrames); + + ... + + drwav_uninit(&wav); + ``` + +If you just want to quickly open and read the audio data in a single operation you can do something like this: + + ```c + unsigned int channels; + unsigned int sampleRate; + drwav_uint64 totalPCMFrameCount; + float* pSampleData = drwav_open_file_and_read_pcm_frames_f32("my_song.wav", &channels, &sampleRate, &totalPCMFrameCount, NULL); + if (pSampleData == NULL) { + // Error opening and reading WAV file. + } + + ... + + drwav_free(pSampleData); + ``` + +The examples above use versions of the API that convert the audio data to a consistent format (32-bit signed PCM, in this case), but you can still output the +audio data in its internal format (see notes below for supported formats): + + ```c + size_t framesRead = drwav_read_pcm_frames(&wav, wav.totalPCMFrameCount, pDecodedInterleavedPCMFrames); + ``` + +You can also read the raw bytes of audio data, which could be useful if dr_wav does not have native support for a particular data format: + + ```c + size_t bytesRead = drwav_read_raw(&wav, bytesToRead, pRawDataBuffer); + ``` + +dr_wav can also be used to output WAV files. This does not currently support compressed formats. To use this, look at `drwav_init_write()`, +`drwav_init_file_write()`, etc. Use `drwav_write_pcm_frames()` to write samples, or `drwav_write_raw()` to write raw data in the "data" chunk. + + ```c + drwav_data_format format; + format.container = drwav_container_riff; // <-- drwav_container_riff = normal WAV files, drwav_container_w64 = Sony Wave64. + format.format = DR_WAVE_FORMAT_PCM; // <-- Any of the DR_WAVE_FORMAT_* codes. + format.channels = 2; + format.sampleRate = 44100; + format.bitsPerSample = 16; + drwav_init_file_write(&wav, "data/recording.wav", &format, NULL); + + ... + + drwav_uint64 framesWritten = drwav_write_pcm_frames(pWav, frameCount, pSamples); + ``` + +dr_wav has seamless support the Sony Wave64 format. The decoder will automatically detect it and it should Just Work without any manual intervention. + + +Build Options +============= +#define these options before including this file. + +#define DR_WAV_NO_CONVERSION_API + Disables conversion APIs such as `drwav_read_pcm_frames_f32()` and `drwav_s16_to_f32()`. + +#define DR_WAV_NO_STDIO + Disables APIs that initialize a decoder from a file such as `drwav_init_file()`, `drwav_init_file_write()`, etc. + + + +Notes +===== +- Samples are always interleaved. +- The default read function does not do any data conversion. Use `drwav_read_pcm_frames_f32()`, `drwav_read_pcm_frames_s32()` and `drwav_read_pcm_frames_s16()` + to read and convert audio data to 32-bit floating point, signed 32-bit integer and signed 16-bit integer samples respectively. Tested and supported internal + formats include the following: + - Unsigned 8-bit PCM + - Signed 12-bit PCM + - Signed 16-bit PCM + - Signed 24-bit PCM + - Signed 32-bit PCM + - IEEE 32-bit floating point + - IEEE 64-bit floating point + - A-law and u-law + - Microsoft ADPCM + - IMA ADPCM (DVI, format code 0x11) +- dr_wav will try to read the WAV file as best it can, even if it's not strictly conformant to the WAV format. +*/ + +#ifndef dr_wav_h +#define dr_wav_h + +#ifdef __cplusplus +extern "C" { +#endif + +#define DRWAV_STRINGIFY(x) #x +#define DRWAV_XSTRINGIFY(x) DRWAV_STRINGIFY(x) + +#define DRWAV_VERSION_MAJOR 0 +#define DRWAV_VERSION_MINOR 12 +#define DRWAV_VERSION_REVISION 7 +#define DRWAV_VERSION_STRING DRWAV_XSTRINGIFY(DRWAV_VERSION_MAJOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_MINOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_REVISION) + +#include /* For size_t. */ + +/* Sized types. Prefer built-in types. Fall back to stdint. */ +#ifdef _MSC_VER + #if defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wlanguage-extension-token" + #pragma GCC diagnostic ignored "-Wlong-long" + #pragma GCC diagnostic ignored "-Wc++11-long-long" + #endif + typedef signed __int8 drwav_int8; + typedef unsigned __int8 drwav_uint8; + typedef signed __int16 drwav_int16; + typedef unsigned __int16 drwav_uint16; + typedef signed __int32 drwav_int32; + typedef unsigned __int32 drwav_uint32; + typedef signed __int64 drwav_int64; + typedef unsigned __int64 drwav_uint64; + #if defined(__clang__) + #pragma GCC diagnostic pop + #endif +#else + #include + typedef int8_t drwav_int8; + typedef uint8_t drwav_uint8; + typedef int16_t drwav_int16; + typedef uint16_t drwav_uint16; + typedef int32_t drwav_int32; + typedef uint32_t drwav_uint32; + typedef int64_t drwav_int64; + typedef uint64_t drwav_uint64; +#endif +typedef drwav_uint8 drwav_bool8; +typedef drwav_uint32 drwav_bool32; +#define DRWAV_TRUE 1 +#define DRWAV_FALSE 0 + +#if !defined(DRWAV_API) + #if defined(DRWAV_DLL) + #if defined(_WIN32) + #define DRWAV_DLL_IMPORT __declspec(dllimport) + #define DRWAV_DLL_EXPORT __declspec(dllexport) + #define DRWAV_DLL_PRIVATE static + #else + #if defined(__GNUC__) && __GNUC__ >= 4 + #define DRWAV_DLL_IMPORT __attribute__((visibility("default"))) + #define DRWAV_DLL_EXPORT __attribute__((visibility("default"))) + #define DRWAV_DLL_PRIVATE __attribute__((visibility("hidden"))) + #else + #define DRWAV_DLL_IMPORT + #define DRWAV_DLL_EXPORT + #define DRWAV_DLL_PRIVATE static + #endif + #endif + + #if defined(DR_WAV_IMPLEMENTATION) || defined(DRWAV_IMPLEMENTATION) + #define DRWAV_API DRWAV_DLL_EXPORT + #else + #define DRWAV_API DRWAV_DLL_IMPORT + #endif + #define DRWAV_PRIVATE DRWAV_DLL_PRIVATE + #else + #define DRWAV_API extern + #define DRWAV_PRIVATE static + #endif +#endif + +typedef drwav_int32 drwav_result; +#define DRWAV_SUCCESS 0 +#define DRWAV_ERROR -1 /* A generic error. */ +#define DRWAV_INVALID_ARGS -2 +#define DRWAV_INVALID_OPERATION -3 +#define DRWAV_OUT_OF_MEMORY -4 +#define DRWAV_OUT_OF_RANGE -5 +#define DRWAV_ACCESS_DENIED -6 +#define DRWAV_DOES_NOT_EXIST -7 +#define DRWAV_ALREADY_EXISTS -8 +#define DRWAV_TOO_MANY_OPEN_FILES -9 +#define DRWAV_INVALID_FILE -10 +#define DRWAV_TOO_BIG -11 +#define DRWAV_PATH_TOO_LONG -12 +#define DRWAV_NAME_TOO_LONG -13 +#define DRWAV_NOT_DIRECTORY -14 +#define DRWAV_IS_DIRECTORY -15 +#define DRWAV_DIRECTORY_NOT_EMPTY -16 +#define DRWAV_END_OF_FILE -17 +#define DRWAV_NO_SPACE -18 +#define DRWAV_BUSY -19 +#define DRWAV_IO_ERROR -20 +#define DRWAV_INTERRUPT -21 +#define DRWAV_UNAVAILABLE -22 +#define DRWAV_ALREADY_IN_USE -23 +#define DRWAV_BAD_ADDRESS -24 +#define DRWAV_BAD_SEEK -25 +#define DRWAV_BAD_PIPE -26 +#define DRWAV_DEADLOCK -27 +#define DRWAV_TOO_MANY_LINKS -28 +#define DRWAV_NOT_IMPLEMENTED -29 +#define DRWAV_NO_MESSAGE -30 +#define DRWAV_BAD_MESSAGE -31 +#define DRWAV_NO_DATA_AVAILABLE -32 +#define DRWAV_INVALID_DATA -33 +#define DRWAV_TIMEOUT -34 +#define DRWAV_NO_NETWORK -35 +#define DRWAV_NOT_UNIQUE -36 +#define DRWAV_NOT_SOCKET -37 +#define DRWAV_NO_ADDRESS -38 +#define DRWAV_BAD_PROTOCOL -39 +#define DRWAV_PROTOCOL_UNAVAILABLE -40 +#define DRWAV_PROTOCOL_NOT_SUPPORTED -41 +#define DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED -42 +#define DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED -43 +#define DRWAV_SOCKET_NOT_SUPPORTED -44 +#define DRWAV_CONNECTION_RESET -45 +#define DRWAV_ALREADY_CONNECTED -46 +#define DRWAV_NOT_CONNECTED -47 +#define DRWAV_CONNECTION_REFUSED -48 +#define DRWAV_NO_HOST -49 +#define DRWAV_IN_PROGRESS -50 +#define DRWAV_CANCELLED -51 +#define DRWAV_MEMORY_ALREADY_MAPPED -52 +#define DRWAV_AT_END -53 + +/* Common data formats. */ +#define DR_WAVE_FORMAT_PCM 0x1 +#define DR_WAVE_FORMAT_ADPCM 0x2 +#define DR_WAVE_FORMAT_IEEE_FLOAT 0x3 +#define DR_WAVE_FORMAT_ALAW 0x6 +#define DR_WAVE_FORMAT_MULAW 0x7 +#define DR_WAVE_FORMAT_DVI_ADPCM 0x11 +#define DR_WAVE_FORMAT_EXTENSIBLE 0xFFFE + +/* Constants. */ +#ifndef DRWAV_MAX_SMPL_LOOPS +#define DRWAV_MAX_SMPL_LOOPS 1 +#endif + +/* Flags to pass into drwav_init_ex(), etc. */ +#define DRWAV_SEQUENTIAL 0x00000001 + +DRWAV_API void drwav_version(drwav_uint32* pMajor, drwav_uint32* pMinor, drwav_uint32* pRevision); +DRWAV_API const char* drwav_version_string(); + +typedef enum +{ + drwav_seek_origin_start, + drwav_seek_origin_current +} drwav_seek_origin; + +typedef enum +{ + drwav_container_riff, + drwav_container_w64 +} drwav_container; + +typedef struct +{ + union + { + drwav_uint8 fourcc[4]; + drwav_uint8 guid[16]; + } id; + + /* The size in bytes of the chunk. */ + drwav_uint64 sizeInBytes; + + /* + RIFF = 2 byte alignment. + W64 = 8 byte alignment. + */ + unsigned int paddingSize; +} drwav_chunk_header; + +typedef struct +{ + /* + The format tag exactly as specified in the wave file's "fmt" chunk. This can be used by applications + that require support for data formats not natively supported by dr_wav. + */ + drwav_uint16 formatTag; + + /* The number of channels making up the audio data. When this is set to 1 it is mono, 2 is stereo, etc. */ + drwav_uint16 channels; + + /* The sample rate. Usually set to something like 44100. */ + drwav_uint32 sampleRate; + + /* Average bytes per second. You probably don't need this, but it's left here for informational purposes. */ + drwav_uint32 avgBytesPerSec; + + /* Block align. This is equal to the number of channels * bytes per sample. */ + drwav_uint16 blockAlign; + + /* Bits per sample. */ + drwav_uint16 bitsPerSample; + + /* The size of the extended data. Only used internally for validation, but left here for informational purposes. */ + drwav_uint16 extendedSize; + + /* + The number of valid bits per sample. When is equal to WAVE_FORMAT_EXTENSIBLE, + is always rounded up to the nearest multiple of 8. This variable contains information about exactly how + many bits are valid per sample. Mainly used for informational purposes. + */ + drwav_uint16 validBitsPerSample; + + /* The channel mask. Not used at the moment. */ + drwav_uint32 channelMask; + + /* The sub-format, exactly as specified by the wave file. */ + drwav_uint8 subFormat[16]; +} drwav_fmt; + +DRWAV_API drwav_uint16 drwav_fmt_get_format(const drwav_fmt* pFMT); + + +/* +Callback for when data is read. Return value is the number of bytes actually read. + +pUserData [in] The user data that was passed to drwav_init() and family. +pBufferOut [out] The output buffer. +bytesToRead [in] The number of bytes to read. + +Returns the number of bytes actually read. + +A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until +either the entire bytesToRead is filled or you have reached the end of the stream. +*/ +typedef size_t (* drwav_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead); + +/* +Callback for when data is written. Returns value is the number of bytes actually written. + +pUserData [in] The user data that was passed to drwav_init_write() and family. +pData [out] A pointer to the data to write. +bytesToWrite [in] The number of bytes to write. + +Returns the number of bytes actually written. + +If the return value differs from bytesToWrite, it indicates an error. +*/ +typedef size_t (* drwav_write_proc)(void* pUserData, const void* pData, size_t bytesToWrite); + +/* +Callback for when data needs to be seeked. + +pUserData [in] The user data that was passed to drwav_init() and family. +offset [in] The number of bytes to move, relative to the origin. Will never be negative. +origin [in] The origin of the seek - the current position or the start of the stream. + +Returns whether or not the seek was successful. + +Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which will be either drwav_seek_origin_start or +drwav_seek_origin_current. +*/ +typedef drwav_bool32 (* drwav_seek_proc)(void* pUserData, int offset, drwav_seek_origin origin); + +/* +Callback for when drwav_init_ex() finds a chunk. + +pChunkUserData [in] The user data that was passed to the pChunkUserData parameter of drwav_init_ex() and family. +onRead [in] A pointer to the function to call when reading. +onSeek [in] A pointer to the function to call when seeking. +pReadSeekUserData [in] The user data that was passed to the pReadSeekUserData parameter of drwav_init_ex() and family. +pChunkHeader [in] A pointer to an object containing basic header information about the chunk. Use this to identify the chunk. +container [in] Whether or not the WAV file is a RIFF or Wave64 container. If you're unsure of the difference, assume RIFF. +pFMT [in] A pointer to the object containing the contents of the "fmt" chunk. + +Returns the number of bytes read + seeked. + +To read data from the chunk, call onRead(), passing in pReadSeekUserData as the first parameter. Do the same for seeking with onSeek(). The return value must +be the total number of bytes you have read _plus_ seeked. + +Use the `container` argument to discriminate the fields in `pChunkHeader->id`. If the container is `drwav_container_riff` you should use `id.fourcc`, +otherwise you should use `id.guid`. + +The `pFMT` parameter can be used to determine the data format of the wave file. Use `drwav_fmt_get_format()` to get the sample format, which will be one of the +`DR_WAVE_FORMAT_*` identifiers. + +The read pointer will be sitting on the first byte after the chunk's header. You must not attempt to read beyond the boundary of the chunk. +*/ +typedef drwav_uint64 (* drwav_chunk_proc)(void* pChunkUserData, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pReadSeekUserData, const drwav_chunk_header* pChunkHeader, drwav_container container, const drwav_fmt* pFMT); + +typedef struct +{ + void* pUserData; + void* (* onMalloc)(size_t sz, void* pUserData); + void* (* onRealloc)(void* p, size_t sz, void* pUserData); + void (* onFree)(void* p, void* pUserData); +} drwav_allocation_callbacks; + +/* Structure for internal use. Only used for loaders opened with drwav_init_memory(). */ +typedef struct +{ + const drwav_uint8* data; + size_t dataSize; + size_t currentReadPos; +} drwav__memory_stream; + +/* Structure for internal use. Only used for writers opened with drwav_init_memory_write(). */ +typedef struct +{ + void** ppData; + size_t* pDataSize; + size_t dataSize; + size_t dataCapacity; + size_t currentWritePos; +} drwav__memory_stream_write; + +typedef struct +{ + drwav_container container; /* RIFF, W64. */ + drwav_uint32 format; /* DR_WAVE_FORMAT_* */ + drwav_uint32 channels; + drwav_uint32 sampleRate; + drwav_uint32 bitsPerSample; +} drwav_data_format; + + +/* See the following for details on the 'smpl' chunk: https://sites.google.com/site/musicgapi/technical-documents/wav-file-format#smpl */ +typedef struct +{ + drwav_uint32 cuePointId; + drwav_uint32 type; + drwav_uint32 start; + drwav_uint32 end; + drwav_uint32 fraction; + drwav_uint32 playCount; +} drwav_smpl_loop; + + typedef struct +{ + drwav_uint32 manufacturer; + drwav_uint32 product; + drwav_uint32 samplePeriod; + drwav_uint32 midiUnityNotes; + drwav_uint32 midiPitchFraction; + drwav_uint32 smpteFormat; + drwav_uint32 smpteOffset; + drwav_uint32 numSampleLoops; + drwav_uint32 samplerData; + drwav_smpl_loop loops[DRWAV_MAX_SMPL_LOOPS]; +} drwav_smpl; + +typedef struct +{ + /* A pointer to the function to call when more data is needed. */ + drwav_read_proc onRead; + + /* A pointer to the function to call when data needs to be written. Only used when the drwav object is opened in write mode. */ + drwav_write_proc onWrite; + + /* A pointer to the function to call when the wav file needs to be seeked. */ + drwav_seek_proc onSeek; + + /* The user data to pass to callbacks. */ + void* pUserData; + + /* Allocation callbacks. */ + drwav_allocation_callbacks allocationCallbacks; + + + /* Whether or not the WAV file is formatted as a standard RIFF file or W64. */ + drwav_container container; + + + /* Structure containing format information exactly as specified by the wav file. */ + drwav_fmt fmt; + + /* The sample rate. Will be set to something like 44100. */ + drwav_uint32 sampleRate; + + /* The number of channels. This will be set to 1 for monaural streams, 2 for stereo, etc. */ + drwav_uint16 channels; + + /* The bits per sample. Will be set to something like 16, 24, etc. */ + drwav_uint16 bitsPerSample; + + /* Equal to fmt.formatTag, or the value specified by fmt.subFormat if fmt.formatTag is equal to 65534 (WAVE_FORMAT_EXTENSIBLE). */ + drwav_uint16 translatedFormatTag; + + /* The total number of PCM frames making up the audio data. */ + drwav_uint64 totalPCMFrameCount; + + + /* The size in bytes of the data chunk. */ + drwav_uint64 dataChunkDataSize; + + /* The position in the stream of the first byte of the data chunk. This is used for seeking. */ + drwav_uint64 dataChunkDataPos; + + /* The number of bytes remaining in the data chunk. */ + drwav_uint64 bytesRemaining; + + + /* + Only used in sequential write mode. Keeps track of the desired size of the "data" chunk at the point of initialization time. Always + set to 0 for non-sequential writes and when the drwav object is opened in read mode. Used for validation. + */ + drwav_uint64 dataChunkDataSizeTargetWrite; + + /* Keeps track of whether or not the wav writer was initialized in sequential mode. */ + drwav_bool32 isSequentialWrite; + + + /* smpl chunk. */ + drwav_smpl smpl; + + + /* A hack to avoid a DRWAV_MALLOC() when opening a decoder with drwav_init_memory(). */ + drwav__memory_stream memoryStream; + drwav__memory_stream_write memoryStreamWrite; + + /* Generic data for compressed formats. This data is shared across all block-compressed formats. */ + struct + { + drwav_uint64 iCurrentPCMFrame; /* The index of the next PCM frame that will be read by drwav_read_*(). This is used with "totalPCMFrameCount" to ensure we don't read excess samples at the end of the last block. */ + } compressed; + + /* Microsoft ADPCM specific data. */ + struct + { + drwav_uint32 bytesRemainingInBlock; + drwav_uint16 predictor[2]; + drwav_int32 delta[2]; + drwav_int32 cachedFrames[4]; /* Samples are stored in this cache during decoding. */ + drwav_uint32 cachedFrameCount; + drwav_int32 prevFrames[2][2]; /* The previous 2 samples for each channel (2 channels at most). */ + } msadpcm; + + /* IMA ADPCM specific data. */ + struct + { + drwav_uint32 bytesRemainingInBlock; + drwav_int32 predictor[2]; + drwav_int32 stepIndex[2]; + drwav_int32 cachedFrames[16]; /* Samples are stored in this cache during decoding. */ + drwav_uint32 cachedFrameCount; + } ima; +} drwav; + + +/* +Initializes a pre-allocated drwav object for reading. + +pWav [out] A pointer to the drwav object being initialized. +onRead [in] The function to call when data needs to be read from the client. +onSeek [in] The function to call when the read position of the client data needs to move. +onChunk [in, optional] The function to call when a chunk is enumerated at initialized time. +pUserData, pReadSeekUserData [in, optional] A pointer to application defined data that will be passed to onRead and onSeek. +pChunkUserData [in, optional] A pointer to application defined data that will be passed to onChunk. +flags [in, optional] A set of flags for controlling how things are loaded. + +Returns true if successful; false otherwise. + +Close the loader with drwav_uninit(). + +This is the lowest level function for initializing a WAV file. You can also use drwav_init_file() and drwav_init_memory() +to open the stream from a file or from a block of memory respectively. + +Possible values for flags: + DRWAV_SEQUENTIAL: Never perform a backwards seek while loading. This disables the chunk callback and will cause this function + to return as soon as the data chunk is found. Any chunks after the data chunk will be ignored. + +drwav_init() is equivalent to "drwav_init_ex(pWav, onRead, onSeek, NULL, pUserData, NULL, 0);". + +The onChunk callback is not called for the WAVE or FMT chunks. The contents of the FMT chunk can be read from pWav->fmt +after the function returns. + +See also: drwav_init_file(), drwav_init_memory(), drwav_uninit() +*/ +DRWAV_API drwav_bool32 drwav_init(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_ex(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_chunk_proc onChunk, void* pReadSeekUserData, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks); + +/* +Initializes a pre-allocated drwav object for writing. + +onWrite [in] The function to call when data needs to be written. +onSeek [in] The function to call when the write position needs to move. +pUserData [in, optional] A pointer to application defined data that will be passed to onWrite and onSeek. + +Returns true if successful; false otherwise. + +Close the writer with drwav_uninit(). + +This is the lowest level function for initializing a WAV file. You can also use drwav_init_file_write() and drwav_init_memory_write() +to open the stream from a file or from a block of memory respectively. + +If the total sample count is known, you can use drwav_init_write_sequential(). This avoids the need for dr_wav to perform +a post-processing step for storing the total sample count and the size of the data chunk which requires a backwards seek. + +See also: drwav_init_file_write(), drwav_init_memory_write(), drwav_uninit() +*/ +DRWAV_API drwav_bool32 drwav_init_write(drwav* pWav, const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_write_sequential(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_write_sequential_pcm_frames(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks); + +/* +Utility function to determine the target size of the entire data to be written (including all headers and chunks). + +Returns the target size in bytes. + +Useful if the application needs to know the size to allocate. + +Only writing to the RIFF chunk and one data chunk is currently supported. + +See also: drwav_init_write(), drwav_init_file_write(), drwav_init_memory_write() +*/ +DRWAV_API drwav_uint64 drwav_target_write_size_bytes(const drwav_data_format* pFormat, drwav_uint64 totalSampleCount); + +/* +Uninitializes the given drwav object. + +Use this only for objects initialized with drwav_init*() functions (drwav_init(), drwav_init_ex(), drwav_init_write(), drwav_init_write_sequential()). +*/ +DRWAV_API drwav_result drwav_uninit(drwav* pWav); + + +/* +Reads raw audio data. + +This is the lowest level function for reading audio data. It simply reads the given number of +bytes of the raw internal sample data. + +Consider using drwav_read_pcm_frames_s16(), drwav_read_pcm_frames_s32() or drwav_read_pcm_frames_f32() for +reading sample data in a consistent format. + +pBufferOut can be NULL in which case a seek will be performed. + +Returns the number of bytes actually read. +*/ +DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOut); + +/* +Reads up to the specified number of PCM frames from the WAV file. + +The output data will be in the file's internal format, converted to native-endian byte order. Use +drwav_read_pcm_frames_s16/f32/s32() to read data in a specific format. + +If the return value is less than it means the end of the file has been reached or +you have requested more PCM frames than can possibly fit in the output buffer. + +This function will only work when sample data is of a fixed size and uncompressed. If you are +using a compressed format consider using drwav_read_raw() or drwav_read_pcm_frames_s16/s32/f32(). + +pBufferOut can be NULL in which case a seek will be performed. +*/ +DRWAV_API drwav_uint64 drwav_read_pcm_frames(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut); +DRWAV_API drwav_uint64 drwav_read_pcm_frames_le(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut); +DRWAV_API drwav_uint64 drwav_read_pcm_frames_be(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut); + +/* +Seeks to the given PCM frame. + +Returns true if successful; false otherwise. +*/ +DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetFrameIndex); + + +/* +Writes raw audio data. + +Returns the number of bytes actually written. If this differs from bytesToWrite, it indicates an error. +*/ +DRWAV_API size_t drwav_write_raw(drwav* pWav, size_t bytesToWrite, const void* pData); + +/* +Writes PCM frames. + +Returns the number of PCM frames written. + +Input samples need to be in native-endian byte order. On big-endian architectures the input data will be converted to +little-endian. Use drwav_write_raw() to write raw audio data without performing any conversion. +*/ +DRWAV_API drwav_uint64 drwav_write_pcm_frames(drwav* pWav, drwav_uint64 framesToWrite, const void* pData); +DRWAV_API drwav_uint64 drwav_write_pcm_frames_le(drwav* pWav, drwav_uint64 framesToWrite, const void* pData); +DRWAV_API drwav_uint64 drwav_write_pcm_frames_be(drwav* pWav, drwav_uint64 framesToWrite, const void* pData); + + +/* Conversion Utilities */ +#ifndef DR_WAV_NO_CONVERSION_API + +/* +Reads a chunk of audio data and converts it to signed 16-bit PCM samples. + +pBufferOut can be NULL in which case a seek will be performed. + +Returns the number of PCM frames actually read. + +If the return value is less than it means the end of the file has been reached. +*/ +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut); +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16le(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut); +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16be(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut); + +/* Low-level function for converting unsigned 8-bit PCM samples to signed 16-bit PCM samples. */ +DRWAV_API void drwav_u8_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount); + +/* Low-level function for converting signed 24-bit PCM samples to signed 16-bit PCM samples. */ +DRWAV_API void drwav_s24_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount); + +/* Low-level function for converting signed 32-bit PCM samples to signed 16-bit PCM samples. */ +DRWAV_API void drwav_s32_to_s16(drwav_int16* pOut, const drwav_int32* pIn, size_t sampleCount); + +/* Low-level function for converting IEEE 32-bit floating point samples to signed 16-bit PCM samples. */ +DRWAV_API void drwav_f32_to_s16(drwav_int16* pOut, const float* pIn, size_t sampleCount); + +/* Low-level function for converting IEEE 64-bit floating point samples to signed 16-bit PCM samples. */ +DRWAV_API void drwav_f64_to_s16(drwav_int16* pOut, const double* pIn, size_t sampleCount); + +/* Low-level function for converting A-law samples to signed 16-bit PCM samples. */ +DRWAV_API void drwav_alaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount); + +/* Low-level function for converting u-law samples to signed 16-bit PCM samples. */ +DRWAV_API void drwav_mulaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount); + + +/* +Reads a chunk of audio data and converts it to IEEE 32-bit floating point samples. + +pBufferOut can be NULL in which case a seek will be performed. + +Returns the number of PCM frames actually read. + +If the return value is less than it means the end of the file has been reached. +*/ +DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut); +DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32le(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut); +DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32be(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut); + +/* Low-level function for converting unsigned 8-bit PCM samples to IEEE 32-bit floating point samples. */ +DRWAV_API void drwav_u8_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount); + +/* Low-level function for converting signed 16-bit PCM samples to IEEE 32-bit floating point samples. */ +DRWAV_API void drwav_s16_to_f32(float* pOut, const drwav_int16* pIn, size_t sampleCount); + +/* Low-level function for converting signed 24-bit PCM samples to IEEE 32-bit floating point samples. */ +DRWAV_API void drwav_s24_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount); + +/* Low-level function for converting signed 32-bit PCM samples to IEEE 32-bit floating point samples. */ +DRWAV_API void drwav_s32_to_f32(float* pOut, const drwav_int32* pIn, size_t sampleCount); + +/* Low-level function for converting IEEE 64-bit floating point samples to IEEE 32-bit floating point samples. */ +DRWAV_API void drwav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount); + +/* Low-level function for converting A-law samples to IEEE 32-bit floating point samples. */ +DRWAV_API void drwav_alaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount); + +/* Low-level function for converting u-law samples to IEEE 32-bit floating point samples. */ +DRWAV_API void drwav_mulaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount); + + +/* +Reads a chunk of audio data and converts it to signed 32-bit PCM samples. + +pBufferOut can be NULL in which case a seek will be performed. + +Returns the number of PCM frames actually read. + +If the return value is less than it means the end of the file has been reached. +*/ +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut); +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32le(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut); +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32be(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut); + +/* Low-level function for converting unsigned 8-bit PCM samples to signed 32-bit PCM samples. */ +DRWAV_API void drwav_u8_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount); + +/* Low-level function for converting signed 16-bit PCM samples to signed 32-bit PCM samples. */ +DRWAV_API void drwav_s16_to_s32(drwav_int32* pOut, const drwav_int16* pIn, size_t sampleCount); + +/* Low-level function for converting signed 24-bit PCM samples to signed 32-bit PCM samples. */ +DRWAV_API void drwav_s24_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount); + +/* Low-level function for converting IEEE 32-bit floating point samples to signed 32-bit PCM samples. */ +DRWAV_API void drwav_f32_to_s32(drwav_int32* pOut, const float* pIn, size_t sampleCount); + +/* Low-level function for converting IEEE 64-bit floating point samples to signed 32-bit PCM samples. */ +DRWAV_API void drwav_f64_to_s32(drwav_int32* pOut, const double* pIn, size_t sampleCount); + +/* Low-level function for converting A-law samples to signed 32-bit PCM samples. */ +DRWAV_API void drwav_alaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount); + +/* Low-level function for converting u-law samples to signed 32-bit PCM samples. */ +DRWAV_API void drwav_mulaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount); + +#endif /* DR_WAV_NO_CONVERSION_API */ + + +/* High-Level Convenience Helpers */ + +#ifndef DR_WAV_NO_STDIO +/* +Helper for initializing a wave file for reading using stdio. + +This holds the internal FILE object until drwav_uninit() is called. Keep this in mind if you're caching drwav +objects because the operating system may restrict the number of file handles an application can have open at +any given time. +*/ +DRWAV_API drwav_bool32 drwav_init_file(drwav* pWav, const char* filename, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_file_ex(drwav* pWav, const char* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_file_w(drwav* pWav, const wchar_t* filename, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_file_ex_w(drwav* pWav, const wchar_t* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks); + +/* +Helper for initializing a wave file for writing using stdio. + +This holds the internal FILE object until drwav_uninit() is called. Keep this in mind if you're caching drwav +objects because the operating system may restrict the number of file handles an application can have open at +any given time. +*/ +DRWAV_API drwav_bool32 drwav_init_file_write(drwav* pWav, const char* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_file_write_sequential(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_file_write_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_file_write_sequential_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks); +#endif /* DR_WAV_NO_STDIO */ + +/* +Helper for initializing a loader from a pre-allocated memory buffer. + +This does not create a copy of the data. It is up to the application to ensure the buffer remains valid for +the lifetime of the drwav object. + +The buffer should contain the contents of the entire wave file, not just the sample data. +*/ +DRWAV_API drwav_bool32 drwav_init_memory(drwav* pWav, const void* data, size_t dataSize, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_memory_ex(drwav* pWav, const void* data, size_t dataSize, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks); + +/* +Helper for initializing a writer which outputs data to a memory buffer. + +dr_wav will manage the memory allocations, however it is up to the caller to free the data with drwav_free(). + +The buffer will remain allocated even after drwav_uninit() is called. Indeed, the buffer should not be +considered valid until after drwav_uninit() has been called anyway. +*/ +DRWAV_API drwav_bool32 drwav_init_memory_write(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_memory_write_sequential(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_bool32 drwav_init_memory_write_sequential_pcm_frames(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks); + + +#ifndef DR_WAV_NO_CONVERSION_API +/* +Opens and reads an entire wav file in a single operation. + +The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer. +*/ +DRWAV_API drwav_int16* drwav_open_and_read_pcm_frames_s16(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API float* drwav_open_and_read_pcm_frames_f32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_int32* drwav_open_and_read_pcm_frames_s32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +#ifndef DR_WAV_NO_STDIO +/* +Opens and decodes an entire wav file in a single operation. + +The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer. +*/ +DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +#endif +/* +Opens and decodes an entire wav file from a block of memory in a single operation. + +The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer. +*/ +DRWAV_API drwav_int16* drwav_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API float* drwav_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +DRWAV_API drwav_int32* drwav_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks); +#endif + +/* Frees data that was allocated internally by dr_wav. */ +DRWAV_API void drwav_free(void* p, const drwav_allocation_callbacks* pAllocationCallbacks); + +/* Converts bytes from a wav stream to a sized type of native endian. */ +DRWAV_API drwav_uint16 drwav_bytes_to_u16(const drwav_uint8* data); +DRWAV_API drwav_int16 drwav_bytes_to_s16(const drwav_uint8* data); +DRWAV_API drwav_uint32 drwav_bytes_to_u32(const drwav_uint8* data); +DRWAV_API drwav_int32 drwav_bytes_to_s32(const drwav_uint8* data); +DRWAV_API drwav_uint64 drwav_bytes_to_u64(const drwav_uint8* data); +DRWAV_API drwav_int64 drwav_bytes_to_s64(const drwav_uint8* data); + +/* Compares a GUID for the purpose of checking the type of a Wave64 chunk. */ +DRWAV_API drwav_bool32 drwav_guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16]); + +/* Compares a four-character-code for the purpose of checking the type of a RIFF chunk. */ +DRWAV_API drwav_bool32 drwav_fourcc_equal(const drwav_uint8* a, const char* b); + +#ifdef __cplusplus +} +#endif +#endif /* dr_wav_h */ + + +/************************************************************************************************************************************************************ + ************************************************************************************************************************************************************ + + IMPLEMENTATION + + ************************************************************************************************************************************************************ + ************************************************************************************************************************************************************/ +#if defined(DR_WAV_IMPLEMENTATION) || defined(DRWAV_IMPLEMENTATION) +#ifndef dr_wav_c +#define dr_wav_c + +#include +#include /* For memcpy(), memset() */ +#include /* For INT_MAX */ + +#ifndef DR_WAV_NO_STDIO +#include +#include +#endif + +/* Standard library stuff. */ +#ifndef DRWAV_ASSERT +#include +#define DRWAV_ASSERT(expression) assert(expression) +#endif +#ifndef DRWAV_MALLOC +#define DRWAV_MALLOC(sz) malloc((sz)) +#endif +#ifndef DRWAV_REALLOC +#define DRWAV_REALLOC(p, sz) realloc((p), (sz)) +#endif +#ifndef DRWAV_FREE +#define DRWAV_FREE(p) free((p)) +#endif +#ifndef DRWAV_COPY_MEMORY +#define DRWAV_COPY_MEMORY(dst, src, sz) memcpy((dst), (src), (sz)) +#endif +#ifndef DRWAV_ZERO_MEMORY +#define DRWAV_ZERO_MEMORY(p, sz) memset((p), 0, (sz)) +#endif +#ifndef DRWAV_ZERO_OBJECT +#define DRWAV_ZERO_OBJECT(p) DRWAV_ZERO_MEMORY((p), sizeof(*p)) +#endif + +#define drwav_countof(x) (sizeof(x) / sizeof(x[0])) +#define drwav_align(x, a) ((((x) + (a) - 1) / (a)) * (a)) +#define drwav_min(a, b) (((a) < (b)) ? (a) : (b)) +#define drwav_max(a, b) (((a) > (b)) ? (a) : (b)) +#define drwav_clamp(x, lo, hi) (drwav_max((lo), drwav_min((hi), (x)))) + +#define DRWAV_MAX_SIMD_VECTOR_SIZE 64 /* 64 for AVX-512 in the future. */ + +/* CPU architecture. */ +#if defined(__x86_64__) || defined(_M_X64) + #define DRWAV_X64 +#elif defined(__i386) || defined(_M_IX86) + #define DRWAV_X86 +#elif defined(__arm__) || defined(_M_ARM) + #define DRWAV_ARM +#endif + +#ifdef _MSC_VER + #define DRWAV_INLINE __forceinline +#elif defined(__GNUC__) + /* + I've had a bug report where GCC is emitting warnings about functions possibly not being inlineable. This warning happens when + the __attribute__((always_inline)) attribute is defined without an "inline" statement. I think therefore there must be some + case where "__inline__" is not always defined, thus the compiler emitting these warnings. When using -std=c89 or -ansi on the + command line, we cannot use the "inline" keyword and instead need to use "__inline__". In an attempt to work around this issue + I am using "__inline__" only when we're compiling in strict ANSI mode. + */ + #if defined(__STRICT_ANSI__) + #define DRWAV_INLINE __inline__ __attribute__((always_inline)) + #else + #define DRWAV_INLINE inline __attribute__((always_inline)) + #endif +#else + #define DRWAV_INLINE +#endif + +#if defined(SIZE_MAX) + #define DRWAV_SIZE_MAX SIZE_MAX +#else + #if defined(_WIN64) || defined(_LP64) || defined(__LP64__) + #define DRWAV_SIZE_MAX ((drwav_uint64)0xFFFFFFFFFFFFFFFF) + #else + #define DRWAV_SIZE_MAX 0xFFFFFFFF + #endif +#endif + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + #define DRWAV_HAS_BYTESWAP16_INTRINSIC + #define DRWAV_HAS_BYTESWAP32_INTRINSIC + #define DRWAV_HAS_BYTESWAP64_INTRINSIC +#elif defined(__clang__) + #if defined(__has_builtin) + #if __has_builtin(__builtin_bswap16) + #define DRWAV_HAS_BYTESWAP16_INTRINSIC + #endif + #if __has_builtin(__builtin_bswap32) + #define DRWAV_HAS_BYTESWAP32_INTRINSIC + #endif + #if __has_builtin(__builtin_bswap64) + #define DRWAV_HAS_BYTESWAP64_INTRINSIC + #endif + #endif +#elif defined(__GNUC__) + #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define DRWAV_HAS_BYTESWAP32_INTRINSIC + #define DRWAV_HAS_BYTESWAP64_INTRINSIC + #endif + #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) + #define DRWAV_HAS_BYTESWAP16_INTRINSIC + #endif +#endif + +DRWAV_API void drwav_version(drwav_uint32* pMajor, drwav_uint32* pMinor, drwav_uint32* pRevision) +{ + if (pMajor) { + *pMajor = DRWAV_VERSION_MAJOR; + } + + if (pMinor) { + *pMinor = DRWAV_VERSION_MINOR; + } + + if (pRevision) { + *pRevision = DRWAV_VERSION_REVISION; + } +} + +DRWAV_API const char* drwav_version_string() +{ + return DRWAV_VERSION_STRING; +} + +/* +These limits are used for basic validation when initializing the decoder. If you exceed these limits, first of all: what on Earth are +you doing?! (Let me know, I'd be curious!) Second, you can adjust these by #define-ing them before the dr_wav implementation. +*/ +#ifndef DRWAV_MAX_SAMPLE_RATE +#define DRWAV_MAX_SAMPLE_RATE 384000 +#endif +#ifndef DRWAV_MAX_CHANNELS +#define DRWAV_MAX_CHANNELS 256 +#endif +#ifndef DRWAV_MAX_BITS_PER_SAMPLE +#define DRWAV_MAX_BITS_PER_SAMPLE 64 +#endif + +static const drwav_uint8 drwavGUID_W64_RIFF[16] = {0x72,0x69,0x66,0x66, 0x2E,0x91, 0xCF,0x11, 0xA5,0xD6, 0x28,0xDB,0x04,0xC1,0x00,0x00}; /* 66666972-912E-11CF-A5D6-28DB04C10000 */ +static const drwav_uint8 drwavGUID_W64_WAVE[16] = {0x77,0x61,0x76,0x65, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 65766177-ACF3-11D3-8CD1-00C04F8EDB8A */ +static const drwav_uint8 drwavGUID_W64_JUNK[16] = {0x6A,0x75,0x6E,0x6B, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 6B6E756A-ACF3-11D3-8CD1-00C04F8EDB8A */ +static const drwav_uint8 drwavGUID_W64_FMT [16] = {0x66,0x6D,0x74,0x20, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 20746D66-ACF3-11D3-8CD1-00C04F8EDB8A */ +static const drwav_uint8 drwavGUID_W64_FACT[16] = {0x66,0x61,0x63,0x74, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 74636166-ACF3-11D3-8CD1-00C04F8EDB8A */ +static const drwav_uint8 drwavGUID_W64_DATA[16] = {0x64,0x61,0x74,0x61, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 61746164-ACF3-11D3-8CD1-00C04F8EDB8A */ +static const drwav_uint8 drwavGUID_W64_SMPL[16] = {0x73,0x6D,0x70,0x6C, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 6C706D73-ACF3-11D3-8CD1-00C04F8EDB8A */ + +static DRWAV_INLINE drwav_bool32 drwav__guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16]) +{ + int i; + for (i = 0; i < 16; i += 1) { + if (a[i] != b[i]) { + return DRWAV_FALSE; + } + } + + return DRWAV_TRUE; +} + +static DRWAV_INLINE drwav_bool32 drwav__fourcc_equal(const drwav_uint8* a, const char* b) +{ + return + a[0] == b[0] && + a[1] == b[1] && + a[2] == b[2] && + a[3] == b[3]; +} + + + +static DRWAV_INLINE int drwav__is_little_endian(void) +{ +#if defined(DRWAV_X86) || defined(DRWAV_X64) + return DRWAV_TRUE; +#elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN + return DRWAV_TRUE; +#else + int n = 1; + return (*(char*)&n) == 1; +#endif +} + +static DRWAV_INLINE drwav_uint16 drwav__bytes_to_u16(const drwav_uint8* data) +{ + return (data[0] << 0) | (data[1] << 8); +} + +static DRWAV_INLINE drwav_int16 drwav__bytes_to_s16(const drwav_uint8* data) +{ + return (short)drwav__bytes_to_u16(data); +} + +static DRWAV_INLINE drwav_uint32 drwav__bytes_to_u32(const drwav_uint8* data) +{ + return (data[0] << 0) | (data[1] << 8) | (data[2] << 16) | (data[3] << 24); +} + +static DRWAV_INLINE drwav_int32 drwav__bytes_to_s32(const drwav_uint8* data) +{ + return (drwav_int32)drwav__bytes_to_u32(data); +} + +static DRWAV_INLINE drwav_uint64 drwav__bytes_to_u64(const drwav_uint8* data) +{ + return + ((drwav_uint64)data[0] << 0) | ((drwav_uint64)data[1] << 8) | ((drwav_uint64)data[2] << 16) | ((drwav_uint64)data[3] << 24) | + ((drwav_uint64)data[4] << 32) | ((drwav_uint64)data[5] << 40) | ((drwav_uint64)data[6] << 48) | ((drwav_uint64)data[7] << 56); +} + +static DRWAV_INLINE drwav_int64 drwav__bytes_to_s64(const drwav_uint8* data) +{ + return (drwav_int64)drwav__bytes_to_u64(data); +} + +static DRWAV_INLINE void drwav__bytes_to_guid(const drwav_uint8* data, drwav_uint8* guid) +{ + int i; + for (i = 0; i < 16; ++i) { + guid[i] = data[i]; + } +} + + +static DRWAV_INLINE drwav_uint16 drwav__bswap16(drwav_uint16 n) +{ +#ifdef DRWAV_HAS_BYTESWAP16_INTRINSIC + #if defined(_MSC_VER) + return _byteswap_ushort(n); + #elif defined(__GNUC__) || defined(__clang__) + return __builtin_bswap16(n); + #else + #error "This compiler does not support the byte swap intrinsic." + #endif +#else + return ((n & 0xFF00) >> 8) | + ((n & 0x00FF) << 8); +#endif +} + +static DRWAV_INLINE drwav_uint32 drwav__bswap32(drwav_uint32 n) +{ +#ifdef DRWAV_HAS_BYTESWAP32_INTRINSIC + #if defined(_MSC_VER) + return _byteswap_ulong(n); + #elif defined(__GNUC__) || defined(__clang__) + #if defined(DRWAV_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(DRWAV_64BIT) /* <-- 64-bit inline assembly has not been tested, so disabling for now. */ + /* Inline assembly optimized implementation for ARM. In my testing, GCC does not generate optimized code with __builtin_bswap32(). */ + drwav_uint32 r; + __asm__ __volatile__ ( + #if defined(DRWAV_64BIT) + "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n) /* <-- This is untested. If someone in the community could test this, that would be appreciated! */ + #else + "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n) + #endif + ); + return r; + #else + return __builtin_bswap32(n); + #endif + #else + #error "This compiler does not support the byte swap intrinsic." + #endif +#else + return ((n & 0xFF000000) >> 24) | + ((n & 0x00FF0000) >> 8) | + ((n & 0x0000FF00) << 8) | + ((n & 0x000000FF) << 24); +#endif +} + +static DRWAV_INLINE drwav_uint64 drwav__bswap64(drwav_uint64 n) +{ +#ifdef DRWAV_HAS_BYTESWAP64_INTRINSIC + #if defined(_MSC_VER) + return _byteswap_uint64(n); + #elif defined(__GNUC__) || defined(__clang__) + return __builtin_bswap64(n); + #else + #error "This compiler does not support the byte swap intrinsic." + #endif +#else + return ((n & (drwav_uint64)0xFF00000000000000) >> 56) | + ((n & (drwav_uint64)0x00FF000000000000) >> 40) | + ((n & (drwav_uint64)0x0000FF0000000000) >> 24) | + ((n & (drwav_uint64)0x000000FF00000000) >> 8) | + ((n & (drwav_uint64)0x00000000FF000000) << 8) | + ((n & (drwav_uint64)0x0000000000FF0000) << 24) | + ((n & (drwav_uint64)0x000000000000FF00) << 40) | + ((n & (drwav_uint64)0x00000000000000FF) << 56); +#endif +} + + +static DRWAV_INLINE drwav_int16 drwav__bswap_s16(drwav_int16 n) +{ + return (drwav_int16)drwav__bswap16((drwav_uint16)n); +} + +static DRWAV_INLINE void drwav__bswap_samples_s16(drwav_int16* pSamples, drwav_uint64 sampleCount) +{ + drwav_uint64 iSample; + for (iSample = 0; iSample < sampleCount; iSample += 1) { + pSamples[iSample] = drwav__bswap_s16(pSamples[iSample]); + } +} + + +static DRWAV_INLINE void drwav__bswap_s24(drwav_uint8* p) +{ + drwav_uint8 t; + t = p[0]; + p[0] = p[2]; + p[2] = t; +} + +static DRWAV_INLINE void drwav__bswap_samples_s24(drwav_uint8* pSamples, drwav_uint64 sampleCount) +{ + drwav_uint64 iSample; + for (iSample = 0; iSample < sampleCount; iSample += 1) { + drwav_uint8* pSample = pSamples + (iSample*3); + drwav__bswap_s24(pSample); + } +} + + +static DRWAV_INLINE drwav_int32 drwav__bswap_s32(drwav_int32 n) +{ + return (drwav_int32)drwav__bswap32((drwav_uint32)n); +} + +static DRWAV_INLINE void drwav__bswap_samples_s32(drwav_int32* pSamples, drwav_uint64 sampleCount) +{ + drwav_uint64 iSample; + for (iSample = 0; iSample < sampleCount; iSample += 1) { + pSamples[iSample] = drwav__bswap_s32(pSamples[iSample]); + } +} + + +static DRWAV_INLINE float drwav__bswap_f32(float n) +{ + union { + drwav_uint32 i; + float f; + } x; + x.f = n; + x.i = drwav__bswap32(x.i); + + return x.f; +} + +static DRWAV_INLINE void drwav__bswap_samples_f32(float* pSamples, drwav_uint64 sampleCount) +{ + drwav_uint64 iSample; + for (iSample = 0; iSample < sampleCount; iSample += 1) { + pSamples[iSample] = drwav__bswap_f32(pSamples[iSample]); + } +} + + +static DRWAV_INLINE double drwav__bswap_f64(double n) +{ + union { + drwav_uint64 i; + double f; + } x; + x.f = n; + x.i = drwav__bswap64(x.i); + + return x.f; +} + +static DRWAV_INLINE void drwav__bswap_samples_f64(double* pSamples, drwav_uint64 sampleCount) +{ + drwav_uint64 iSample; + for (iSample = 0; iSample < sampleCount; iSample += 1) { + pSamples[iSample] = drwav__bswap_f64(pSamples[iSample]); + } +} + + +static DRWAV_INLINE void drwav__bswap_samples_pcm(void* pSamples, drwav_uint64 sampleCount, drwav_uint32 bytesPerSample) +{ + /* Assumes integer PCM. Floating point PCM is done in drwav__bswap_samples_ieee(). */ + switch (bytesPerSample) + { + case 2: /* s16, s12 (loosely packed) */ + { + drwav__bswap_samples_s16((drwav_int16*)pSamples, sampleCount); + } break; + case 3: /* s24 */ + { + drwav__bswap_samples_s24((drwav_uint8*)pSamples, sampleCount); + } break; + case 4: /* s32 */ + { + drwav__bswap_samples_s32((drwav_int32*)pSamples, sampleCount); + } break; + default: + { + /* Unsupported format. */ + DRWAV_ASSERT(DRWAV_FALSE); + } break; + } +} + +static DRWAV_INLINE void drwav__bswap_samples_ieee(void* pSamples, drwav_uint64 sampleCount, drwav_uint32 bytesPerSample) +{ + switch (bytesPerSample) + { + #if 0 /* Contributions welcome for f16 support. */ + case 2: /* f16 */ + { + drwav__bswap_samples_f16((drwav_float16*)pSamples, sampleCount); + } break; + #endif + case 4: /* f32 */ + { + drwav__bswap_samples_f32((float*)pSamples, sampleCount); + } break; + case 8: /* f64 */ + { + drwav__bswap_samples_f64((double*)pSamples, sampleCount); + } break; + default: + { + /* Unsupported format. */ + DRWAV_ASSERT(DRWAV_FALSE); + } break; + } +} + +static DRWAV_INLINE void drwav__bswap_samples(void* pSamples, drwav_uint64 sampleCount, drwav_uint32 bytesPerSample, drwav_uint16 format) +{ + switch (format) + { + case DR_WAVE_FORMAT_PCM: + { + drwav__bswap_samples_pcm(pSamples, sampleCount, bytesPerSample); + } break; + + case DR_WAVE_FORMAT_IEEE_FLOAT: + { + drwav__bswap_samples_ieee(pSamples, sampleCount, bytesPerSample); + } break; + + case DR_WAVE_FORMAT_ALAW: + case DR_WAVE_FORMAT_MULAW: + { + drwav__bswap_samples_s16((drwav_int16*)pSamples, sampleCount); + } break; + + case DR_WAVE_FORMAT_ADPCM: + case DR_WAVE_FORMAT_DVI_ADPCM: + default: + { + /* Unsupported format. */ + DRWAV_ASSERT(DRWAV_FALSE); + } break; + } +} + + +static void* drwav__malloc_default(size_t sz, void* pUserData) +{ + (void)pUserData; + return DRWAV_MALLOC(sz); +} + +static void* drwav__realloc_default(void* p, size_t sz, void* pUserData) +{ + (void)pUserData; + return DRWAV_REALLOC(p, sz); +} + +static void drwav__free_default(void* p, void* pUserData) +{ + (void)pUserData; + DRWAV_FREE(p); +} + + +static void* drwav__malloc_from_callbacks(size_t sz, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (pAllocationCallbacks == NULL) { + return NULL; + } + + if (pAllocationCallbacks->onMalloc != NULL) { + return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData); + } + + /* Try using realloc(). */ + if (pAllocationCallbacks->onRealloc != NULL) { + return pAllocationCallbacks->onRealloc(NULL, sz, pAllocationCallbacks->pUserData); + } + + return NULL; +} + +static void* drwav__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (pAllocationCallbacks == NULL) { + return NULL; + } + + if (pAllocationCallbacks->onRealloc != NULL) { + return pAllocationCallbacks->onRealloc(p, szNew, pAllocationCallbacks->pUserData); + } + + /* Try emulating realloc() in terms of malloc()/free(). */ + if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) { + void* p2; + + p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData); + if (p2 == NULL) { + return NULL; + } + + if (p != NULL) { + DRWAV_COPY_MEMORY(p2, p, szOld); + pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData); + } + + return p2; + } + + return NULL; +} + +static void drwav__free_from_callbacks(void* p, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (p == NULL || pAllocationCallbacks == NULL) { + return; + } + + if (pAllocationCallbacks->onFree != NULL) { + pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData); + } +} + + +static drwav_allocation_callbacks drwav_copy_allocation_callbacks_or_defaults(const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (pAllocationCallbacks != NULL) { + /* Copy. */ + return *pAllocationCallbacks; + } else { + /* Defaults. */ + drwav_allocation_callbacks allocationCallbacks; + allocationCallbacks.pUserData = NULL; + allocationCallbacks.onMalloc = drwav__malloc_default; + allocationCallbacks.onRealloc = drwav__realloc_default; + allocationCallbacks.onFree = drwav__free_default; + return allocationCallbacks; + } +} + + +static DRWAV_INLINE drwav_bool32 drwav__is_compressed_format_tag(drwav_uint16 formatTag) +{ + return + formatTag == DR_WAVE_FORMAT_ADPCM || + formatTag == DR_WAVE_FORMAT_DVI_ADPCM; +} + +static unsigned int drwav__chunk_padding_size_riff(drwav_uint64 chunkSize) +{ + return (unsigned int)(chunkSize % 2); +} + +static unsigned int drwav__chunk_padding_size_w64(drwav_uint64 chunkSize) +{ + return (unsigned int)(chunkSize % 8); +} + +static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut); +static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut); +static drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount); + +static drwav_result drwav__read_chunk_header(drwav_read_proc onRead, void* pUserData, drwav_container container, drwav_uint64* pRunningBytesReadOut, drwav_chunk_header* pHeaderOut) +{ + if (container == drwav_container_riff) { + drwav_uint8 sizeInBytes[4]; + + if (onRead(pUserData, pHeaderOut->id.fourcc, 4) != 4) { + return DRWAV_AT_END; + } + + if (onRead(pUserData, sizeInBytes, 4) != 4) { + return DRWAV_INVALID_FILE; + } + + pHeaderOut->sizeInBytes = drwav__bytes_to_u32(sizeInBytes); + pHeaderOut->paddingSize = drwav__chunk_padding_size_riff(pHeaderOut->sizeInBytes); + *pRunningBytesReadOut += 8; + } else { + drwav_uint8 sizeInBytes[8]; + + if (onRead(pUserData, pHeaderOut->id.guid, 16) != 16) { + return DRWAV_AT_END; + } + + if (onRead(pUserData, sizeInBytes, 8) != 8) { + return DRWAV_INVALID_FILE; + } + + pHeaderOut->sizeInBytes = drwav__bytes_to_u64(sizeInBytes) - 24; /* <-- Subtract 24 because w64 includes the size of the header. */ + pHeaderOut->paddingSize = drwav__chunk_padding_size_w64(pHeaderOut->sizeInBytes); + *pRunningBytesReadOut += 24; + } + + return DRWAV_SUCCESS; +} + +static drwav_bool32 drwav__seek_forward(drwav_seek_proc onSeek, drwav_uint64 offset, void* pUserData) +{ + drwav_uint64 bytesRemainingToSeek = offset; + while (bytesRemainingToSeek > 0) { + if (bytesRemainingToSeek > 0x7FFFFFFF) { + if (!onSeek(pUserData, 0x7FFFFFFF, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + bytesRemainingToSeek -= 0x7FFFFFFF; + } else { + if (!onSeek(pUserData, (int)bytesRemainingToSeek, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + bytesRemainingToSeek = 0; + } + } + + return DRWAV_TRUE; +} + +static drwav_bool32 drwav__seek_from_start(drwav_seek_proc onSeek, drwav_uint64 offset, void* pUserData) +{ + if (offset <= 0x7FFFFFFF) { + return onSeek(pUserData, (int)offset, drwav_seek_origin_start); + } + + /* Larger than 32-bit seek. */ + if (!onSeek(pUserData, 0x7FFFFFFF, drwav_seek_origin_start)) { + return DRWAV_FALSE; + } + offset -= 0x7FFFFFFF; + + for (;;) { + if (offset <= 0x7FFFFFFF) { + return onSeek(pUserData, (int)offset, drwav_seek_origin_current); + } + + if (!onSeek(pUserData, 0x7FFFFFFF, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + offset -= 0x7FFFFFFF; + } + + /* Should never get here. */ + /*return DRWAV_TRUE; */ +} + + +static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, drwav_container container, drwav_uint64* pRunningBytesReadOut, drwav_fmt* fmtOut) +{ + drwav_chunk_header header; + drwav_uint8 fmt[16]; + + if (drwav__read_chunk_header(onRead, pUserData, container, pRunningBytesReadOut, &header) != DRWAV_SUCCESS) { + return DRWAV_FALSE; + } + + + /* Skip non-fmt chunks. */ + while ((container == drwav_container_riff && !drwav__fourcc_equal(header.id.fourcc, "fmt ")) || (container == drwav_container_w64 && !drwav__guid_equal(header.id.guid, drwavGUID_W64_FMT))) { + if (!drwav__seek_forward(onSeek, header.sizeInBytes + header.paddingSize, pUserData)) { + return DRWAV_FALSE; + } + *pRunningBytesReadOut += header.sizeInBytes + header.paddingSize; + + /* Try the next header. */ + if (drwav__read_chunk_header(onRead, pUserData, container, pRunningBytesReadOut, &header) != DRWAV_SUCCESS) { + return DRWAV_FALSE; + } + } + + + /* Validation. */ + if (container == drwav_container_riff) { + if (!drwav__fourcc_equal(header.id.fourcc, "fmt ")) { + return DRWAV_FALSE; + } + } else { + if (!drwav__guid_equal(header.id.guid, drwavGUID_W64_FMT)) { + return DRWAV_FALSE; + } + } + + + if (onRead(pUserData, fmt, sizeof(fmt)) != sizeof(fmt)) { + return DRWAV_FALSE; + } + *pRunningBytesReadOut += sizeof(fmt); + + fmtOut->formatTag = drwav__bytes_to_u16(fmt + 0); + fmtOut->channels = drwav__bytes_to_u16(fmt + 2); + fmtOut->sampleRate = drwav__bytes_to_u32(fmt + 4); + fmtOut->avgBytesPerSec = drwav__bytes_to_u32(fmt + 8); + fmtOut->blockAlign = drwav__bytes_to_u16(fmt + 12); + fmtOut->bitsPerSample = drwav__bytes_to_u16(fmt + 14); + + fmtOut->extendedSize = 0; + fmtOut->validBitsPerSample = 0; + fmtOut->channelMask = 0; + memset(fmtOut->subFormat, 0, sizeof(fmtOut->subFormat)); + + if (header.sizeInBytes > 16) { + drwav_uint8 fmt_cbSize[2]; + int bytesReadSoFar = 0; + + if (onRead(pUserData, fmt_cbSize, sizeof(fmt_cbSize)) != sizeof(fmt_cbSize)) { + return DRWAV_FALSE; /* Expecting more data. */ + } + *pRunningBytesReadOut += sizeof(fmt_cbSize); + + bytesReadSoFar = 18; + + fmtOut->extendedSize = drwav__bytes_to_u16(fmt_cbSize); + if (fmtOut->extendedSize > 0) { + /* Simple validation. */ + if (fmtOut->formatTag == DR_WAVE_FORMAT_EXTENSIBLE) { + if (fmtOut->extendedSize != 22) { + return DRWAV_FALSE; + } + } + + if (fmtOut->formatTag == DR_WAVE_FORMAT_EXTENSIBLE) { + drwav_uint8 fmtext[22]; + if (onRead(pUserData, fmtext, fmtOut->extendedSize) != fmtOut->extendedSize) { + return DRWAV_FALSE; /* Expecting more data. */ + } + + fmtOut->validBitsPerSample = drwav__bytes_to_u16(fmtext + 0); + fmtOut->channelMask = drwav__bytes_to_u32(fmtext + 2); + drwav__bytes_to_guid(fmtext + 6, fmtOut->subFormat); + } else { + if (!onSeek(pUserData, fmtOut->extendedSize, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + } + *pRunningBytesReadOut += fmtOut->extendedSize; + + bytesReadSoFar += fmtOut->extendedSize; + } + + /* Seek past any leftover bytes. For w64 the leftover will be defined based on the chunk size. */ + if (!onSeek(pUserData, (int)(header.sizeInBytes - bytesReadSoFar), drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + *pRunningBytesReadOut += (header.sizeInBytes - bytesReadSoFar); + } + + if (header.paddingSize > 0) { + if (!onSeek(pUserData, header.paddingSize, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + *pRunningBytesReadOut += header.paddingSize; + } + + return DRWAV_TRUE; +} + + +static size_t drwav__on_read(drwav_read_proc onRead, void* pUserData, void* pBufferOut, size_t bytesToRead, drwav_uint64* pCursor) +{ + size_t bytesRead; + + DRWAV_ASSERT(onRead != NULL); + DRWAV_ASSERT(pCursor != NULL); + + bytesRead = onRead(pUserData, pBufferOut, bytesToRead); + *pCursor += bytesRead; + return bytesRead; +} + +#if 0 +static drwav_bool32 drwav__on_seek(drwav_seek_proc onSeek, void* pUserData, int offset, drwav_seek_origin origin, drwav_uint64* pCursor) +{ + DRWAV_ASSERT(onSeek != NULL); + DRWAV_ASSERT(pCursor != NULL); + + if (!onSeek(pUserData, offset, origin)) { + return DRWAV_FALSE; + } + + if (origin == drwav_seek_origin_start) { + *pCursor = offset; + } else { + *pCursor += offset; + } + + return DRWAV_TRUE; +} +#endif + + + +static drwav_uint32 drwav_get_bytes_per_pcm_frame(drwav* pWav) +{ + /* + The bytes per frame is a bit ambiguous. It can be either be based on the bits per sample, or the block align. The way I'm doing it here + is that if the bits per sample is a multiple of 8, use floor(bitsPerSample*channels/8), otherwise fall back to the block align. + */ + if ((pWav->bitsPerSample & 0x7) == 0) { + /* Bits per sample is a multiple of 8. */ + return (pWav->bitsPerSample * pWav->fmt.channels) >> 3; + } else { + return pWav->fmt.blockAlign; + } +} + +DRWAV_API drwav_uint16 drwav_fmt_get_format(const drwav_fmt* pFMT) +{ + if (pFMT == NULL) { + return 0; + } + + if (pFMT->formatTag != DR_WAVE_FORMAT_EXTENSIBLE) { + return pFMT->formatTag; + } else { + return drwav__bytes_to_u16(pFMT->subFormat); /* Only the first two bytes are required. */ + } +} + +static drwav_bool32 drwav_preinit(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pReadSeekUserData, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (pWav == NULL || onRead == NULL || onSeek == NULL) { + return DRWAV_FALSE; + } + + DRWAV_ZERO_MEMORY(pWav, sizeof(*pWav)); + pWav->onRead = onRead; + pWav->onSeek = onSeek; + pWav->pUserData = pReadSeekUserData; + pWav->allocationCallbacks = drwav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks); + + if (pWav->allocationCallbacks.onFree == NULL || (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) { + return DRWAV_FALSE; /* Invalid allocation callbacks. */ + } + + return DRWAV_TRUE; +} + +static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags) +{ + /* This function assumes drwav_preinit() has been called beforehand. */ + + drwav_uint64 cursor; /* <-- Keeps track of the byte position so we can seek to specific locations. */ + drwav_bool32 sequential; + drwav_uint8 riff[4]; + drwav_fmt fmt; + unsigned short translatedFormatTag; + drwav_uint64 sampleCountFromFactChunk; + drwav_bool32 foundDataChunk; + drwav_uint64 dataChunkSize; + drwav_uint64 chunkSize; + + cursor = 0; + sequential = (flags & DRWAV_SEQUENTIAL) != 0; + + /* The first 4 bytes should be the RIFF identifier. */ + if (drwav__on_read(pWav->onRead, pWav->pUserData, riff, sizeof(riff), &cursor) != sizeof(riff)) { + return DRWAV_FALSE; + } + + /* + The first 4 bytes can be used to identify the container. For RIFF files it will start with "RIFF" and for + w64 it will start with "riff". + */ + if (drwav__fourcc_equal(riff, "RIFF")) { + pWav->container = drwav_container_riff; + } else if (drwav__fourcc_equal(riff, "riff")) { + int i; + drwav_uint8 riff2[12]; + + pWav->container = drwav_container_w64; + + /* Check the rest of the GUID for validity. */ + if (drwav__on_read(pWav->onRead, pWav->pUserData, riff2, sizeof(riff2), &cursor) != sizeof(riff2)) { + return DRWAV_FALSE; + } + + for (i = 0; i < 12; ++i) { + if (riff2[i] != drwavGUID_W64_RIFF[i+4]) { + return DRWAV_FALSE; + } + } + } else { + return DRWAV_FALSE; /* Unknown or unsupported container. */ + } + + + if (pWav->container == drwav_container_riff) { + drwav_uint8 chunkSizeBytes[4]; + drwav_uint8 wave[4]; + + /* RIFF/WAVE */ + if (drwav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) { + return DRWAV_FALSE; + } + + if (drwav__bytes_to_u32(chunkSizeBytes) < 36) { + return DRWAV_FALSE; /* Chunk size should always be at least 36 bytes. */ + } + + if (drwav__on_read(pWav->onRead, pWav->pUserData, wave, sizeof(wave), &cursor) != sizeof(wave)) { + return DRWAV_FALSE; + } + + if (!drwav__fourcc_equal(wave, "WAVE")) { + return DRWAV_FALSE; /* Expecting "WAVE". */ + } + } else { + drwav_uint8 chunkSizeBytes[8]; + drwav_uint8 wave[16]; + + /* W64 */ + if (drwav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) { + return DRWAV_FALSE; + } + + if (drwav__bytes_to_u64(chunkSizeBytes) < 80) { + return DRWAV_FALSE; + } + + if (drwav__on_read(pWav->onRead, pWav->pUserData, wave, sizeof(wave), &cursor) != sizeof(wave)) { + return DRWAV_FALSE; + } + + if (!drwav__guid_equal(wave, drwavGUID_W64_WAVE)) { + return DRWAV_FALSE; + } + } + + + /* The next bytes should be the "fmt " chunk. */ + if (!drwav__read_fmt(pWav->onRead, pWav->onSeek, pWav->pUserData, pWav->container, &cursor, &fmt)) { + return DRWAV_FALSE; /* Failed to read the "fmt " chunk. */ + } + + /* Basic validation. */ + if ((fmt.sampleRate == 0 || fmt.sampleRate > DRWAV_MAX_SAMPLE_RATE) || + (fmt.channels == 0 || fmt.channels > DRWAV_MAX_CHANNELS) || + (fmt.bitsPerSample == 0 || fmt.bitsPerSample > DRWAV_MAX_BITS_PER_SAMPLE) || + fmt.blockAlign == 0) { + return DRWAV_FALSE; /* Probably an invalid WAV file. */ + } + + + /* Translate the internal format. */ + translatedFormatTag = fmt.formatTag; + if (translatedFormatTag == DR_WAVE_FORMAT_EXTENSIBLE) { + translatedFormatTag = drwav__bytes_to_u16(fmt.subFormat + 0); + } + + + + sampleCountFromFactChunk = 0; + + /* + We need to enumerate over each chunk for two reasons: + 1) The "data" chunk may not be the next one + 2) We may want to report each chunk back to the client + + In order to correctly report each chunk back to the client we will need to keep looping until the end of the file. + */ + foundDataChunk = DRWAV_FALSE; + dataChunkSize = 0; + + /* The next chunk we care about is the "data" chunk. This is not necessarily the next chunk so we'll need to loop. */ + for (;;) + { + drwav_chunk_header header; + drwav_result result = drwav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header); + if (result != DRWAV_SUCCESS) { + if (!foundDataChunk) { + return DRWAV_FALSE; + } else { + break; /* Probably at the end of the file. Get out of the loop. */ + } + } + + /* Tell the client about this chunk. */ + if (!sequential && onChunk != NULL) { + drwav_uint64 callbackBytesRead = onChunk(pChunkUserData, pWav->onRead, pWav->onSeek, pWav->pUserData, &header, pWav->container, &fmt); + + /* + dr_wav may need to read the contents of the chunk, so we now need to seek back to the position before + we called the callback. + */ + if (callbackBytesRead > 0) { + if (!drwav__seek_from_start(pWav->onSeek, cursor, pWav->pUserData)) { + return DRWAV_FALSE; + } + } + } + + + if (!foundDataChunk) { + pWav->dataChunkDataPos = cursor; + } + + chunkSize = header.sizeInBytes; + if (pWav->container == drwav_container_riff) { + if (drwav__fourcc_equal(header.id.fourcc, "data")) { + foundDataChunk = DRWAV_TRUE; + dataChunkSize = chunkSize; + } + } else { + if (drwav__guid_equal(header.id.guid, drwavGUID_W64_DATA)) { + foundDataChunk = DRWAV_TRUE; + dataChunkSize = chunkSize; + } + } + + /* + If at this point we have found the data chunk and we're running in sequential mode, we need to break out of this loop. The reason for + this is that we would otherwise require a backwards seek which sequential mode forbids. + */ + if (foundDataChunk && sequential) { + break; + } + + /* Optional. Get the total sample count from the FACT chunk. This is useful for compressed formats. */ + if (pWav->container == drwav_container_riff) { + if (drwav__fourcc_equal(header.id.fourcc, "fact")) { + drwav_uint32 sampleCount; + if (drwav__on_read(pWav->onRead, pWav->pUserData, &sampleCount, 4, &cursor) != 4) { + return DRWAV_FALSE; + } + chunkSize -= 4; + + if (!foundDataChunk) { + pWav->dataChunkDataPos = cursor; + } + + /* + The sample count in the "fact" chunk is either unreliable, or I'm not understanding it properly. For now I am only enabling this + for Microsoft ADPCM formats. + */ + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + sampleCountFromFactChunk = sampleCount; + } else { + sampleCountFromFactChunk = 0; + } + } + } else { + if (drwav__guid_equal(header.id.guid, drwavGUID_W64_FACT)) { + if (drwav__on_read(pWav->onRead, pWav->pUserData, &sampleCountFromFactChunk, 8, &cursor) != 8) { + return DRWAV_FALSE; + } + chunkSize -= 8; + + if (!foundDataChunk) { + pWav->dataChunkDataPos = cursor; + } + } + } + + /* "smpl" chunk. */ + if (pWav->container == drwav_container_riff) { + if (drwav__fourcc_equal(header.id.fourcc, "smpl")) { + drwav_uint8 smplHeaderData[36]; /* 36 = size of the smpl header section, not including the loop data. */ + if (chunkSize >= sizeof(smplHeaderData)) { + drwav_uint64 bytesJustRead = drwav__on_read(pWav->onRead, pWav->pUserData, smplHeaderData, sizeof(smplHeaderData), &cursor); + chunkSize -= bytesJustRead; + + if (bytesJustRead == sizeof(smplHeaderData)) { + drwav_uint32 iLoop; + + pWav->smpl.manufacturer = drwav__bytes_to_u32(smplHeaderData+0); + pWav->smpl.product = drwav__bytes_to_u32(smplHeaderData+4); + pWav->smpl.samplePeriod = drwav__bytes_to_u32(smplHeaderData+8); + pWav->smpl.midiUnityNotes = drwav__bytes_to_u32(smplHeaderData+12); + pWav->smpl.midiPitchFraction = drwav__bytes_to_u32(smplHeaderData+16); + pWav->smpl.smpteFormat = drwav__bytes_to_u32(smplHeaderData+20); + pWav->smpl.smpteOffset = drwav__bytes_to_u32(smplHeaderData+24); + pWav->smpl.numSampleLoops = drwav__bytes_to_u32(smplHeaderData+28); + pWav->smpl.samplerData = drwav__bytes_to_u32(smplHeaderData+32); + + for (iLoop = 0; iLoop < pWav->smpl.numSampleLoops && iLoop < drwav_countof(pWav->smpl.loops); ++iLoop) { + drwav_uint8 smplLoopData[24]; /* 24 = size of a loop section in the smpl chunk. */ + bytesJustRead = drwav__on_read(pWav->onRead, pWav->pUserData, smplLoopData, sizeof(smplLoopData), &cursor); + chunkSize -= bytesJustRead; + + if (bytesJustRead == sizeof(smplLoopData)) { + pWav->smpl.loops[iLoop].cuePointId = drwav__bytes_to_u32(smplLoopData+0); + pWav->smpl.loops[iLoop].type = drwav__bytes_to_u32(smplLoopData+4); + pWav->smpl.loops[iLoop].start = drwav__bytes_to_u32(smplLoopData+8); + pWav->smpl.loops[iLoop].end = drwav__bytes_to_u32(smplLoopData+12); + pWav->smpl.loops[iLoop].fraction = drwav__bytes_to_u32(smplLoopData+16); + pWav->smpl.loops[iLoop].playCount = drwav__bytes_to_u32(smplLoopData+20); + } else { + break; /* Break from the smpl loop for loop. */ + } + } + } + } else { + /* Looks like invalid data. Ignore the chunk. */ + } + } + } else { + if (drwav__guid_equal(header.id.guid, drwavGUID_W64_SMPL)) { + /* + This path will be hit when a W64 WAV file contains a smpl chunk. I don't have a sample file to test this path, so a contribution + is welcome to add support for this. + */ + } + } + + /* Make sure we seek past the padding. */ + chunkSize += header.paddingSize; + if (!drwav__seek_forward(pWav->onSeek, chunkSize, pWav->pUserData)) { + break; + } + cursor += chunkSize; + + if (!foundDataChunk) { + pWav->dataChunkDataPos = cursor; + } + } + + /* If we haven't found a data chunk, return an error. */ + if (!foundDataChunk) { + return DRWAV_FALSE; + } + + /* We may have moved passed the data chunk. If so we need to move back. If running in sequential mode we can assume we are already sitting on the data chunk. */ + if (!sequential) { + if (!drwav__seek_from_start(pWav->onSeek, pWav->dataChunkDataPos, pWav->pUserData)) { + return DRWAV_FALSE; + } + cursor = pWav->dataChunkDataPos; + } + + + /* At this point we should be sitting on the first byte of the raw audio data. */ + + pWav->fmt = fmt; + pWav->sampleRate = fmt.sampleRate; + pWav->channels = fmt.channels; + pWav->bitsPerSample = fmt.bitsPerSample; + pWav->bytesRemaining = dataChunkSize; + pWav->translatedFormatTag = translatedFormatTag; + pWav->dataChunkDataSize = dataChunkSize; + + if (sampleCountFromFactChunk != 0) { + pWav->totalPCMFrameCount = sampleCountFromFactChunk; + } else { + pWav->totalPCMFrameCount = dataChunkSize / drwav_get_bytes_per_pcm_frame(pWav); + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + drwav_uint64 totalBlockHeaderSizeInBytes; + drwav_uint64 blockCount = dataChunkSize / fmt.blockAlign; + + /* Make sure any trailing partial block is accounted for. */ + if ((blockCount * fmt.blockAlign) < dataChunkSize) { + blockCount += 1; + } + + /* We decode two samples per byte. There will be blockCount headers in the data chunk. This is enough to know how to calculate the total PCM frame count. */ + totalBlockHeaderSizeInBytes = blockCount * (6*fmt.channels); + pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels; + } + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + drwav_uint64 totalBlockHeaderSizeInBytes; + drwav_uint64 blockCount = dataChunkSize / fmt.blockAlign; + + /* Make sure any trailing partial block is accounted for. */ + if ((blockCount * fmt.blockAlign) < dataChunkSize) { + blockCount += 1; + } + + /* We decode two samples per byte. There will be blockCount headers in the data chunk. This is enough to know how to calculate the total PCM frame count. */ + totalBlockHeaderSizeInBytes = blockCount * (4*fmt.channels); + pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels; + + /* The header includes a decoded sample for each channel which acts as the initial predictor sample. */ + pWav->totalPCMFrameCount += blockCount; + } + } + + /* Some formats only support a certain number of channels. */ + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM || pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + if (pWav->channels > 2) { + return DRWAV_FALSE; + } + } + +#ifdef DR_WAV_LIBSNDFILE_COMPAT + /* + I use libsndfile as a benchmark for testing, however in the version I'm using (from the Windows installer on the libsndfile website), + it appears the total sample count libsndfile uses for MS-ADPCM is incorrect. It would seem they are computing the total sample count + from the number of blocks, however this results in the inclusion of extra silent samples at the end of the last block. The correct + way to know the total sample count is to inspect the "fact" chunk, which should always be present for compressed formats, and should + always include the sample count. This little block of code below is only used to emulate the libsndfile logic so I can properly run my + correctness tests against libsndfile, and is disabled by default. + */ + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + drwav_uint64 blockCount = dataChunkSize / fmt.blockAlign; + pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (6*pWav->channels))) * 2)) / fmt.channels; /* x2 because two samples per byte. */ + } + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + drwav_uint64 blockCount = dataChunkSize / fmt.blockAlign; + pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (4*pWav->channels))) * 2) + (blockCount * pWav->channels)) / fmt.channels; + } +#endif + + return DRWAV_TRUE; +} + +DRWAV_API drwav_bool32 drwav_init(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + return drwav_init_ex(pWav, onRead, onSeek, NULL, pUserData, NULL, 0, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_ex(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_chunk_proc onChunk, void* pReadSeekUserData, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (!drwav_preinit(pWav, onRead, onSeek, pReadSeekUserData, pAllocationCallbacks)) { + return DRWAV_FALSE; + } + + return drwav_init__internal(pWav, onChunk, pChunkUserData, flags); +} + + +static drwav_uint32 drwav__riff_chunk_size_riff(drwav_uint64 dataChunkSize) +{ + drwav_uint32 dataSubchunkPaddingSize = drwav__chunk_padding_size_riff(dataChunkSize); + + if (dataChunkSize <= (0xFFFFFFFFUL - 36 - dataSubchunkPaddingSize)) { + return 36 + (drwav_uint32)(dataChunkSize + dataSubchunkPaddingSize); + } else { + return 0xFFFFFFFF; + } +} + +static drwav_uint32 drwav__data_chunk_size_riff(drwav_uint64 dataChunkSize) +{ + if (dataChunkSize <= 0xFFFFFFFFUL) { + return (drwav_uint32)dataChunkSize; + } else { + return 0xFFFFFFFFUL; + } +} + +static drwav_uint64 drwav__riff_chunk_size_w64(drwav_uint64 dataChunkSize) +{ + drwav_uint64 dataSubchunkPaddingSize = drwav__chunk_padding_size_w64(dataChunkSize); + + return 80 + 24 + dataChunkSize + dataSubchunkPaddingSize; /* +24 because W64 includes the size of the GUID and size fields. */ +} + +static drwav_uint64 drwav__data_chunk_size_w64(drwav_uint64 dataChunkSize) +{ + return 24 + dataChunkSize; /* +24 because W64 includes the size of the GUID and size fields. */ +} + + +static size_t drwav__write(drwav* pWav, const void* pData, size_t dataSize) +{ + DRWAV_ASSERT(pWav != NULL); + DRWAV_ASSERT(pWav->onWrite != NULL); + + /* Generic write. Assumes no byte reordering required. */ + return pWav->onWrite(pWav->pUserData, pData, dataSize); +} + +static size_t drwav__write_u16ne_to_le(drwav* pWav, drwav_uint16 value) +{ + DRWAV_ASSERT(pWav != NULL); + DRWAV_ASSERT(pWav->onWrite != NULL); + + if (!drwav__is_little_endian()) { + value = drwav__bswap16(value); + } + + return drwav__write(pWav, &value, 2); +} + +static size_t drwav__write_u32ne_to_le(drwav* pWav, drwav_uint32 value) +{ + DRWAV_ASSERT(pWav != NULL); + DRWAV_ASSERT(pWav->onWrite != NULL); + + if (!drwav__is_little_endian()) { + value = drwav__bswap32(value); + } + + return drwav__write(pWav, &value, 4); +} + +static size_t drwav__write_u64ne_to_le(drwav* pWav, drwav_uint64 value) +{ + DRWAV_ASSERT(pWav != NULL); + DRWAV_ASSERT(pWav->onWrite != NULL); + + if (!drwav__is_little_endian()) { + value = drwav__bswap64(value); + } + + return drwav__write(pWav, &value, 8); +} + + +static drwav_bool32 drwav_preinit_write(drwav* pWav, const drwav_data_format* pFormat, drwav_bool32 isSequential, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (pWav == NULL || onWrite == NULL) { + return DRWAV_FALSE; + } + + if (!isSequential && onSeek == NULL) { + return DRWAV_FALSE; /* <-- onSeek is required when in non-sequential mode. */ + } + + /* Not currently supporting compressed formats. Will need to add support for the "fact" chunk before we enable this. */ + if (pFormat->format == DR_WAVE_FORMAT_EXTENSIBLE) { + return DRWAV_FALSE; + } + if (pFormat->format == DR_WAVE_FORMAT_ADPCM || pFormat->format == DR_WAVE_FORMAT_DVI_ADPCM) { + return DRWAV_FALSE; + } + + DRWAV_ZERO_MEMORY(pWav, sizeof(*pWav)); + pWav->onWrite = onWrite; + pWav->onSeek = onSeek; + pWav->pUserData = pUserData; + pWav->allocationCallbacks = drwav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks); + + if (pWav->allocationCallbacks.onFree == NULL || (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) { + return DRWAV_FALSE; /* Invalid allocation callbacks. */ + } + + pWav->fmt.formatTag = (drwav_uint16)pFormat->format; + pWav->fmt.channels = (drwav_uint16)pFormat->channels; + pWav->fmt.sampleRate = pFormat->sampleRate; + pWav->fmt.avgBytesPerSec = (drwav_uint32)((pFormat->bitsPerSample * pFormat->sampleRate * pFormat->channels) / 8); + pWav->fmt.blockAlign = (drwav_uint16)((pFormat->channels * pFormat->bitsPerSample) / 8); + pWav->fmt.bitsPerSample = (drwav_uint16)pFormat->bitsPerSample; + pWav->fmt.extendedSize = 0; + pWav->isSequentialWrite = isSequential; + + return DRWAV_TRUE; +} + +static drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount) +{ + /* The function assumes drwav_preinit_write() was called beforehand. */ + + size_t runningPos = 0; + drwav_uint64 initialDataChunkSize = 0; + drwav_uint64 chunkSizeFMT; + + /* + The initial values for the "RIFF" and "data" chunks depends on whether or not we are initializing in sequential mode or not. In + sequential mode we set this to its final values straight away since they can be calculated from the total sample count. In non- + sequential mode we initialize it all to zero and fill it out in drwav_uninit() using a backwards seek. + */ + if (pWav->isSequentialWrite) { + initialDataChunkSize = (totalSampleCount * pWav->fmt.bitsPerSample) / 8; + + /* + The RIFF container has a limit on the number of samples. drwav is not allowing this. There's no practical limits for Wave64 + so for the sake of simplicity I'm not doing any validation for that. + */ + if (pFormat->container == drwav_container_riff) { + if (initialDataChunkSize > (0xFFFFFFFFUL - 36)) { + return DRWAV_FALSE; /* Not enough room to store every sample. */ + } + } + } + + pWav->dataChunkDataSizeTargetWrite = initialDataChunkSize; + + + /* "RIFF" chunk. */ + if (pFormat->container == drwav_container_riff) { + drwav_uint32 chunkSizeRIFF = 36 + (drwav_uint32)initialDataChunkSize; /* +36 = "RIFF"+[RIFF Chunk Size]+"WAVE" + [sizeof "fmt " chunk] */ + runningPos += drwav__write(pWav, "RIFF", 4); + runningPos += drwav__write_u32ne_to_le(pWav, chunkSizeRIFF); + runningPos += drwav__write(pWav, "WAVE", 4); + } else { + drwav_uint64 chunkSizeRIFF = 80 + 24 + initialDataChunkSize; /* +24 because W64 includes the size of the GUID and size fields. */ + runningPos += drwav__write(pWav, drwavGUID_W64_RIFF, 16); + runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeRIFF); + runningPos += drwav__write(pWav, drwavGUID_W64_WAVE, 16); + } + + /* "fmt " chunk. */ + if (pFormat->container == drwav_container_riff) { + chunkSizeFMT = 16; + runningPos += drwav__write(pWav, "fmt ", 4); + runningPos += drwav__write_u32ne_to_le(pWav, (drwav_uint32)chunkSizeFMT); + } else { + chunkSizeFMT = 40; + runningPos += drwav__write(pWav, drwavGUID_W64_FMT, 16); + runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeFMT); + } + + runningPos += drwav__write_u16ne_to_le(pWav, pWav->fmt.formatTag); + runningPos += drwav__write_u16ne_to_le(pWav, pWav->fmt.channels); + runningPos += drwav__write_u32ne_to_le(pWav, pWav->fmt.sampleRate); + runningPos += drwav__write_u32ne_to_le(pWav, pWav->fmt.avgBytesPerSec); + runningPos += drwav__write_u16ne_to_le(pWav, pWav->fmt.blockAlign); + runningPos += drwav__write_u16ne_to_le(pWav, pWav->fmt.bitsPerSample); + + pWav->dataChunkDataPos = runningPos; + + /* "data" chunk. */ + if (pFormat->container == drwav_container_riff) { + drwav_uint32 chunkSizeDATA = (drwav_uint32)initialDataChunkSize; + runningPos += drwav__write(pWav, "data", 4); + runningPos += drwav__write_u32ne_to_le(pWav, chunkSizeDATA); + } else { + drwav_uint64 chunkSizeDATA = 24 + initialDataChunkSize; /* +24 because W64 includes the size of the GUID and size fields. */ + runningPos += drwav__write(pWav, drwavGUID_W64_DATA, 16); + runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeDATA); + } + + + /* Simple validation. */ + if (pFormat->container == drwav_container_riff) { + if (runningPos != 20 + chunkSizeFMT + 8) { + return DRWAV_FALSE; + } + } else { + if (runningPos != 40 + chunkSizeFMT + 24) { + return DRWAV_FALSE; + } + } + + + /* Set some properties for the client's convenience. */ + pWav->container = pFormat->container; + pWav->channels = (drwav_uint16)pFormat->channels; + pWav->sampleRate = pFormat->sampleRate; + pWav->bitsPerSample = (drwav_uint16)pFormat->bitsPerSample; + pWav->translatedFormatTag = (drwav_uint16)pFormat->format; + + return DRWAV_TRUE; +} + + +DRWAV_API drwav_bool32 drwav_init_write(drwav* pWav, const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (!drwav_preinit_write(pWav, pFormat, DRWAV_FALSE, onWrite, onSeek, pUserData, pAllocationCallbacks)) { + return DRWAV_FALSE; + } + + return drwav_init_write__internal(pWav, pFormat, 0); /* DRWAV_FALSE = Not Sequential */ +} + +DRWAV_API drwav_bool32 drwav_init_write_sequential(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (!drwav_preinit_write(pWav, pFormat, DRWAV_TRUE, onWrite, NULL, pUserData, pAllocationCallbacks)) { + return DRWAV_FALSE; + } + + return drwav_init_write__internal(pWav, pFormat, totalSampleCount); /* DRWAV_TRUE = Sequential */ +} + +DRWAV_API drwav_bool32 drwav_init_write_sequential_pcm_frames(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (pFormat == NULL) { + return DRWAV_FALSE; + } + + return drwav_init_write_sequential(pWav, pFormat, totalPCMFrameCount*pFormat->channels, onWrite, pUserData, pAllocationCallbacks); +} + +DRWAV_API drwav_uint64 drwav_target_write_size_bytes(const drwav_data_format* pFormat, drwav_uint64 totalSampleCount) +{ + /* Casting totalSampleCount to drwav_int64 for VC6 compatibility. No issues in practice because nobody is going to exhaust the whole 63 bits. */ + drwav_uint64 targetDataSizeBytes = (drwav_uint64)((drwav_int64)totalSampleCount * pFormat->channels * pFormat->bitsPerSample/8.0); + drwav_uint64 riffChunkSizeBytes; + drwav_uint64 fileSizeBytes; + + if (pFormat->container == drwav_container_riff) { + riffChunkSizeBytes = drwav__riff_chunk_size_riff(targetDataSizeBytes); + fileSizeBytes = (8 + riffChunkSizeBytes); /* +8 because WAV doesn't include the size of the ChunkID and ChunkSize fields. */ + } else { + riffChunkSizeBytes = drwav__riff_chunk_size_w64(targetDataSizeBytes); + fileSizeBytes = riffChunkSizeBytes; + } + + return fileSizeBytes; +} + + +#ifndef DR_WAV_NO_STDIO + +/* drwav_result_from_errno() is only used for fopen() and wfopen() so putting it inside DR_WAV_NO_STDIO for now. If something else needs this later we can move it out. */ +#include +static drwav_result drwav_result_from_errno(int e) +{ + switch (e) + { + case 0: return DRWAV_SUCCESS; + #ifdef EPERM + case EPERM: return DRWAV_INVALID_OPERATION; + #endif + #ifdef ENOENT + case ENOENT: return DRWAV_DOES_NOT_EXIST; + #endif + #ifdef ESRCH + case ESRCH: return DRWAV_DOES_NOT_EXIST; + #endif + #ifdef EINTR + case EINTR: return DRWAV_INTERRUPT; + #endif + #ifdef EIO + case EIO: return DRWAV_IO_ERROR; + #endif + #ifdef ENXIO + case ENXIO: return DRWAV_DOES_NOT_EXIST; + #endif + #ifdef E2BIG + case E2BIG: return DRWAV_INVALID_ARGS; + #endif + #ifdef ENOEXEC + case ENOEXEC: return DRWAV_INVALID_FILE; + #endif + #ifdef EBADF + case EBADF: return DRWAV_INVALID_FILE; + #endif + #ifdef ECHILD + case ECHILD: return DRWAV_ERROR; + #endif + #ifdef EAGAIN + case EAGAIN: return DRWAV_UNAVAILABLE; + #endif + #ifdef ENOMEM + case ENOMEM: return DRWAV_OUT_OF_MEMORY; + #endif + #ifdef EACCES + case EACCES: return DRWAV_ACCESS_DENIED; + #endif + #ifdef EFAULT + case EFAULT: return DRWAV_BAD_ADDRESS; + #endif + #ifdef ENOTBLK + case ENOTBLK: return DRWAV_ERROR; + #endif + #ifdef EBUSY + case EBUSY: return DRWAV_BUSY; + #endif + #ifdef EEXIST + case EEXIST: return DRWAV_ALREADY_EXISTS; + #endif + #ifdef EXDEV + case EXDEV: return DRWAV_ERROR; + #endif + #ifdef ENODEV + case ENODEV: return DRWAV_DOES_NOT_EXIST; + #endif + #ifdef ENOTDIR + case ENOTDIR: return DRWAV_NOT_DIRECTORY; + #endif + #ifdef EISDIR + case EISDIR: return DRWAV_IS_DIRECTORY; + #endif + #ifdef EINVAL + case EINVAL: return DRWAV_INVALID_ARGS; + #endif + #ifdef ENFILE + case ENFILE: return DRWAV_TOO_MANY_OPEN_FILES; + #endif + #ifdef EMFILE + case EMFILE: return DRWAV_TOO_MANY_OPEN_FILES; + #endif + #ifdef ENOTTY + case ENOTTY: return DRWAV_INVALID_OPERATION; + #endif + #ifdef ETXTBSY + case ETXTBSY: return DRWAV_BUSY; + #endif + #ifdef EFBIG + case EFBIG: return DRWAV_TOO_BIG; + #endif + #ifdef ENOSPC + case ENOSPC: return DRWAV_NO_SPACE; + #endif + #ifdef ESPIPE + case ESPIPE: return DRWAV_BAD_SEEK; + #endif + #ifdef EROFS + case EROFS: return DRWAV_ACCESS_DENIED; + #endif + #ifdef EMLINK + case EMLINK: return DRWAV_TOO_MANY_LINKS; + #endif + #ifdef EPIPE + case EPIPE: return DRWAV_BAD_PIPE; + #endif + #ifdef EDOM + case EDOM: return DRWAV_OUT_OF_RANGE; + #endif + #ifdef ERANGE + case ERANGE: return DRWAV_OUT_OF_RANGE; + #endif + #ifdef EDEADLK + case EDEADLK: return DRWAV_DEADLOCK; + #endif + #ifdef ENAMETOOLONG + case ENAMETOOLONG: return DRWAV_PATH_TOO_LONG; + #endif + #ifdef ENOLCK + case ENOLCK: return DRWAV_ERROR; + #endif + #ifdef ENOSYS + case ENOSYS: return DRWAV_NOT_IMPLEMENTED; + #endif + #ifdef ENOTEMPTY + case ENOTEMPTY: return DRWAV_DIRECTORY_NOT_EMPTY; + #endif + #ifdef ELOOP + case ELOOP: return DRWAV_TOO_MANY_LINKS; + #endif + #ifdef ENOMSG + case ENOMSG: return DRWAV_NO_MESSAGE; + #endif + #ifdef EIDRM + case EIDRM: return DRWAV_ERROR; + #endif + #ifdef ECHRNG + case ECHRNG: return DRWAV_ERROR; + #endif + #ifdef EL2NSYNC + case EL2NSYNC: return DRWAV_ERROR; + #endif + #ifdef EL3HLT + case EL3HLT: return DRWAV_ERROR; + #endif + #ifdef EL3RST + case EL3RST: return DRWAV_ERROR; + #endif + #ifdef ELNRNG + case ELNRNG: return DRWAV_OUT_OF_RANGE; + #endif + #ifdef EUNATCH + case EUNATCH: return DRWAV_ERROR; + #endif + #ifdef ENOCSI + case ENOCSI: return DRWAV_ERROR; + #endif + #ifdef EL2HLT + case EL2HLT: return DRWAV_ERROR; + #endif + #ifdef EBADE + case EBADE: return DRWAV_ERROR; + #endif + #ifdef EBADR + case EBADR: return DRWAV_ERROR; + #endif + #ifdef EXFULL + case EXFULL: return DRWAV_ERROR; + #endif + #ifdef ENOANO + case ENOANO: return DRWAV_ERROR; + #endif + #ifdef EBADRQC + case EBADRQC: return DRWAV_ERROR; + #endif + #ifdef EBADSLT + case EBADSLT: return DRWAV_ERROR; + #endif + #ifdef EBFONT + case EBFONT: return DRWAV_INVALID_FILE; + #endif + #ifdef ENOSTR + case ENOSTR: return DRWAV_ERROR; + #endif + #ifdef ENODATA + case ENODATA: return DRWAV_NO_DATA_AVAILABLE; + #endif + #ifdef ETIME + case ETIME: return DRWAV_TIMEOUT; + #endif + #ifdef ENOSR + case ENOSR: return DRWAV_NO_DATA_AVAILABLE; + #endif + #ifdef ENONET + case ENONET: return DRWAV_NO_NETWORK; + #endif + #ifdef ENOPKG + case ENOPKG: return DRWAV_ERROR; + #endif + #ifdef EREMOTE + case EREMOTE: return DRWAV_ERROR; + #endif + #ifdef ENOLINK + case ENOLINK: return DRWAV_ERROR; + #endif + #ifdef EADV + case EADV: return DRWAV_ERROR; + #endif + #ifdef ESRMNT + case ESRMNT: return DRWAV_ERROR; + #endif + #ifdef ECOMM + case ECOMM: return DRWAV_ERROR; + #endif + #ifdef EPROTO + case EPROTO: return DRWAV_ERROR; + #endif + #ifdef EMULTIHOP + case EMULTIHOP: return DRWAV_ERROR; + #endif + #ifdef EDOTDOT + case EDOTDOT: return DRWAV_ERROR; + #endif + #ifdef EBADMSG + case EBADMSG: return DRWAV_BAD_MESSAGE; + #endif + #ifdef EOVERFLOW + case EOVERFLOW: return DRWAV_TOO_BIG; + #endif + #ifdef ENOTUNIQ + case ENOTUNIQ: return DRWAV_NOT_UNIQUE; + #endif + #ifdef EBADFD + case EBADFD: return DRWAV_ERROR; + #endif + #ifdef EREMCHG + case EREMCHG: return DRWAV_ERROR; + #endif + #ifdef ELIBACC + case ELIBACC: return DRWAV_ACCESS_DENIED; + #endif + #ifdef ELIBBAD + case ELIBBAD: return DRWAV_INVALID_FILE; + #endif + #ifdef ELIBSCN + case ELIBSCN: return DRWAV_INVALID_FILE; + #endif + #ifdef ELIBMAX + case ELIBMAX: return DRWAV_ERROR; + #endif + #ifdef ELIBEXEC + case ELIBEXEC: return DRWAV_ERROR; + #endif + #ifdef EILSEQ + case EILSEQ: return DRWAV_INVALID_DATA; + #endif + #ifdef ERESTART + case ERESTART: return DRWAV_ERROR; + #endif + #ifdef ESTRPIPE + case ESTRPIPE: return DRWAV_ERROR; + #endif + #ifdef EUSERS + case EUSERS: return DRWAV_ERROR; + #endif + #ifdef ENOTSOCK + case ENOTSOCK: return DRWAV_NOT_SOCKET; + #endif + #ifdef EDESTADDRREQ + case EDESTADDRREQ: return DRWAV_NO_ADDRESS; + #endif + #ifdef EMSGSIZE + case EMSGSIZE: return DRWAV_TOO_BIG; + #endif + #ifdef EPROTOTYPE + case EPROTOTYPE: return DRWAV_BAD_PROTOCOL; + #endif + #ifdef ENOPROTOOPT + case ENOPROTOOPT: return DRWAV_PROTOCOL_UNAVAILABLE; + #endif + #ifdef EPROTONOSUPPORT + case EPROTONOSUPPORT: return DRWAV_PROTOCOL_NOT_SUPPORTED; + #endif + #ifdef ESOCKTNOSUPPORT + case ESOCKTNOSUPPORT: return DRWAV_SOCKET_NOT_SUPPORTED; + #endif + #ifdef EOPNOTSUPP + case EOPNOTSUPP: return DRWAV_INVALID_OPERATION; + #endif + #ifdef EPFNOSUPPORT + case EPFNOSUPPORT: return DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED; + #endif + #ifdef EAFNOSUPPORT + case EAFNOSUPPORT: return DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED; + #endif + #ifdef EADDRINUSE + case EADDRINUSE: return DRWAV_ALREADY_IN_USE; + #endif + #ifdef EADDRNOTAVAIL + case EADDRNOTAVAIL: return DRWAV_ERROR; + #endif + #ifdef ENETDOWN + case ENETDOWN: return DRWAV_NO_NETWORK; + #endif + #ifdef ENETUNREACH + case ENETUNREACH: return DRWAV_NO_NETWORK; + #endif + #ifdef ENETRESET + case ENETRESET: return DRWAV_NO_NETWORK; + #endif + #ifdef ECONNABORTED + case ECONNABORTED: return DRWAV_NO_NETWORK; + #endif + #ifdef ECONNRESET + case ECONNRESET: return DRWAV_CONNECTION_RESET; + #endif + #ifdef ENOBUFS + case ENOBUFS: return DRWAV_NO_SPACE; + #endif + #ifdef EISCONN + case EISCONN: return DRWAV_ALREADY_CONNECTED; + #endif + #ifdef ENOTCONN + case ENOTCONN: return DRWAV_NOT_CONNECTED; + #endif + #ifdef ESHUTDOWN + case ESHUTDOWN: return DRWAV_ERROR; + #endif + #ifdef ETOOMANYREFS + case ETOOMANYREFS: return DRWAV_ERROR; + #endif + #ifdef ETIMEDOUT + case ETIMEDOUT: return DRWAV_TIMEOUT; + #endif + #ifdef ECONNREFUSED + case ECONNREFUSED: return DRWAV_CONNECTION_REFUSED; + #endif + #ifdef EHOSTDOWN + case EHOSTDOWN: return DRWAV_NO_HOST; + #endif + #ifdef EHOSTUNREACH + case EHOSTUNREACH: return DRWAV_NO_HOST; + #endif + #ifdef EALREADY + case EALREADY: return DRWAV_IN_PROGRESS; + #endif + #ifdef EINPROGRESS + case EINPROGRESS: return DRWAV_IN_PROGRESS; + #endif + #ifdef ESTALE + case ESTALE: return DRWAV_INVALID_FILE; + #endif + #ifdef EUCLEAN + case EUCLEAN: return DRWAV_ERROR; + #endif + #ifdef ENOTNAM + case ENOTNAM: return DRWAV_ERROR; + #endif + #ifdef ENAVAIL + case ENAVAIL: return DRWAV_ERROR; + #endif + #ifdef EISNAM + case EISNAM: return DRWAV_ERROR; + #endif + #ifdef EREMOTEIO + case EREMOTEIO: return DRWAV_IO_ERROR; + #endif + #ifdef EDQUOT + case EDQUOT: return DRWAV_NO_SPACE; + #endif + #ifdef ENOMEDIUM + case ENOMEDIUM: return DRWAV_DOES_NOT_EXIST; + #endif + #ifdef EMEDIUMTYPE + case EMEDIUMTYPE: return DRWAV_ERROR; + #endif + #ifdef ECANCELED + case ECANCELED: return DRWAV_CANCELLED; + #endif + #ifdef ENOKEY + case ENOKEY: return DRWAV_ERROR; + #endif + #ifdef EKEYEXPIRED + case EKEYEXPIRED: return DRWAV_ERROR; + #endif + #ifdef EKEYREVOKED + case EKEYREVOKED: return DRWAV_ERROR; + #endif + #ifdef EKEYREJECTED + case EKEYREJECTED: return DRWAV_ERROR; + #endif + #ifdef EOWNERDEAD + case EOWNERDEAD: return DRWAV_ERROR; + #endif + #ifdef ENOTRECOVERABLE + case ENOTRECOVERABLE: return DRWAV_ERROR; + #endif + #ifdef ERFKILL + case ERFKILL: return DRWAV_ERROR; + #endif + #ifdef EHWPOISON + case EHWPOISON: return DRWAV_ERROR; + #endif + default: return DRWAV_ERROR; + } +} + +static drwav_result drwav_fopen(FILE** ppFile, const char* pFilePath, const char* pOpenMode) +{ +#if _MSC_VER && _MSC_VER >= 1400 + errno_t err; +#endif + + if (ppFile != NULL) { + *ppFile = NULL; /* Safety. */ + } + + if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) { + return DRWAV_INVALID_ARGS; + } + +#if _MSC_VER && _MSC_VER >= 1400 + err = fopen_s(ppFile, pFilePath, pOpenMode); + if (err != 0) { + return drwav_result_from_errno(err); + } +#else +#if defined(_WIN32) || defined(__APPLE__) + *ppFile = fopen(pFilePath, pOpenMode); +#else + #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64 && defined(_LARGEFILE64_SOURCE) + *ppFile = fopen64(pFilePath, pOpenMode); + #else + *ppFile = fopen(pFilePath, pOpenMode); + #endif +#endif + if (*ppFile == NULL) { + drwav_result result = drwav_result_from_errno(errno); + if (result == DRWAV_SUCCESS) { + result = DRWAV_ERROR; /* Just a safety check to make sure we never ever return success when pFile == NULL. */ + } + + return result; + } +#endif + + return DRWAV_SUCCESS; +} + +/* +_wfopen() isn't always available in all compilation environments. + + * Windows only. + * MSVC seems to support it universally as far back as VC6 from what I can tell (haven't checked further back). + * MinGW-64 (both 32- and 64-bit) seems to support it. + * MinGW wraps it in !defined(__STRICT_ANSI__). + +This can be reviewed as compatibility issues arise. The preference is to use _wfopen_s() and _wfopen() as opposed to the wcsrtombs() +fallback, so if you notice your compiler not detecting this properly I'm happy to look at adding support. +*/ +#if defined(_WIN32) + #if defined(_MSC_VER) || defined(__MINGW64__) || !defined(__STRICT_ANSI__) + #define DRWAV_HAS_WFOPEN + #endif +#endif + +static drwav_result drwav_wfopen(FILE** ppFile, const wchar_t* pFilePath, const wchar_t* pOpenMode, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (ppFile != NULL) { + *ppFile = NULL; /* Safety. */ + } + + if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) { + return DRWAV_INVALID_ARGS; + } + +#if defined(DRWAV_HAS_WFOPEN) + { + /* Use _wfopen() on Windows. */ + #if defined(_MSC_VER) && _MSC_VER >= 1400 + errno_t err = _wfopen_s(ppFile, pFilePath, pOpenMode); + if (err != 0) { + return drwav_result_from_errno(err); + } + #else + *ppFile = _wfopen(pFilePath, pOpenMode); + if (*ppFile == NULL) { + return drwav_result_from_errno(errno); + } + #endif + (void)pAllocationCallbacks; + } +#else + /* + Use fopen() on anything other than Windows. Requires a conversion. This is annoying because fopen() is locale specific. The only real way I can + think of to do this is with wcsrtombs(). Note that wcstombs() is apparently not thread-safe because it uses a static global mbstate_t object for + maintaining state. I've checked this with -std=c89 and it works, but if somebody get's a compiler error I'll look into improving compatibility. + */ + { + mbstate_t mbs; + size_t lenMB; + const wchar_t* pFilePathTemp = pFilePath; + char* pFilePathMB = NULL; + char pOpenModeMB[32] = {0}; + + /* Get the length first. */ + DRWAV_ZERO_OBJECT(&mbs); + lenMB = wcsrtombs(NULL, &pFilePathTemp, 0, &mbs); + if (lenMB == (size_t)-1) { + return drwav_result_from_errno(errno); + } + + pFilePathMB = (char*)drwav__malloc_from_callbacks(lenMB + 1, pAllocationCallbacks); + if (pFilePathMB == NULL) { + return DRWAV_OUT_OF_MEMORY; + } + + pFilePathTemp = pFilePath; + DRWAV_ZERO_OBJECT(&mbs); + wcsrtombs(pFilePathMB, &pFilePathTemp, lenMB + 1, &mbs); + + /* The open mode should always consist of ASCII characters so we should be able to do a trivial conversion. */ + { + size_t i = 0; + for (;;) { + if (pOpenMode[i] == 0) { + pOpenModeMB[i] = '\0'; + break; + } + + pOpenModeMB[i] = (char)pOpenMode[i]; + i += 1; + } + } + + *ppFile = fopen(pFilePathMB, pOpenModeMB); + + drwav__free_from_callbacks(pFilePathMB, pAllocationCallbacks); + } + + if (*ppFile == NULL) { + return DRWAV_ERROR; + } +#endif + + return DRWAV_SUCCESS; +} + + +static size_t drwav__on_read_stdio(void* pUserData, void* pBufferOut, size_t bytesToRead) +{ + return fread(pBufferOut, 1, bytesToRead, (FILE*)pUserData); +} + +static size_t drwav__on_write_stdio(void* pUserData, const void* pData, size_t bytesToWrite) +{ + return fwrite(pData, 1, bytesToWrite, (FILE*)pUserData); +} + +static drwav_bool32 drwav__on_seek_stdio(void* pUserData, int offset, drwav_seek_origin origin) +{ + return fseek((FILE*)pUserData, offset, (origin == drwav_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0; +} + +DRWAV_API drwav_bool32 drwav_init_file(drwav* pWav, const char* filename, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + return drwav_init_file_ex(pWav, filename, NULL, NULL, 0, pAllocationCallbacks); +} + + +static drwav_bool32 drwav_init_file__internal_FILE(drwav* pWav, FILE* pFile, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav_bool32 result; + + result = drwav_preinit(pWav, drwav__on_read_stdio, drwav__on_seek_stdio, (void*)pFile, pAllocationCallbacks); + if (result != DRWAV_TRUE) { + fclose(pFile); + return result; + } + + result = drwav_init__internal(pWav, onChunk, pChunkUserData, flags); + if (result != DRWAV_TRUE) { + fclose(pFile); + return result; + } + + return DRWAV_TRUE; +} + +DRWAV_API drwav_bool32 drwav_init_file_ex(drwav* pWav, const char* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + FILE* pFile; + if (drwav_fopen(&pFile, filename, "rb") != DRWAV_SUCCESS) { + return DRWAV_FALSE; + } + + /* This takes ownership of the FILE* object. */ + return drwav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_file_w(drwav* pWav, const wchar_t* filename, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + return drwav_init_file_ex_w(pWav, filename, NULL, NULL, 0, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_file_ex_w(drwav* pWav, const wchar_t* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + FILE* pFile; + if (drwav_wfopen(&pFile, filename, L"rb", pAllocationCallbacks) != DRWAV_SUCCESS) { + return DRWAV_FALSE; + } + + /* This takes ownership of the FILE* object. */ + return drwav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks); +} + + +static drwav_bool32 drwav_init_file_write__internal_FILE(drwav* pWav, FILE* pFile, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav_bool32 result; + + result = drwav_preinit_write(pWav, pFormat, isSequential, drwav__on_write_stdio, drwav__on_seek_stdio, (void*)pFile, pAllocationCallbacks); + if (result != DRWAV_TRUE) { + fclose(pFile); + return result; + } + + result = drwav_init_write__internal(pWav, pFormat, totalSampleCount); + if (result != DRWAV_TRUE) { + fclose(pFile); + return result; + } + + return DRWAV_TRUE; +} + +static drwav_bool32 drwav_init_file_write__internal(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + FILE* pFile; + if (drwav_fopen(&pFile, filename, "wb") != DRWAV_SUCCESS) { + return DRWAV_FALSE; + } + + /* This takes ownership of the FILE* object. */ + return drwav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks); +} + +static drwav_bool32 drwav_init_file_write_w__internal(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + FILE* pFile; + if (drwav_wfopen(&pFile, filename, L"wb", pAllocationCallbacks) != DRWAV_SUCCESS) { + return DRWAV_FALSE; + } + + /* This takes ownership of the FILE* object. */ + return drwav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_file_write(drwav* pWav, const char* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + return drwav_init_file_write__internal(pWav, filename, pFormat, 0, DRWAV_FALSE, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_file_write_sequential(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + return drwav_init_file_write__internal(pWav, filename, pFormat, totalSampleCount, DRWAV_TRUE, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (pFormat == NULL) { + return DRWAV_FALSE; + } + + return drwav_init_file_write_sequential(pWav, filename, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_file_write_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + return drwav_init_file_write_w__internal(pWav, filename, pFormat, 0, DRWAV_FALSE, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_file_write_sequential_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + return drwav_init_file_write_w__internal(pWav, filename, pFormat, totalSampleCount, DRWAV_TRUE, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (pFormat == NULL) { + return DRWAV_FALSE; + } + + return drwav_init_file_write_sequential_w(pWav, filename, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks); +} +#endif /* DR_WAV_NO_STDIO */ + + +static size_t drwav__on_read_memory(void* pUserData, void* pBufferOut, size_t bytesToRead) +{ + drwav* pWav = (drwav*)pUserData; + size_t bytesRemaining; + + DRWAV_ASSERT(pWav != NULL); + DRWAV_ASSERT(pWav->memoryStream.dataSize >= pWav->memoryStream.currentReadPos); + + bytesRemaining = pWav->memoryStream.dataSize - pWav->memoryStream.currentReadPos; + if (bytesToRead > bytesRemaining) { + bytesToRead = bytesRemaining; + } + + if (bytesToRead > 0) { + DRWAV_COPY_MEMORY(pBufferOut, pWav->memoryStream.data + pWav->memoryStream.currentReadPos, bytesToRead); + pWav->memoryStream.currentReadPos += bytesToRead; + } + + return bytesToRead; +} + +static drwav_bool32 drwav__on_seek_memory(void* pUserData, int offset, drwav_seek_origin origin) +{ + drwav* pWav = (drwav*)pUserData; + DRWAV_ASSERT(pWav != NULL); + + if (origin == drwav_seek_origin_current) { + if (offset > 0) { + if (pWav->memoryStream.currentReadPos + offset > pWav->memoryStream.dataSize) { + return DRWAV_FALSE; /* Trying to seek too far forward. */ + } + } else { + if (pWav->memoryStream.currentReadPos < (size_t)-offset) { + return DRWAV_FALSE; /* Trying to seek too far backwards. */ + } + } + + /* This will never underflow thanks to the clamps above. */ + pWav->memoryStream.currentReadPos += offset; + } else { + if ((drwav_uint32)offset <= pWav->memoryStream.dataSize) { + pWav->memoryStream.currentReadPos = offset; + } else { + return DRWAV_FALSE; /* Trying to seek too far forward. */ + } + } + + return DRWAV_TRUE; +} + +static size_t drwav__on_write_memory(void* pUserData, const void* pDataIn, size_t bytesToWrite) +{ + drwav* pWav = (drwav*)pUserData; + size_t bytesRemaining; + + DRWAV_ASSERT(pWav != NULL); + DRWAV_ASSERT(pWav->memoryStreamWrite.dataCapacity >= pWav->memoryStreamWrite.currentWritePos); + + bytesRemaining = pWav->memoryStreamWrite.dataCapacity - pWav->memoryStreamWrite.currentWritePos; + if (bytesRemaining < bytesToWrite) { + /* Need to reallocate. */ + void* pNewData; + size_t newDataCapacity = (pWav->memoryStreamWrite.dataCapacity == 0) ? 256 : pWav->memoryStreamWrite.dataCapacity * 2; + + /* If doubling wasn't enough, just make it the minimum required size to write the data. */ + if ((newDataCapacity - pWav->memoryStreamWrite.currentWritePos) < bytesToWrite) { + newDataCapacity = pWav->memoryStreamWrite.currentWritePos + bytesToWrite; + } + + pNewData = drwav__realloc_from_callbacks(*pWav->memoryStreamWrite.ppData, newDataCapacity, pWav->memoryStreamWrite.dataCapacity, &pWav->allocationCallbacks); + if (pNewData == NULL) { + return 0; + } + + *pWav->memoryStreamWrite.ppData = pNewData; + pWav->memoryStreamWrite.dataCapacity = newDataCapacity; + } + + DRWAV_COPY_MEMORY(((drwav_uint8*)(*pWav->memoryStreamWrite.ppData)) + pWav->memoryStreamWrite.currentWritePos, pDataIn, bytesToWrite); + + pWav->memoryStreamWrite.currentWritePos += bytesToWrite; + if (pWav->memoryStreamWrite.dataSize < pWav->memoryStreamWrite.currentWritePos) { + pWav->memoryStreamWrite.dataSize = pWav->memoryStreamWrite.currentWritePos; + } + + *pWav->memoryStreamWrite.pDataSize = pWav->memoryStreamWrite.dataSize; + + return bytesToWrite; +} + +static drwav_bool32 drwav__on_seek_memory_write(void* pUserData, int offset, drwav_seek_origin origin) +{ + drwav* pWav = (drwav*)pUserData; + DRWAV_ASSERT(pWav != NULL); + + if (origin == drwav_seek_origin_current) { + if (offset > 0) { + if (pWav->memoryStreamWrite.currentWritePos + offset > pWav->memoryStreamWrite.dataSize) { + offset = (int)(pWav->memoryStreamWrite.dataSize - pWav->memoryStreamWrite.currentWritePos); /* Trying to seek too far forward. */ + } + } else { + if (pWav->memoryStreamWrite.currentWritePos < (size_t)-offset) { + offset = -(int)pWav->memoryStreamWrite.currentWritePos; /* Trying to seek too far backwards. */ + } + } + + /* This will never underflow thanks to the clamps above. */ + pWav->memoryStreamWrite.currentWritePos += offset; + } else { + if ((drwav_uint32)offset <= pWav->memoryStreamWrite.dataSize) { + pWav->memoryStreamWrite.currentWritePos = offset; + } else { + pWav->memoryStreamWrite.currentWritePos = pWav->memoryStreamWrite.dataSize; /* Trying to seek too far forward. */ + } + } + + return DRWAV_TRUE; +} + +DRWAV_API drwav_bool32 drwav_init_memory(drwav* pWav, const void* data, size_t dataSize, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + return drwav_init_memory_ex(pWav, data, dataSize, NULL, NULL, 0, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_memory_ex(drwav* pWav, const void* data, size_t dataSize, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (data == NULL || dataSize == 0) { + return DRWAV_FALSE; + } + + if (!drwav_preinit(pWav, drwav__on_read_memory, drwav__on_seek_memory, pWav, pAllocationCallbacks)) { + return DRWAV_FALSE; + } + + pWav->memoryStream.data = (const drwav_uint8*)data; + pWav->memoryStream.dataSize = dataSize; + pWav->memoryStream.currentReadPos = 0; + + return drwav_init__internal(pWav, onChunk, pChunkUserData, flags); +} + + +static drwav_bool32 drwav_init_memory_write__internal(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (ppData == NULL || pDataSize == NULL) { + return DRWAV_FALSE; + } + + *ppData = NULL; /* Important because we're using realloc()! */ + *pDataSize = 0; + + if (!drwav_preinit_write(pWav, pFormat, isSequential, drwav__on_write_memory, drwav__on_seek_memory_write, pWav, pAllocationCallbacks)) { + return DRWAV_FALSE; + } + + pWav->memoryStreamWrite.ppData = ppData; + pWav->memoryStreamWrite.pDataSize = pDataSize; + pWav->memoryStreamWrite.dataSize = 0; + pWav->memoryStreamWrite.dataCapacity = 0; + pWav->memoryStreamWrite.currentWritePos = 0; + + return drwav_init_write__internal(pWav, pFormat, totalSampleCount); +} + +DRWAV_API drwav_bool32 drwav_init_memory_write(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, 0, DRWAV_FALSE, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_memory_write_sequential(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, totalSampleCount, DRWAV_TRUE, pAllocationCallbacks); +} + +DRWAV_API drwav_bool32 drwav_init_memory_write_sequential_pcm_frames(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (pFormat == NULL) { + return DRWAV_FALSE; + } + + return drwav_init_memory_write_sequential(pWav, ppData, pDataSize, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks); +} + + + +DRWAV_API drwav_result drwav_uninit(drwav* pWav) +{ + drwav_result result = DRWAV_SUCCESS; + + if (pWav == NULL) { + return DRWAV_INVALID_ARGS; + } + + /* + If the drwav object was opened in write mode we'll need to finalize a few things: + - Make sure the "data" chunk is aligned to 16-bits for RIFF containers, or 64 bits for W64 containers. + - Set the size of the "data" chunk. + */ + if (pWav->onWrite != NULL) { + drwav_uint32 paddingSize = 0; + + /* Padding. Do not adjust pWav->dataChunkDataSize - this should not include the padding. */ + if (pWav->container == drwav_container_riff) { + paddingSize = drwav__chunk_padding_size_riff(pWav->dataChunkDataSize); + } else { + paddingSize = drwav__chunk_padding_size_w64(pWav->dataChunkDataSize); + } + + if (paddingSize > 0) { + drwav_uint64 paddingData = 0; + drwav__write(pWav, &paddingData, paddingSize); /* Byte order does not matter for this. */ + } + + /* + Chunk sizes. When using sequential mode, these will have been filled in at initialization time. We only need + to do this when using non-sequential mode. + */ + if (pWav->onSeek && !pWav->isSequentialWrite) { + if (pWav->container == drwav_container_riff) { + /* The "RIFF" chunk size. */ + if (pWav->onSeek(pWav->pUserData, 4, drwav_seek_origin_start)) { + drwav_uint32 riffChunkSize = drwav__riff_chunk_size_riff(pWav->dataChunkDataSize); + drwav__write_u32ne_to_le(pWav, riffChunkSize); + } + + /* the "data" chunk size. */ + if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos + 4, drwav_seek_origin_start)) { + drwav_uint32 dataChunkSize = drwav__data_chunk_size_riff(pWav->dataChunkDataSize); + drwav__write_u32ne_to_le(pWav, dataChunkSize); + } + } else { + /* The "RIFF" chunk size. */ + if (pWav->onSeek(pWav->pUserData, 16, drwav_seek_origin_start)) { + drwav_uint64 riffChunkSize = drwav__riff_chunk_size_w64(pWav->dataChunkDataSize); + drwav__write_u64ne_to_le(pWav, riffChunkSize); + } + + /* The "data" chunk size. */ + if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos + 16, drwav_seek_origin_start)) { + drwav_uint64 dataChunkSize = drwav__data_chunk_size_w64(pWav->dataChunkDataSize); + drwav__write_u64ne_to_le(pWav, dataChunkSize); + } + } + } + + /* Validation for sequential mode. */ + if (pWav->isSequentialWrite) { + if (pWav->dataChunkDataSize != pWav->dataChunkDataSizeTargetWrite) { + result = DRWAV_INVALID_FILE; + } + } + } + +#ifndef DR_WAV_NO_STDIO + /* + If we opened the file with drwav_open_file() we will want to close the file handle. We can know whether or not drwav_open_file() + was used by looking at the onRead and onSeek callbacks. + */ + if (pWav->onRead == drwav__on_read_stdio || pWav->onWrite == drwav__on_write_stdio) { + fclose((FILE*)pWav->pUserData); + } +#endif + + return result; +} + + + +DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOut) +{ + size_t bytesRead; + + if (pWav == NULL || bytesToRead == 0) { + return 0; + } + + if (bytesToRead > pWav->bytesRemaining) { + bytesToRead = (size_t)pWav->bytesRemaining; + } + + if (pBufferOut != NULL) { + bytesRead = pWav->onRead(pWav->pUserData, pBufferOut, bytesToRead); + } else { + /* We need to seek. If we fail, we need to read-and-discard to make sure we get a good byte count. */ + bytesRead = 0; + while (bytesRead < bytesToRead) { + size_t bytesToSeek = (bytesToRead - bytesRead); + if (bytesToSeek > 0x7FFFFFFF) { + bytesToSeek = 0x7FFFFFFF; + } + + if (pWav->onSeek(pWav->pUserData, (int)bytesToSeek, drwav_seek_origin_current) == DRWAV_FALSE) { + break; + } + + bytesRead += bytesToSeek; + } + + /* When we get here we may need to read-and-discard some data. */ + while (bytesRead < bytesToRead) { + drwav_uint8 buffer[4096]; + size_t bytesSeeked; + size_t bytesToSeek = (bytesToRead - bytesRead); + if (bytesToSeek > sizeof(buffer)) { + bytesToSeek = sizeof(buffer); + } + + bytesSeeked = pWav->onRead(pWav->pUserData, buffer, bytesToSeek); + bytesRead += bytesSeeked; + + if (bytesSeeked < bytesToSeek) { + break; /* Reached the end. */ + } + } + } + + pWav->bytesRemaining -= bytesRead; + return bytesRead; +} + + + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_le(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut) +{ + drwav_uint32 bytesPerFrame; + + if (pWav == NULL || framesToRead == 0) { + return 0; + } + + /* Cannot use this function for compressed formats. */ + if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) { + return 0; + } + + bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + /* Don't try to read more samples than can potentially fit in the output buffer. */ + if (framesToRead * bytesPerFrame > DRWAV_SIZE_MAX) { + framesToRead = DRWAV_SIZE_MAX / bytesPerFrame; + } + + return drwav_read_raw(pWav, (size_t)(framesToRead * bytesPerFrame), pBufferOut) / bytesPerFrame; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_be(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut) +{ + drwav_uint64 framesRead = drwav_read_pcm_frames_le(pWav, framesToRead, pBufferOut); + + if (pBufferOut != NULL) { + drwav__bswap_samples(pBufferOut, framesRead*pWav->channels, drwav_get_bytes_per_pcm_frame(pWav)/pWav->channels, pWav->translatedFormatTag); + } + + return framesRead; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut) +{ + if (drwav__is_little_endian()) { + return drwav_read_pcm_frames_le(pWav, framesToRead, pBufferOut); + } else { + return drwav_read_pcm_frames_be(pWav, framesToRead, pBufferOut); + } +} + + + +DRWAV_API drwav_bool32 drwav_seek_to_first_pcm_frame(drwav* pWav) +{ + if (pWav->onWrite != NULL) { + return DRWAV_FALSE; /* No seeking in write mode. */ + } + + if (!pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos, drwav_seek_origin_start)) { + return DRWAV_FALSE; + } + + if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) { + pWav->compressed.iCurrentPCMFrame = 0; + } + + pWav->bytesRemaining = pWav->dataChunkDataSize; + return DRWAV_TRUE; +} + +DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetFrameIndex) +{ + /* Seeking should be compatible with wave files > 2GB. */ + + if (pWav == NULL || pWav->onSeek == NULL) { + return DRWAV_FALSE; + } + + /* No seeking in write mode. */ + if (pWav->onWrite != NULL) { + return DRWAV_FALSE; + } + + /* If there are no samples, just return DRWAV_TRUE without doing anything. */ + if (pWav->totalPCMFrameCount == 0) { + return DRWAV_TRUE; + } + + /* Make sure the sample is clamped. */ + if (targetFrameIndex >= pWav->totalPCMFrameCount) { + targetFrameIndex = pWav->totalPCMFrameCount - 1; + } + + /* + For compressed formats we just use a slow generic seek. If we are seeking forward we just seek forward. If we are going backwards we need + to seek back to the start. + */ + if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) { + /* TODO: This can be optimized. */ + + /* + If we're seeking forward it's simple - just keep reading samples until we hit the sample we're requesting. If we're seeking backwards, + we first need to seek back to the start and then just do the same thing as a forward seek. + */ + if (targetFrameIndex < pWav->compressed.iCurrentPCMFrame) { + if (!drwav_seek_to_first_pcm_frame(pWav)) { + return DRWAV_FALSE; + } + } + + if (targetFrameIndex > pWav->compressed.iCurrentPCMFrame) { + drwav_uint64 offsetInFrames = targetFrameIndex - pWav->compressed.iCurrentPCMFrame; + + drwav_int16 devnull[2048]; + while (offsetInFrames > 0) { + drwav_uint64 framesRead = 0; + drwav_uint64 framesToRead = offsetInFrames; + if (framesToRead > drwav_countof(devnull)/pWav->channels) { + framesToRead = drwav_countof(devnull)/pWav->channels; + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + framesRead = drwav_read_pcm_frames_s16__msadpcm(pWav, framesToRead, devnull); + } else if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + framesRead = drwav_read_pcm_frames_s16__ima(pWav, framesToRead, devnull); + } else { + DRWAV_ASSERT(DRWAV_FALSE); /* If this assertion is triggered it means I've implemented a new compressed format but forgot to add a branch for it here. */ + } + + if (framesRead != framesToRead) { + return DRWAV_FALSE; + } + + offsetInFrames -= framesRead; + } + } + } else { + drwav_uint64 totalSizeInBytes; + drwav_uint64 currentBytePos; + drwav_uint64 targetBytePos; + drwav_uint64 offset; + + totalSizeInBytes = pWav->totalPCMFrameCount * drwav_get_bytes_per_pcm_frame(pWav); + DRWAV_ASSERT(totalSizeInBytes >= pWav->bytesRemaining); + + currentBytePos = totalSizeInBytes - pWav->bytesRemaining; + targetBytePos = targetFrameIndex * drwav_get_bytes_per_pcm_frame(pWav); + + if (currentBytePos < targetBytePos) { + /* Offset forwards. */ + offset = (targetBytePos - currentBytePos); + } else { + /* Offset backwards. */ + if (!drwav_seek_to_first_pcm_frame(pWav)) { + return DRWAV_FALSE; + } + offset = targetBytePos; + } + + while (offset > 0) { + int offset32 = ((offset > INT_MAX) ? INT_MAX : (int)offset); + if (!pWav->onSeek(pWav->pUserData, offset32, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + + pWav->bytesRemaining -= offset32; + offset -= offset32; + } + } + + return DRWAV_TRUE; +} + + +DRWAV_API size_t drwav_write_raw(drwav* pWav, size_t bytesToWrite, const void* pData) +{ + size_t bytesWritten; + + if (pWav == NULL || bytesToWrite == 0 || pData == NULL) { + return 0; + } + + bytesWritten = pWav->onWrite(pWav->pUserData, pData, bytesToWrite); + pWav->dataChunkDataSize += bytesWritten; + + return bytesWritten; +} + + +DRWAV_API drwav_uint64 drwav_write_pcm_frames_le(drwav* pWav, drwav_uint64 framesToWrite, const void* pData) +{ + drwav_uint64 bytesToWrite; + drwav_uint64 bytesWritten; + const drwav_uint8* pRunningData; + + if (pWav == NULL || framesToWrite == 0 || pData == NULL) { + return 0; + } + + bytesToWrite = ((framesToWrite * pWav->channels * pWav->bitsPerSample) / 8); + if (bytesToWrite > DRWAV_SIZE_MAX) { + return 0; + } + + bytesWritten = 0; + pRunningData = (const drwav_uint8*)pData; + + while (bytesToWrite > 0) { + size_t bytesJustWritten; + drwav_uint64 bytesToWriteThisIteration; + + bytesToWriteThisIteration = bytesToWrite; + DRWAV_ASSERT(bytesToWriteThisIteration <= DRWAV_SIZE_MAX); /* <-- This is checked above. */ + + bytesJustWritten = drwav_write_raw(pWav, (size_t)bytesToWriteThisIteration, pRunningData); + if (bytesJustWritten == 0) { + break; + } + + bytesToWrite -= bytesJustWritten; + bytesWritten += bytesJustWritten; + pRunningData += bytesJustWritten; + } + + return (bytesWritten * 8) / pWav->bitsPerSample / pWav->channels; +} + +DRWAV_API drwav_uint64 drwav_write_pcm_frames_be(drwav* pWav, drwav_uint64 framesToWrite, const void* pData) +{ + drwav_uint64 bytesToWrite; + drwav_uint64 bytesWritten; + drwav_uint32 bytesPerSample; + const drwav_uint8* pRunningData; + + if (pWav == NULL || framesToWrite == 0 || pData == NULL) { + return 0; + } + + bytesToWrite = ((framesToWrite * pWav->channels * pWav->bitsPerSample) / 8); + if (bytesToWrite > DRWAV_SIZE_MAX) { + return 0; + } + + bytesWritten = 0; + pRunningData = (const drwav_uint8*)pData; + + bytesPerSample = drwav_get_bytes_per_pcm_frame(pWav) / pWav->channels; + + while (bytesToWrite > 0) { + drwav_uint8 temp[4096]; + drwav_uint32 sampleCount; + size_t bytesJustWritten; + drwav_uint64 bytesToWriteThisIteration; + + bytesToWriteThisIteration = bytesToWrite; + DRWAV_ASSERT(bytesToWriteThisIteration <= DRWAV_SIZE_MAX); /* <-- This is checked above. */ + + /* + WAV files are always little-endian. We need to byte swap on big-endian architectures. Since our input buffer is read-only we need + to use an intermediary buffer for the conversion. + */ + sampleCount = sizeof(temp)/bytesPerSample; + + if (bytesToWriteThisIteration > ((drwav_uint64)sampleCount)*bytesPerSample) { + bytesToWriteThisIteration = ((drwav_uint64)sampleCount)*bytesPerSample; + } + + DRWAV_COPY_MEMORY(temp, pRunningData, (size_t)bytesToWriteThisIteration); + drwav__bswap_samples(temp, sampleCount, bytesPerSample, pWav->translatedFormatTag); + + bytesJustWritten = drwav_write_raw(pWav, (size_t)bytesToWriteThisIteration, temp); + if (bytesJustWritten == 0) { + break; + } + + bytesToWrite -= bytesJustWritten; + bytesWritten += bytesJustWritten; + pRunningData += bytesJustWritten; + } + + return (bytesWritten * 8) / pWav->bitsPerSample / pWav->channels; +} + +DRWAV_API drwav_uint64 drwav_write_pcm_frames(drwav* pWav, drwav_uint64 framesToWrite, const void* pData) +{ + if (drwav__is_little_endian()) { + return drwav_write_pcm_frames_le(pWav, framesToWrite, pData); + } else { + return drwav_write_pcm_frames_be(pWav, framesToWrite, pData); + } +} + + +static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut) +{ + drwav_uint64 totalFramesRead = 0; + + DRWAV_ASSERT(pWav != NULL); + DRWAV_ASSERT(framesToRead > 0); + + /* TODO: Lots of room for optimization here. */ + + while (framesToRead > 0 && pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) { + /* If there are no cached frames we need to load a new block. */ + if (pWav->msadpcm.cachedFrameCount == 0 && pWav->msadpcm.bytesRemainingInBlock == 0) { + if (pWav->channels == 1) { + /* Mono. */ + drwav_uint8 header[7]; + if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) { + return totalFramesRead; + } + pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header); + + pWav->msadpcm.predictor[0] = header[0]; + pWav->msadpcm.delta[0] = drwav__bytes_to_s16(header + 1); + pWav->msadpcm.prevFrames[0][1] = (drwav_int32)drwav__bytes_to_s16(header + 3); + pWav->msadpcm.prevFrames[0][0] = (drwav_int32)drwav__bytes_to_s16(header + 5); + pWav->msadpcm.cachedFrames[2] = pWav->msadpcm.prevFrames[0][0]; + pWav->msadpcm.cachedFrames[3] = pWav->msadpcm.prevFrames[0][1]; + pWav->msadpcm.cachedFrameCount = 2; + } else { + /* Stereo. */ + drwav_uint8 header[14]; + if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) { + return totalFramesRead; + } + pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header); + + pWav->msadpcm.predictor[0] = header[0]; + pWav->msadpcm.predictor[1] = header[1]; + pWav->msadpcm.delta[0] = drwav__bytes_to_s16(header + 2); + pWav->msadpcm.delta[1] = drwav__bytes_to_s16(header + 4); + pWav->msadpcm.prevFrames[0][1] = (drwav_int32)drwav__bytes_to_s16(header + 6); + pWav->msadpcm.prevFrames[1][1] = (drwav_int32)drwav__bytes_to_s16(header + 8); + pWav->msadpcm.prevFrames[0][0] = (drwav_int32)drwav__bytes_to_s16(header + 10); + pWav->msadpcm.prevFrames[1][0] = (drwav_int32)drwav__bytes_to_s16(header + 12); + + pWav->msadpcm.cachedFrames[0] = pWav->msadpcm.prevFrames[0][0]; + pWav->msadpcm.cachedFrames[1] = pWav->msadpcm.prevFrames[1][0]; + pWav->msadpcm.cachedFrames[2] = pWav->msadpcm.prevFrames[0][1]; + pWav->msadpcm.cachedFrames[3] = pWav->msadpcm.prevFrames[1][1]; + pWav->msadpcm.cachedFrameCount = 2; + } + } + + /* Output anything that's cached. */ + while (framesToRead > 0 && pWav->msadpcm.cachedFrameCount > 0 && pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) { + if (pBufferOut != NULL) { + drwav_uint32 iSample = 0; + for (iSample = 0; iSample < pWav->channels; iSample += 1) { + pBufferOut[iSample] = (drwav_int16)pWav->msadpcm.cachedFrames[(drwav_countof(pWav->msadpcm.cachedFrames) - (pWav->msadpcm.cachedFrameCount*pWav->channels)) + iSample]; + } + + pBufferOut += pWav->channels; + } + + framesToRead -= 1; + totalFramesRead += 1; + pWav->compressed.iCurrentPCMFrame += 1; + pWav->msadpcm.cachedFrameCount -= 1; + } + + if (framesToRead == 0) { + return totalFramesRead; + } + + + /* + If there's nothing left in the cache, just go ahead and load more. If there's nothing left to load in the current block we just continue to the next + loop iteration which will trigger the loading of a new block. + */ + if (pWav->msadpcm.cachedFrameCount == 0) { + if (pWav->msadpcm.bytesRemainingInBlock == 0) { + continue; + } else { + static drwav_int32 adaptationTable[] = { + 230, 230, 230, 230, 307, 409, 512, 614, + 768, 614, 512, 409, 307, 230, 230, 230 + }; + static drwav_int32 coeff1Table[] = { 256, 512, 0, 192, 240, 460, 392 }; + static drwav_int32 coeff2Table[] = { 0, -256, 0, 64, 0, -208, -232 }; + + drwav_uint8 nibbles; + drwav_int32 nibble0; + drwav_int32 nibble1; + + if (pWav->onRead(pWav->pUserData, &nibbles, 1) != 1) { + return totalFramesRead; + } + pWav->msadpcm.bytesRemainingInBlock -= 1; + + /* TODO: Optimize away these if statements. */ + nibble0 = ((nibbles & 0xF0) >> 4); if ((nibbles & 0x80)) { nibble0 |= 0xFFFFFFF0UL; } + nibble1 = ((nibbles & 0x0F) >> 0); if ((nibbles & 0x08)) { nibble1 |= 0xFFFFFFF0UL; } + + if (pWav->channels == 1) { + /* Mono. */ + drwav_int32 newSample0; + drwav_int32 newSample1; + + newSample0 = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8; + newSample0 += nibble0 * pWav->msadpcm.delta[0]; + newSample0 = drwav_clamp(newSample0, -32768, 32767); + + pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8; + if (pWav->msadpcm.delta[0] < 16) { + pWav->msadpcm.delta[0] = 16; + } + + pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1]; + pWav->msadpcm.prevFrames[0][1] = newSample0; + + + newSample1 = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8; + newSample1 += nibble1 * pWav->msadpcm.delta[0]; + newSample1 = drwav_clamp(newSample1, -32768, 32767); + + pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[0]) >> 8; + if (pWav->msadpcm.delta[0] < 16) { + pWav->msadpcm.delta[0] = 16; + } + + pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1]; + pWav->msadpcm.prevFrames[0][1] = newSample1; + + + pWav->msadpcm.cachedFrames[2] = newSample0; + pWav->msadpcm.cachedFrames[3] = newSample1; + pWav->msadpcm.cachedFrameCount = 2; + } else { + /* Stereo. */ + drwav_int32 newSample0; + drwav_int32 newSample1; + + /* Left. */ + newSample0 = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8; + newSample0 += nibble0 * pWav->msadpcm.delta[0]; + newSample0 = drwav_clamp(newSample0, -32768, 32767); + + pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8; + if (pWav->msadpcm.delta[0] < 16) { + pWav->msadpcm.delta[0] = 16; + } + + pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1]; + pWav->msadpcm.prevFrames[0][1] = newSample0; + + + /* Right. */ + newSample1 = ((pWav->msadpcm.prevFrames[1][1] * coeff1Table[pWav->msadpcm.predictor[1]]) + (pWav->msadpcm.prevFrames[1][0] * coeff2Table[pWav->msadpcm.predictor[1]])) >> 8; + newSample1 += nibble1 * pWav->msadpcm.delta[1]; + newSample1 = drwav_clamp(newSample1, -32768, 32767); + + pWav->msadpcm.delta[1] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[1]) >> 8; + if (pWav->msadpcm.delta[1] < 16) { + pWav->msadpcm.delta[1] = 16; + } + + pWav->msadpcm.prevFrames[1][0] = pWav->msadpcm.prevFrames[1][1]; + pWav->msadpcm.prevFrames[1][1] = newSample1; + + pWav->msadpcm.cachedFrames[2] = newSample0; + pWav->msadpcm.cachedFrames[3] = newSample1; + pWav->msadpcm.cachedFrameCount = 1; + } + } + } + } + + return totalFramesRead; +} + + +static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut) +{ + drwav_uint64 totalFramesRead = 0; + drwav_uint32 iChannel; + + static drwav_int32 indexTable[16] = { + -1, -1, -1, -1, 2, 4, 6, 8, + -1, -1, -1, -1, 2, 4, 6, 8 + }; + + static drwav_int32 stepTable[89] = { + 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, + 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, + 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, + 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, + 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, + 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, + 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, + 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, + 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 + }; + + DRWAV_ASSERT(pWav != NULL); + DRWAV_ASSERT(framesToRead > 0); + + /* TODO: Lots of room for optimization here. */ + + while (framesToRead > 0 && pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) { + /* If there are no cached samples we need to load a new block. */ + if (pWav->ima.cachedFrameCount == 0 && pWav->ima.bytesRemainingInBlock == 0) { + if (pWav->channels == 1) { + /* Mono. */ + drwav_uint8 header[4]; + if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) { + return totalFramesRead; + } + pWav->ima.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header); + + if (header[2] >= drwav_countof(stepTable)) { + pWav->onSeek(pWav->pUserData, pWav->ima.bytesRemainingInBlock, drwav_seek_origin_current); + pWav->ima.bytesRemainingInBlock = 0; + return totalFramesRead; /* Invalid data. */ + } + + pWav->ima.predictor[0] = drwav__bytes_to_s16(header + 0); + pWav->ima.stepIndex[0] = header[2]; + pWav->ima.cachedFrames[drwav_countof(pWav->ima.cachedFrames) - 1] = pWav->ima.predictor[0]; + pWav->ima.cachedFrameCount = 1; + } else { + /* Stereo. */ + drwav_uint8 header[8]; + if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) { + return totalFramesRead; + } + pWav->ima.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header); + + if (header[2] >= drwav_countof(stepTable) || header[6] >= drwav_countof(stepTable)) { + pWav->onSeek(pWav->pUserData, pWav->ima.bytesRemainingInBlock, drwav_seek_origin_current); + pWav->ima.bytesRemainingInBlock = 0; + return totalFramesRead; /* Invalid data. */ + } + + pWav->ima.predictor[0] = drwav__bytes_to_s16(header + 0); + pWav->ima.stepIndex[0] = header[2]; + pWav->ima.predictor[1] = drwav__bytes_to_s16(header + 4); + pWav->ima.stepIndex[1] = header[6]; + + pWav->ima.cachedFrames[drwav_countof(pWav->ima.cachedFrames) - 2] = pWav->ima.predictor[0]; + pWav->ima.cachedFrames[drwav_countof(pWav->ima.cachedFrames) - 1] = pWav->ima.predictor[1]; + pWav->ima.cachedFrameCount = 1; + } + } + + /* Output anything that's cached. */ + while (framesToRead > 0 && pWav->ima.cachedFrameCount > 0 && pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) { + if (pBufferOut != NULL) { + drwav_uint32 iSample; + for (iSample = 0; iSample < pWav->channels; iSample += 1) { + pBufferOut[iSample] = (drwav_int16)pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + iSample]; + } + pBufferOut += pWav->channels; + } + + framesToRead -= 1; + totalFramesRead += 1; + pWav->compressed.iCurrentPCMFrame += 1; + pWav->ima.cachedFrameCount -= 1; + } + + if (framesToRead == 0) { + return totalFramesRead; + } + + /* + If there's nothing left in the cache, just go ahead and load more. If there's nothing left to load in the current block we just continue to the next + loop iteration which will trigger the loading of a new block. + */ + if (pWav->ima.cachedFrameCount == 0) { + if (pWav->ima.bytesRemainingInBlock == 0) { + continue; + } else { + /* + From what I can tell with stereo streams, it looks like every 4 bytes (8 samples) is for one channel. So it goes 4 bytes for the + left channel, 4 bytes for the right channel. + */ + pWav->ima.cachedFrameCount = 8; + for (iChannel = 0; iChannel < pWav->channels; ++iChannel) { + drwav_uint32 iByte; + drwav_uint8 nibbles[4]; + if (pWav->onRead(pWav->pUserData, &nibbles, 4) != 4) { + pWav->ima.cachedFrameCount = 0; + return totalFramesRead; + } + pWav->ima.bytesRemainingInBlock -= 4; + + for (iByte = 0; iByte < 4; ++iByte) { + drwav_uint8 nibble0 = ((nibbles[iByte] & 0x0F) >> 0); + drwav_uint8 nibble1 = ((nibbles[iByte] & 0xF0) >> 4); + + drwav_int32 step = stepTable[pWav->ima.stepIndex[iChannel]]; + drwav_int32 predictor = pWav->ima.predictor[iChannel]; + + drwav_int32 diff = step >> 3; + if (nibble0 & 1) diff += step >> 2; + if (nibble0 & 2) diff += step >> 1; + if (nibble0 & 4) diff += step; + if (nibble0 & 8) diff = -diff; + + predictor = drwav_clamp(predictor + diff, -32768, 32767); + pWav->ima.predictor[iChannel] = predictor; + pWav->ima.stepIndex[iChannel] = drwav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble0], 0, (drwav_int32)drwav_countof(stepTable)-1); + pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + (iByte*2+0)*pWav->channels + iChannel] = predictor; + + + step = stepTable[pWav->ima.stepIndex[iChannel]]; + predictor = pWav->ima.predictor[iChannel]; + + diff = step >> 3; + if (nibble1 & 1) diff += step >> 2; + if (nibble1 & 2) diff += step >> 1; + if (nibble1 & 4) diff += step; + if (nibble1 & 8) diff = -diff; + + predictor = drwav_clamp(predictor + diff, -32768, 32767); + pWav->ima.predictor[iChannel] = predictor; + pWav->ima.stepIndex[iChannel] = drwav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble1], 0, (drwav_int32)drwav_countof(stepTable)-1); + pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + (iByte*2+1)*pWav->channels + iChannel] = predictor; + } + } + } + } + } + + return totalFramesRead; +} + + +#ifndef DR_WAV_NO_CONVERSION_API +static unsigned short g_drwavAlawTable[256] = { + 0xEA80, 0xEB80, 0xE880, 0xE980, 0xEE80, 0xEF80, 0xEC80, 0xED80, 0xE280, 0xE380, 0xE080, 0xE180, 0xE680, 0xE780, 0xE480, 0xE580, + 0xF540, 0xF5C0, 0xF440, 0xF4C0, 0xF740, 0xF7C0, 0xF640, 0xF6C0, 0xF140, 0xF1C0, 0xF040, 0xF0C0, 0xF340, 0xF3C0, 0xF240, 0xF2C0, + 0xAA00, 0xAE00, 0xA200, 0xA600, 0xBA00, 0xBE00, 0xB200, 0xB600, 0x8A00, 0x8E00, 0x8200, 0x8600, 0x9A00, 0x9E00, 0x9200, 0x9600, + 0xD500, 0xD700, 0xD100, 0xD300, 0xDD00, 0xDF00, 0xD900, 0xDB00, 0xC500, 0xC700, 0xC100, 0xC300, 0xCD00, 0xCF00, 0xC900, 0xCB00, + 0xFEA8, 0xFEB8, 0xFE88, 0xFE98, 0xFEE8, 0xFEF8, 0xFEC8, 0xFED8, 0xFE28, 0xFE38, 0xFE08, 0xFE18, 0xFE68, 0xFE78, 0xFE48, 0xFE58, + 0xFFA8, 0xFFB8, 0xFF88, 0xFF98, 0xFFE8, 0xFFF8, 0xFFC8, 0xFFD8, 0xFF28, 0xFF38, 0xFF08, 0xFF18, 0xFF68, 0xFF78, 0xFF48, 0xFF58, + 0xFAA0, 0xFAE0, 0xFA20, 0xFA60, 0xFBA0, 0xFBE0, 0xFB20, 0xFB60, 0xF8A0, 0xF8E0, 0xF820, 0xF860, 0xF9A0, 0xF9E0, 0xF920, 0xF960, + 0xFD50, 0xFD70, 0xFD10, 0xFD30, 0xFDD0, 0xFDF0, 0xFD90, 0xFDB0, 0xFC50, 0xFC70, 0xFC10, 0xFC30, 0xFCD0, 0xFCF0, 0xFC90, 0xFCB0, + 0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280, 0x1D80, 0x1C80, 0x1F80, 0x1E80, 0x1980, 0x1880, 0x1B80, 0x1A80, + 0x0AC0, 0x0A40, 0x0BC0, 0x0B40, 0x08C0, 0x0840, 0x09C0, 0x0940, 0x0EC0, 0x0E40, 0x0FC0, 0x0F40, 0x0CC0, 0x0C40, 0x0DC0, 0x0D40, + 0x5600, 0x5200, 0x5E00, 0x5A00, 0x4600, 0x4200, 0x4E00, 0x4A00, 0x7600, 0x7200, 0x7E00, 0x7A00, 0x6600, 0x6200, 0x6E00, 0x6A00, + 0x2B00, 0x2900, 0x2F00, 0x2D00, 0x2300, 0x2100, 0x2700, 0x2500, 0x3B00, 0x3900, 0x3F00, 0x3D00, 0x3300, 0x3100, 0x3700, 0x3500, + 0x0158, 0x0148, 0x0178, 0x0168, 0x0118, 0x0108, 0x0138, 0x0128, 0x01D8, 0x01C8, 0x01F8, 0x01E8, 0x0198, 0x0188, 0x01B8, 0x01A8, + 0x0058, 0x0048, 0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028, 0x00D8, 0x00C8, 0x00F8, 0x00E8, 0x0098, 0x0088, 0x00B8, 0x00A8, + 0x0560, 0x0520, 0x05E0, 0x05A0, 0x0460, 0x0420, 0x04E0, 0x04A0, 0x0760, 0x0720, 0x07E0, 0x07A0, 0x0660, 0x0620, 0x06E0, 0x06A0, + 0x02B0, 0x0290, 0x02F0, 0x02D0, 0x0230, 0x0210, 0x0270, 0x0250, 0x03B0, 0x0390, 0x03F0, 0x03D0, 0x0330, 0x0310, 0x0370, 0x0350 +}; + +static unsigned short g_drwavMulawTable[256] = { + 0x8284, 0x8684, 0x8A84, 0x8E84, 0x9284, 0x9684, 0x9A84, 0x9E84, 0xA284, 0xA684, 0xAA84, 0xAE84, 0xB284, 0xB684, 0xBA84, 0xBE84, + 0xC184, 0xC384, 0xC584, 0xC784, 0xC984, 0xCB84, 0xCD84, 0xCF84, 0xD184, 0xD384, 0xD584, 0xD784, 0xD984, 0xDB84, 0xDD84, 0xDF84, + 0xE104, 0xE204, 0xE304, 0xE404, 0xE504, 0xE604, 0xE704, 0xE804, 0xE904, 0xEA04, 0xEB04, 0xEC04, 0xED04, 0xEE04, 0xEF04, 0xF004, + 0xF0C4, 0xF144, 0xF1C4, 0xF244, 0xF2C4, 0xF344, 0xF3C4, 0xF444, 0xF4C4, 0xF544, 0xF5C4, 0xF644, 0xF6C4, 0xF744, 0xF7C4, 0xF844, + 0xF8A4, 0xF8E4, 0xF924, 0xF964, 0xF9A4, 0xF9E4, 0xFA24, 0xFA64, 0xFAA4, 0xFAE4, 0xFB24, 0xFB64, 0xFBA4, 0xFBE4, 0xFC24, 0xFC64, + 0xFC94, 0xFCB4, 0xFCD4, 0xFCF4, 0xFD14, 0xFD34, 0xFD54, 0xFD74, 0xFD94, 0xFDB4, 0xFDD4, 0xFDF4, 0xFE14, 0xFE34, 0xFE54, 0xFE74, + 0xFE8C, 0xFE9C, 0xFEAC, 0xFEBC, 0xFECC, 0xFEDC, 0xFEEC, 0xFEFC, 0xFF0C, 0xFF1C, 0xFF2C, 0xFF3C, 0xFF4C, 0xFF5C, 0xFF6C, 0xFF7C, + 0xFF88, 0xFF90, 0xFF98, 0xFFA0, 0xFFA8, 0xFFB0, 0xFFB8, 0xFFC0, 0xFFC8, 0xFFD0, 0xFFD8, 0xFFE0, 0xFFE8, 0xFFF0, 0xFFF8, 0x0000, + 0x7D7C, 0x797C, 0x757C, 0x717C, 0x6D7C, 0x697C, 0x657C, 0x617C, 0x5D7C, 0x597C, 0x557C, 0x517C, 0x4D7C, 0x497C, 0x457C, 0x417C, + 0x3E7C, 0x3C7C, 0x3A7C, 0x387C, 0x367C, 0x347C, 0x327C, 0x307C, 0x2E7C, 0x2C7C, 0x2A7C, 0x287C, 0x267C, 0x247C, 0x227C, 0x207C, + 0x1EFC, 0x1DFC, 0x1CFC, 0x1BFC, 0x1AFC, 0x19FC, 0x18FC, 0x17FC, 0x16FC, 0x15FC, 0x14FC, 0x13FC, 0x12FC, 0x11FC, 0x10FC, 0x0FFC, + 0x0F3C, 0x0EBC, 0x0E3C, 0x0DBC, 0x0D3C, 0x0CBC, 0x0C3C, 0x0BBC, 0x0B3C, 0x0ABC, 0x0A3C, 0x09BC, 0x093C, 0x08BC, 0x083C, 0x07BC, + 0x075C, 0x071C, 0x06DC, 0x069C, 0x065C, 0x061C, 0x05DC, 0x059C, 0x055C, 0x051C, 0x04DC, 0x049C, 0x045C, 0x041C, 0x03DC, 0x039C, + 0x036C, 0x034C, 0x032C, 0x030C, 0x02EC, 0x02CC, 0x02AC, 0x028C, 0x026C, 0x024C, 0x022C, 0x020C, 0x01EC, 0x01CC, 0x01AC, 0x018C, + 0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104, 0x00F4, 0x00E4, 0x00D4, 0x00C4, 0x00B4, 0x00A4, 0x0094, 0x0084, + 0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040, 0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000 +}; + +static DRWAV_INLINE drwav_int16 drwav__alaw_to_s16(drwav_uint8 sampleIn) +{ + return (short)g_drwavAlawTable[sampleIn]; +} + +static DRWAV_INLINE drwav_int16 drwav__mulaw_to_s16(drwav_uint8 sampleIn) +{ + return (short)g_drwavMulawTable[sampleIn]; +} + + + +static void drwav__pcm_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample) +{ + unsigned int i; + + /* Special case for 8-bit sample data because it's treated as unsigned. */ + if (bytesPerSample == 1) { + drwav_u8_to_s16(pOut, pIn, totalSampleCount); + return; + } + + + /* Slightly more optimal implementation for common formats. */ + if (bytesPerSample == 2) { + for (i = 0; i < totalSampleCount; ++i) { + *pOut++ = ((const drwav_int16*)pIn)[i]; + } + return; + } + if (bytesPerSample == 3) { + drwav_s24_to_s16(pOut, pIn, totalSampleCount); + return; + } + if (bytesPerSample == 4) { + drwav_s32_to_s16(pOut, (const drwav_int32*)pIn, totalSampleCount); + return; + } + + + /* Anything more than 64 bits per sample is not supported. */ + if (bytesPerSample > 8) { + DRWAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut)); + return; + } + + + /* Generic, slow converter. */ + for (i = 0; i < totalSampleCount; ++i) { + drwav_uint64 sample = 0; + unsigned int shift = (8 - bytesPerSample) * 8; + + unsigned int j; + for (j = 0; j < bytesPerSample; j += 1) { + DRWAV_ASSERT(j < 8); + sample |= (drwav_uint64)(pIn[j]) << shift; + shift += 8; + } + + pIn += j; + *pOut++ = (drwav_int16)((drwav_int64)sample >> 48); + } +} + +static void drwav__ieee_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample) +{ + if (bytesPerSample == 4) { + drwav_f32_to_s16(pOut, (const float*)pIn, totalSampleCount); + return; + } else if (bytesPerSample == 8) { + drwav_f64_to_s16(pOut, (const double*)pIn, totalSampleCount); + return; + } else { + /* Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. */ + DRWAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut)); + return; + } +} + +static drwav_uint64 drwav_read_pcm_frames_s16__pcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut) +{ + drwav_uint32 bytesPerFrame; + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + + /* Fast path. */ + if ((pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM && pWav->bitsPerSample == 16) || pBufferOut == NULL) { + return drwav_read_pcm_frames(pWav, framesToRead, pBufferOut); + } + + bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav__pcm_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_s16__ieee(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + drwav_uint32 bytesPerFrame; + + if (pBufferOut == NULL) { + return drwav_read_pcm_frames(pWav, framesToRead, NULL); + } + + bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav__ieee_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_s16__alaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + drwav_uint32 bytesPerFrame; + + if (pBufferOut == NULL) { + return drwav_read_pcm_frames(pWav, framesToRead, NULL); + } + + bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav_alaw_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels)); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_s16__mulaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + drwav_uint32 bytesPerFrame; + + if (pBufferOut == NULL) { + return drwav_read_pcm_frames(pWav, framesToRead, NULL); + } + + bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav_mulaw_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels)); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut) +{ + if (pWav == NULL || framesToRead == 0) { + return 0; + } + + if (pBufferOut == NULL) { + return drwav_read_pcm_frames(pWav, framesToRead, NULL); + } + + /* Don't try to read more samples than can potentially fit in the output buffer. */ + if (framesToRead * pWav->channels * sizeof(drwav_int16) > DRWAV_SIZE_MAX) { + framesToRead = DRWAV_SIZE_MAX / sizeof(drwav_int16) / pWav->channels; + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM) { + return drwav_read_pcm_frames_s16__pcm(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT) { + return drwav_read_pcm_frames_s16__ieee(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ALAW) { + return drwav_read_pcm_frames_s16__alaw(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_MULAW) { + return drwav_read_pcm_frames_s16__mulaw(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + return drwav_read_pcm_frames_s16__msadpcm(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + return drwav_read_pcm_frames_s16__ima(pWav, framesToRead, pBufferOut); + } + + return 0; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16le(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut) +{ + drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, framesToRead, pBufferOut); + if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_FALSE) { + drwav__bswap_samples_s16(pBufferOut, framesRead*pWav->channels); + } + + return framesRead; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16be(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut) +{ + drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, framesToRead, pBufferOut); + if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_TRUE) { + drwav__bswap_samples_s16(pBufferOut, framesRead*pWav->channels); + } + + return framesRead; +} + + +DRWAV_API void drwav_u8_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + int r; + size_t i; + for (i = 0; i < sampleCount; ++i) { + int x = pIn[i]; + r = x << 8; + r = r - 32768; + pOut[i] = (short)r; + } +} + +DRWAV_API void drwav_s24_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + int r; + size_t i; + for (i = 0; i < sampleCount; ++i) { + int x = ((int)(((unsigned int)(((const drwav_uint8*)pIn)[i*3+0]) << 8) | ((unsigned int)(((const drwav_uint8*)pIn)[i*3+1]) << 16) | ((unsigned int)(((const drwav_uint8*)pIn)[i*3+2])) << 24)) >> 8; + r = x >> 8; + pOut[i] = (short)r; + } +} + +DRWAV_API void drwav_s32_to_s16(drwav_int16* pOut, const drwav_int32* pIn, size_t sampleCount) +{ + int r; + size_t i; + for (i = 0; i < sampleCount; ++i) { + int x = pIn[i]; + r = x >> 16; + pOut[i] = (short)r; + } +} + +DRWAV_API void drwav_f32_to_s16(drwav_int16* pOut, const float* pIn, size_t sampleCount) +{ + int r; + size_t i; + for (i = 0; i < sampleCount; ++i) { + float x = pIn[i]; + float c; + c = ((x < -1) ? -1 : ((x > 1) ? 1 : x)); + c = c + 1; + r = (int)(c * 32767.5f); + r = r - 32768; + pOut[i] = (short)r; + } +} + +DRWAV_API void drwav_f64_to_s16(drwav_int16* pOut, const double* pIn, size_t sampleCount) +{ + int r; + size_t i; + for (i = 0; i < sampleCount; ++i) { + double x = pIn[i]; + double c; + c = ((x < -1) ? -1 : ((x > 1) ? 1 : x)); + c = c + 1; + r = (int)(c * 32767.5); + r = r - 32768; + pOut[i] = (short)r; + } +} + +DRWAV_API void drwav_alaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + size_t i; + for (i = 0; i < sampleCount; ++i) { + pOut[i] = drwav__alaw_to_s16(pIn[i]); + } +} + +DRWAV_API void drwav_mulaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + size_t i; + for (i = 0; i < sampleCount; ++i) { + pOut[i] = drwav__mulaw_to_s16(pIn[i]); + } +} + + + +static void drwav__pcm_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount, unsigned int bytesPerSample) +{ + unsigned int i; + + /* Special case for 8-bit sample data because it's treated as unsigned. */ + if (bytesPerSample == 1) { + drwav_u8_to_f32(pOut, pIn, sampleCount); + return; + } + + /* Slightly more optimal implementation for common formats. */ + if (bytesPerSample == 2) { + drwav_s16_to_f32(pOut, (const drwav_int16*)pIn, sampleCount); + return; + } + if (bytesPerSample == 3) { + drwav_s24_to_f32(pOut, pIn, sampleCount); + return; + } + if (bytesPerSample == 4) { + drwav_s32_to_f32(pOut, (const drwav_int32*)pIn, sampleCount); + return; + } + + + /* Anything more than 64 bits per sample is not supported. */ + if (bytesPerSample > 8) { + DRWAV_ZERO_MEMORY(pOut, sampleCount * sizeof(*pOut)); + return; + } + + + /* Generic, slow converter. */ + for (i = 0; i < sampleCount; ++i) { + drwav_uint64 sample = 0; + unsigned int shift = (8 - bytesPerSample) * 8; + + unsigned int j; + for (j = 0; j < bytesPerSample; j += 1) { + DRWAV_ASSERT(j < 8); + sample |= (drwav_uint64)(pIn[j]) << shift; + shift += 8; + } + + pIn += j; + *pOut++ = (float)((drwav_int64)sample / 9223372036854775807.0); + } +} + +static void drwav__ieee_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount, unsigned int bytesPerSample) +{ + if (bytesPerSample == 4) { + unsigned int i; + for (i = 0; i < sampleCount; ++i) { + *pOut++ = ((const float*)pIn)[i]; + } + return; + } else if (bytesPerSample == 8) { + drwav_f64_to_f32(pOut, (const double*)pIn, sampleCount); + return; + } else { + /* Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. */ + DRWAV_ZERO_MEMORY(pOut, sampleCount * sizeof(*pOut)); + return; + } +} + + +static drwav_uint64 drwav_read_pcm_frames_f32__pcm(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + + drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav__pcm_to_f32(pBufferOut, sampleData, (size_t)framesRead*pWav->channels, bytesPerFrame/pWav->channels); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_f32__msadpcm(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut) +{ + /* + We're just going to borrow the implementation from the drwav_read_s16() since ADPCM is a little bit more complicated than other formats and I don't + want to duplicate that code. + */ + drwav_uint64 totalFramesRead = 0; + drwav_int16 samples16[2048]; + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16); + if (framesRead == 0) { + break; + } + + drwav_s16_to_f32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */ + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_f32__ima(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut) +{ + /* + We're just going to borrow the implementation from the drwav_read_s16() since IMA-ADPCM is a little bit more complicated than other formats and I don't + want to duplicate that code. + */ + drwav_uint64 totalFramesRead = 0; + drwav_int16 samples16[2048]; + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16); + if (framesRead == 0) { + break; + } + + drwav_s16_to_f32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */ + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_f32__ieee(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + drwav_uint32 bytesPerFrame; + + /* Fast path. */ + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT && pWav->bitsPerSample == 32) { + return drwav_read_pcm_frames(pWav, framesToRead, pBufferOut); + } + + bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav__ieee_to_f32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_f32__alaw(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav_alaw_to_f32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels)); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_f32__mulaw(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + + drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav_mulaw_to_f32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels)); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut) +{ + if (pWav == NULL || framesToRead == 0) { + return 0; + } + + if (pBufferOut == NULL) { + return drwav_read_pcm_frames(pWav, framesToRead, NULL); + } + + /* Don't try to read more samples than can potentially fit in the output buffer. */ + if (framesToRead * pWav->channels * sizeof(float) > DRWAV_SIZE_MAX) { + framesToRead = DRWAV_SIZE_MAX / sizeof(float) / pWav->channels; + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM) { + return drwav_read_pcm_frames_f32__pcm(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + return drwav_read_pcm_frames_f32__msadpcm(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT) { + return drwav_read_pcm_frames_f32__ieee(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ALAW) { + return drwav_read_pcm_frames_f32__alaw(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_MULAW) { + return drwav_read_pcm_frames_f32__mulaw(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + return drwav_read_pcm_frames_f32__ima(pWav, framesToRead, pBufferOut); + } + + return 0; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32le(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut) +{ + drwav_uint64 framesRead = drwav_read_pcm_frames_f32(pWav, framesToRead, pBufferOut); + if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_FALSE) { + drwav__bswap_samples_f32(pBufferOut, framesRead*pWav->channels); + } + + return framesRead; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32be(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut) +{ + drwav_uint64 framesRead = drwav_read_pcm_frames_f32(pWav, framesToRead, pBufferOut); + if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_TRUE) { + drwav__bswap_samples_f32(pBufferOut, framesRead*pWav->channels); + } + + return framesRead; +} + + +DRWAV_API void drwav_u8_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + +#ifdef DR_WAV_LIBSNDFILE_COMPAT + /* + It appears libsndfile uses slightly different logic for the u8 -> f32 conversion to dr_wav, which in my opinion is incorrect. It appears + libsndfile performs the conversion something like "f32 = (u8 / 256) * 2 - 1", however I think it should be "f32 = (u8 / 255) * 2 - 1" (note + the divisor of 256 vs 255). I use libsndfile as a benchmark for testing, so I'm therefore leaving this block here just for my automated + correctness testing. This is disabled by default. + */ + for (i = 0; i < sampleCount; ++i) { + *pOut++ = (pIn[i] / 256.0f) * 2 - 1; + } +#else + for (i = 0; i < sampleCount; ++i) { + float x = pIn[i]; + x = x * 0.00784313725490196078f; /* 0..255 to 0..2 */ + x = x - 1; /* 0..2 to -1..1 */ + + *pOut++ = x; + } +#endif +} + +DRWAV_API void drwav_s16_to_f32(float* pOut, const drwav_int16* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + *pOut++ = pIn[i] * 0.000030517578125f; + } +} + +DRWAV_API void drwav_s24_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + double x; + drwav_uint32 a = ((drwav_uint32)(pIn[i*3+0]) << 8); + drwav_uint32 b = ((drwav_uint32)(pIn[i*3+1]) << 16); + drwav_uint32 c = ((drwav_uint32)(pIn[i*3+2]) << 24); + + x = (double)((drwav_int32)(a | b | c) >> 8); + *pOut++ = (float)(x * 0.00000011920928955078125); + } +} + +DRWAV_API void drwav_s32_to_f32(float* pOut, const drwav_int32* pIn, size_t sampleCount) +{ + size_t i; + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + *pOut++ = (float)(pIn[i] / 2147483648.0); + } +} + +DRWAV_API void drwav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + *pOut++ = (float)pIn[i]; + } +} + +DRWAV_API void drwav_alaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + *pOut++ = drwav__alaw_to_s16(pIn[i]) / 32768.0f; + } +} + +DRWAV_API void drwav_mulaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + *pOut++ = drwav__mulaw_to_s16(pIn[i]) / 32768.0f; + } +} + + + +static void drwav__pcm_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample) +{ + unsigned int i; + + /* Special case for 8-bit sample data because it's treated as unsigned. */ + if (bytesPerSample == 1) { + drwav_u8_to_s32(pOut, pIn, totalSampleCount); + return; + } + + /* Slightly more optimal implementation for common formats. */ + if (bytesPerSample == 2) { + drwav_s16_to_s32(pOut, (const drwav_int16*)pIn, totalSampleCount); + return; + } + if (bytesPerSample == 3) { + drwav_s24_to_s32(pOut, pIn, totalSampleCount); + return; + } + if (bytesPerSample == 4) { + for (i = 0; i < totalSampleCount; ++i) { + *pOut++ = ((const drwav_int32*)pIn)[i]; + } + return; + } + + + /* Anything more than 64 bits per sample is not supported. */ + if (bytesPerSample > 8) { + DRWAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut)); + return; + } + + + /* Generic, slow converter. */ + for (i = 0; i < totalSampleCount; ++i) { + drwav_uint64 sample = 0; + unsigned int shift = (8 - bytesPerSample) * 8; + + unsigned int j; + for (j = 0; j < bytesPerSample; j += 1) { + DRWAV_ASSERT(j < 8); + sample |= (drwav_uint64)(pIn[j]) << shift; + shift += 8; + } + + pIn += j; + *pOut++ = (drwav_int32)((drwav_int64)sample >> 32); + } +} + +static void drwav__ieee_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample) +{ + if (bytesPerSample == 4) { + drwav_f32_to_s32(pOut, (const float*)pIn, totalSampleCount); + return; + } else if (bytesPerSample == 8) { + drwav_f64_to_s32(pOut, (const double*)pIn, totalSampleCount); + return; + } else { + /* Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. */ + DRWAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut)); + return; + } +} + + +static drwav_uint64 drwav_read_pcm_frames_s32__pcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + drwav_uint32 bytesPerFrame; + + /* Fast path. */ + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM && pWav->bitsPerSample == 32) { + return drwav_read_pcm_frames(pWav, framesToRead, pBufferOut); + } + + bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav__pcm_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_s32__msadpcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut) +{ + /* + We're just going to borrow the implementation from the drwav_read_s16() since ADPCM is a little bit more complicated than other formats and I don't + want to duplicate that code. + */ + drwav_uint64 totalFramesRead = 0; + drwav_int16 samples16[2048]; + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16); + if (framesRead == 0) { + break; + } + + drwav_s16_to_s32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */ + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_s32__ima(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut) +{ + /* + We're just going to borrow the implementation from the drwav_read_s16() since IMA-ADPCM is a little bit more complicated than other formats and I don't + want to duplicate that code. + */ + drwav_uint64 totalFramesRead = 0; + drwav_int16 samples16[2048]; + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16); + if (framesRead == 0) { + break; + } + + drwav_s16_to_s32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */ + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_s32__ieee(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + + drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav__ieee_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_s32__alaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + + drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav_alaw_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels)); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +static drwav_uint64 drwav_read_pcm_frames_s32__mulaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut) +{ + drwav_uint64 totalFramesRead; + drwav_uint8 sampleData[4096]; + + drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav); + if (bytesPerFrame == 0) { + return 0; + } + + totalFramesRead = 0; + + while (framesToRead > 0) { + drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData); + if (framesRead == 0) { + break; + } + + drwav_mulaw_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels)); + + pBufferOut += framesRead*pWav->channels; + framesToRead -= framesRead; + totalFramesRead += framesRead; + } + + return totalFramesRead; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut) +{ + if (pWav == NULL || framesToRead == 0) { + return 0; + } + + if (pBufferOut == NULL) { + return drwav_read_pcm_frames(pWav, framesToRead, NULL); + } + + /* Don't try to read more samples than can potentially fit in the output buffer. */ + if (framesToRead * pWav->channels * sizeof(drwav_int32) > DRWAV_SIZE_MAX) { + framesToRead = DRWAV_SIZE_MAX / sizeof(drwav_int32) / pWav->channels; + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM) { + return drwav_read_pcm_frames_s32__pcm(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + return drwav_read_pcm_frames_s32__msadpcm(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT) { + return drwav_read_pcm_frames_s32__ieee(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ALAW) { + return drwav_read_pcm_frames_s32__alaw(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_MULAW) { + return drwav_read_pcm_frames_s32__mulaw(pWav, framesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + return drwav_read_pcm_frames_s32__ima(pWav, framesToRead, pBufferOut); + } + + return 0; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32le(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut) +{ + drwav_uint64 framesRead = drwav_read_pcm_frames_s32(pWav, framesToRead, pBufferOut); + if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_FALSE) { + drwav__bswap_samples_s32(pBufferOut, framesRead*pWav->channels); + } + + return framesRead; +} + +DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32be(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut) +{ + drwav_uint64 framesRead = drwav_read_pcm_frames_s32(pWav, framesToRead, pBufferOut); + if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_TRUE) { + drwav__bswap_samples_s32(pBufferOut, framesRead*pWav->channels); + } + + return framesRead; +} + + +DRWAV_API void drwav_u8_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + *pOut++ = ((int)pIn[i] - 128) << 24; + } +} + +DRWAV_API void drwav_s16_to_s32(drwav_int32* pOut, const drwav_int16* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + *pOut++ = pIn[i] << 16; + } +} + +DRWAV_API void drwav_s24_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + unsigned int s0 = pIn[i*3 + 0]; + unsigned int s1 = pIn[i*3 + 1]; + unsigned int s2 = pIn[i*3 + 2]; + + drwav_int32 sample32 = (drwav_int32)((s0 << 8) | (s1 << 16) | (s2 << 24)); + *pOut++ = sample32; + } +} + +DRWAV_API void drwav_f32_to_s32(drwav_int32* pOut, const float* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + *pOut++ = (drwav_int32)(2147483648.0 * pIn[i]); + } +} + +DRWAV_API void drwav_f64_to_s32(drwav_int32* pOut, const double* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + *pOut++ = (drwav_int32)(2147483648.0 * pIn[i]); + } +} + +DRWAV_API void drwav_alaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i = 0; i < sampleCount; ++i) { + *pOut++ = ((drwav_int32)drwav__alaw_to_s16(pIn[i])) << 16; + } +} + +DRWAV_API void drwav_mulaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + size_t i; + + if (pOut == NULL || pIn == NULL) { + return; + } + + for (i= 0; i < sampleCount; ++i) { + *pOut++ = ((drwav_int32)drwav__mulaw_to_s16(pIn[i])) << 16; + } +} + + + +static drwav_int16* drwav__read_pcm_frames_and_close_s16(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalFrameCount) +{ + drwav_uint64 sampleDataSize; + drwav_int16* pSampleData; + drwav_uint64 framesRead; + + DRWAV_ASSERT(pWav != NULL); + + sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(drwav_int16); + if (sampleDataSize > DRWAV_SIZE_MAX) { + drwav_uninit(pWav); + return NULL; /* File's too big. */ + } + + pSampleData = (drwav_int16*)drwav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */ + if (pSampleData == NULL) { + drwav_uninit(pWav); + return NULL; /* Failed to allocate memory. */ + } + + framesRead = drwav_read_pcm_frames_s16(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData); + if (framesRead != pWav->totalPCMFrameCount) { + drwav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks); + drwav_uninit(pWav); + return NULL; /* There was an error reading the samples. */ + } + + drwav_uninit(pWav); + + if (sampleRate) { + *sampleRate = pWav->sampleRate; + } + if (channels) { + *channels = pWav->channels; + } + if (totalFrameCount) { + *totalFrameCount = pWav->totalPCMFrameCount; + } + + return pSampleData; +} + +static float* drwav__read_pcm_frames_and_close_f32(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalFrameCount) +{ + drwav_uint64 sampleDataSize; + float* pSampleData; + drwav_uint64 framesRead; + + DRWAV_ASSERT(pWav != NULL); + + sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(float); + if (sampleDataSize > DRWAV_SIZE_MAX) { + drwav_uninit(pWav); + return NULL; /* File's too big. */ + } + + pSampleData = (float*)drwav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */ + if (pSampleData == NULL) { + drwav_uninit(pWav); + return NULL; /* Failed to allocate memory. */ + } + + framesRead = drwav_read_pcm_frames_f32(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData); + if (framesRead != pWav->totalPCMFrameCount) { + drwav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks); + drwav_uninit(pWav); + return NULL; /* There was an error reading the samples. */ + } + + drwav_uninit(pWav); + + if (sampleRate) { + *sampleRate = pWav->sampleRate; + } + if (channels) { + *channels = pWav->channels; + } + if (totalFrameCount) { + *totalFrameCount = pWav->totalPCMFrameCount; + } + + return pSampleData; +} + +static drwav_int32* drwav__read_pcm_frames_and_close_s32(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalFrameCount) +{ + drwav_uint64 sampleDataSize; + drwav_int32* pSampleData; + drwav_uint64 framesRead; + + DRWAV_ASSERT(pWav != NULL); + + sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(drwav_int32); + if (sampleDataSize > DRWAV_SIZE_MAX) { + drwav_uninit(pWav); + return NULL; /* File's too big. */ + } + + pSampleData = (drwav_int32*)drwav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */ + if (pSampleData == NULL) { + drwav_uninit(pWav); + return NULL; /* Failed to allocate memory. */ + } + + framesRead = drwav_read_pcm_frames_s32(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData); + if (framesRead != pWav->totalPCMFrameCount) { + drwav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks); + drwav_uninit(pWav); + return NULL; /* There was an error reading the samples. */ + } + + drwav_uninit(pWav); + + if (sampleRate) { + *sampleRate = pWav->sampleRate; + } + if (channels) { + *channels = pWav->channels; + } + if (totalFrameCount) { + *totalFrameCount = pWav->totalPCMFrameCount; + } + + return pSampleData; +} + + + +DRWAV_API drwav_int16* drwav_open_and_read_pcm_frames_s16(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init(&wav, onRead, onSeek, pUserData, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} + +DRWAV_API float* drwav_open_and_read_pcm_frames_f32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init(&wav, onRead, onSeek, pUserData, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} + +DRWAV_API drwav_int32* drwav_open_and_read_pcm_frames_s32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init(&wav, onRead, onSeek, pUserData, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} + +#ifndef DR_WAV_NO_STDIO +DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init_file(&wav, filename, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} + +DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init_file(&wav, filename, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} + +DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init_file(&wav, filename, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} + + +DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (channelsOut) { + *channelsOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init_file_w(&wav, filename, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} + +DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (channelsOut) { + *channelsOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init_file_w(&wav, filename, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} + +DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (channelsOut) { + *channelsOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init_file_w(&wav, filename, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} +#endif + +DRWAV_API drwav_int16* drwav_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} + +DRWAV_API float* drwav_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} + +DRWAV_API drwav_int32* drwav_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + drwav wav; + + if (channelsOut) { + *channelsOut = 0; + } + if (sampleRateOut) { + *sampleRateOut = 0; + } + if (totalFrameCountOut) { + *totalFrameCountOut = 0; + } + + if (!drwav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) { + return NULL; + } + + return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut); +} +#endif /* DR_WAV_NO_CONVERSION_API */ + + +DRWAV_API void drwav_free(void* p, const drwav_allocation_callbacks* pAllocationCallbacks) +{ + if (pAllocationCallbacks != NULL) { + drwav__free_from_callbacks(p, pAllocationCallbacks); + } else { + drwav__free_default(p, NULL); + } +} + +DRWAV_API drwav_uint16 drwav_bytes_to_u16(const drwav_uint8* data) +{ + return drwav__bytes_to_u16(data); +} + +DRWAV_API drwav_int16 drwav_bytes_to_s16(const drwav_uint8* data) +{ + return drwav__bytes_to_s16(data); +} + +DRWAV_API drwav_uint32 drwav_bytes_to_u32(const drwav_uint8* data) +{ + return drwav__bytes_to_u32(data); +} + +DRWAV_API drwav_int32 drwav_bytes_to_s32(const drwav_uint8* data) +{ + return drwav__bytes_to_s32(data); +} + +DRWAV_API drwav_uint64 drwav_bytes_to_u64(const drwav_uint8* data) +{ + return drwav__bytes_to_u64(data); +} + +DRWAV_API drwav_int64 drwav_bytes_to_s64(const drwav_uint8* data) +{ + return drwav__bytes_to_s64(data); +} + + +DRWAV_API drwav_bool32 drwav_guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16]) +{ + return drwav__guid_equal(a, b); +} + +DRWAV_API drwav_bool32 drwav_fourcc_equal(const drwav_uint8* a, const char* b) +{ + return drwav__fourcc_equal(a, b); +} + +#endif /* dr_wav_c */ +#endif /* DR_WAV_IMPLEMENTATION */ + +/* +RELEASE NOTES - v0.11.0 +======================= +Version 0.11.0 has breaking API changes. + +Improved Client-Defined Memory Allocation +----------------------------------------- +The main change with this release is the addition of a more flexible way of implementing custom memory allocation routines. The +existing system of DRWAV_MALLOC, DRWAV_REALLOC and DRWAV_FREE are still in place and will be used by default when no custom +allocation callbacks are specified. + +To use the new system, you pass in a pointer to a drwav_allocation_callbacks object to drwav_init() and family, like this: + + void* my_malloc(size_t sz, void* pUserData) + { + return malloc(sz); + } + void* my_realloc(void* p, size_t sz, void* pUserData) + { + return realloc(p, sz); + } + void my_free(void* p, void* pUserData) + { + free(p); + } + + ... + + drwav_allocation_callbacks allocationCallbacks; + allocationCallbacks.pUserData = &myData; + allocationCallbacks.onMalloc = my_malloc; + allocationCallbacks.onRealloc = my_realloc; + allocationCallbacks.onFree = my_free; + drwav_init_file(&wav, "my_file.wav", &allocationCallbacks); + +The advantage of this new system is that it allows you to specify user data which will be passed in to the allocation routines. + +Passing in null for the allocation callbacks object will cause dr_wav to use defaults which is the same as DRWAV_MALLOC, +DRWAV_REALLOC and DRWAV_FREE and the equivalent of how it worked in previous versions. + +Every API that opens a drwav object now takes this extra parameter. These include the following: + + drwav_init() + drwav_init_ex() + drwav_init_file() + drwav_init_file_ex() + drwav_init_file_w() + drwav_init_file_w_ex() + drwav_init_memory() + drwav_init_memory_ex() + drwav_init_write() + drwav_init_write_sequential() + drwav_init_write_sequential_pcm_frames() + drwav_init_file_write() + drwav_init_file_write_sequential() + drwav_init_file_write_sequential_pcm_frames() + drwav_init_file_write_w() + drwav_init_file_write_sequential_w() + drwav_init_file_write_sequential_pcm_frames_w() + drwav_init_memory_write() + drwav_init_memory_write_sequential() + drwav_init_memory_write_sequential_pcm_frames() + drwav_open_and_read_pcm_frames_s16() + drwav_open_and_read_pcm_frames_f32() + drwav_open_and_read_pcm_frames_s32() + drwav_open_file_and_read_pcm_frames_s16() + drwav_open_file_and_read_pcm_frames_f32() + drwav_open_file_and_read_pcm_frames_s32() + drwav_open_file_and_read_pcm_frames_s16_w() + drwav_open_file_and_read_pcm_frames_f32_w() + drwav_open_file_and_read_pcm_frames_s32_w() + drwav_open_memory_and_read_pcm_frames_s16() + drwav_open_memory_and_read_pcm_frames_f32() + drwav_open_memory_and_read_pcm_frames_s32() + +Endian Improvements +------------------- +Previously, the following APIs returned little-endian audio data. These now return native-endian data. This improves compatibility +on big-endian architectures. + + drwav_read_pcm_frames() + drwav_read_pcm_frames_s16() + drwav_read_pcm_frames_s32() + drwav_read_pcm_frames_f32() + drwav_open_and_read_pcm_frames_s16() + drwav_open_and_read_pcm_frames_s32() + drwav_open_and_read_pcm_frames_f32() + drwav_open_file_and_read_pcm_frames_s16() + drwav_open_file_and_read_pcm_frames_s32() + drwav_open_file_and_read_pcm_frames_f32() + drwav_open_file_and_read_pcm_frames_s16_w() + drwav_open_file_and_read_pcm_frames_s32_w() + drwav_open_file_and_read_pcm_frames_f32_w() + drwav_open_memory_and_read_pcm_frames_s16() + drwav_open_memory_and_read_pcm_frames_s32() + drwav_open_memory_and_read_pcm_frames_f32() + +APIs have been added to give you explicit control over whether or not audio data is read or written in big- or little-endian byte +order: + + drwav_read_pcm_frames_le() + drwav_read_pcm_frames_be() + drwav_read_pcm_frames_s16le() + drwav_read_pcm_frames_s16be() + drwav_read_pcm_frames_f32le() + drwav_read_pcm_frames_f32be() + drwav_read_pcm_frames_s32le() + drwav_read_pcm_frames_s32be() + drwav_write_pcm_frames_le() + drwav_write_pcm_frames_be() + +Removed APIs +------------ +The following APIs were deprecated in version 0.10.0 and have now been removed: + + drwav_open() + drwav_open_ex() + drwav_open_write() + drwav_open_write_sequential() + drwav_open_file() + drwav_open_file_ex() + drwav_open_file_write() + drwav_open_file_write_sequential() + drwav_open_memory() + drwav_open_memory_ex() + drwav_open_memory_write() + drwav_open_memory_write_sequential() + drwav_close() + + + +RELEASE NOTES - v0.10.0 +======================= +Version 0.10.0 has breaking API changes. There are no significant bug fixes in this release, so if you are affected you do +not need to upgrade. + +Removed APIs +------------ +The following APIs were deprecated in version 0.9.0 and have been completely removed in version 0.10.0: + + drwav_read() + drwav_read_s16() + drwav_read_f32() + drwav_read_s32() + drwav_seek_to_sample() + drwav_write() + drwav_open_and_read_s16() + drwav_open_and_read_f32() + drwav_open_and_read_s32() + drwav_open_file_and_read_s16() + drwav_open_file_and_read_f32() + drwav_open_file_and_read_s32() + drwav_open_memory_and_read_s16() + drwav_open_memory_and_read_f32() + drwav_open_memory_and_read_s32() + drwav::totalSampleCount + +See release notes for version 0.9.0 at the bottom of this file for replacement APIs. + +Deprecated APIs +--------------- +The following APIs have been deprecated. There is a confusing and completely arbitrary difference between drwav_init*() and +drwav_open*(), where drwav_init*() initializes a pre-allocated drwav object, whereas drwav_open*() will first allocated a +drwav object on the heap and then initialize it. drwav_open*() has been deprecated which means you must now use a pre- +allocated drwav object with drwav_init*(). If you need the previous functionality, you can just do a malloc() followed by +a called to one of the drwav_init*() APIs. + + drwav_open() + drwav_open_ex() + drwav_open_write() + drwav_open_write_sequential() + drwav_open_file() + drwav_open_file_ex() + drwav_open_file_write() + drwav_open_file_write_sequential() + drwav_open_memory() + drwav_open_memory_ex() + drwav_open_memory_write() + drwav_open_memory_write_sequential() + drwav_close() + +These APIs will be removed completely in a future version. The rationale for this change is to remove confusion between the +two different ways to initialize a drwav object. +*/ + +/* +REVISION HISTORY +================ +v0.12.7 - 2020-07-15 + - Fix some bugs on big-endian architectures. + - Fix an error in s24 to f32 conversion. + +v0.12.6 - 2020-06-23 + - Change drwav_read_*() to allow NULL to be passed in as the output buffer which is equivalent to a forward seek. + - Fix a buffer overflow when trying to decode invalid IMA-ADPCM files. + - Add include guard for the implementation section. + +v0.12.5 - 2020-05-27 + - Minor documentation fix. + +v0.12.4 - 2020-05-16 + - Replace assert() with DRWAV_ASSERT(). + - Add compile-time and run-time version querying. + - DRWAV_VERSION_MINOR + - DRWAV_VERSION_MAJOR + - DRWAV_VERSION_REVISION + - DRWAV_VERSION_STRING + - drwav_version() + - drwav_version_string() + +v0.12.3 - 2020-04-30 + - Fix compilation errors with VC6. + +v0.12.2 - 2020-04-21 + - Fix a bug where drwav_init_file() does not close the file handle after attempting to load an erroneous file. + +v0.12.1 - 2020-04-13 + - Fix some pedantic warnings. + +v0.12.0 - 2020-04-04 + - API CHANGE: Add container and format parameters to the chunk callback. + - Minor documentation updates. + +v0.11.5 - 2020-03-07 + - Fix compilation error with Visual Studio .NET 2003. + +v0.11.4 - 2020-01-29 + - Fix some static analysis warnings. + - Fix a bug when reading f32 samples from an A-law encoded stream. + +v0.11.3 - 2020-01-12 + - Minor changes to some f32 format conversion routines. + - Minor bug fix for ADPCM conversion when end of file is reached. + +v0.11.2 - 2019-12-02 + - Fix a possible crash when using custom memory allocators without a custom realloc() implementation. + - Fix an integer overflow bug. + - Fix a null pointer dereference bug. + - Add limits to sample rate, channels and bits per sample to tighten up some validation. + +v0.11.1 - 2019-10-07 + - Internal code clean up. + +v0.11.0 - 2019-10-06 + - API CHANGE: Add support for user defined memory allocation routines. This system allows the program to specify their own memory allocation + routines with a user data pointer for client-specific contextual data. This adds an extra parameter to the end of the following APIs: + - drwav_init() + - drwav_init_ex() + - drwav_init_file() + - drwav_init_file_ex() + - drwav_init_file_w() + - drwav_init_file_w_ex() + - drwav_init_memory() + - drwav_init_memory_ex() + - drwav_init_write() + - drwav_init_write_sequential() + - drwav_init_write_sequential_pcm_frames() + - drwav_init_file_write() + - drwav_init_file_write_sequential() + - drwav_init_file_write_sequential_pcm_frames() + - drwav_init_file_write_w() + - drwav_init_file_write_sequential_w() + - drwav_init_file_write_sequential_pcm_frames_w() + - drwav_init_memory_write() + - drwav_init_memory_write_sequential() + - drwav_init_memory_write_sequential_pcm_frames() + - drwav_open_and_read_pcm_frames_s16() + - drwav_open_and_read_pcm_frames_f32() + - drwav_open_and_read_pcm_frames_s32() + - drwav_open_file_and_read_pcm_frames_s16() + - drwav_open_file_and_read_pcm_frames_f32() + - drwav_open_file_and_read_pcm_frames_s32() + - drwav_open_file_and_read_pcm_frames_s16_w() + - drwav_open_file_and_read_pcm_frames_f32_w() + - drwav_open_file_and_read_pcm_frames_s32_w() + - drwav_open_memory_and_read_pcm_frames_s16() + - drwav_open_memory_and_read_pcm_frames_f32() + - drwav_open_memory_and_read_pcm_frames_s32() + Set this extra parameter to NULL to use defaults which is the same as the previous behaviour. Setting this NULL will use + DRWAV_MALLOC, DRWAV_REALLOC and DRWAV_FREE. + - Add support for reading and writing PCM frames in an explicit endianness. New APIs: + - drwav_read_pcm_frames_le() + - drwav_read_pcm_frames_be() + - drwav_read_pcm_frames_s16le() + - drwav_read_pcm_frames_s16be() + - drwav_read_pcm_frames_f32le() + - drwav_read_pcm_frames_f32be() + - drwav_read_pcm_frames_s32le() + - drwav_read_pcm_frames_s32be() + - drwav_write_pcm_frames_le() + - drwav_write_pcm_frames_be() + - Remove deprecated APIs. + - API CHANGE: The following APIs now return native-endian data. Previously they returned little-endian data. + - drwav_read_pcm_frames() + - drwav_read_pcm_frames_s16() + - drwav_read_pcm_frames_s32() + - drwav_read_pcm_frames_f32() + - drwav_open_and_read_pcm_frames_s16() + - drwav_open_and_read_pcm_frames_s32() + - drwav_open_and_read_pcm_frames_f32() + - drwav_open_file_and_read_pcm_frames_s16() + - drwav_open_file_and_read_pcm_frames_s32() + - drwav_open_file_and_read_pcm_frames_f32() + - drwav_open_file_and_read_pcm_frames_s16_w() + - drwav_open_file_and_read_pcm_frames_s32_w() + - drwav_open_file_and_read_pcm_frames_f32_w() + - drwav_open_memory_and_read_pcm_frames_s16() + - drwav_open_memory_and_read_pcm_frames_s32() + - drwav_open_memory_and_read_pcm_frames_f32() + +v0.10.1 - 2019-08-31 + - Correctly handle partial trailing ADPCM blocks. + +v0.10.0 - 2019-08-04 + - Remove deprecated APIs. + - Add wchar_t variants for file loading APIs: + drwav_init_file_w() + drwav_init_file_ex_w() + drwav_init_file_write_w() + drwav_init_file_write_sequential_w() + - Add drwav_target_write_size_bytes() which calculates the total size in bytes of a WAV file given a format and sample count. + - Add APIs for specifying the PCM frame count instead of the sample count when opening in sequential write mode: + drwav_init_write_sequential_pcm_frames() + drwav_init_file_write_sequential_pcm_frames() + drwav_init_file_write_sequential_pcm_frames_w() + drwav_init_memory_write_sequential_pcm_frames() + - Deprecate drwav_open*() and drwav_close(): + drwav_open() + drwav_open_ex() + drwav_open_write() + drwav_open_write_sequential() + drwav_open_file() + drwav_open_file_ex() + drwav_open_file_write() + drwav_open_file_write_sequential() + drwav_open_memory() + drwav_open_memory_ex() + drwav_open_memory_write() + drwav_open_memory_write_sequential() + drwav_close() + - Minor documentation updates. + +v0.9.2 - 2019-05-21 + - Fix warnings. + +v0.9.1 - 2019-05-05 + - Add support for C89. + - Change license to choice of public domain or MIT-0. + +v0.9.0 - 2018-12-16 + - API CHANGE: Add new reading APIs for reading by PCM frames instead of samples. Old APIs have been deprecated and + will be removed in v0.10.0. Deprecated APIs and their replacements: + drwav_read() -> drwav_read_pcm_frames() + drwav_read_s16() -> drwav_read_pcm_frames_s16() + drwav_read_f32() -> drwav_read_pcm_frames_f32() + drwav_read_s32() -> drwav_read_pcm_frames_s32() + drwav_seek_to_sample() -> drwav_seek_to_pcm_frame() + drwav_write() -> drwav_write_pcm_frames() + drwav_open_and_read_s16() -> drwav_open_and_read_pcm_frames_s16() + drwav_open_and_read_f32() -> drwav_open_and_read_pcm_frames_f32() + drwav_open_and_read_s32() -> drwav_open_and_read_pcm_frames_s32() + drwav_open_file_and_read_s16() -> drwav_open_file_and_read_pcm_frames_s16() + drwav_open_file_and_read_f32() -> drwav_open_file_and_read_pcm_frames_f32() + drwav_open_file_and_read_s32() -> drwav_open_file_and_read_pcm_frames_s32() + drwav_open_memory_and_read_s16() -> drwav_open_memory_and_read_pcm_frames_s16() + drwav_open_memory_and_read_f32() -> drwav_open_memory_and_read_pcm_frames_f32() + drwav_open_memory_and_read_s32() -> drwav_open_memory_and_read_pcm_frames_s32() + drwav::totalSampleCount -> drwav::totalPCMFrameCount + - API CHANGE: Rename drwav_open_and_read_file_*() to drwav_open_file_and_read_*(). + - API CHANGE: Rename drwav_open_and_read_memory_*() to drwav_open_memory_and_read_*(). + - Add built-in support for smpl chunks. + - Add support for firing a callback for each chunk in the file at initialization time. + - This is enabled through the drwav_init_ex(), etc. family of APIs. + - Handle invalid FMT chunks more robustly. + +v0.8.5 - 2018-09-11 + - Const correctness. + - Fix a potential stack overflow. + +v0.8.4 - 2018-08-07 + - Improve 64-bit detection. + +v0.8.3 - 2018-08-05 + - Fix C++ build on older versions of GCC. + +v0.8.2 - 2018-08-02 + - Fix some big-endian bugs. + +v0.8.1 - 2018-06-29 + - Add support for sequential writing APIs. + - Disable seeking in write mode. + - Fix bugs with Wave64. + - Fix typos. + +v0.8 - 2018-04-27 + - Bug fix. + - Start using major.minor.revision versioning. + +v0.7f - 2018-02-05 + - Restrict ADPCM formats to a maximum of 2 channels. + +v0.7e - 2018-02-02 + - Fix a crash. + +v0.7d - 2018-02-01 + - Fix a crash. + +v0.7c - 2018-02-01 + - Set drwav.bytesPerSample to 0 for all compressed formats. + - Fix a crash when reading 16-bit floating point WAV files. In this case dr_wav will output silence for + all format conversion reading APIs (*_s16, *_s32, *_f32 APIs). + - Fix some divide-by-zero errors. + +v0.7b - 2018-01-22 + - Fix errors with seeking of compressed formats. + - Fix compilation error when DR_WAV_NO_CONVERSION_API + +v0.7a - 2017-11-17 + - Fix some GCC warnings. + +v0.7 - 2017-11-04 + - Add writing APIs. + +v0.6 - 2017-08-16 + - API CHANGE: Rename dr_* types to drwav_*. + - Add support for custom implementations of malloc(), realloc(), etc. + - Add support for Microsoft ADPCM. + - Add support for IMA ADPCM (DVI, format code 0x11). + - Optimizations to drwav_read_s16(). + - Bug fixes. + +v0.5g - 2017-07-16 + - Change underlying type for booleans to unsigned. + +v0.5f - 2017-04-04 + - Fix a minor bug with drwav_open_and_read_s16() and family. + +v0.5e - 2016-12-29 + - Added support for reading samples as signed 16-bit integers. Use the _s16() family of APIs for this. + - Minor fixes to documentation. + +v0.5d - 2016-12-28 + - Use drwav_int* and drwav_uint* sized types to improve compiler support. + +v0.5c - 2016-11-11 + - Properly handle JUNK chunks that come before the FMT chunk. + +v0.5b - 2016-10-23 + - A minor change to drwav_bool8 and drwav_bool32 types. + +v0.5a - 2016-10-11 + - Fixed a bug with drwav_open_and_read() and family due to incorrect argument ordering. + - Improve A-law and mu-law efficiency. + +v0.5 - 2016-09-29 + - API CHANGE. Swap the order of "channels" and "sampleRate" parameters in drwav_open_and_read*(). Rationale for this is to + keep it consistent with dr_audio and dr_flac. + +v0.4b - 2016-09-18 + - Fixed a typo in documentation. + +v0.4a - 2016-09-18 + - Fixed a typo. + - Change date format to ISO 8601 (YYYY-MM-DD) + +v0.4 - 2016-07-13 + - API CHANGE. Make onSeek consistent with dr_flac. + - API CHANGE. Rename drwav_seek() to drwav_seek_to_sample() for clarity and consistency with dr_flac. + - Added support for Sony Wave64. + +v0.3a - 2016-05-28 + - API CHANGE. Return drwav_bool32 instead of int in onSeek callback. + - Fixed a memory leak. + +v0.3 - 2016-05-22 + - Lots of API changes for consistency. + +v0.2a - 2016-05-16 + - Fixed Linux/GCC build. + +v0.2 - 2016-05-11 + - Added support for reading data as signed 32-bit PCM for consistency with dr_flac. + +v0.1a - 2016-05-07 + - Fixed a bug in drwav_open_file() where the file handle would not be closed if the loader failed to initialize. + +v0.1 - 2016-05-04 + - Initial versioned release. +*/ + +/* +This software is available as a choice of the following licenses. Choose +whichever you prefer. + +=============================================================================== +ALTERNATIVE 1 - Public Domain (www.unlicense.org) +=============================================================================== +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. + +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to + +=============================================================================== +ALTERNATIVE 2 - MIT No Attribution +=============================================================================== +Copyright 2020 David Reid + +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. + +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. +*/ diff --git a/libs/include/fmt123.h b/libs/include/fmt123.h new file mode 100644 index 0000000..cc30a06 --- /dev/null +++ b/libs/include/fmt123.h @@ -0,0 +1,135 @@ +/* + libmpg123: MPEG Audio Decoder library + + separate header just for audio format definitions not tied to + library code + + copyright 1995-2015 by the mpg123 project + free software under the terms of the LGPL 2.1 + see COPYING and AUTHORS files in distribution or http://mpg123.org +*/ + +#ifndef MPG123_ENC_H +#define MPG123_ENC_H + +/** \file fmt123.h Audio format definitions. */ + +/** \defgroup mpg123_enc mpg123 PCM sample encodings + * These are definitions for audio formats used by libmpg123 and + * libout123. + * + * @{ + */ + +/** An enum over all sample types possibly known to mpg123. + * The values are designed as bit flags to allow bitmasking for encoding + * families. + * This is also why the enum is not used as type for actual encoding variables, + * plain integers (at least 16 bit, 15 bit being used) cover the possible + * combinations of these flags. + * + * Note that (your build of) libmpg123 does not necessarily support all these. + * Usually, you can expect the 8bit encodings and signed 16 bit. + * Also 32bit float will be usual beginning with mpg123-1.7.0 . + * What you should bear in mind is that (SSE, etc) optimized routines may be + * absent for some formats. We do have SSE for 16, 32 bit and float, though. + * 24 bit integer is done via postprocessing of 32 bit output -- just cutting + * the last byte, no rounding, even. If you want better, do it yourself. + * + * All formats are in native byte order. If you need different endinaness, you + * can simply postprocess the output buffers (libmpg123 wouldn't do anything + * else). The macro MPG123_SAMPLESIZE() can be helpful there. + */ +enum mpg123_enc_enum +{ +/* 0000 0000 0000 1111 Some 8 bit integer encoding. */ + MPG123_ENC_8 = 0x00f +/* 0000 0000 0100 0000 Some 16 bit integer encoding. */ +, MPG123_ENC_16 = 0x040 +/* 0100 0000 0000 0000 Some 24 bit integer encoding. */ +, MPG123_ENC_24 = 0x4000 +/* 0000 0001 0000 0000 Some 32 bit integer encoding. */ +, MPG123_ENC_32 = 0x100 +/* 0000 0000 1000 0000 Some signed integer encoding. */ +, MPG123_ENC_SIGNED = 0x080 +/* 0000 1110 0000 0000 Some float encoding. */ +, MPG123_ENC_FLOAT = 0xe00 +/* 0000 0000 1101 0000 signed 16 bit */ +, MPG123_ENC_SIGNED_16 = (MPG123_ENC_16|MPG123_ENC_SIGNED|0x10) +/* 0000 0000 0110 0000 unsigned 16 bit */ +, MPG123_ENC_UNSIGNED_16 = (MPG123_ENC_16|0x20) +/* 0000 0000 0000 0001 unsigned 8 bit */ +, MPG123_ENC_UNSIGNED_8 = 0x01 +/* 0000 0000 1000 0010 signed 8 bit */ +, MPG123_ENC_SIGNED_8 = (MPG123_ENC_SIGNED|0x02) +/* 0000 0000 0000 0100 ulaw 8 bit */ +, MPG123_ENC_ULAW_8 = 0x04 +/* 0000 0000 0000 1000 alaw 8 bit */ +, MPG123_ENC_ALAW_8 = 0x08 +/* 0001 0001 1000 0000 signed 32 bit */ +, MPG123_ENC_SIGNED_32 = MPG123_ENC_32|MPG123_ENC_SIGNED|0x1000 +/* 0010 0001 0000 0000 unsigned 32 bit */ +, MPG123_ENC_UNSIGNED_32 = MPG123_ENC_32|0x2000 +/* 0101 0000 1000 0000 signed 24 bit */ +, MPG123_ENC_SIGNED_24 = MPG123_ENC_24|MPG123_ENC_SIGNED|0x1000 +/* 0110 0000 0000 0000 unsigned 24 bit */ +, MPG123_ENC_UNSIGNED_24 = MPG123_ENC_24|0x2000 +/* 0000 0010 0000 0000 32bit float */ +, MPG123_ENC_FLOAT_32 = 0x200 +/* 0000 0100 0000 0000 64bit float */ +, MPG123_ENC_FLOAT_64 = 0x400 +/* Any possibly known encoding from the list above. */ +, MPG123_ENC_ANY = ( MPG123_ENC_SIGNED_16 | MPG123_ENC_UNSIGNED_16 + | MPG123_ENC_UNSIGNED_8 | MPG123_ENC_SIGNED_8 + | MPG123_ENC_ULAW_8 | MPG123_ENC_ALAW_8 + | MPG123_ENC_SIGNED_32 | MPG123_ENC_UNSIGNED_32 + | MPG123_ENC_SIGNED_24 | MPG123_ENC_UNSIGNED_24 + | MPG123_ENC_FLOAT_32 | MPG123_ENC_FLOAT_64 ) +}; + +/** Get size of one PCM sample with given encoding. + * This is included both in libmpg123 and libout123. Both offer + * an API function to provide the macro results from library + * compile-time, not that of you application. This most likely + * does not matter as I do not expect any fresh PCM sample + * encoding to appear. But who knows? Perhaps the encoding type + * will be abused for funny things in future, not even plain PCM. + * And, by the way: Thomas really likes the ?: operator. + * \param enc the encoding (mpg123_enc_enum value) + * \return size of one sample in bytes + */ +#define MPG123_SAMPLESIZE(enc) ( \ + (enc) & MPG123_ENC_8 \ + ? 1 \ + : ( (enc) & MPG123_ENC_16 \ + ? 2 \ + : ( (enc) & MPG123_ENC_24 \ + ? 3 \ + : ( ( (enc) & MPG123_ENC_32 \ + || (enc) == MPG123_ENC_FLOAT_32 ) \ + ? 4 \ + : ( (enc) == MPG123_ENC_FLOAT_64 \ + ? 8 \ + : 0 \ +) ) ) ) ) + +/** Structure defining an audio format. + * Providing the members as individual function arguments to define a certain + * output format is easy enough. This struct makes is more comfortable to deal + * with a list of formats. + * Negative values for the members might be used to communicate use of default + * values. + */ +struct mpg123_fmt +{ + long rate; /**< sampling rate in Hz */ + int channels; /**< channel count */ + /** encoding code, can be single value or bitwise or of members of + * mpg123_enc_enum */ + int encoding; +}; + +/* @} */ + +#endif + diff --git a/libs/include/glib2d.h b/libs/include/glib2d.h new file mode 100644 index 0000000..73a9be5 --- /dev/null +++ b/libs/include/glib2d.h @@ -0,0 +1,804 @@ +/** \mainpage gLib2D Documentation + * + * \section intro Introduction + * + * gLib2D by Geecko - A simple, fast, light-weight 2D graphics library. \n\n + * This library has been designed to replace the old graphics.c library + * and to simplify the use of pspgu.\n + * The goals : keep it simple, keep it small, keep it fast. + * + * \section limits Known limitations + * + * - Draw & display buffers can't actually be used as real textures. Just a way + * to get the vram pointer. + * - No support for multiples contexts (e.g. sharing coordinates beetween + * textures using some gBegin calls at a time). + * - Manipulating textures (clear, get pixel info...) is not possible. + * - When some 512*512 rotated, colorized and scaled textures are rendered + * at a time, the framerate *could* go under 60 fps. + * + * \section install Installation + * + * - Simply put glib2d.c and glib2d.h in your source directory. \n + * - Then add glib2d.o and link "-lpng -ljpeg -lz -lpspgu -lm -lpspvram" + * in your Makefile. + * - You're done ! + * + * \section copyright License + * + * This work is licensed under the LGPLv3 License. \n + * See the LICENSE file for more details. \n + * You can support the library by marking your homebrew with + * "Using gLib2D by Geecko". + * + * \section contact Contact + * + * Please report bugs or submit ideas at : \n geecko.dev@free.fr \n\n + * Get the full documentation on : \n http://geecko.dev.free.fr \n\n + * Also stay tuned on... \n + * https://github.com/GeeckoDev (contributors would be a plus!) \n + * http://twitter.com/GeeckoDev + */ + +/** + * \file glib2d.h + * \brief gLib2D Header + * \version Beta 5 + */ + +#ifndef GLIB2D_H +#define GLIB2D_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/** + * \def G2D_USE_* + * \brief Choose if the * extension support is enabled. + * + * Otherwise, this part will be not compiled to gain some space. + * Enable this to get * support, disable to avoid compilation errors + */ + +#define G2D_USE_BMP +#define G2D_USE_GIF +#define G2D_USE_JPEG +#define G2D_USE_PCX +#define G2D_USE_PNG +#define G2D_USE_PNM +#define G2D_USE_TGA + +/** + * \def G2D_SCR_W + * \brief Screen width constant, in pixels. + */ +/** + * \def G2D_SCR_H + * \brief Screen height constant, in pixels. + */ +#define G2D_SCR_W (480) +#define G2D_SCR_H (272) + +/** + * \def G2D_RGBA(r,g,b,a) + * \brief Create a g2dColor. + * + * This macro creates a g2dColor from 4 values, red, green, blue and alpha. + * Input range is from 0 to 255. + */ +#define G2D_RGBA(r, g, b, a) ((r)|((g)<<8)|((b)<<16)|((a)<<24)) + +/** + * \def G2D_GET_R(color) + * \brief Get red channel value from a g2dColor. + */ +/** + * \def G2D_GET_G(color) + * \brief Get green channel value from a g2dColor. + */ +/** + * \def G2D_GET_B(color) + * \brief Get blue channel value from a g2dColor. + */ +/** + * \def G2D_GET_A(color) + * \brief Get alpha channel value from a g2dColor. + */ +#define G2D_GET_R(color) (((color) ) & 0xFF) +#define G2D_GET_G(color) (((color) >> 8) & 0xFF) +#define G2D_GET_B(color) (((color) >> 16) & 0xFF) +#define G2D_GET_A(color) (((color) >> 24) & 0xFF) + +/** + * \def G2D_MODULATE(color,luminance,alpha) + * \brief g2dColor modulation. + * + * This macro modulates the luminance & alpha of a g2dColor. + * Input range is from 0 to 255. + */ +#define G2D_MODULATE(color,luminance,alpha) \ + G2D_RGBA((int)(luminance) * G2D_GET_R(color) / 255, \ + (int)(luminance) * G2D_GET_G(color) / 255, \ + (int)(luminance) * G2D_GET_B(color) / 255, \ + (int)(alpha ) * G2D_GET_A(color) / 255) + +/** + * \enum g2dColors + * \brief Colors enumeration. + * + * Primary, secondary, tertiary and grayscale colors are defined. + */ +enum g2dColors { + // Primary colors + RED = 0xFF0000FF, + GREEN = 0xFF00FF00, + BLUE = 0xFFFF0000, + // Secondary colors + CYAN = 0xFFFFFF00, + MAGENTA = 0xFFFF00FF, + YELLOW = 0xFF00FFFF, + // Tertiary colors + AZURE = 0xFFFF7F00, + VIOLET = 0xFFFF007F, + ROSE = 0xFF7F00FF, + ORANGE = 0xFF007FFF, + CHARTREUSE = 0xFF00FF7F, + SPRING_GREEN = 0xFF7FFF00, + // Grayscale + WHITE = 0xFFFFFFFF, + LITEGRAY = 0xFFBFBFBF, + GRAY = 0xFF7F7F7F, + DARKGRAY = 0xFF3F3F3F, + BLACK = 0xFF000000 +}; + +/** + * \enum g2dCoord_Mode + * \brief Coordinates modes enumeration. + * + * Choose where the coordinates correspond in the object. + * Can only be used with g2dSetCoordMode. + */ +/** + * \enum g2dLine_Mode + * \brief Line modes enumeration. + * + * Change line draw properties. + * Can only be used with g2dBeginLines. + */ +/** + * \enum g2dFlip_Mode + * \brief Flip modes enumeration. + * + * Change flip properties. + * Can only be used with g2dFlip. + */ +/** + * \enum g2dTex_Mode + * \brief Texture modes enumeration. + * + * Change texture properties. + * Can only be used with g2dTexLoad. + */ +typedef enum { + G2D_UP_LEFT, + G2D_UP_RIGHT, + G2D_DOWN_RIGHT, + G2D_DOWN_LEFT, + G2D_CENTER +} g2dCoord_Mode; +typedef enum { + G2D_STRIP = 1 /**< Make a line strip. */ +} g2dLine_Mode; +typedef enum { + G2D_VSYNC = 1 /**< Limit the FPS to 60 (synchronized with the screen). + Better quality and less power consumption. */ +} g2dFlip_Mode; +typedef enum { + G2D_SWIZZLE = 1 /**< Recommended. Use it to speedup rendering. */ +} g2dTex_Mode; + +/** + * \var g2dAlpha + * \brief Alpha type. + */ +/** + * \var g2dColor + * \brief Color type. + */ +typedef int g2dAlpha; +typedef unsigned int g2dColor; + +/** + * \struct g2dTexture + * \brief Texture structure. + */ +typedef struct { + int tw; /**< Real texture width. A power of two. */ + int th; /**< Real texture height. A power of two. */ + int w; /**< Texture width, as seen when drawing. */ + int h; /**< Texture height, as seen when drawing. */ + float ratio; /**< Width/height ratio. */ + bool swizzled; /**< Is the texture swizzled ? */ + g2dColor *data; /**< Pointer to raw data. */ +} g2dTexture; + +/** + * \var g2d_draw_buffer + * \brief The current draw buffer as a texture. + */ +/** + * \var g2d_disp_buffer + * \brief The current display buffer as a texture. + */ +extern g2dTexture g2d_draw_buffer; +extern g2dTexture g2d_disp_buffer; + +/** + * \brief Initializes the library. + * + * This function will create a GU context and setup the display buffers. + * Automatically called by the other functions. + */ +void g2dInit(void); + +/** + * \brief Shutdowns the library. + * + * This function will destroy the GU context. + */ +void g2dTerm(void); + +/** + * \brief Clears screen & depth buffer. + * @param color Screen clear color + * + * This function clears the screen, and clears the zbuffer if depth coordinate + * is used in the loop. Will automatically init the GU if needed. + */ +void g2dClear(g2dColor color); + +/** + * \brief Clears depth buffer. + * + * This function clears the zbuffer to zero (z range 0-65535). + * Will automatically init the GU if needed. + */ +void g2dClearZ(void); + +/** + * \brief Begins rectangles rendering. + * @param tex Pointer to a texture, pass NULL to get a colored rectangle. + * + * This function begins object rendering. Resets all properties. + * One g2dAdd() call per object. + * Only one texture can be used, but multiple objects can be rendered at a time. + * g2dBegin*() / g2dEnd() couple can be called multiple times in the loop, + * to render multiple textures. + */ +void g2dBeginRects(g2dTexture *tex); + +/** + * \brief Begins lines rendering. + * @param line_mode A g2dLine_Mode constant. + * + * This function begins object rendering. Calls g2dReset(). + * Two g2dAdd() calls per object. + * Pass G2D_LINE_STRIP to make a line strip (two calls, then one per object). + */ +void g2dBeginLines(g2dLine_Mode mode); + +/** + * \brief Begins quads rendering. + * @param tex Pointer to a texture, pass NULL to get a colored quad. + * + * This function begins object rendering. Resets all properties. + * Four g2dAdd() calls per object, first for the up left corner, then clockwise. + * Only one texture can be used, but multiple objects can be rendered at a time. + * g2dBegin*() / g2dEnd() couple can be called multiple times in the loop, + * to render multiple textures. + */ +void g2dBeginQuads(g2dTexture *tex); + +/** + * \brief Begins points rendering. + * + * This function begins object rendering. Resets all properties. + * One g2dAdd() call per object. + */ +void g2dBeginPoints(void); + +/** + * \brief Ends object rendering. + * + * This function ends object rendering. Must be called after g2dBegin*() to add + * objects to the display list. Automatically adapts pspgu functionnalities + * to get the best performance possible. + */ +void g2dEnd(void); + +/** + * \brief Resets current transformation and attribution. + * + * This function must be called during object rendering. + * Calls g2dResetCoord(), g2dResetRotation(), g2dResetScale(), + * g2dResetColor(), g2dResetAlpha(), g2dResetCrop() and g2dResetTex(). + */ +void g2dReset(void); + +/** + * \brief Flips the screen. + * @param flip_mode A g2dFlip_Mode constant. + * + * This function must be called at the end of the loop. + * Renders the whole display list to the draw buffer. + * Inverts framebuffers to display the whole thing. + */ +void g2dFlip(g2dFlip_Mode mode); + +/** + * \brief Pushes the current transformation & attribution to a new object. + * + * This function must be called during object rendering. + */ +void g2dAdd(void); + +/** + * \brief Saves the current transformation to stack. + * + * This function must be called during object rendering. + * The stack is 64 saves high. + * Use it like the OpenGL one. + */ +void g2dPush(void); + +/** + * \brief Restore the current transformation from stack. + * + * This function must be called during object rendering. + * The stack is 64 saves high. + * Use it like the OpenGL one. + */ +void g2dPop(void); + +/** + * \brief Creates a new blank texture. + * @param w Width of the texture. + * @param h Height of the texture. + * + * This function returns NULL on allocation fail. + */ +g2dTexture* g2dTexCreate(int w, int h); + +/** + * \brief Frees a texture & set its pointer to NULL. + * @param tex Pointer to the variable which contains the texture pointer. + * + * This function is used to gain memory when a texture is useless. + * Must pass the pointer to the variable which contains the pointer, + * to set it to NULL (passing NULL to a g2dBegin* function is safe). + */ +void g2dTexFree(g2dTexture **tex); + +/** + * \brief Loads an image. + * @param path Path to the file. + * @param tex_mode A g2dTex_Mode constant. + * @returns Pointer to the generated texture. + * + * Swizzling is enabled only for 16*16+ textures (useless on small textures), pass G2D_SWIZZLE to enable it. + * Texture supported up to 512*512 in size only (hardware limitation). + */ +g2dTexture *g2dTexLoad(const char *path, g2dTex_Mode mode); + +/** + * \brief Loads an image from memory. + * @param data Pointer to buffer. + * @param size Size of buffer. + * @param tex_mode A g2dTex_Mode constant. + * @returns Pointer to the generated texture. + * + * Swizzling is enabled only for 16*16+ textures (useless on small textures), pass G2D_SWIZZLE to enable it. + * Texture supported up to 512*512 in size only (hardware limitation). + */ +g2dTexture *g2dTexLoadMemory(void *data, int size, g2dTex_Mode mode); + +/** + * \brief Resets the current coordinates. + * + * This function must be called during object rendering. + * Sets g2dSetCoordMode() to G2D_UP_LEFT and g2dSetCoordXYZ() to (0,0,0). + */ +void g2dResetCoord(void); + +/** + * \brief Set coordinate mode. + * @param coord_mode A gCoord_Mode. + * + * This function must be called during object rendering. + * Defines where the coordinates correspond in the object. + */ +void g2dSetCoordMode(g2dCoord_Mode mode); + +/** + * \brief Gets the current position. + * @param x Pointer to save the current x (in pixels). + * @param y Pointer to save the current y (in pixels). + * @param z Pointer to save the current z (in pixels). + * + * This function must be called during object rendering. + * Parameters are pointers to float, not int ! + * Pass NULL if not needed. + */ +void g2dGetCoordXYZ(float *x, float *y, float *z); + +/** + * \brief Sets the new position. + * @param x New x, in pixels. + * @param y New y, in pixels. + * + * This function must be called during object rendering. + */ +void g2dSetCoordXY(float x, float y); + +/** + * \brief Sets the new position, with depth support. + * @param x New x, in pixels. + * @param y New y, in pixels. + * @param z New z, in pixels. (front 0-65535 back) + * + * This function must be called during object rendering. + */ +void g2dSetCoordXYZ(float x, float y, float z); + +/** + * \brief Sets the new position, relative to the current. + * @param x New x increment, in pixels. + * @param y New y increment, in pixels. + * + * This function must be called during object rendering. + */ +void g2dSetCoordXYRelative(float x, float y); + +/** + * \brief Sets the new position, with depth support, relative to the current. + * @param x New x increment, in pixels. + * @param y New y increment, in pixels. + * @param z New z increment, in pixels. + * + * This function must be called during object rendering. + */ +void g2dSetCoordXYZRelative(float x, float y, float z); + +/** + * \brief Use integer coordinates. + * @param use false to desactivate (better look, by default), + true to activate (can be useful when you have glitches). + * + * This function must be called during object rendering. + */ +void g2dSetCoordInteger(bool use); + +/** + * \brief Resets the global scale. + * + * This function resets the global scale to 1.f. + * Translations and scales are multiplied by this factor. + */ +void g2dResetGlobalScale(void); + +/** + * \brief Resets the current scale. + * + * This function must be called during object rendering. + * Sets the scale to the current texture size or (10,10). + */ +void g2dResetScale(void); + +/** + * \brief Gets the global scale. + * @param scale Pointer to save the global scale (factor). + * + * Pass NULL if not needed. + */ +void g2dGetGlobalScale(float *scale); + +/** + * \brief Gets the current scale. + * @param w Pointer to save the current width (in pixels). + * @param h Pointer to save the current height (in pixels). + * + * This function must be called during object rendering. + * Parameters are pointers to float, not int ! + * Pass NULL if not needed. + */ +void g2dGetScaleWH(float *w, float *h); + +/** + * \brief Sets the global scale. + * + * Translations and scales are multiplied by this factor. + */ +void g2dSetGlobalScale(float scale); + +/** + * \brief Sets the new scale. + * @param w Width scale factor. + * @param h Height scale factor. + * + * This function must be called during object rendering. + * g2dResetScale() is called, then width & height scale are + * multiplied by these values. + * Negative values can be passed to invert the texture. + */ +void g2dSetScale(float w, float h); + +/** + * \brief Sets the new scale, in pixels. + * @param w New width, in pixels. + * @param h New height, in pixels. + * + * This function must be called during object rendering. + * Negative values can be passed to invert the texture. + */ +void g2dSetScaleWH(float w, float h); + +/** + * \brief Sets the new scale, relative to the current. + * @param w Width scale factor. + * @param h Height scale factor. + * + * This function must be called during object rendering. + * Current width & height scale are multiplied by these values. + * Negative values can be passed to invert the texture. + */ +void g2dSetScaleRelative(float w, float h); + +/** + * \brief Sets the new scale, in pixels, relative to the current. + * @param w New width to increment, in pixels. + * @param h New height to increment, in pixels. + * + * This function must be called during object rendering. + * Negative values can be passed to invert the texture. + */ +void g2dSetScaleWHRelative(float w, float h); + +/** + * \brief Resets the current color. + * + * This function must be called during object rendering. + * Sets g2dSetColor() to WHITE. + */ +void g2dResetColor(void); + +/** + * \brief Resets the current alpha. + * + * This function must be called during object rendering. + * Sets g2dSetAlpha() to 255. + */ +void g2dResetAlpha(void); + +/** + * \brief Gets the current alpha. + * @param alpha Pointer to save the current alpha (0-255). + * + * This function must be called during object rendering. + * Pass NULL if not needed. + */ +void g2dGetAlpha(g2dAlpha *alpha); + +/** + * \brief Sets the new color. + * @param color The new color. + * + * This function must be called during object rendering. + * Can be used to colorize any object. + */ +void g2dSetColor(g2dColor color); + +/** + * \brief Sets the new alpha. + * @param alpha The new alpha (0-255). + * + * This function must be called during object rendering. + * Can be used to make any object transparent. + */ +void g2dSetAlpha(g2dAlpha alpha); + +/** + * \brief Sets the new alpha, relative to the current alpha. + * @param alpha The new alpha increment. + * + * This function must be called during object rendering. + * Can be used to make any object transparent. + */ +void g2dSetAlphaRelative(int alpha); + +/** + * \brief Resets the current rotation. + * + * This function must be called during object rendering. + * Sets g2dSetRotation() to 0°. + */ +void g2dResetRotation(void); + +/** + * \brief Gets the current rotation, in radians. + * @param radians Pointer to save the current rotation. + * + * This function must be called during object rendering. + * Pass NULL if not needed. + */ +void g2dGetRotationRad(float *radians); + +/** + * \brief Gets the current rotation, in degrees. + * @param degrees Pointer to save the current rotation. + * + * This function must be called during object rendering. + * Pass NULL if not needed. + */ +void g2dGetRotation(float *degrees); + +/** + * \brief Sets the new rotation, in radians. + * @param radians The new angle. + * + * This function must be called during object rendering. + * The rotation center is the actual coordinates. + */ +void g2dSetRotationRad(float radians); + +/** + * \brief Sets the new rotation, in degrees. + * @param degrees The new angle. + * + * This function must be called during object rendering. + * The rotation center is the actual coordinates. + */ +void g2dSetRotation(float degrees); + +/** + * \brief Sets the new rotation, relative to the current, in radians. + * @param radians The new angle increment. + * + * This function must be called during object rendering. + * The rotation center is the actual coordinates. + */ +void g2dSetRotationRadRelative(float radians); + +/** + * \brief Sets the new rotation, relative to the current, in degrees. + * @param degrees The new angle increment. + * + * This function must be called during object rendering. + * The rotation center is the actual coordinates. + */ +void g2dSetRotationRelative(float degrees); + +/** + * \brief Resets the current crop. + * + * This function must be called during object rendering. + * Sets g2dSetCropXY() to (0;0) and g2dSetCropWH() to (tex->w,tex->h). + */ +void g2dResetCrop(void); + +/** + * \brief Gets the current crop position. + * @param x Pointer to save the current crop x. + * @param y Pointer to save the current crop y. + * + * This function must be called during object rendering. + * Pass NULL if not needed. + */ +void g2dGetCropXY(int *x, int *y); + +/** + * \brief Gets the current crop scale. + * @param w Pointer to save the current crop width. + * @param h Pointer to save the current crop height. + * + * This function must be called during object rendering. + * Pass NULL if not needed. + */ +void g2dGetCropWH(int *w, int *h); + +/** + * \brief Sets the new crop position. + * @param x New x, in pixels. + * @param y New y, in pixels. + * + * This function must be called during object rendering. Defines crop position. + * If the rectangle is larger or next to the texture, it will be repeated + * when g2dSetTexRepeat is enabled. Useful for a tileset. + */ +void g2dSetCropXY(int x, int y); + +/** + * \brief Sets the new crop size. + * @param w New width, in pixels. + * @param h New height, in pixels. + * + * This function must be called during object rendering. Defines crop size. + * If the rectangle is larger or next to the texture, it will be repeated + * when g2dSetTexRepeat is enabled. Useful for a tileset. + */ +void g2dSetCropWH(int w, int h); + +/** + * \brief Sets the new crop position, relative to the current. + * @param x New x increment, in pixels. + * @param y New y increment, in pixels. + * + * This function must be called during object rendering. Defines crop position. + * If the rectangle is larger or next to the texture, texture will be repeated + * when g2dSetTexRepeat is enabled. Useful for a tileset. + */ +void g2dSetCropXYRelative(int x, int y); + +/** + * \brief Sets the new crop size, relative to the current. + * @param w New width increment, in pixels. + * @param h New height increment, in pixels. + * + * This function must be called during object rendering. Defines crop size. + * If the rectangle is larger or next to the texture, texture will be repeated + * when g2dSetTexRepeat is enabled. Useful for a tileset. + */ +void g2dSetCropWHRelative(int w, int h); + +/** + * \brief Resets texture properties. + * + * This function must be called during object rendering. + */ +void g2dResetTex(void); + +/** + * \brief Set texture wrap. + * @param use true to repeat, false to clamp (by default). + * + * This function must be called during object rendering. + */ +void g2dSetTexRepeat(bool use); + +/** + * \brief Use the bilinear filter with the texture. + * @param use true to activate (better look, by default). + false to desactivate (better performance). + * + * This function must be called during object rendering. + * Only useful when scaling. + */ +void g2dSetTexLinear(bool use); + +/** + * \brief Resets the draw zone to the entire screen. + * + * This function can be called everywhere in the loop. + */ +void g2dResetScissor(void); + +/** + * \brief Sets the draw zone. + * @param x New x position. + * @param y New y position. + * @param w New width. + * @param h New height. + * + * This function can be called everywhere in the loop. + * Pixel draw will be skipped outside this rectangle. + */ +void g2dSetScissor(int x, int y, int w, int h); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libs/include/intraFont.h b/libs/include/intraFont.h new file mode 100644 index 0000000..3b3bf2d --- /dev/null +++ b/libs/include/intraFont.h @@ -0,0 +1,369 @@ +/* + * intraFont.h + * This file is used to display the PSP's internal font (pgf and bwfon firmware files) + * intraFont Version 0.31 by BenHur - http://www.psp-programming.com/benhur + * + * Uses parts of pgeFont by InsertWittyName - http://insomniac.0x89.org + * G-spec code by Geecko + * + * This work is licensed under the Creative Commons Attribution-Share Alike 3.0 License. + * See LICENSE for more details. + * + */ + +#ifndef __INTRAFONT_H__ +#define __INTRAFONT_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "libccc.h" + +/** @defgroup intraFont Font Library + * @{ + */ + +#define INTRAFONT_ADVANCE_H 0x00000000 //default: advance horizontaly from one char to the next +#define INTRAFONT_ADVANCE_V 0x00000100 +#define INTRAFONT_ALIGN_LEFT 0x00000000 //default: left-align the text +#define INTRAFONT_ALIGN_CENTER 0x00000200 +#define INTRAFONT_ALIGN_RIGHT 0x00000400 +#define INTRAFONT_ALIGN_FULL 0x00000600 //full justify text to width set by intraFontSetTextWidth() +#define INTRAFONT_SCROLL_LEFT 0x00002000 //in intraFontPrintColumn if text does not fit text is scrolled to the left + //(requires redrawing at ~60 FPS with x position returned by previous call to intraFontPrintColumn()) +#define INTRAFONT_SCROLL_SEESAW 0x00002200 //in intraFontPrintColumn if text does not fit text is scrolled left and right +#define INTRAFONT_SCROLL_RIGHT 0x00002400 //in intraFontPrintColumn if text does not fit text is scrolled to the right +#define INTRAFONT_SCROLL_THROUGH 0x00002600 //in intraFontPrintColumn if text does not fit text is scrolled through (to the left) +#define INTRAFONT_WIDTH_VAR 0x00000000 //default: variable-width +#define INTRAFONT_WIDTH_FIX 0x00000800 //set your custom fixed witdh to 24 pixels: INTRAFONT_WIDTH_FIX | 24 + //(max is 255, set to 0 to use default fixed width, this width will be scaled by size) +#define INTRAFONT_ACTIVE 0x00001000 //assumes the font-texture resides inside sceGuTex already, prevents unecessary reloading -> very small speed-gain +#define INTRAFONT_CACHE_MED 0x00000000 //default: 256x256 texture (enough to cache about 100 chars) +#define INTRAFONT_CACHE_LARGE 0x00004000 //512x512 texture(enough to cache all chars of ltn0.pgf or ... or ltn15.pgf or kr0.pgf) +#define INTRAFONT_CACHE_ASCII 0x00008000 //try to cache all ASCII chars during fontload (uses less memory and is faster to draw text, but slower to load font) + //if it fails: (because the cache is too small) it will automatically switch to chache on-the-fly with a medium texture + //if it succeeds: (all chars and shadows fit into chache) it will free some now unneeded memory +#define INTRAFONT_CACHE_ALL 0x0000C000 //try to cache all chars during fontload (uses less memory and is faster to draw text, but slower to load font) + //if it fails: (because the cache is too small) it will automatically switch to chache on-the-fly with a large texture + //if it succeeds: (all chars and shadows fit into chache) it will free some now unneeded memory +#define INTRAFONT_STRING_ASCII (0x00010000*CCC_CP000) //default: interpret strings as ascii text (ISO/IEC 8859-1) +#define INTRAFONT_STRING_CP437 (0x00010000*CCC_CP437) //interpret strings as ascii text (codepage 437) +#define INTRAFONT_STRING_CP850 (0x00010000*CCC_CP850) //interpret strings as ascii text (codepage 850) +#define INTRAFONT_STRING_CP866 (0x00010000*CCC_CP866) //interpret strings as ascii text (codepage 866) +#define INTRAFONT_STRING_SJIS (0x00010000*CCC_CP932) //interpret strings as shifted-jis (used for japanese) +#define INTRAFONT_STRING_GBK (0x00010000*CCC_CP936) //interpret strings as GBK (used for simplified chinese) +#define INTRAFONT_STRING_KOR (0x00010000*CCC_CP949) //interpret strings as Korean codepage 949 +#define INTRAFONT_STRING_BIG5 (0x00010000*CCC_CP950) //interpret strings as BIG5 (used for traditional chinese) +#define INTRAFONT_STRING_CP1251 (0x00010000*CCC_CP1251) //interpret strings as ascii text (codepage windows-1251) +#define INTRAFONT_STRING_CP1252 (0x00010000*CCC_CP1252) //interpret strings as ascii text (codepage windows-1252) +#define INTRAFONT_STRING_UTF8 (0x00010000*CCC_CPUTF8) //interpret strings as UTF-8 + +/** @note The following definitions are used internally by ::intraFont and have no other relevance.*/ +#define FILETYPE_PGF 0x00 +#define FILETYPE_BWFON 0x01 +#define PGF_BMP_H_ROWS 0x01 +#define PGF_BMP_V_ROWS 0x02 +#define PGF_BMP_OVERLAY 0x03 +#define PGF_NO_EXTRA1 0x04 +#define PGF_NO_EXTRA2 0x08 +#define PGF_NO_EXTRA3 0x10 +#define PGF_CHARGLYPH 0x20 +#define PGF_SHADOWGLYPH 0x40 //warning: this flag is not contained in the metric header flags and is only provided for simpler call to intraFontGetGlyph - ONLY check with (flags & PGF_CHARGLYPH) +#define PGF_CACHED 0x80 +#define PGF_WIDTH_MASK 0x000000FF +#define PGF_OPTIONS_MASK 0x00003FFF +#define PGF_ALIGN_MASK 0x00000600 +#define PGF_SCROLL_MASK 0x00002600 +#define PGF_CACHE_MASK 0x0000C000 +#define PGF_STRING_MASK 0x00FF0000 + + +/** + * A Glyph struct + * + * @note This is used internally by ::intraFont and has no other relevance. + */ +typedef struct { + unsigned short x; //in pixels + unsigned short y; //in pixels + unsigned char width; //in pixels + unsigned char height; //in pixels + char left; //in pixels + char top; //in pixels + unsigned char flags; + unsigned short shadowID; //to look up in shadowmap + char advance; //in quarterpixels + unsigned long ptr; //offset +} Glyph; + +typedef struct { + unsigned short x; //in pixels + unsigned short y; //in pixels + unsigned char flags; +} GlyphBW; + +/** + * A PGF_Header struct + * + * @note This is used internally by ::intraFont and has no other relevance. + */ +typedef struct { + unsigned short header_start; + unsigned short header_len; + char pgf_id[4]; + unsigned long revision; + unsigned long version; + unsigned long charmap_len; + unsigned long charptr_len; + unsigned long charmap_bpe; + unsigned long charptr_bpe; + unsigned char junk00[21]; + unsigned char family[64]; + unsigned char style[64]; + unsigned char junk01[1]; + unsigned short charmap_min; + unsigned short charmap_max; + unsigned char junk02[50]; + unsigned long fixedsize[2]; + unsigned char junk03[14]; + unsigned char table1_len; + unsigned char table2_len; + unsigned char table3_len; + unsigned char advance_len; + unsigned char junk04[102]; + unsigned long shadowmap_len; + unsigned long shadowmap_bpe; + unsigned char junk05[4]; + unsigned long shadowscale[2]; + //currently no need ; +} PGF_Header; + +/** + * A Font struct + */ +typedef struct intraFont { + char* filename; + unsigned char fileType; /**< FILETYPE_PGF or FILETYPE_BWFON */ + unsigned char* fontdata; + + unsigned char* texture; /**< The bitmap data */ + unsigned int texWidth; /**< Texture size (power2) */ + unsigned int texHeight; /**< Texture height (power2) */ + unsigned short texX; + unsigned short texY; + unsigned short texYSize; + + unsigned short n_chars; + char advancex; /**< in quarterpixels */ + char advancey; /**< in quarterpixels */ + unsigned char charmap_compr_len; /**< length of compression info */ + unsigned short* charmap_compr; /**< Compression info on compressed charmap */ + unsigned short* charmap; /**< Character map */ + Glyph* glyph; /**< Character glyphs */ + GlyphBW* glyphBW; + + unsigned short n_shadows; + unsigned char shadowscale; /**< shadows in pgf file (width, height, left and top properties as well) are scaled by factor of (shadowscale>>6) */ + Glyph* shadowGlyph; /**< Shadow glyph(s) */ + + float size; + unsigned int color; + unsigned int shadowColor; + float angle, Rsin, Rcos; /**< For rotation */ + short isRotated; + unsigned int options; + + struct intraFont* altFont; +} intraFont; + + +/** + * Initialise the Font library + * + * @returns 1 on success. + */ +int intraFontInit(void); + +/** + * Shutdown the Font library + */ +void intraFontShutdown(void); + +/** + * Load a pgf font. + * + * @param filename - Path to the font + * + * @param options - INTRAFONT_XXX flags as defined above including flags related to CACHE (ored together) + * + * @returns A ::intraFont struct + */ +intraFont* intraFontLoad(const char *filename,unsigned int options); + +/** + * Load a pgf font from memory. + * + * @param filename - Path to the font + * + * @param font_buffer - Pointer to the font buffer. + * + * @param filesize - Size of the pointer. + * + * @param options - INTRAFONT_XXX flags as defined above including flags related to CACHE (ored together) + * + * @returns A ::intraFont struct + */ +intraFont* intraFontLoadMem(const char *filename, const char *font_buffer, unsigned int filesize, unsigned int options); + +/** + * Free the specified font. + * + * @param font - A valid ::intraFont + */ +void intraFontUnload(intraFont *font); + +/** + * Activate the specified font. + * + * @param font - A valid ::intraFont + */ +void intraFontActivate(intraFont *font); + +/** + * Set font style + * + * @param font - A valid ::intraFont + * + * @param size - Text size + * + * @param color - Text color + * + * @param angle - Text angle (in degrees) + * + * @param shadowColor - Shadow color (use 0 for no shadow) + * + * @param options - INTRAFONT_XXX flags as defined above except flags related to CACHE (ored together) + */ +void intraFontSetStyle(intraFont *font, float size, unsigned int color, unsigned int shadowColor, float angle, unsigned int options); + +/** + * Set type of string encoding to be used in intraFontPrint[f] + * + * @param font - A valid ::intraFont + * + * @param options - INTRAFONT_STRING_XXX flags as defined above except flags related to CACHE (ored together) + */ +void intraFontSetEncoding(intraFont *font, unsigned int options); + +/** + * Set alternative font + * + * @param font - A valid ::intraFont + * + * @param altFont - A valid ::intraFont that's to be used if font does not contain a character + */ +void intraFontSetAltFont(intraFont *font, intraFont *altFont); + +/** + * Draw UCS-2 encoded text along the baseline starting at x, y. + * + * @param font - A valid ::intraFont + * + * @param x - X position on screen + * + * @param y - Y position on screen + * + * @param width - column width for automatic line breaking (intraFontPrintColumn... versions only) + * + * @param text - UCS-2 encoded text to draw + * + * @param length - char length of text to draw (...Ex versions only) + * + * @returns The x position after the last char + */ +float intraFontPrintUCS2 (intraFont *font, float x, float y, const unsigned short *text); +float intraFontPrintUCS2Ex (intraFont *font, float x, float y, const unsigned short *text, int length); +float intraFontPrintColumnUCS2 (intraFont *font, float x, float y, float width, const unsigned short *text); +float intraFontPrintColumnUCS2Ex(intraFont *font, float x, float y, float width, const unsigned short *text, int length); + +/** + * Draw text along the baseline starting at x, y. + * + * @param font - A valid ::intraFont + * + * @param x - X position on screen + * + * @param y - Y position on screen + * + * @param width - column width for automatic line breaking (intraFontPrintColumn... versions only) + * + * @param text - Text to draw (ASCII & extended ASCII, S-JIS or UTF-8 encoded) + * + * @param length - char length of text to draw (...Ex versions only) + * + * @returns The x position after the last char + */ +float intraFontPrint (intraFont *font, float x, float y, const char *text); +float intraFontPrintEx (intraFont *font, float x, float y, const char *text, int length); +float intraFontPrintColumn (intraFont *font, float x, float y, float width, const char *text); +float intraFontPrintColumnEx(intraFont *font, float x, float y, float width, const char *text, int length); + +/** + * Draw text along the baseline starting at x, y (with formatting). + * + * @param font - A valid ::intraFont + * + * @param x - X position on screen + * + * @param y - Y position on screen + * + * @param width - column width for automatic line breaking (intraFontPrintfColumn... versions only) + * + * @param text - Text to draw (ASCII & extended ASCII, S-JIS or UTF-8 encoded) + * + * @param length - char length of text to draw (...Ex versions only) + * + * @returns The x position after the last char + */ +float intraFontPrintf (intraFont *font, float x, float y, const char *text, ...); +//the following functions might be implemented in a future version of intraFont +//float intraFontPrintfEx (intraFont *font, float x, float y, const char *text, int length, ...); +//float intraFontPrintfColumn (intraFont *font, float x, float y, float width, const char *text, ...); +//float intraFontPrintfColumnEx(intraFont *font, float x, float y, float width, const char *text, int length, ...); + +/** + * Measure a length of text if it were to be drawn + * + * @param font - A valid ::intraFont + * + * @param text - Text to measure (ASCII & extended ASCII, S-JIS or UTF-8 encoded) + * + * @param length - char length of text to measure (...Ex version only) + * + * @returns The total width of the text (until the first newline char) + */ +float intraFontMeasureText (intraFont *font, const char *text); +float intraFontMeasureTextEx(intraFont *font, const char *text, int length); + +/** + * Measure a length of UCS-2 encoded text if it were to be drawn + * + * @param font - A valid ::intraFont + * + * @param text - UCS-2 encoded text to measure + * + * @param length - char length of text to measure (...Ex version only) + * + * @returns The total width of the text (until the first newline char) + */ +float intraFontMeasureTextUCS2 (intraFont *font, const unsigned short *text); +float intraFontMeasureTextUCS2Ex(intraFont *font, const unsigned short *text, int length); + +/** @} */ + +#ifdef __cplusplus +} +#endif // __cplusplus + +#endif // __INTRAFONT_H__ diff --git a/libs/include/kubridge.h b/libs/include/kubridge.h new file mode 100644 index 0000000..a44a1ba --- /dev/null +++ b/libs/include/kubridge.h @@ -0,0 +1,182 @@ +#ifndef __KULIBRARY__ +#define __KULIBRARY__ + +#if defined (__cplusplus) +extern "C" { +#endif + +#include +#include +#include +#include + +/** + * Functions to let user mode access certain functions only available in + * kernel mode +*/ + +/** + * Load a module using ModuleMgrForKernel. + * + * @param path - The path to the module to load. + * @param flags - Unused, always 0 . + * @param option - Pointer to a mod_param_t structure. Can be NULL. + * + * @returns The UID of the loaded module on success, otherwise one of ::PspKernelErrorCodes. + */ +SceUID kuKernelLoadModule(const char *path, int flags, SceKernelLMOption *option); + + +/** + * Load a module with a specific apitype + * + * @param ap�type - The apitype + * @param path - The path to the module to load. + * @param flags - Unused, always 0 . + * @param option - Pointer to a mod_param_t structure. Can be NULL. + * + * @returns The UID of the loaded module on success, otherwise one of ::PspKernelErrorCodes. + */ +SceUID kuKernelLoadModuleWithApitype2(int apitype, const char *path, int flags, SceKernelLMOption *option); + +/** + * Gets the api type + * + * @returns the api type in which the system has booted +*/ +int kuKernelInitApitype(); + +/** + * Gets the filename of the executable to be launched after all modules of the api. + * + * @param initfilename - String where copy the initfilename + * @returns 0 on success +*/ +int kuKernelInitFileName(char *initfilename); + +/** + * + * Gets the device in which the application was launched. + * + * @returns the device code, one of PSPBootFrom values. +*/ +int kuKernelBootFrom(); + +/** + * Get the key configuration in which the system has booted. + * + * @returns the key configuration code, one of PSPKeyConfig values +*/ +int kuKernelInitKeyConfig(); + +/** + * Get the user level of the current thread + * + * @return The user level, < 0 on error + */ +int kuKernelGetUserLevel(void); + +/** + * Set the protection of a block of ddr memory + * + * @param addr - Address to set protection on + * @param size - Size of block + * @param prot - Protection bitmask + * + * @return < 0 on error + */ +int kuKernelSetDdrMemoryProtection(void *addr, int size, int prot); + +/** + * Gets the model of the PSP from user mode. + * This function is available since 3.60 M33. + * In previous version, use the kernel function sceKernelGetModel + * + * @return one of PspModel values +*/ +int kuKernelGetModel(void); + +/** + * Find module by name + * + * @param modname - Name of Module + * @param mod - module structure for output (actually treated as SceModule2) + * + * @return < 0 on error + */ +int kuKernelFindModuleByName(char *modname, SceModule *mod); + +/** + * Invalidate the entire instruction cache + */ +void kuKernelIcacheInvalidateAll(void); + +/** + * Read 4 bytes from memory (with kernel memory access) + * + * @param addr - Address to read, must have 4 bytes alignment + */ +u32 kuKernelPeekw(void *addr); + +/** + * Write 4 bytes to memory (with kernel memory access) + * + * @param addr - Address to write, must have 4 bytes alignment + */ +void kuKernelPokew(void *addr, u32 value); + +/** + * memcpy (with kernel memory access) + * + * @param dest - Destination address + * @param src - Source address + * @param num - copy bytes count + * + * @return Destination address + */ +void *kuKernelMemcpy(void *dest, const void *src, size_t num); + +struct KernelCallArg { + u32 arg1; + u32 arg2; + u32 arg3; + u32 arg4; + u32 arg5; + u32 arg6; + u32 arg7; + u32 arg8; + u32 arg9; + u32 arg10; + u32 arg11; + u32 arg12; + u32 ret1; + u32 ret2; +}; + +/** + * Call a kernel function with kernel privilege + * + * @param func_addr - kernel function address + * @param args - kernel arguments and return values + * + * return < 0 on error + */ +int kuKernelCall(void *func_addr, struct KernelCallArg *args); + +/** + * Call a kernel function with kernel privilege and extended stack + * + * @param func_addr - kernel function address + * @param args - kernel arguments and return values + * + * return < 0 on error + */ +int kuKernelCallExtendStack(void *func_addr, struct KernelCallArg *args, int stack_size); + +void kuKernelGetUmdFile(char *umdfile, int size); + +#if defined (__cplusplus) +} +#endif + +#endif diff --git a/libs/include/libccc.h b/libs/include/libccc.h new file mode 100644 index 0000000..5ec214a --- /dev/null +++ b/libs/include/libccc.h @@ -0,0 +1,108 @@ +/* + * libccc.h + * Character Code Conversion Library + * Version 0.31 by BenHur - http://www.psp-programming.com/benhur + * + * This work is licensed under the Creative Commons Attribution-Share Alike 3.0 License. + * See LICENSE for more details. + * + */ + +#ifndef __LIBCCC_H__ +#define __LIBCCC_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/** @defgroup character code conversion library + * @{ + */ + +typedef unsigned short cccUCS2; +typedef unsigned char cccCode; + +/* supported codepages */ +#define CCC_CP000 0x00 //ASCII +#define CCC_CP437 0x01 //US +#define CCC_CP850 0x05 //Multilingual Latin I +#define CCC_CP866 0x0b //Russian +#define CCC_CP932 0x0d //S-JIS +#define CCC_CP936 0x0e //GBK +#define CCC_CP949 0x0f //Korean +#define CCC_CP950 0x10 //Big5 +#define CCC_CP1251 0x12 //Cyrillic +#define CCC_CP1252 0x13 //Latin II +#define CCC_CPUTF8 0xff //UTF-8 +#define CCC_N_CP 0x14 //number of codepages (for array definition) + +/* error codes */ +#define CCC_SUCCESS 0x00000000 +#define CCC_ERROR_BUFFER_SIZE 0x80000104 +#define CCC_ERROR_INPUT_STREAM 0x80000108 +#define CCC_ERROR_MEM_ALLOC 0x800200D9 +#define CCC_ERROR_FILE_READ 0x80020130 +#define CCC_ERROR_UNSUPPORTED 0x80020325 + + +/** + * Character counting + * + * @param str - zero terminated string + * + * @param cp - codepage + * + * @returns number of characters in the string + */ +int cccStrlen(cccCode const * str); //for single byte character sets +int cccStrlenSJIS(cccCode const * str); +int cccStrlenGBK(cccCode const * str); +int cccStrlenKOR(cccCode const * str); +int cccStrlenBIG5(cccCode const * str); +int cccStrlenUTF8(cccCode const * str); +int cccStrlenCode(cccCode const * str, unsigned char cp); +int cccStrlenUCS2(cccUCS2 const * str); + +/** + * Character code conversion + * + * @param dst - output string + * + * @param count - size of output buffer + * + * @param str - input string + * + * @param cp - codepage + * + * @returns number of converted character codes + */ +int cccSJIStoUCS2(cccUCS2 * dst, size_t count, cccCode const * str); +int cccGBKtoUCS2 (cccUCS2 * dst, size_t count, cccCode const * str); +int cccKORtoUCS2 (cccUCS2 * dst, size_t count, cccCode const * str); +int cccBIG5toUCS2(cccUCS2 * dst, size_t count, cccCode const * str); +int cccUTF8toUCS2(cccUCS2 * dst, size_t count, cccCode const * str); +int cccCodetoUCS2(cccUCS2 * dst, size_t count, cccCode const * str, unsigned char cp); + +/** + * Set error character (character that's used for code points where conversion failed) + * + * @param code - new error character (default: 0) + * + * @returns previous error character + */ +cccUCS2 cccSetErrorCharUCS2(cccUCS2 code); + +/** + * Shutdown the Character Code Conversion Library + */ +void cccShutDown(void); + +/** @} */ + +#ifdef __cplusplus +} +#endif // __cplusplus + +#endif // __LIBCCC_H__ diff --git a/libs/include/mpg123.h b/libs/include/mpg123.h new file mode 100644 index 0000000..1a3cd10 --- /dev/null +++ b/libs/include/mpg123.h @@ -0,0 +1,1441 @@ +/* + libmpg123: MPEG Audio Decoder library (version 1.25.10) + + copyright 1995-2015 by the mpg123 project + free software under the terms of the LGPL 2.1 + see COPYING and AUTHORS files in distribution or http://mpg123.org +*/ + +#ifndef MPG123_LIB_H +#define MPG123_LIB_H + +#include + +/** \file mpg123.h The header file for the libmpg123 MPEG Audio decoder */ + +/** A macro to check at compile time which set of API functions to expect. + * This should be incremented at least each time a new symbol is added + * to the header. + */ +#define MPG123_API_VERSION 44 + +#ifndef MPG123_EXPORT +/** Defines needed for MS Visual Studio(tm) DLL builds. + * Every public function must be prefixed with MPG123_EXPORT. When building + * the DLL ensure to define BUILD_MPG123_DLL. This makes the function accessible + * for clients and includes it in the import library which is created together + * with the DLL. When consuming the DLL ensure to define LINK_MPG123_DLL which + * imports the functions from the DLL. + */ +#ifdef BUILD_MPG123_DLL +/* The dll exports. */ +#define MPG123_EXPORT __declspec(dllexport) +#else +#ifdef LINK_MPG123_DLL +/* The exe imports. */ +#define MPG123_EXPORT __declspec(dllimport) +#else +/* Nothing on normal/UNIX builds */ +#define MPG123_EXPORT +#endif +#endif +#endif + +/* This is for Visual Studio, so this header works as distributed in the binary downloads */ +#if defined(_MSC_VER) && !defined(MPG123_DEF_SSIZE_T) +#define MPG123_DEF_SSIZE_T +#include +typedef ptrdiff_t ssize_t; +#endif + +#ifndef MPG123_NO_CONFIGURE /* Enable use of this file without configure. */ +#include +#include + +/* Simplified large file handling. + I used to have a check here that prevents building for a library with conflicting large file setup + (application that uses 32 bit offsets with library that uses 64 bits). + While that was perfectly fine in an environment where there is one incarnation of the library, + it hurt GNU/Linux and Solaris systems with multilib where the distribution fails to provide the + correct header matching the 32 bit library (where large files need explicit support) or + the 64 bit library (where there is no distinction). + + New approach: When the app defines _FILE_OFFSET_BITS, it wants non-default large file support, + and thus functions with added suffix (mpg123_open_64). + Any mismatch will be caught at link time because of the _FILE_OFFSET_BITS setting used when + building libmpg123. Plus, there's dual mode large file support in mpg123 since 1.12 now. + Link failure is not the expected outcome of any half-sane usage anymore. + + More complication: What about client code defining _LARGEFILE64_SOURCE? It might want direct access to the _64 functions, along with the ones without suffix. Well, that's possible now via defining MPG123_NO_LARGENAME and MPG123_LARGESUFFIX, respectively, for disabling or enforcing the suffix names. +*/ + +/* + Now, the renaming of large file aware functions. + By default, it appends underscore _FILE_OFFSET_BITS (so, mpg123_seek_64 for mpg123_seek), if _FILE_OFFSET_BITS is defined. You can force a different suffix via MPG123_LARGESUFFIX (that must include the underscore), or you can just disable the whole mess by defining MPG123_NO_LARGENAME. +*/ +#if (!defined MPG123_NO_LARGENAME) && ((defined _FILE_OFFSET_BITS) || (defined MPG123_LARGESUFFIX)) + +/* Need some trickery to concatenate the value(s) of the given macro(s). */ +#define MPG123_MACROCAT_REALLY(a, b) a ## b +#define MPG123_MACROCAT(a, b) MPG123_MACROCAT_REALLY(a, b) +#ifndef MPG123_LARGESUFFIX +#define MPG123_LARGESUFFIX MPG123_MACROCAT(_, _FILE_OFFSET_BITS) +#endif +#define MPG123_LARGENAME(func) MPG123_MACROCAT(func, MPG123_LARGESUFFIX) + +#define mpg123_open MPG123_LARGENAME(mpg123_open) +#define mpg123_open_fd MPG123_LARGENAME(mpg123_open_fd) +#define mpg123_open_handle MPG123_LARGENAME(mpg123_open_handle) +#define mpg123_framebyframe_decode MPG123_LARGENAME(mpg123_framebyframe_decode) +#define mpg123_decode_frame MPG123_LARGENAME(mpg123_decode_frame) +#define mpg123_tell MPG123_LARGENAME(mpg123_tell) +#define mpg123_tellframe MPG123_LARGENAME(mpg123_tellframe) +#define mpg123_tell_stream MPG123_LARGENAME(mpg123_tell_stream) +#define mpg123_seek MPG123_LARGENAME(mpg123_seek) +#define mpg123_feedseek MPG123_LARGENAME(mpg123_feedseek) +#define mpg123_seek_frame MPG123_LARGENAME(mpg123_seek_frame) +#define mpg123_timeframe MPG123_LARGENAME(mpg123_timeframe) +#define mpg123_index MPG123_LARGENAME(mpg123_index) +#define mpg123_set_index MPG123_LARGENAME(mpg123_set_index) +#define mpg123_position MPG123_LARGENAME(mpg123_position) +#define mpg123_length MPG123_LARGENAME(mpg123_length) +#define mpg123_framelength MPG123_LARGENAME(mpg123_framelength) +#define mpg123_set_filesize MPG123_LARGENAME(mpg123_set_filesize) +#define mpg123_replace_reader MPG123_LARGENAME(mpg123_replace_reader) +#define mpg123_replace_reader_handle MPG123_LARGENAME(mpg123_replace_reader_handle) +#define mpg123_framepos MPG123_LARGENAME(mpg123_framepos) + +#endif /* largefile hackery */ + +#endif /* MPG123_NO_CONFIGURE */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** \defgroup mpg123_init mpg123 library and handle setup + * + * Functions to initialise and shutdown the mpg123 library and handles. + * The parameters of handles have workable defaults, you only have to tune them when you want to tune something;-) + * Tip: Use a RVA setting... + * + * @{ + */ + +/** Opaque structure for the libmpg123 decoder handle. */ +struct mpg123_handle_struct; + +/** Opaque structure for the libmpg123 decoder handle. + * Most functions take a pointer to a mpg123_handle as first argument and operate on its data in an object-oriented manner. + */ +typedef struct mpg123_handle_struct mpg123_handle; + +/** Function to initialise the mpg123 library. + * This function is not thread-safe. Call it exactly once per process, before any other (possibly threaded) work with the library. + * + * \return MPG123_OK if successful, otherwise an error number. + */ +MPG123_EXPORT int mpg123_init(void); + +/** Function to close down the mpg123 library. + * This function is not thread-safe. Call it exactly once per process, before any other (possibly threaded) work with the library. */ +MPG123_EXPORT void mpg123_exit(void); + +/** Create a handle with optional choice of decoder (named by a string, see mpg123_decoders() or mpg123_supported_decoders()). + * and optional retrieval of an error code to feed to mpg123_plain_strerror(). + * Optional means: Any of or both the parameters may be NULL. + * + * \param decoder optional choice of decoder variant (NULL for default) + * \param error optional address to store error codes + * \return Non-NULL pointer to fresh handle when successful. + */ +MPG123_EXPORT mpg123_handle *mpg123_new(const char* decoder, int *error); + +/** Delete handle, mh is either a valid mpg123 handle or NULL. + * \param mh handle + */ +MPG123_EXPORT void mpg123_delete(mpg123_handle *mh); + +/** Enumeration of the parameters types that it is possible to set/get. */ +enum mpg123_parms +{ + MPG123_VERBOSE = 0, /**< set verbosity value for enabling messages to stderr, >= 0 makes sense (integer) */ + MPG123_FLAGS, /**< set all flags, p.ex val = MPG123_GAPLESS|MPG123_MONO_MIX (integer) */ + MPG123_ADD_FLAGS, /**< add some flags (integer) */ + MPG123_FORCE_RATE, /**< when value > 0, force output rate to that value (integer) */ + MPG123_DOWN_SAMPLE, /**< 0=native rate, 1=half rate, 2=quarter rate (integer) */ + MPG123_RVA, /**< one of the RVA choices above (integer) */ + MPG123_DOWNSPEED, /**< play a frame N times (integer) */ + MPG123_UPSPEED, /**< play every Nth frame (integer) */ + MPG123_START_FRAME, /**< start with this frame (skip frames before that, integer) */ + MPG123_DECODE_FRAMES, /**< decode only this number of frames (integer) */ + MPG123_ICY_INTERVAL, /**< stream contains ICY metadata with this interval (integer) */ + MPG123_OUTSCALE, /**< the scale for output samples (amplitude - integer or float according to mpg123 output format, normally integer) */ + MPG123_TIMEOUT, /**< timeout for reading from a stream (not supported on win32, integer) */ + MPG123_REMOVE_FLAGS, /**< remove some flags (inverse of MPG123_ADD_FLAGS, integer) */ + MPG123_RESYNC_LIMIT, /**< Try resync on frame parsing for that many bytes or until end of stream (<0 ... integer). This can enlarge the limit for skipping junk on beginning, too (but not reduce it). */ + MPG123_INDEX_SIZE /**< Set the frame index size (if supported). Values <0 mean that the index is allowed to grow dynamically in these steps (in positive direction, of course) -- Use this when you really want a full index with every individual frame. */ + ,MPG123_PREFRAMES /**< Decode/ignore that many frames in advance for layer 3. This is needed to fill bit reservoir after seeking, for example (but also at least one frame in advance is needed to have all "normal" data for layer 3). Give a positive integer value, please.*/ + ,MPG123_FEEDPOOL /**< For feeder mode, keep that many buffers in a pool to avoid frequent malloc/free. The pool is allocated on mpg123_open_feed(). If you change this parameter afterwards, you can trigger growth and shrinkage during decoding. The default value could change any time. If you care about this, then set it. (integer) */ + ,MPG123_FEEDBUFFER /**< Minimal size of one internal feeder buffer, again, the default value is subject to change. (integer) */ +}; + +/** Flag bits for MPG123_FLAGS, use the usual binary or to combine. */ +enum mpg123_param_flags +{ + MPG123_FORCE_MONO = 0x7 /**< 0111 Force some mono mode: This is a test bitmask for seeing if any mono forcing is active. */ + ,MPG123_MONO_LEFT = 0x1 /**< 0001 Force playback of left channel only. */ + ,MPG123_MONO_RIGHT = 0x2 /**< 0010 Force playback of right channel only. */ + ,MPG123_MONO_MIX = 0x4 /**< 0100 Force playback of mixed mono. */ + ,MPG123_FORCE_STEREO = 0x8 /**< 1000 Force stereo output. */ + ,MPG123_FORCE_8BIT = 0x10 /**< 00010000 Force 8bit formats. */ + ,MPG123_QUIET = 0x20 /**< 00100000 Suppress any printouts (overrules verbose). */ + ,MPG123_GAPLESS = 0x40 /**< 01000000 Enable gapless decoding (default on if libmpg123 has support). */ + ,MPG123_NO_RESYNC = 0x80 /**< 10000000 Disable resync stream after error. */ + ,MPG123_SEEKBUFFER = 0x100 /**< 000100000000 Enable small buffer on non-seekable streams to allow some peek-ahead (for better MPEG sync). */ + ,MPG123_FUZZY = 0x200 /**< 001000000000 Enable fuzzy seeks (guessing byte offsets or using approximate seek points from Xing TOC) */ + ,MPG123_FORCE_FLOAT = 0x400 /**< 010000000000 Force floating point output (32 or 64 bits depends on mpg123 internal precision). */ + ,MPG123_PLAIN_ID3TEXT = 0x800 /**< 100000000000 Do not translate ID3 text data to UTF-8. ID3 strings will contain the raw text data, with the first byte containing the ID3 encoding code. */ + ,MPG123_IGNORE_STREAMLENGTH = 0x1000 /**< 1000000000000 Ignore any stream length information contained in the stream, which can be contained in a 'TLEN' frame of an ID3v2 tag or a Xing tag */ + ,MPG123_SKIP_ID3V2 = 0x2000 /**< 10 0000 0000 0000 Do not parse ID3v2 tags, just skip them. */ + ,MPG123_IGNORE_INFOFRAME = 0x4000 /**< 100 0000 0000 0000 Do not parse the LAME/Xing info frame, treat it as normal MPEG data. */ + ,MPG123_AUTO_RESAMPLE = 0x8000 /**< 1000 0000 0000 0000 Allow automatic internal resampling of any kind (default on if supported). Especially when going lowlevel with replacing output buffer, you might want to unset this flag. Setting MPG123_DOWNSAMPLE or MPG123_FORCE_RATE will override this. */ + ,MPG123_PICTURE = 0x10000 /**< 17th bit: Enable storage of pictures from tags (ID3v2 APIC). */ + ,MPG123_NO_PEEK_END = 0x20000 /**< 18th bit: Do not seek to the end of + * the stream in order to probe + * the stream length and search for the id3v1 field. This also means + * the file size is unknown unless set using mpg123_set_filesize() and + * the stream is assumed as non-seekable unless overridden. + */ + ,MPG123_FORCE_SEEKABLE = 0x40000 /**< 19th bit: Force the stream to be seekable. */ +}; + +/** choices for MPG123_RVA */ +enum mpg123_param_rva +{ + MPG123_RVA_OFF = 0 /**< RVA disabled (default). */ + ,MPG123_RVA_MIX = 1 /**< Use mix/track/radio gain. */ + ,MPG123_RVA_ALBUM = 2 /**< Use album/audiophile gain */ + ,MPG123_RVA_MAX = MPG123_RVA_ALBUM /**< The maximum RVA code, may increase in future. */ +}; + +/** Set a specific parameter, for a specific mpg123_handle, using a parameter + * type key chosen from the mpg123_parms enumeration, to the specified value. + * \param mh handle + * \param type parameter choice + * \param value integer value + * \param fvalue floating point value + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_param( mpg123_handle *mh +, enum mpg123_parms type, long value, double fvalue ); + +/** Get a specific parameter, for a specific mpg123_handle. + * See the mpg123_parms enumeration for a list of available parameters. + * \param mh handle + * \param type parameter choice + * \param value integer value return address + * \param fvalue floating point value return address + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_getparam( mpg123_handle *mh +, enum mpg123_parms type, long *value, double *fvalue ); + +/** Feature set available for query with mpg123_feature. */ +enum mpg123_feature_set +{ + MPG123_FEATURE_ABI_UTF8OPEN = 0 /**< mpg123 expects path names to be given in UTF-8 encoding instead of plain native. */ + ,MPG123_FEATURE_OUTPUT_8BIT /**< 8bit output */ + ,MPG123_FEATURE_OUTPUT_16BIT /**< 16bit output */ + ,MPG123_FEATURE_OUTPUT_32BIT /**< 32bit output */ + ,MPG123_FEATURE_INDEX /**< support for building a frame index for accurate seeking */ + ,MPG123_FEATURE_PARSE_ID3V2 /**< id3v2 parsing */ + ,MPG123_FEATURE_DECODE_LAYER1 /**< mpeg layer-1 decoder enabled */ + ,MPG123_FEATURE_DECODE_LAYER2 /**< mpeg layer-2 decoder enabled */ + ,MPG123_FEATURE_DECODE_LAYER3 /**< mpeg layer-3 decoder enabled */ + ,MPG123_FEATURE_DECODE_ACCURATE /**< accurate decoder rounding */ + ,MPG123_FEATURE_DECODE_DOWNSAMPLE /**< downsample (sample omit) */ + ,MPG123_FEATURE_DECODE_NTOM /**< flexible rate decoding */ + ,MPG123_FEATURE_PARSE_ICY /**< ICY support */ + ,MPG123_FEATURE_TIMEOUT_READ /**< Reader with timeout (network). */ + ,MPG123_FEATURE_EQUALIZER /**< tunable equalizer */ +}; + +/** Query libmpg123 features. + * \param key feature selection + * \return 1 for success, 0 for unimplemented functions + */ +MPG123_EXPORT int mpg123_feature(const enum mpg123_feature_set key); + +/* @} */ + + +/** \defgroup mpg123_error mpg123 error handling + * + * Functions to get text version of the error numbers and an enumeration + * of the error codes returned by libmpg123. + * + * Most functions operating on a mpg123_handle simply return MPG123_OK (0) + * on success and MPG123_ERR (-1) on failure, setting the internal error + * variable of the handle to the specific error code. If there was not a valid + * (non-NULL) handle provided to a function operating on one, MPG123_BAD_HANDLE + * may be returned if this can not be confused with a valid positive return + * value. + * Meaning: A function expected to return positive integers on success will + * always indicate error or a special condition by returning a negative one. + * + * Decoding/seek functions may also return message codes MPG123_DONE, + * MPG123_NEW_FORMAT and MPG123_NEED_MORE (all negative, see below on how to + * react). Note that calls to those can be nested, so generally watch out + * for these codes after initial handle setup. + * Especially any function that needs information about the current stream + * to work will try to at least parse the beginning if that did not happen + * yet. + * + * On a function that is supposed to return MPG123_OK on success and + * MPG123_ERR on failure, make sure you check for != MPG123_OK, not + * == MPG123_ERR, as the error code could get more specific in future, + * or there is just a special message from a decoding routine as indicated + * above. + * + * @{ + */ + +/** Enumeration of the message and error codes and returned by libmpg123 functions. */ +enum mpg123_errors +{ + MPG123_DONE=-12, /**< Message: Track ended. Stop decoding. */ + MPG123_NEW_FORMAT=-11, /**< Message: Output format will be different on next call. Note that some libmpg123 versions between 1.4.3 and 1.8.0 insist on you calling mpg123_getformat() after getting this message code. Newer verisons behave like advertised: You have the chance to call mpg123_getformat(), but you can also just continue decoding and get your data. */ + MPG123_NEED_MORE=-10, /**< Message: For feed reader: "Feed me more!" (call mpg123_feed() or mpg123_decode() with some new input data). */ + MPG123_ERR=-1, /**< Generic Error */ + MPG123_OK=0, /**< Success */ + MPG123_BAD_OUTFORMAT, /**< Unable to set up output format! */ + MPG123_BAD_CHANNEL, /**< Invalid channel number specified. */ + MPG123_BAD_RATE, /**< Invalid sample rate specified. */ + MPG123_ERR_16TO8TABLE, /**< Unable to allocate memory for 16 to 8 converter table! */ + MPG123_BAD_PARAM, /**< Bad parameter id! */ + MPG123_BAD_BUFFER, /**< Bad buffer given -- invalid pointer or too small size. */ + MPG123_OUT_OF_MEM, /**< Out of memory -- some malloc() failed. */ + MPG123_NOT_INITIALIZED, /**< You didn't initialize the library! */ + MPG123_BAD_DECODER, /**< Invalid decoder choice. */ + MPG123_BAD_HANDLE, /**< Invalid mpg123 handle. */ + MPG123_NO_BUFFERS, /**< Unable to initialize frame buffers (out of memory?). */ + MPG123_BAD_RVA, /**< Invalid RVA mode. */ + MPG123_NO_GAPLESS, /**< This build doesn't support gapless decoding. */ + MPG123_NO_SPACE, /**< Not enough buffer space. */ + MPG123_BAD_TYPES, /**< Incompatible numeric data types. */ + MPG123_BAD_BAND, /**< Bad equalizer band. */ + MPG123_ERR_NULL, /**< Null pointer given where valid storage address needed. */ + MPG123_ERR_READER, /**< Error reading the stream. */ + MPG123_NO_SEEK_FROM_END,/**< Cannot seek from end (end is not known). */ + MPG123_BAD_WHENCE, /**< Invalid 'whence' for seek function.*/ + MPG123_NO_TIMEOUT, /**< Build does not support stream timeouts. */ + MPG123_BAD_FILE, /**< File access error. */ + MPG123_NO_SEEK, /**< Seek not supported by stream. */ + MPG123_NO_READER, /**< No stream opened. */ + MPG123_BAD_PARS, /**< Bad parameter handle. */ + MPG123_BAD_INDEX_PAR, /**< Bad parameters to mpg123_index() and mpg123_set_index() */ + MPG123_OUT_OF_SYNC, /**< Lost track in bytestream and did not try to resync. */ + MPG123_RESYNC_FAIL, /**< Resync failed to find valid MPEG data. */ + MPG123_NO_8BIT, /**< No 8bit encoding possible. */ + MPG123_BAD_ALIGN, /**< Stack aligmnent error */ + MPG123_NULL_BUFFER, /**< NULL input buffer with non-zero size... */ + MPG123_NO_RELSEEK, /**< Relative seek not possible (screwed up file offset) */ + MPG123_NULL_POINTER, /**< You gave a null pointer somewhere where you shouldn't have. */ + MPG123_BAD_KEY, /**< Bad key value given. */ + MPG123_NO_INDEX, /**< No frame index in this build. */ + MPG123_INDEX_FAIL, /**< Something with frame index went wrong. */ + MPG123_BAD_DECODER_SETUP, /**< Something prevents a proper decoder setup */ + MPG123_MISSING_FEATURE /**< This feature has not been built into libmpg123. */ + ,MPG123_BAD_VALUE /**< A bad value has been given, somewhere. */ + ,MPG123_LSEEK_FAILED /**< Low-level seek failed. */ + ,MPG123_BAD_CUSTOM_IO /**< Custom I/O not prepared. */ + ,MPG123_LFS_OVERFLOW /**< Offset value overflow during translation of large file API calls -- your client program cannot handle that large file. */ + ,MPG123_INT_OVERFLOW /**< Some integer overflow. */ +}; + +/** Look up error strings given integer code. + * \param errcode integer error code + * \return string describing what that error error code means + */ +MPG123_EXPORT const char* mpg123_plain_strerror(int errcode); + +/** Give string describing what error has occured in the context of handle mh. + * When a function operating on an mpg123 handle returns MPG123_ERR, you should check for the actual reason via + * char *errmsg = mpg123_strerror(mh) + * This function will catch mh == NULL and return the message for MPG123_BAD_HANDLE. + * \param mh handle + * \return error message + */ +MPG123_EXPORT const char* mpg123_strerror(mpg123_handle *mh); + +/** Return the plain errcode intead of a string. + * \param mh handle + * \return error code recorded in handle or MPG123_BAD_HANDLE + */ +MPG123_EXPORT int mpg123_errcode(mpg123_handle *mh); + +/*@}*/ + + +/** \defgroup mpg123_decoder mpg123 decoder selection + * + * Functions to list and select the available decoders. + * Perhaps the most prominent feature of mpg123: You have several (optimized) decoders to choose from (on x86 and PPC (MacOS) systems, that is). + * + * @{ + */ + +/** Get available decoder list. + * \return NULL-terminated array of generally available decoder names (plain 8bit ASCII) + */ +MPG123_EXPORT const char **mpg123_decoders(void); + +/** Get supported decoder list. + * \return NULL-terminated array of the decoders supported by the CPU (plain 8bit ASCII) + */ +MPG123_EXPORT const char **mpg123_supported_decoders(void); + +/** Set the active decoder. + * \param mh handle + * \param decoder_name name of decoder + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_decoder(mpg123_handle *mh, const char* decoder_name); + +/** Get the currently active decoder name. + * The active decoder engine can vary depening on output constraints, + * mostly non-resampling, integer output is accelerated via 3DNow & Co. but for + * other modes a fallback engine kicks in. + * Note that this can return a decoder that is only active in the hidden and not + * available as decoder choice from the outside. + * \param mh handle + * \return The decoder name or NULL on error. + */ +MPG123_EXPORT const char* mpg123_current_decoder(mpg123_handle *mh); + +/*@}*/ + + +/** \defgroup mpg123_output mpg123 output audio format + * + * Functions to get and select the format of the decoded audio. + * + * Before you dive in, please be warned that you might get confused by this. This seems to happen a lot, therefore I am trying to explain in advance. + * + * The mpg123 library decides what output format to use when encountering the first frame in a stream, or actually any frame that is still valid but differs from the frames before in the prompted output format. At such a deciding point, an internal table of allowed encodings, sampling rates and channel setups is consulted. According to this table, an output format is chosen and the decoding engine set up accordingly (including optimized routines for different output formats). This might seem unusual but it just follows from the non-existence of "MPEG audio files" with defined overall properties. There are streams, streams are concatenations of (semi) independent frames. We store streams on disk and call them "MPEG audio files", but that does not change their nature as the decoder is concerned (the LAME/Xing header for gapless decoding makes things interesting again). + * + * To get to the point: What you do with mpg123_format() and friends is to fill the internal table of allowed formats before it is used. That includes removing support for some formats or adding your forced sample rate (see MPG123_FORCE_RATE) that will be used with the crude internal resampler. Also keep in mind that the sample encoding is just a question of choice -- the MPEG frames do only indicate their native sampling rate and channel count. If you want to decode to integer or float samples, 8 or 16 bit ... that is your decision. In a "clean" world, libmpg123 would always decode to 32 bit float and let you handle any sample conversion. But there are optimized routines that work faster by directly decoding to the desired encoding / accuracy. We prefer efficiency over conceptual tidyness. + * + * People often start out thinking that mpg123_format() should change the actual decoding format on the fly. That is wrong. It only has effect on the next natural change of output format, when libmpg123 will consult its format table again. To make life easier, you might want to call mpg123_format_none() before any thing else and then just allow one desired encoding and a limited set of sample rates / channel choices that you actually intend to deal with. You can force libmpg123 to decode everything to 44100 KHz, stereo, 16 bit integer ... it will duplicate mono channels and even do resampling if needed (unless that feature is disabled in the build, same with some encodings). But I have to stress that the resampling of libmpg123 is very crude and doesn't even contain any kind of "proper" interpolation. + * + * In any case, watch out for MPG123_NEW_FORMAT as return message from decoding routines and call mpg123_getformat() to get the currently active output format. + * + * @{ + */ + +/** They can be combined into one number (3) to indicate mono and stereo... */ +enum mpg123_channelcount +{ + MPG123_MONO = 1 /**< mono */ + ,MPG123_STEREO = 2 /**< stereo */ +}; + +/** An array of supported standard sample rates + * These are possible native sample rates of MPEG audio files. + * You can still force mpg123 to resample to a different one, but by default you will only get audio in one of these samplings. + * \param list Store a pointer to the sample rates array there. + * \param number Store the number of sample rates there. */ +MPG123_EXPORT void mpg123_rates(const long **list, size_t *number); + +/** An array of supported audio encodings. + * An audio encoding is one of the fully qualified members of mpg123_enc_enum (MPG123_ENC_SIGNED_16, not MPG123_SIGNED). + * \param list Store a pointer to the encodings array there. + * \param number Store the number of encodings there. */ +MPG123_EXPORT void mpg123_encodings(const int **list, size_t *number); + +/** Return the size (in bytes) of one mono sample of the named encoding. + * \param encoding The encoding value to analyze. + * \return positive size of encoding in bytes, 0 on invalid encoding. */ +MPG123_EXPORT int mpg123_encsize(int encoding); + +/** Configure a mpg123 handle to accept no output format at all, + * use before specifying supported formats with mpg123_format + * \param mh handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_format_none(mpg123_handle *mh); + +/** Configure mpg123 handle to accept all formats + * (also any custom rate you may set) -- this is default. + * \param mh handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_format_all(mpg123_handle *mh); + +/** Set the audio format support of a mpg123_handle in detail: + * \param mh handle + * \param rate The sample rate value (in Hertz). + * \param channels A combination of MPG123_STEREO and MPG123_MONO. + * \param encodings A combination of accepted encodings for rate and channels, p.ex MPG123_ENC_SIGNED16 | MPG123_ENC_ULAW_8 (or 0 for no support). Please note that some encodings may not be supported in the library build and thus will be ignored here. + * \return MPG123_OK on success, MPG123_ERR if there was an error. */ +MPG123_EXPORT int mpg123_format( mpg123_handle *mh +, long rate, int channels, int encodings ); + +/** Check to see if a specific format at a specific rate is supported + * by mpg123_handle. + * \param mh handle + * \param rate sampling rate + * \param encoding encoding + * \return 0 for no support (that includes invalid parameters), MPG123_STEREO, + * MPG123_MONO or MPG123_STEREO|MPG123_MONO. */ +MPG123_EXPORT int mpg123_format_support( mpg123_handle *mh +, long rate, int encoding ); + +/** Get the current output format written to the addresses given. + * If the stream is freshly loaded, this will try to parse enough + * of it to give you the format to come. This clears the flag that + * would otherwise make the first decoding call return + * MPG123_NEW_FORMAT. + * \param mh handle + * \param rate sampling rate return address + * \param channels channel count return address + * \param encoding encoding return address + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_getformat( mpg123_handle *mh +, long *rate, int *channels, int *encoding ); + +/** Get the current output format written to the addresses given. + * This differs from plain mpg123_getformat() in that you can choose + * _not_ to clear the flag that would trigger the next decoding call + * to return MPG123_NEW_FORMAT in case of a new format arriving. + * \param mh handle + * \param rate sampling rate return address + * \param channels channel count return address + * \param encoding encoding return address + * \param clear_flag if true, clear internal format flag + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_getformat2( mpg123_handle *mh +, long *rate, int *channels, int *encoding, int clear_flag ); + +/*@}*/ + + +/** \defgroup mpg123_input mpg123 file input and decoding + * + * Functions for input bitstream and decoding operations. + * Decoding/seek functions may also return message codes MPG123_DONE, MPG123_NEW_FORMAT and MPG123_NEED_MORE (please read up on these on how to react!). + * @{ + */ + +/* reading samples / triggering decoding, possible return values: */ +/** Enumeration of the error codes returned by libmpg123 functions. */ + +/** Open and prepare to decode the specified file by filesystem path. + * This does not open HTTP urls; libmpg123 contains no networking code. + * If you want to decode internet streams, use mpg123_open_fd() or mpg123_open_feed(). + * \param mh handle + * \param path filesystem path + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_open(mpg123_handle *mh, const char *path); + +/** Use an already opened file descriptor as the bitstream input + * mpg123_close() will _not_ close the file descriptor. + * \param mh handle + * \param fd file descriptor + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_open_fd(mpg123_handle *mh, int fd); + +/** Use an opaque handle as bitstream input. This works only with the + * replaced I/O from mpg123_replace_reader_handle()! + * mpg123_close() will call the cleanup callback for your handle (if you gave one). + * \param mh handle + * \param iohandle your handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_open_handle(mpg123_handle *mh, void *iohandle); + +/** Open a new bitstream and prepare for direct feeding + * This works together with mpg123_decode(); you are responsible for reading and feeding the input bitstream. + * \param mh handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_open_feed(mpg123_handle *mh); + +/** Closes the source, if libmpg123 opened it. + * \param mh handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_close(mpg123_handle *mh); + +/** Read from stream and decode up to outmemsize bytes. + * \param mh handle + * \param outmemory address of output buffer to write to + * \param outmemsize maximum number of bytes to write + * \param done address to store the number of actually decoded bytes to + * \return MPG123_OK or error/message code + */ +MPG123_EXPORT int mpg123_read(mpg123_handle *mh +, unsigned char *outmemory, size_t outmemsize, size_t *done ); + +/** Feed data for a stream that has been opened with mpg123_open_feed(). + * It's give and take: You provide the bytestream, mpg123 gives you the decoded samples. + * \param mh handle + * \param in input buffer + * \param size number of input bytes + * \return MPG123_OK or error/message code. + */ +MPG123_EXPORT int mpg123_feed( mpg123_handle *mh +, const unsigned char *in, size_t size ); + +/** Decode MPEG Audio from inmemory to outmemory. + * This is very close to a drop-in replacement for old mpglib. + * When you give zero-sized output buffer the input will be parsed until + * decoded data is available. This enables you to get MPG123_NEW_FORMAT (and query it) + * without taking decoded data. + * Think of this function being the union of mpg123_read() and mpg123_feed() (which it actually is, sort of;-). + * You can actually always decide if you want those specialized functions in separate steps or one call this one here. + * \param mh handle + * \param inmemory input buffer + * \param inmemsize number of input bytes + * \param outmemory output buffer + * \param outmemsize maximum number of output bytes + * \param done address to store the number of actually decoded bytes to + * \return error/message code (watch out especially for MPG123_NEED_MORE) + */ +MPG123_EXPORT int mpg123_decode( mpg123_handle *mh +, const unsigned char *inmemory, size_t inmemsize +, unsigned char *outmemory, size_t outmemsize, size_t *done ); + +/** Decode next MPEG frame to internal buffer + * or read a frame and return after setting a new format. + * \param mh handle + * \param num current frame offset gets stored there + * \param audio This pointer is set to the internal buffer to read the decoded audio from. + * \param bytes number of output bytes ready in the buffer + * \return MPG123_OK or error/message code + */ +MPG123_EXPORT int mpg123_decode_frame( mpg123_handle *mh +, off_t *num, unsigned char **audio, size_t *bytes ); + +/** Decode current MPEG frame to internal buffer. + * Warning: This is experimental API that might change in future releases! + * Please watch mpg123 development closely when using it. + * \param mh handle + * \param num last frame offset gets stored there + * \param audio this pointer is set to the internal buffer to read the decoded audio from. + * \param bytes number of output bytes ready in the buffer + * \return MPG123_OK or error/message code + */ +MPG123_EXPORT int mpg123_framebyframe_decode( mpg123_handle *mh +, off_t *num, unsigned char **audio, size_t *bytes ); + +/** Find, read and parse the next mp3 frame + * Warning: This is experimental API that might change in future releases! + * Please watch mpg123 development closely when using it. + * \param mh handle + * \return MPG123_OK or error/message code + */ +MPG123_EXPORT int mpg123_framebyframe_next(mpg123_handle *mh); + +/** Get access to the raw input data for the last parsed frame. + * This gives you a direct look (and write access) to the frame body data. + * Together with the raw header, you can reconstruct the whole raw MPEG stream without junk and meta data, or play games by actually modifying the frame body data before decoding this frame (mpg123_framebyframe_decode()). + * A more sane use would be to use this for CRC checking (see mpg123_info() and MPG123_CRC), the first two bytes of the body make up the CRC16 checksum, if present. + * You can provide NULL for a parameter pointer when you are not interested in the value. + * + * \param mh handle + * \param header the 4-byte MPEG header + * \param bodydata pointer to the frame body stored in the handle (without the header) + * \param bodybytes size of frame body in bytes (without the header) + * \return MPG123_OK if there was a yet un-decoded frame to get the + * data from, MPG123_BAD_HANDLE or MPG123_ERR otherwise (without further + * explanation, the error state of the mpg123_handle is not modified by + * this function). + */ +MPG123_EXPORT int mpg123_framedata( mpg123_handle *mh +, unsigned long *header, unsigned char **bodydata, size_t *bodybytes ); + +/** Get the input position (byte offset in stream) of the last parsed frame. + * This can be used for external seek index building, for example. + * It just returns the internally stored offset, regardless of validity -- + * you ensure that a valid frame has been parsed before! + * \param mh handle + * \return byte offset in stream + */ +MPG123_EXPORT off_t mpg123_framepos(mpg123_handle *mh); + +/*@}*/ + + +/** \defgroup mpg123_seek mpg123 position and seeking + * + * Functions querying and manipulating position in the decoded audio bitstream. + * The position is measured in decoded audio samples, or MPEG frame offset for the specific functions. + * If gapless code is in effect, the positions are adjusted to compensate the skipped padding/delay - meaning, you should not care about that at all and just use the position defined for the samples you get out of the decoder;-) + * The general usage is modelled after stdlib's ftell() and fseek(). + * Especially, the whence parameter for the seek functions has the same meaning as the one for fseek() and needs the same constants from stdlib.h: + * - SEEK_SET: set position to (or near to) specified offset + * - SEEK_CUR: change position by offset from now + * - SEEK_END: set position to offset from end + * + * Note that sample-accurate seek only works when gapless support has been enabled at compile time; seek is frame-accurate otherwise. + * Also, really sample-accurate seeking (meaning that you get the identical sample value after seeking compared to plain decoding up to the position) is only guaranteed when you do not mess with the position code by using MPG123_UPSPEED, MPG123_DOWNSPEED or MPG123_START_FRAME. The first two mainly should cause trouble with NtoM resampling, but in any case with these options in effect, you have to keep in mind that the sample offset is not the same as counting the samples you get from decoding since mpg123 counts the skipped samples, too (or the samples played twice only once)! + * Short: When you care about the sample position, don't mess with those parameters;-) + * Also, seeking is not guaranteed to work for all streams (underlying stream may not support it). + * And yet another caveat: If the stream is concatenated out of differing pieces (Frankenstein stream), seeking may suffer, too. + * + * @{ + */ + +/** Returns the current position in samples. + * On the next successful read, you'd get that sample. + * \param mh handle + * \return sample offset or MPG123_ERR (null handle) + */ +MPG123_EXPORT off_t mpg123_tell(mpg123_handle *mh); + +/** Returns the frame number that the next read will give you data from. + * \param mh handle + * \return frame offset or MPG123_ERR (null handle) + */ +MPG123_EXPORT off_t mpg123_tellframe(mpg123_handle *mh); + +/** Returns the current byte offset in the input stream. + * \param mh handle + * \return byte offset or MPG123_ERR (null handle) + */ +MPG123_EXPORT off_t mpg123_tell_stream(mpg123_handle *mh); + +/** Seek to a desired sample offset. + * Usage is modelled afer the standard lseek(). + * \param mh handle + * \param sampleoff offset in PCM samples + * \param whence one of SEEK_SET, SEEK_CUR or SEEK_END + * \return The resulting offset >= 0 or error/message code + */ +MPG123_EXPORT off_t mpg123_seek( mpg123_handle *mh +, off_t sampleoff, int whence ); + +/** Seek to a desired sample offset in data feeding mode. + * This just prepares things to be right only if you ensure that the next chunk of input data will be from input_offset byte position. + * \param mh handle + * \param sampleoff offset in PCM samples + * \param whence one of SEEK_SET, SEEK_CUR or SEEK_END + * \param input_offset The position it expects to be at the + * next time data is fed to mpg123_decode(). + * \return The resulting offset >= 0 or error/message code */ +MPG123_EXPORT off_t mpg123_feedseek( mpg123_handle *mh +, off_t sampleoff, int whence, off_t *input_offset ); + +/** Seek to a desired MPEG frame offset. + * Usage is modelled afer the standard lseek(). + * \param mh handle + * \param frameoff offset in MPEG frames + * \param whence one of SEEK_SET, SEEK_CUR or SEEK_END + * \return The resulting offset >= 0 or error/message code */ +MPG123_EXPORT off_t mpg123_seek_frame( mpg123_handle *mh +, off_t frameoff, int whence ); + +/** Return a MPEG frame offset corresponding to an offset in seconds. + * This assumes that the samples per frame do not change in the file/stream, which is a good assumption for any sane file/stream only. + * \return frame offset >= 0 or error/message code */ +MPG123_EXPORT off_t mpg123_timeframe(mpg123_handle *mh, double sec); + +/** Give access to the frame index table that is managed for seeking. + * You are asked not to modify the values... Use mpg123_set_index to set the + * seek index + * \param mh handle + * \param offsets pointer to the index array + * \param step one index byte offset advances this many MPEG frames + * \param fill number of recorded index offsets; size of the array + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_index( mpg123_handle *mh +, off_t **offsets, off_t *step, size_t *fill ); + +/** Set the frame index table + * Setting offsets to NULL and fill > 0 will allocate fill entries. Setting offsets + * to NULL and fill to 0 will clear the index and free the allocated memory used by the index. + * \param mh handle + * \param offsets pointer to the index array + * \param step one index byte offset advances this many MPEG frames + * \param fill number of recorded index offsets; size of the array + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_set_index( mpg123_handle *mh +, off_t *offsets, off_t step, size_t fill ); + +/** An old crutch to keep old mpg123 binaries happy. + * WARNING: This function is there only to avoid runtime linking errors with + * standalone mpg123 before version 1.23.0 (if you strangely update the + * library but not the end-user program) and actually is broken + * for various cases (p.ex. 24 bit output). Do never use. It might eventually + * be purged from the library. + */ +MPG123_EXPORT int mpg123_position( mpg123_handle *mh, off_t frame_offset, off_t buffered_bytes, off_t *current_frame, off_t *frames_left, double *current_seconds, double *seconds_left); + +/*@}*/ + + +/** \defgroup mpg123_voleq mpg123 volume and equalizer + * + * @{ + */ + +/** another channel enumeration, for left/right choice */ +enum mpg123_channels +{ + MPG123_LEFT=0x1 /**< The Left Channel. */ + ,MPG123_RIGHT=0x2 /**< The Right Channel. */ + ,MPG123_LR=0x3 /**< Both left and right channel; same as MPG123_LEFT|MPG123_RIGHT */ +}; + +/** Set the 32 Band Audio Equalizer settings. + * \param mh handle + * \param channel Can be MPG123_LEFT, MPG123_RIGHT or MPG123_LEFT|MPG123_RIGHT for both. + * \param band The equaliser band to change (from 0 to 31) + * \param val The (linear) adjustment factor. + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_eq( mpg123_handle *mh +, enum mpg123_channels channel, int band, double val ); + +/** Get the 32 Band Audio Equalizer settings. + * \param mh handle + * \param channel Can be MPG123_LEFT, MPG123_RIGHT or MPG123_LEFT|MPG123_RIGHT for (arithmetic mean of) both. + * \param band The equaliser band to change (from 0 to 31) + * \return The (linear) adjustment factor (zero for pad parameters) */ +MPG123_EXPORT double mpg123_geteq(mpg123_handle *mh + , enum mpg123_channels channel, int band); + +/** Reset the 32 Band Audio Equalizer settings to flat + * \param mh handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_reset_eq(mpg123_handle *mh); + +/** Set the absolute output volume including the RVA setting, + * vol<0 just applies (a possibly changed) RVA setting. + * \param mh handle + * \param vol volume value (linear factor) + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_volume(mpg123_handle *mh, double vol); + +/** Adjust output volume including the RVA setting by chosen amount + * \param mh handle + * \param change volume value (linear factor increment) + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_volume_change(mpg123_handle *mh, double change); + +/** Return current volume setting, the actual value due to RVA, and the RVA + * adjustment itself. It's all as double float value to abstract the sample + * format. The volume values are linear factors / amplitudes (not percent) + * and the RVA value is in decibels. + * \param mh handle + * \param base return address for base volume (linear factor) + * \param really return address for actual volume (linear factor) + * \param rva_db return address for RVA value (decibels) + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_getvolume(mpg123_handle *mh, double *base, double *really, double *rva_db); + +/* TODO: Set some preamp in addition / to replace internal RVA handling? */ + +/*@}*/ + + +/** \defgroup mpg123_status mpg123 status and information + * + * @{ + */ + +/** Enumeration of the mode types of Variable Bitrate */ +enum mpg123_vbr { + MPG123_CBR=0, /**< Constant Bitrate Mode (default) */ + MPG123_VBR, /**< Variable Bitrate Mode */ + MPG123_ABR /**< Average Bitrate Mode */ +}; + +/** Enumeration of the MPEG Versions */ +enum mpg123_version { + MPG123_1_0=0, /**< MPEG Version 1.0 */ + MPG123_2_0, /**< MPEG Version 2.0 */ + MPG123_2_5 /**< MPEG Version 2.5 */ +}; + + +/** Enumeration of the MPEG Audio mode. + * Only the mono mode has 1 channel, the others have 2 channels. */ +enum mpg123_mode { + MPG123_M_STEREO=0, /**< Standard Stereo. */ + MPG123_M_JOINT, /**< Joint Stereo. */ + MPG123_M_DUAL, /**< Dual Channel. */ + MPG123_M_MONO /**< Single Channel. */ +}; + + +/** Enumeration of the MPEG Audio flag bits */ +enum mpg123_flags { + MPG123_CRC=0x1, /**< The bitstream is error protected using 16-bit CRC. */ + MPG123_COPYRIGHT=0x2, /**< The bitstream is copyrighted. */ + MPG123_PRIVATE=0x4, /**< The private bit has been set. */ + MPG123_ORIGINAL=0x8 /**< The bitstream is an original, not a copy. */ +}; + +/** Data structure for storing information about a frame of MPEG Audio */ +struct mpg123_frameinfo +{ + enum mpg123_version version; /**< The MPEG version (1.0/2.0/2.5). */ + int layer; /**< The MPEG Audio Layer (MP1/MP2/MP3). */ + long rate; /**< The sampling rate in Hz. */ + enum mpg123_mode mode; /**< The audio mode (Mono, Stereo, Joint-stero, Dual Channel). */ + int mode_ext; /**< The mode extension bit flag. */ + int framesize; /**< The size of the frame (in bytes, including header). */ + enum mpg123_flags flags; /**< MPEG Audio flag bits. Just now I realize that it should be declared as int, not enum. It's a bitwise combination of the enum values. */ + int emphasis; /**< The emphasis type. */ + int bitrate; /**< Bitrate of the frame (kbps). */ + int abr_rate; /**< The target average bitrate. */ + enum mpg123_vbr vbr; /**< The VBR mode. */ +}; + +/** Get frame information about the MPEG audio bitstream and store it in a mpg123_frameinfo structure. + * \param mh handle + * \param mi address of existing frameinfo structure to write to + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_info(mpg123_handle *mh, struct mpg123_frameinfo *mi); + +/** Get the safe output buffer size for all cases + * (when you want to replace the internal buffer) + * \return safe buffer size + */ +MPG123_EXPORT size_t mpg123_safe_buffer(void); + +/** Make a full parsing scan of each frame in the file. ID3 tags are found. An + * accurate length value is stored. Seek index will be filled. A seek back to + * current position is performed. At all, this function refuses work when + * stream is not seekable. + * \param mh handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_scan(mpg123_handle *mh); + +/** Return, if possible, the full (expected) length of current track in frames. + * \param mh handle + * \return length >= 0 or MPG123_ERR if there is no length guess possible. + */ +MPG123_EXPORT off_t mpg123_framelength(mpg123_handle *mh); + +/** Return, if possible, the full (expected) length of current track in samples. + * \param mh handle + * \return length >= 0 or MPG123_ERR if there is no length guess possible. + */ +MPG123_EXPORT off_t mpg123_length(mpg123_handle *mh); + +/** Override the value for file size in bytes. + * Useful for getting sensible track length values in feed mode or for HTTP streams. + * \param mh handle + * \param size file size in bytes + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_set_filesize(mpg123_handle *mh, off_t size); + +/** Get MPEG frame duration in seconds. + * \param mh handle + * \return frame duration in seconds, <0 on error + */ +MPG123_EXPORT double mpg123_tpf(mpg123_handle *mh); + +/** Get MPEG frame duration in samples. + * \param mh handle + * \return samples per frame for the most recently parsed frame; <0 on errors + */ +MPG123_EXPORT int mpg123_spf(mpg123_handle *mh); + +/** Get and reset the clip count. + * \param mh handle + * \return count of clipped samples + */ +MPG123_EXPORT long mpg123_clip(mpg123_handle *mh); + + +/** The key values for state information from mpg123_getstate(). */ +enum mpg123_state +{ + MPG123_ACCURATE = 1 /**< Query if positons are currently accurate (integer value, 0 if false, 1 if true). */ + ,MPG123_BUFFERFILL /**< Get fill of internal (feed) input buffer as integer byte count returned as long and as double. An error is returned on integer overflow while converting to (signed) long, but the returned floating point value shold still be fine. */ + ,MPG123_FRANKENSTEIN /**< Stream consists of carelessly stitched together files. Seeking may yield unexpected results (also with MPG123_ACCURATE, it may be confused). */ + ,MPG123_FRESH_DECODER /**< Decoder structure has been updated, possibly indicating changed stream (integer value, 0 if false, 1 if true). Flag is cleared after retrieval. */ +}; + +/** Get various current decoder/stream state information. + * \param mh handle + * \param key the key to identify the information to give. + * \param val the address to return (long) integer values to + * \param fval the address to return floating point values to + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_getstate( mpg123_handle *mh +, enum mpg123_state key, long *val, double *fval ); + +/*@}*/ + + +/** \defgroup mpg123_metadata mpg123 metadata handling + * + * Functions to retrieve the metadata from MPEG Audio files and streams. + * Also includes string handling functions. + * + * @{ + */ + +/** Data structure for storing strings in a safer way than a standard C-String. + * Can also hold a number of null-terminated strings. */ +typedef struct +{ + char* p; /**< pointer to the string data */ + size_t size; /**< raw number of bytes allocated */ + size_t fill; /**< number of used bytes (including closing zero byte) */ +} mpg123_string; + +/** Create and allocate memory for a new mpg123_string + * \param sb string handle (address of existing structure on your side) + */ +MPG123_EXPORT void mpg123_init_string(mpg123_string* sb); + +/** Free-up mempory for an existing mpg123_string + * \param sb string handle + */ +MPG123_EXPORT void mpg123_free_string(mpg123_string* sb); + +/** Change the size of a mpg123_string + * \param sb string handle + * \param news new size in bytes + * \return 0 on error, 1 on success + */ +MPG123_EXPORT int mpg123_resize_string(mpg123_string* sb, size_t news); + +/** Increase size of a mpg123_string if necessary (it may stay larger). + * Note that the functions for adding and setting in current libmpg123 + * use this instead of mpg123_resize_string(). + * That way, you can preallocate memory and safely work afterwards with + * pieces. + * \param sb string handle + * \param news new minimum size + * \return 0 on error, 1 on success + */ +MPG123_EXPORT int mpg123_grow_string(mpg123_string* sb, size_t news); + +/** Copy the contents of one mpg123_string string to another. + * Yes the order of arguments is reversed compated to memcpy(). + * \param from string handle + * \param to string handle + * \return 0 on error, 1 on success + */ +MPG123_EXPORT int mpg123_copy_string(mpg123_string* from, mpg123_string* to); + +/** Append a C-String to an mpg123_string + * \param sb string handle + * \param stuff to append + * \return 0 on error, 1 on success + */ +MPG123_EXPORT int mpg123_add_string(mpg123_string* sb, const char* stuff); + +/** Append a C-substring to an mpg123 string + * \param sb string handle + * \param stuff content to copy + * \param from offset to copy from + * \param count number of characters to copy (a null-byte is always appended) + * \return 0 on error, 1 on success + */ +MPG123_EXPORT int mpg123_add_substring( mpg123_string *sb +, const char *stuff, size_t from, size_t count ); + +/** Set the content of a mpg123_string to a C-string + * \param sb string handle + * \param stuff content to copy + * \return 0 on error, 1 on success + */ +MPG123_EXPORT int mpg123_set_string(mpg123_string* sb, const char* stuff); + +/** Set the content of a mpg123_string to a C-substring + * \param sb string handle + * \param stuff the future content + * \param from offset to copy from + * \param count number of characters to copy (a null-byte is always appended) + * \return 0 on error, 1 on success + */ +MPG123_EXPORT int mpg123_set_substring( mpg123_string *sb +, const char *stuff, size_t from, size_t count ); + +/** Count characters in a mpg123 string (non-null bytes or UTF-8 characters). + * Even with the fill property, the character count is not obvious as there could be multiple trailing null bytes. + * \param sb string handle + * \param utf8 a flag to tell if the string is in utf8 encoding + * \return character count +*/ +MPG123_EXPORT size_t mpg123_strlen(mpg123_string *sb, int utf8); + +/** Remove trailing \\r and \\n, if present. + * \param sb string handle + * \return 0 on error, 1 on success + */ +MPG123_EXPORT int mpg123_chomp_string(mpg123_string *sb); + +/** The mpg123 text encodings. This contains encodings we encounter in ID3 tags or ICY meta info. */ +enum mpg123_text_encoding +{ + mpg123_text_unknown = 0 /**< Unkown encoding... mpg123_id3_encoding can return that on invalid codes. */ + ,mpg123_text_utf8 = 1 /**< UTF-8 */ + ,mpg123_text_latin1 = 2 /**< ISO-8859-1. Note that sometimes latin1 in ID3 is abused for totally different encodings. */ + ,mpg123_text_icy = 3 /**< ICY metadata encoding, usually CP-1252 but we take it as UTF-8 if it qualifies as such. */ + ,mpg123_text_cp1252 = 4 /**< Really CP-1252 without any guessing. */ + ,mpg123_text_utf16 = 5 /**< Some UTF-16 encoding. The last of a set of leading BOMs (byte order mark) rules. + * When there is no BOM, big endian ordering is used. Note that UCS-2 qualifies as UTF-8 when + * you don't mess with the reserved code points. If you want to decode little endian data + * without BOM you need to prepend 0xff 0xfe yourself. */ + ,mpg123_text_utf16bom = 6 /**< Just an alias for UTF-16, ID3v2 has this as distinct code. */ + ,mpg123_text_utf16be = 7 /**< Another alias for UTF16 from ID3v2. Note, that, because of the mess that is reality, + * BOMs are used if encountered. There really is not much distinction between the UTF16 types for mpg123 + * One exception: Since this is seen in ID3v2 tags, leading null bytes are skipped for all other UTF16 + * types (we expect a BOM before real data there), not so for utf16be!*/ + ,mpg123_text_max = 7 /**< Placeholder for the maximum encoding value. */ +}; + +/** The encoding byte values from ID3v2. */ +enum mpg123_id3_enc +{ + mpg123_id3_latin1 = 0 /**< Note: This sometimes can mean anything in practice... */ + ,mpg123_id3_utf16bom = 1 /**< UTF16, UCS-2 ... it's all the same for practical purposes. */ + ,mpg123_id3_utf16be = 2 /**< Big-endian UTF-16, BOM see note for mpg123_text_utf16be. */ + ,mpg123_id3_utf8 = 3 /**< Our lovely overly ASCII-compatible 8 byte encoding for the world. */ + ,mpg123_id3_enc_max = 3 /**< Placeholder to check valid range of encoding byte. */ +}; + +/** Convert ID3 encoding byte to mpg123 encoding index. + * \param id3_enc_byte the ID3 encoding code + * \return the mpg123 encoding index + */ + +MPG123_EXPORT enum mpg123_text_encoding mpg123_enc_from_id3(unsigned char id3_enc_byte); + +/** Store text data in string, after converting to UTF-8 from indicated encoding + * A prominent error can be that you provided an unknown encoding value, or this build of libmpg123 lacks support for certain encodings (ID3 or ICY stuff missing). + * Also, you might want to take a bit of care with preparing the data; for example, strip leading zeroes (I have seen that). + * \param sb target string + * \param enc mpg123 text encoding value + * \param source source buffer with plain unsigned bytes (you might need to cast from signed char) + * \param source_size number of bytes in the source buffer + * \return 0 on error, 1 on success (on error, mpg123_free_string is called on sb) + */ +MPG123_EXPORT int mpg123_store_utf8(mpg123_string *sb, enum mpg123_text_encoding enc, const unsigned char *source, size_t source_size); + +/** Sub data structure for ID3v2, for storing various text fields (including comments). + * This is for ID3v2 COMM, TXXX and all the other text fields. + * Only COMM and TXXX have a description, only COMM and USLT have a language. + * You should consult the ID3v2 specification for the use of the various text fields ("frames" in ID3v2 documentation, I use "fields" here to separate from MPEG frames). */ +typedef struct +{ + char lang[3]; /**< Three-letter language code (not terminated). */ + char id[4]; /**< The ID3v2 text field id, like TALB, TPE2, ... (4 characters, no string termination). */ + mpg123_string description; /**< Empty for the generic comment... */ + mpg123_string text; /**< ... */ +} mpg123_text; + +/** The picture type values from ID3v2. */ +enum mpg123_id3_pic_type +{ + mpg123_id3_pic_other = 0 /**< see ID3v2 docs */ + ,mpg123_id3_pic_icon = 1 /**< see ID3v2 docs */ + ,mpg123_id3_pic_other_icon = 2 /**< see ID3v2 docs */ + ,mpg123_id3_pic_front_cover = 3 /**< see ID3v2 docs */ + ,mpg123_id3_pic_back_cover = 4 /**< see ID3v2 docs */ + ,mpg123_id3_pic_leaflet = 5 /**< see ID3v2 docs */ + ,mpg123_id3_pic_media = 6 /**< see ID3v2 docs */ + ,mpg123_id3_pic_lead = 7 /**< see ID3v2 docs */ + ,mpg123_id3_pic_artist = 8 /**< see ID3v2 docs */ + ,mpg123_id3_pic_conductor = 9 /**< see ID3v2 docs */ + ,mpg123_id3_pic_orchestra = 10 /**< see ID3v2 docs */ + ,mpg123_id3_pic_composer = 11 /**< see ID3v2 docs */ + ,mpg123_id3_pic_lyricist = 12 /**< see ID3v2 docs */ + ,mpg123_id3_pic_location = 13 /**< see ID3v2 docs */ + ,mpg123_id3_pic_recording = 14 /**< see ID3v2 docs */ + ,mpg123_id3_pic_performance = 15 /**< see ID3v2 docs */ + ,mpg123_id3_pic_video = 16 /**< see ID3v2 docs */ + ,mpg123_id3_pic_fish = 17 /**< see ID3v2 docs */ + ,mpg123_id3_pic_illustration = 18 /**< see ID3v2 docs */ + ,mpg123_id3_pic_artist_logo = 19 /**< see ID3v2 docs */ + ,mpg123_id3_pic_publisher_logo = 20 /**< see ID3v2 docs */ +}; + +/** Sub data structure for ID3v2, for storing picture data including comment. + * This is for the ID3v2 APIC field. You should consult the ID3v2 specification + * for the use of the APIC field ("frames" in ID3v2 documentation, I use "fields" + * here to separate from MPEG frames). */ +typedef struct +{ + char type; /**< mpg123_id3_pic_type value */ + mpg123_string description; /**< description string */ + mpg123_string mime_type; /**< MIME type */ + size_t size; /**< size in bytes */ + unsigned char* data; /**< pointer to the image data */ +} mpg123_picture; + +/** Data structure for storing IDV3v2 tags. + * This structure is not a direct binary mapping with the file contents. + * The ID3v2 text frames are allowed to contain multiple strings. + * So check for null bytes until you reach the mpg123_string fill. + * All text is encoded in UTF-8. */ +typedef struct +{ + unsigned char version; /**< 3 or 4 for ID3v2.3 or ID3v2.4. */ + mpg123_string *title; /**< Title string (pointer into text_list). */ + mpg123_string *artist; /**< Artist string (pointer into text_list). */ + mpg123_string *album; /**< Album string (pointer into text_list). */ + mpg123_string *year; /**< The year as a string (pointer into text_list). */ + mpg123_string *genre; /**< Genre String (pointer into text_list). The genre string(s) may very well need postprocessing, esp. for ID3v2.3. */ + mpg123_string *comment; /**< Pointer to last encountered comment text with empty description. */ + /* Encountered ID3v2 fields are appended to these lists. + There can be multiple occurences, the pointers above always point to the last encountered data. */ + mpg123_text *comment_list; /**< Array of comments. */ + size_t comments; /**< Number of comments. */ + mpg123_text *text; /**< Array of ID3v2 text fields (including USLT) */ + size_t texts; /**< Numer of text fields. */ + mpg123_text *extra; /**< The array of extra (TXXX) fields. */ + size_t extras; /**< Number of extra text (TXXX) fields. */ + mpg123_picture *picture; /**< Array of ID3v2 pictures fields (APIC). */ + size_t pictures; /**< Number of picture (APIC) fields. */ +} mpg123_id3v2; + +/** Data structure for ID3v1 tags (the last 128 bytes of a file). + * Don't take anything for granted (like string termination)! + * Also note the change ID3v1.1 did: comment[28] = 0; comment[29] = track_number + * It is your task to support ID3v1 only or ID3v1.1 ...*/ +typedef struct +{ + char tag[3]; /**< Always the string "TAG", the classic intro. */ + char title[30]; /**< Title string. */ + char artist[30]; /**< Artist string. */ + char album[30]; /**< Album string. */ + char year[4]; /**< Year string. */ + char comment[30]; /**< Comment string. */ + unsigned char genre; /**< Genre index. */ +} mpg123_id3v1; + +#define MPG123_ID3 0x3 /**< 0011 There is some ID3 info. Also matches 0010 or NEW_ID3. */ +#define MPG123_NEW_ID3 0x1 /**< 0001 There is ID3 info that changed since last call to mpg123_id3. */ +#define MPG123_ICY 0xc /**< 1100 There is some ICY info. Also matches 0100 or NEW_ICY.*/ +#define MPG123_NEW_ICY 0x4 /**< 0100 There is ICY info that changed since last call to mpg123_icy. */ + +/** Query if there is (new) meta info, be it ID3 or ICY (or something new in future). + * \param mh handle + * \return combination of flags, 0 on error (same as "nothing new") + */ +MPG123_EXPORT int mpg123_meta_check(mpg123_handle *mh); + +/** Clean up meta data storage (ID3v2 and ICY), freeing memory. + * \param mh handle + */ +MPG123_EXPORT void mpg123_meta_free(mpg123_handle *mh); + +/** Point v1 and v2 to existing data structures wich may change on any next read/decode function call. + * v1 and/or v2 can be set to NULL when there is no corresponding data. + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_id3( mpg123_handle *mh +, mpg123_id3v1 **v1, mpg123_id3v2 **v2 ); + +/** Point icy_meta to existing data structure wich may change on any next read/decode function call. + * \param mh handle + * \param icy_meta return address for ICY meta string (set to NULL if nothing there) + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_icy(mpg123_handle *mh, char **icy_meta); + +/** Decode from windows-1252 (the encoding ICY metainfo used) to UTF-8. + * Note that this is very similar to mpg123_store_utf8(&sb, mpg123_text_icy, icy_text, strlen(icy_text+1)) . + * \param icy_text The input data in ICY encoding + * \return pointer to newly allocated buffer with UTF-8 data (You free() it!) */ +MPG123_EXPORT char* mpg123_icy2utf8(const char* icy_text); + + +/* @} */ + + +/** \defgroup mpg123_advpar mpg123 advanced parameter API + * + * Direct access to a parameter set without full handle around it. + * Possible uses: + * - Influence behaviour of library _during_ initialization of handle (MPG123_VERBOSE). + * - Use one set of parameters for multiple handles. + * + * The functions for handling mpg123_pars (mpg123_par() and mpg123_fmt() + * family) directly return a fully qualified mpg123 error code, the ones + * operating on full handles normally MPG123_OK or MPG123_ERR, storing the + * specific error code itseld inside the handle. + * + * @{ + */ + +/** Opaque structure for the libmpg123 decoder parameters. */ +struct mpg123_pars_struct; + +/** Opaque structure for the libmpg123 decoder parameters. */ +typedef struct mpg123_pars_struct mpg123_pars; + +/** Create a handle with preset parameters. + * \param mp parameter handle + * \param decoder decoder choice + * \param error error code return address + * \return mpg123 handle + */ +MPG123_EXPORT mpg123_handle *mpg123_parnew( mpg123_pars *mp +, const char* decoder, int *error ); + +/** Allocate memory for and return a pointer to a new mpg123_pars + * \param error error code return address + * \return new parameter handle + */ +MPG123_EXPORT mpg123_pars *mpg123_new_pars(int *error); + +/** Delete and free up memory used by a mpg123_pars data structure + * \param mp parameter handle + */ +MPG123_EXPORT void mpg123_delete_pars(mpg123_pars* mp); + +/** Configure mpg123 parameters to accept no output format at all, + * use before specifying supported formats with mpg123_format + * \param mp parameter handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_fmt_none(mpg123_pars *mp); + +/** Configure mpg123 parameters to accept all formats + * (also any custom rate you may set) -- this is default. + * \param mp parameter handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_fmt_all(mpg123_pars *mp); + +/** Set the audio format support of a mpg123_pars in detail: + * \param mp parameter handle + * \param rate The sample rate value (in Hertz). + * \param channels A combination of MPG123_STEREO and MPG123_MONO. + * \param encodings A combination of accepted encodings for rate and channels, + * p.ex MPG123_ENC_SIGNED16|MPG123_ENC_ULAW_8 (or 0 for no + * support). + * \return MPG123_OK on success +*/ +MPG123_EXPORT int mpg123_fmt(mpg123_pars *mp +, long rate, int channels, int encodings); + +/** Check to see if a specific format at a specific rate is supported + * by mpg123_pars. + * \param mp parameter handle + * \param rate sampling rate + * \param encoding encoding + * \return 0 for no support (that includes invalid parameters), MPG123_STEREO, + * MPG123_MONO or MPG123_STEREO|MPG123_MONO. */ +MPG123_EXPORT int mpg123_fmt_support(mpg123_pars *mp, long rate, int encoding); + +/** Set a specific parameter, for a specific mpg123_pars, using a parameter + * type key chosen from the mpg123_parms enumeration, to the specified value. + * \param mp parameter handle + * \param type parameter choice + * \param value integer value + * \param fvalue floating point value + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_par( mpg123_pars *mp +, enum mpg123_parms type, long value, double fvalue ); + +/** Get a specific parameter, for a specific mpg123_pars. + * See the mpg123_parms enumeration for a list of available parameters. + * \param mp parameter handle + * \param type parameter choice + * \param value integer value return address + * \param fvalue floating point value return address + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_getpar( mpg123_pars *mp +, enum mpg123_parms type, long *value, double *fvalue); + +/* @} */ + + +/** \defgroup mpg123_lowio mpg123 low level I/O + * You may want to do tricky stuff with I/O that does not work with mpg123's default file access or you want to make it decode into your own pocket... + * + * @{ */ + +/** Replace default internal buffer with user-supplied buffer. + * Instead of working on it's own private buffer, mpg123 will directly use the one you provide for storing decoded audio. + * Note that the required buffer size could be bigger than expected from output + * encoding if libmpg123 has to convert from primary decoder output (p.ex. 32 bit + * storage for 24 bit output). + * \param mh handle + * \param data pointer to user buffer + * \param size of buffer in bytes + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_replace_buffer(mpg123_handle *mh +, unsigned char *data, size_t size); + +/** The max size of one frame's decoded output with current settings. + * Use that to determine an appropriate minimum buffer size for decoding one frame. + * \param mh handle + * \return maximum decoded data size in bytes + */ +MPG123_EXPORT size_t mpg123_outblock(mpg123_handle *mh); + +/** Replace low-level stream access functions; read and lseek as known in POSIX. + * You can use this to make any fancy file opening/closing yourself, + * using mpg123_open_fd() to set the file descriptor for your read/lseek + * (doesn't need to be a "real" file descriptor...). + * Setting a function to NULL means that the default internal read is + * used (active from next mpg123_open call on). + * Note: As it would be troublesome to mess with this while having a file open, + * this implies mpg123_close(). + * \param mh handle + * \param r_read callback for reading (behaviour like POSIX read) + * \param r_lseek callback for seeking (like POSIX lseek) + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_replace_reader( mpg123_handle *mh +, ssize_t (*r_read) (int, void *, size_t) +, off_t (*r_lseek)(int, off_t, int) +); + +/** Replace I/O functions with your own ones operating on some kind of + * handle instead of integer descriptors. + * The handle is a void pointer, so you can pass any data you want... + * mpg123_open_handle() is the call you make to use the I/O defined here. + * There is no fallback to internal read/seek here. + * Note: As it would be troublesome to mess with this while having a file open, + * this mpg123_close() is implied here. + * \param mh handle + * \param r_read callback for reading (behaviour like POSIX read) + * \param r_lseek callback for seeking (like POSIX lseek) + * \param cleanup A callback to clean up an I/O handle on mpg123_close, + * can be NULL for none (you take care of cleaning your handles). + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_replace_reader_handle( mpg123_handle *mh +, ssize_t (*r_read) (void *, void *, size_t) +, off_t (*r_lseek)(void *, off_t, int) +, void (*cleanup)(void*) ); + +/* @} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libs/include/ogg/config_types.h b/libs/include/ogg/config_types.h new file mode 100644 index 0000000..1a87df6 --- /dev/null +++ b/libs/include/ogg/config_types.h @@ -0,0 +1,26 @@ +#ifndef __CONFIG_TYPES_H__ +#define __CONFIG_TYPES_H__ + +/* these are filled in by configure or cmake*/ +#define INCLUDE_INTTYPES_H 1 +#define INCLUDE_STDINT_H 1 +#define INCLUDE_SYS_TYPES_H 1 + +#if INCLUDE_INTTYPES_H +# include +#endif +#if INCLUDE_STDINT_H +# include +#endif +#if INCLUDE_SYS_TYPES_H +# include +#endif + +typedef int16_t ogg_int16_t; +typedef uint16_t ogg_uint16_t; +typedef int32_t ogg_int32_t; +typedef uint32_t ogg_uint32_t; +typedef int64_t ogg_int64_t; +typedef uint64_t ogg_uint64_t; + +#endif diff --git a/libs/include/ogg/ogg.h b/libs/include/ogg/ogg.h new file mode 100644 index 0000000..c4325aa --- /dev/null +++ b/libs/include/ogg/ogg.h @@ -0,0 +1,209 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 * + * by the Xiph.Org Foundation http://www.xiph.org/ * + * * + ******************************************************************** + + function: toplevel libogg include + + ********************************************************************/ +#ifndef _OGG_H +#define _OGG_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +typedef struct { + void *iov_base; + size_t iov_len; +} ogg_iovec_t; + +typedef struct { + long endbyte; + int endbit; + + unsigned char *buffer; + unsigned char *ptr; + long storage; +} oggpack_buffer; + +/* ogg_page is used to encapsulate the data in one Ogg bitstream page *****/ + +typedef struct { + unsigned char *header; + long header_len; + unsigned char *body; + long body_len; +} ogg_page; + +/* ogg_stream_state contains the current encode/decode state of a logical + Ogg bitstream **********************************************************/ + +typedef struct { + unsigned char *body_data; /* bytes from packet bodies */ + long body_storage; /* storage elements allocated */ + long body_fill; /* elements stored; fill mark */ + long body_returned; /* elements of fill returned */ + + + int *lacing_vals; /* The values that will go to the segment table */ + ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact + this way, but it is simple coupled to the + lacing fifo */ + long lacing_storage; + long lacing_fill; + long lacing_packet; + long lacing_returned; + + unsigned char header[282]; /* working space for header encode */ + int header_fill; + + int e_o_s; /* set when we have buffered the last packet in the + logical bitstream */ + int b_o_s; /* set after we've written the initial page + of a logical bitstream */ + long serialno; + long pageno; + ogg_int64_t packetno; /* sequence number for decode; the framing + knows where there's a hole in the data, + but we need coupling so that the codec + (which is in a separate abstraction + layer) also knows about the gap */ + ogg_int64_t granulepos; + +} ogg_stream_state; + +/* ogg_packet is used to encapsulate the data and metadata belonging + to a single raw Ogg/Vorbis packet *************************************/ + +typedef struct { + unsigned char *packet; + long bytes; + long b_o_s; + long e_o_s; + + ogg_int64_t granulepos; + + ogg_int64_t packetno; /* sequence number for decode; the framing + knows where there's a hole in the data, + but we need coupling so that the codec + (which is in a separate abstraction + layer) also knows about the gap */ +} ogg_packet; + +typedef struct { + unsigned char *data; + int storage; + int fill; + int returned; + + int unsynced; + int headerbytes; + int bodybytes; +} ogg_sync_state; + +/* Ogg BITSTREAM PRIMITIVES: bitstream ************************/ + +extern void oggpack_writeinit(oggpack_buffer *b); +extern int oggpack_writecheck(oggpack_buffer *b); +extern void oggpack_writetrunc(oggpack_buffer *b,long bits); +extern void oggpack_writealign(oggpack_buffer *b); +extern void oggpack_writecopy(oggpack_buffer *b,void *source,long bits); +extern void oggpack_reset(oggpack_buffer *b); +extern void oggpack_writeclear(oggpack_buffer *b); +extern void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes); +extern void oggpack_write(oggpack_buffer *b,unsigned long value,int bits); +extern long oggpack_look(oggpack_buffer *b,int bits); +extern long oggpack_look1(oggpack_buffer *b); +extern void oggpack_adv(oggpack_buffer *b,int bits); +extern void oggpack_adv1(oggpack_buffer *b); +extern long oggpack_read(oggpack_buffer *b,int bits); +extern long oggpack_read1(oggpack_buffer *b); +extern long oggpack_bytes(oggpack_buffer *b); +extern long oggpack_bits(oggpack_buffer *b); +extern unsigned char *oggpack_get_buffer(oggpack_buffer *b); + +extern void oggpackB_writeinit(oggpack_buffer *b); +extern int oggpackB_writecheck(oggpack_buffer *b); +extern void oggpackB_writetrunc(oggpack_buffer *b,long bits); +extern void oggpackB_writealign(oggpack_buffer *b); +extern void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits); +extern void oggpackB_reset(oggpack_buffer *b); +extern void oggpackB_writeclear(oggpack_buffer *b); +extern void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes); +extern void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits); +extern long oggpackB_look(oggpack_buffer *b,int bits); +extern long oggpackB_look1(oggpack_buffer *b); +extern void oggpackB_adv(oggpack_buffer *b,int bits); +extern void oggpackB_adv1(oggpack_buffer *b); +extern long oggpackB_read(oggpack_buffer *b,int bits); +extern long oggpackB_read1(oggpack_buffer *b); +extern long oggpackB_bytes(oggpack_buffer *b); +extern long oggpackB_bits(oggpack_buffer *b); +extern unsigned char *oggpackB_get_buffer(oggpack_buffer *b); + +/* Ogg BITSTREAM PRIMITIVES: encoding **************************/ + +extern int ogg_stream_packetin(ogg_stream_state *os, ogg_packet *op); +extern int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov, + int count, long e_o_s, ogg_int64_t granulepos); +extern int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og); +extern int ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill); +extern int ogg_stream_flush(ogg_stream_state *os, ogg_page *og); +extern int ogg_stream_flush_fill(ogg_stream_state *os, ogg_page *og, int nfill); + +/* Ogg BITSTREAM PRIMITIVES: decoding **************************/ + +extern int ogg_sync_init(ogg_sync_state *oy); +extern int ogg_sync_clear(ogg_sync_state *oy); +extern int ogg_sync_reset(ogg_sync_state *oy); +extern int ogg_sync_destroy(ogg_sync_state *oy); +extern int ogg_sync_check(ogg_sync_state *oy); + +extern char *ogg_sync_buffer(ogg_sync_state *oy, long size); +extern int ogg_sync_wrote(ogg_sync_state *oy, long bytes); +extern long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og); +extern int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og); +extern int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og); +extern int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op); +extern int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op); + +/* Ogg BITSTREAM PRIMITIVES: general ***************************/ + +extern int ogg_stream_init(ogg_stream_state *os,int serialno); +extern int ogg_stream_clear(ogg_stream_state *os); +extern int ogg_stream_reset(ogg_stream_state *os); +extern int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno); +extern int ogg_stream_destroy(ogg_stream_state *os); +extern int ogg_stream_check(ogg_stream_state *os); +extern int ogg_stream_eos(ogg_stream_state *os); + +extern void ogg_page_checksum_set(ogg_page *og); + +extern int ogg_page_version(const ogg_page *og); +extern int ogg_page_continued(const ogg_page *og); +extern int ogg_page_bos(const ogg_page *og); +extern int ogg_page_eos(const ogg_page *og); +extern ogg_int64_t ogg_page_granulepos(const ogg_page *og); +extern int ogg_page_serialno(const ogg_page *og); +extern long ogg_page_pageno(const ogg_page *og); +extern int ogg_page_packets(const ogg_page *og); + +extern void ogg_packet_clear(ogg_packet *op); + + +#ifdef __cplusplus +} +#endif + +#endif /* _OGG_H */ diff --git a/libs/include/ogg/os_types.h b/libs/include/ogg/os_types.h new file mode 100644 index 0000000..eb8a322 --- /dev/null +++ b/libs/include/ogg/os_types.h @@ -0,0 +1,158 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002 * + * by the Xiph.Org Foundation http://www.xiph.org/ * + * * + ******************************************************************** + + function: Define a consistent set of types on each platform. + + ********************************************************************/ +#ifndef _OS_TYPES_H +#define _OS_TYPES_H + +/* make it easy on the folks that want to compile the libs with a + different malloc than stdlib */ +#define _ogg_malloc malloc +#define _ogg_calloc calloc +#define _ogg_realloc realloc +#define _ogg_free free + +#if defined(_WIN32) + +# if defined(__CYGWIN__) +# include + typedef int16_t ogg_int16_t; + typedef uint16_t ogg_uint16_t; + typedef int32_t ogg_int32_t; + typedef uint32_t ogg_uint32_t; + typedef int64_t ogg_int64_t; + typedef uint64_t ogg_uint64_t; +# elif defined(__MINGW32__) +# include + typedef short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long ogg_int64_t; + typedef unsigned long long ogg_uint64_t; +# elif defined(__MWERKS__) + typedef long long ogg_int64_t; + typedef unsigned long long ogg_uint64_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef short ogg_int16_t; + typedef unsigned short ogg_uint16_t; +# else +# if defined(_MSC_VER) && (_MSC_VER >= 1800) /* MSVC 2013 and newer */ +# include + typedef int16_t ogg_int16_t; + typedef uint16_t ogg_uint16_t; + typedef int32_t ogg_int32_t; + typedef uint32_t ogg_uint32_t; + typedef int64_t ogg_int64_t; + typedef uint64_t ogg_uint64_t; +# else + /* MSVC/Borland */ + typedef __int64 ogg_int64_t; + typedef __int32 ogg_int32_t; + typedef unsigned __int32 ogg_uint32_t; + typedef unsigned __int64 ogg_uint64_t; + typedef __int16 ogg_int16_t; + typedef unsigned __int16 ogg_uint16_t; +# endif +# endif + +#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */ + +# include + typedef int16_t ogg_int16_t; + typedef uint16_t ogg_uint16_t; + typedef int32_t ogg_int32_t; + typedef uint32_t ogg_uint32_t; + typedef int64_t ogg_int64_t; + typedef uint64_t ogg_uint64_t; + +#elif defined(__HAIKU__) + + /* Haiku */ +# include + typedef short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long ogg_int64_t; + typedef unsigned long long ogg_uint64_t; + +#elif defined(__BEOS__) + + /* Be */ +# include + typedef int16_t ogg_int16_t; + typedef uint16_t ogg_uint16_t; + typedef int32_t ogg_int32_t; + typedef uint32_t ogg_uint32_t; + typedef int64_t ogg_int64_t; + typedef uint64_t ogg_uint64_t; + +#elif defined (__EMX__) + + /* OS/2 GCC */ + typedef short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long ogg_int64_t; + typedef unsigned long long ogg_uint64_t; + + +#elif defined (DJGPP) + + /* DJGPP */ + typedef short ogg_int16_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long ogg_int64_t; + typedef unsigned long long ogg_uint64_t; + +#elif defined(R5900) + + /* PS2 EE */ + typedef long ogg_int64_t; + typedef unsigned long ogg_uint64_t; + typedef int ogg_int32_t; + typedef unsigned ogg_uint32_t; + typedef short ogg_int16_t; + +#elif defined(__SYMBIAN32__) + + /* Symbian GCC */ + typedef signed short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef signed int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long int ogg_int64_t; + typedef unsigned long long int ogg_uint64_t; + +#elif defined(__TMS320C6X__) + + /* TI C64x compiler */ + typedef signed short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef signed int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long int ogg_int64_t; + typedef unsigned long long int ogg_uint64_t; + +#else + +# include + +#endif + +#endif /* _OS_TYPES_H */ diff --git a/libs/include/opus/opus.h b/libs/include/opus/opus.h new file mode 100644 index 0000000..d282f21 --- /dev/null +++ b/libs/include/opus/opus.h @@ -0,0 +1,981 @@ +/* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited + Written by Jean-Marc Valin and Koen Vos */ +/* + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/** + * @file opus.h + * @brief Opus reference implementation API + */ + +#ifndef OPUS_H +#define OPUS_H + +#include "opus_types.h" +#include "opus_defines.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @mainpage Opus + * + * The Opus codec is designed for interactive speech and audio transmission over the Internet. + * It is designed by the IETF Codec Working Group and incorporates technology from + * Skype's SILK codec and Xiph.Org's CELT codec. + * + * The Opus codec is designed to handle a wide range of interactive audio applications, + * including Voice over IP, videoconferencing, in-game chat, and even remote live music + * performances. It can scale from low bit-rate narrowband speech to very high quality + * stereo music. Its main features are: + + * @li Sampling rates from 8 to 48 kHz + * @li Bit-rates from 6 kb/s to 510 kb/s + * @li Support for both constant bit-rate (CBR) and variable bit-rate (VBR) + * @li Audio bandwidth from narrowband to full-band + * @li Support for speech and music + * @li Support for mono and stereo + * @li Support for multichannel (up to 255 channels) + * @li Frame sizes from 2.5 ms to 60 ms + * @li Good loss robustness and packet loss concealment (PLC) + * @li Floating point and fixed-point implementation + * + * Documentation sections: + * @li @ref opus_encoder + * @li @ref opus_decoder + * @li @ref opus_repacketizer + * @li @ref opus_multistream + * @li @ref opus_libinfo + * @li @ref opus_custom + */ + +/** @defgroup opus_encoder Opus Encoder + * @{ + * + * @brief This page describes the process and functions used to encode Opus. + * + * Since Opus is a stateful codec, the encoding process starts with creating an encoder + * state. This can be done with: + * + * @code + * int error; + * OpusEncoder *enc; + * enc = opus_encoder_create(Fs, channels, application, &error); + * @endcode + * + * From this point, @c enc can be used for encoding an audio stream. An encoder state + * @b must @b not be used for more than one stream at the same time. Similarly, the encoder + * state @b must @b not be re-initialized for each frame. + * + * While opus_encoder_create() allocates memory for the state, it's also possible + * to initialize pre-allocated memory: + * + * @code + * int size; + * int error; + * OpusEncoder *enc; + * size = opus_encoder_get_size(channels); + * enc = malloc(size); + * error = opus_encoder_init(enc, Fs, channels, application); + * @endcode + * + * where opus_encoder_get_size() returns the required size for the encoder state. Note that + * future versions of this code may change the size, so no assuptions should be made about it. + * + * The encoder state is always continuous in memory and only a shallow copy is sufficient + * to copy it (e.g. memcpy()) + * + * It is possible to change some of the encoder's settings using the opus_encoder_ctl() + * interface. All these settings already default to the recommended value, so they should + * only be changed when necessary. The most common settings one may want to change are: + * + * @code + * opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate)); + * opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity)); + * opus_encoder_ctl(enc, OPUS_SET_SIGNAL(signal_type)); + * @endcode + * + * where + * + * @arg bitrate is in bits per second (b/s) + * @arg complexity is a value from 1 to 10, where 1 is the lowest complexity and 10 is the highest + * @arg signal_type is either OPUS_AUTO (default), OPUS_SIGNAL_VOICE, or OPUS_SIGNAL_MUSIC + * + * See @ref opus_encoderctls and @ref opus_genericctls for a complete list of parameters that can be set or queried. Most parameters can be set or changed at any time during a stream. + * + * To encode a frame, opus_encode() or opus_encode_float() must be called with exactly one frame (2.5, 5, 10, 20, 40 or 60 ms) of audio data: + * @code + * len = opus_encode(enc, audio_frame, frame_size, packet, max_packet); + * @endcode + * + * where + *

    + *
  • audio_frame is the audio data in opus_int16 (or float for opus_encode_float())
    • + *
  • frame_size is the duration of the frame in samples (per channel)
    • + *
  • packet is the byte array to which the compressed data is written
    • + *
  • max_packet is the maximum number of bytes that can be written in the packet (4000 bytes is recommended). + * Do not use max_packet to control VBR target bitrate, instead use the #OPUS_SET_BITRATE CTL.
    • + *
+ * + * opus_encode() and opus_encode_float() return the number of bytes actually written to the packet. + * The return value can be negative, which indicates that an error has occurred. If the return value + * is 2 bytes or less, then the packet does not need to be transmitted (DTX). + * + * Once the encoder state if no longer needed, it can be destroyed with + * + * @code + * opus_encoder_destroy(enc); + * @endcode + * + * If the encoder was created with opus_encoder_init() rather than opus_encoder_create(), + * then no action is required aside from potentially freeing the memory that was manually + * allocated for it (calling free(enc) for the example above) + * + */ + +/** Opus encoder state. + * This contains the complete state of an Opus encoder. + * It is position independent and can be freely copied. + * @see opus_encoder_create,opus_encoder_init + */ +typedef struct OpusEncoder OpusEncoder; + +/** Gets the size of an OpusEncoder structure. + * @param[in] channels int: Number of channels. + * This must be 1 or 2. + * @returns The size in bytes. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_encoder_get_size(int channels); + +/** + */ + +/** Allocates and initializes an encoder state. + * There are three coding modes: + * + * @ref OPUS_APPLICATION_VOIP gives best quality at a given bitrate for voice + * signals. It enhances the input signal by high-pass filtering and + * emphasizing formants and harmonics. Optionally it includes in-band + * forward error correction to protect against packet loss. Use this + * mode for typical VoIP applications. Because of the enhancement, + * even at high bitrates the output may sound different from the input. + * + * @ref OPUS_APPLICATION_AUDIO gives best quality at a given bitrate for most + * non-voice signals like music. Use this mode for music and mixed + * (music/voice) content, broadcast, and applications requiring less + * than 15 ms of coding delay. + * + * @ref OPUS_APPLICATION_RESTRICTED_LOWDELAY configures low-delay mode that + * disables the speech-optimized mode in exchange for slightly reduced delay. + * This mode can only be set on an newly initialized or freshly reset encoder + * because it changes the codec delay. + * + * This is useful when the caller knows that the speech-optimized modes will not be needed (use with caution). + * @param [in] Fs opus_int32: Sampling rate of input signal (Hz) + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param [in] channels int: Number of channels (1 or 2) in input signal + * @param [in] application int: Coding mode (@ref OPUS_APPLICATION_VOIP/@ref OPUS_APPLICATION_AUDIO/@ref OPUS_APPLICATION_RESTRICTED_LOWDELAY) + * @param [out] error int*: @ref opus_errorcodes + * @note Regardless of the sampling rate and number channels selected, the Opus encoder + * can switch to a lower audio bandwidth or number of channels if the bitrate + * selected is too low. This also means that it is safe to always use 48 kHz stereo input + * and let the encoder optimize the encoding. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusEncoder *opus_encoder_create( + opus_int32 Fs, + int channels, + int application, + int *error +); + +/** Initializes a previously allocated encoder state + * The memory pointed to by st must be at least the size returned by opus_encoder_get_size(). + * This is intended for applications which use their own allocator instead of malloc. + * @see opus_encoder_create(),opus_encoder_get_size() + * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL. + * @param [in] st OpusEncoder*: Encoder state + * @param [in] Fs opus_int32: Sampling rate of input signal (Hz) + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param [in] channels int: Number of channels (1 or 2) in input signal + * @param [in] application int: Coding mode (OPUS_APPLICATION_VOIP/OPUS_APPLICATION_AUDIO/OPUS_APPLICATION_RESTRICTED_LOWDELAY) + * @retval #OPUS_OK Success or @ref opus_errorcodes + */ +OPUS_EXPORT int opus_encoder_init( + OpusEncoder *st, + opus_int32 Fs, + int channels, + int application +) OPUS_ARG_NONNULL(1); + +/** Encodes an Opus frame. + * @param [in] st OpusEncoder*: Encoder state + * @param [in] pcm opus_int16*: Input signal (interleaved if 2 channels). length is frame_size*channels*sizeof(opus_int16) + * @param [in] frame_size int: Number of samples per channel in the + * input signal. + * This must be an Opus frame size for + * the encoder's sampling rate. + * For example, at 48 kHz the permitted + * values are 120, 240, 480, 960, 1920, + * and 2880. + * Passing in a duration of less than + * 10 ms (480 samples at 48 kHz) will + * prevent the encoder from using the LPC + * or hybrid modes. + * @param [out] data unsigned char*: Output payload. + * This must contain storage for at + * least \a max_data_bytes. + * @param [in] max_data_bytes opus_int32: Size of the allocated + * memory for the output + * payload. This may be + * used to impose an upper limit on + * the instant bitrate, but should + * not be used as the only bitrate + * control. Use #OPUS_SET_BITRATE to + * control the bitrate. + * @returns The length of the encoded packet (in bytes) on success or a + * negative error code (see @ref opus_errorcodes) on failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_encode( + OpusEncoder *st, + const opus_int16 *pcm, + int frame_size, + unsigned char *data, + opus_int32 max_data_bytes +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4); + +/** Encodes an Opus frame from floating point input. + * @param [in] st OpusEncoder*: Encoder state + * @param [in] pcm float*: Input in float format (interleaved if 2 channels), with a normal range of +/-1.0. + * Samples with a range beyond +/-1.0 are supported but will + * be clipped by decoders using the integer API and should + * only be used if it is known that the far end supports + * extended dynamic range. + * length is frame_size*channels*sizeof(float) + * @param [in] frame_size int: Number of samples per channel in the + * input signal. + * This must be an Opus frame size for + * the encoder's sampling rate. + * For example, at 48 kHz the permitted + * values are 120, 240, 480, 960, 1920, + * and 2880. + * Passing in a duration of less than + * 10 ms (480 samples at 48 kHz) will + * prevent the encoder from using the LPC + * or hybrid modes. + * @param [out] data unsigned char*: Output payload. + * This must contain storage for at + * least \a max_data_bytes. + * @param [in] max_data_bytes opus_int32: Size of the allocated + * memory for the output + * payload. This may be + * used to impose an upper limit on + * the instant bitrate, but should + * not be used as the only bitrate + * control. Use #OPUS_SET_BITRATE to + * control the bitrate. + * @returns The length of the encoded packet (in bytes) on success or a + * negative error code (see @ref opus_errorcodes) on failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_encode_float( + OpusEncoder *st, + const float *pcm, + int frame_size, + unsigned char *data, + opus_int32 max_data_bytes +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4); + +/** Frees an OpusEncoder allocated by opus_encoder_create(). + * @param[in] st OpusEncoder*: State to be freed. + */ +OPUS_EXPORT void opus_encoder_destroy(OpusEncoder *st); + +/** Perform a CTL function on an Opus encoder. + * + * Generally the request and subsequent arguments are generated + * by a convenience macro. + * @param st OpusEncoder*: Encoder state. + * @param request This and all remaining parameters should be replaced by one + * of the convenience macros in @ref opus_genericctls or + * @ref opus_encoderctls. + * @see opus_genericctls + * @see opus_encoderctls + */ +OPUS_EXPORT int opus_encoder_ctl(OpusEncoder *st, int request, ...) OPUS_ARG_NONNULL(1); +/**@}*/ + +/** @defgroup opus_decoder Opus Decoder + * @{ + * + * @brief This page describes the process and functions used to decode Opus. + * + * The decoding process also starts with creating a decoder + * state. This can be done with: + * @code + * int error; + * OpusDecoder *dec; + * dec = opus_decoder_create(Fs, channels, &error); + * @endcode + * where + * @li Fs is the sampling rate and must be 8000, 12000, 16000, 24000, or 48000 + * @li channels is the number of channels (1 or 2) + * @li error will hold the error code in case of failure (or #OPUS_OK on success) + * @li the return value is a newly created decoder state to be used for decoding + * + * While opus_decoder_create() allocates memory for the state, it's also possible + * to initialize pre-allocated memory: + * @code + * int size; + * int error; + * OpusDecoder *dec; + * size = opus_decoder_get_size(channels); + * dec = malloc(size); + * error = opus_decoder_init(dec, Fs, channels); + * @endcode + * where opus_decoder_get_size() returns the required size for the decoder state. Note that + * future versions of this code may change the size, so no assuptions should be made about it. + * + * The decoder state is always continuous in memory and only a shallow copy is sufficient + * to copy it (e.g. memcpy()) + * + * To decode a frame, opus_decode() or opus_decode_float() must be called with a packet of compressed audio data: + * @code + * frame_size = opus_decode(dec, packet, len, decoded, max_size, 0); + * @endcode + * where + * + * @li packet is the byte array containing the compressed data + * @li len is the exact number of bytes contained in the packet + * @li decoded is the decoded audio data in opus_int16 (or float for opus_decode_float()) + * @li max_size is the max duration of the frame in samples (per channel) that can fit into the decoded_frame array + * + * opus_decode() and opus_decode_float() return the number of samples (per channel) decoded from the packet. + * If that value is negative, then an error has occurred. This can occur if the packet is corrupted or if the audio + * buffer is too small to hold the decoded audio. + * + * Opus is a stateful codec with overlapping blocks and as a result Opus + * packets are not coded independently of each other. Packets must be + * passed into the decoder serially and in the correct order for a correct + * decode. Lost packets can be replaced with loss concealment by calling + * the decoder with a null pointer and zero length for the missing packet. + * + * A single codec state may only be accessed from a single thread at + * a time and any required locking must be performed by the caller. Separate + * streams must be decoded with separate decoder states and can be decoded + * in parallel unless the library was compiled with NONTHREADSAFE_PSEUDOSTACK + * defined. + * + */ + +/** Opus decoder state. + * This contains the complete state of an Opus decoder. + * It is position independent and can be freely copied. + * @see opus_decoder_create,opus_decoder_init + */ +typedef struct OpusDecoder OpusDecoder; + +/** Gets the size of an OpusDecoder structure. + * @param [in] channels int: Number of channels. + * This must be 1 or 2. + * @returns The size in bytes. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decoder_get_size(int channels); + +/** Allocates and initializes a decoder state. + * @param [in] Fs opus_int32: Sample rate to decode at (Hz). + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param [in] channels int: Number of channels (1 or 2) to decode + * @param [out] error int*: #OPUS_OK Success or @ref opus_errorcodes + * + * Internally Opus stores data at 48000 Hz, so that should be the default + * value for Fs. However, the decoder can efficiently decode to buffers + * at 8, 12, 16, and 24 kHz so if for some reason the caller cannot use + * data at the full sample rate, or knows the compressed data doesn't + * use the full frequency range, it can request decoding at a reduced + * rate. Likewise, the decoder is capable of filling in either mono or + * interleaved stereo pcm buffers, at the caller's request. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusDecoder *opus_decoder_create( + opus_int32 Fs, + int channels, + int *error +); + +/** Initializes a previously allocated decoder state. + * The state must be at least the size returned by opus_decoder_get_size(). + * This is intended for applications which use their own allocator instead of malloc. @see opus_decoder_create,opus_decoder_get_size + * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL. + * @param [in] st OpusDecoder*: Decoder state. + * @param [in] Fs opus_int32: Sampling rate to decode to (Hz). + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param [in] channels int: Number of channels (1 or 2) to decode + * @retval #OPUS_OK Success or @ref opus_errorcodes + */ +OPUS_EXPORT int opus_decoder_init( + OpusDecoder *st, + opus_int32 Fs, + int channels +) OPUS_ARG_NONNULL(1); + +/** Decode an Opus packet. + * @param [in] st OpusDecoder*: Decoder state + * @param [in] data char*: Input payload. Use a NULL pointer to indicate packet loss + * @param [in] len opus_int32: Number of bytes in payload* + * @param [out] pcm opus_int16*: Output signal (interleaved if 2 channels). length + * is frame_size*channels*sizeof(opus_int16) + * @param [in] frame_size Number of samples per channel of available space in \a pcm. + * If this is less than the maximum packet duration (120ms; 5760 for 48kHz), this function will + * not be capable of decoding some packets. In the case of PLC (data==NULL) or FEC (decode_fec=1), + * then frame_size needs to be exactly the duration of audio that is missing, otherwise the + * decoder will not be in the optimal state to decode the next incoming packet. For the PLC and + * FEC cases, frame_size must be a multiple of 2.5 ms. + * @param [in] decode_fec int: Flag (0 or 1) to request that any in-band forward error correction data be + * decoded. If no such data is available, the frame is decoded as if it were lost. + * @returns Number of decoded samples or @ref opus_errorcodes + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decode( + OpusDecoder *st, + const unsigned char *data, + opus_int32 len, + opus_int16 *pcm, + int frame_size, + int decode_fec +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4); + +/** Decode an Opus packet with floating point output. + * @param [in] st OpusDecoder*: Decoder state + * @param [in] data char*: Input payload. Use a NULL pointer to indicate packet loss + * @param [in] len opus_int32: Number of bytes in payload + * @param [out] pcm float*: Output signal (interleaved if 2 channels). length + * is frame_size*channels*sizeof(float) + * @param [in] frame_size Number of samples per channel of available space in \a pcm. + * If this is less than the maximum packet duration (120ms; 5760 for 48kHz), this function will + * not be capable of decoding some packets. In the case of PLC (data==NULL) or FEC (decode_fec=1), + * then frame_size needs to be exactly the duration of audio that is missing, otherwise the + * decoder will not be in the optimal state to decode the next incoming packet. For the PLC and + * FEC cases, frame_size must be a multiple of 2.5 ms. + * @param [in] decode_fec int: Flag (0 or 1) to request that any in-band forward error correction data be + * decoded. If no such data is available the frame is decoded as if it were lost. + * @returns Number of decoded samples or @ref opus_errorcodes + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decode_float( + OpusDecoder *st, + const unsigned char *data, + opus_int32 len, + float *pcm, + int frame_size, + int decode_fec +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4); + +/** Perform a CTL function on an Opus decoder. + * + * Generally the request and subsequent arguments are generated + * by a convenience macro. + * @param st OpusDecoder*: Decoder state. + * @param request This and all remaining parameters should be replaced by one + * of the convenience macros in @ref opus_genericctls or + * @ref opus_decoderctls. + * @see opus_genericctls + * @see opus_decoderctls + */ +OPUS_EXPORT int opus_decoder_ctl(OpusDecoder *st, int request, ...) OPUS_ARG_NONNULL(1); + +/** Frees an OpusDecoder allocated by opus_decoder_create(). + * @param[in] st OpusDecoder*: State to be freed. + */ +OPUS_EXPORT void opus_decoder_destroy(OpusDecoder *st); + +/** Parse an opus packet into one or more frames. + * Opus_decode will perform this operation internally so most applications do + * not need to use this function. + * This function does not copy the frames, the returned pointers are pointers into + * the input packet. + * @param [in] data char*: Opus packet to be parsed + * @param [in] len opus_int32: size of data + * @param [out] out_toc char*: TOC pointer + * @param [out] frames char*[48] encapsulated frames + * @param [out] size opus_int16[48] sizes of the encapsulated frames + * @param [out] payload_offset int*: returns the position of the payload within the packet (in bytes) + * @returns number of frames + */ +OPUS_EXPORT int opus_packet_parse( + const unsigned char *data, + opus_int32 len, + unsigned char *out_toc, + const unsigned char *frames[48], + opus_int16 size[48], + int *payload_offset +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(5); + +/** Gets the bandwidth of an Opus packet. + * @param [in] data char*: Opus packet + * @retval OPUS_BANDWIDTH_NARROWBAND Narrowband (4kHz bandpass) + * @retval OPUS_BANDWIDTH_MEDIUMBAND Mediumband (6kHz bandpass) + * @retval OPUS_BANDWIDTH_WIDEBAND Wideband (8kHz bandpass) + * @retval OPUS_BANDWIDTH_SUPERWIDEBAND Superwideband (12kHz bandpass) + * @retval OPUS_BANDWIDTH_FULLBAND Fullband (20kHz bandpass) + * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_bandwidth(const unsigned char *data) OPUS_ARG_NONNULL(1); + +/** Gets the number of samples per frame from an Opus packet. + * @param [in] data char*: Opus packet. + * This must contain at least one byte of + * data. + * @param [in] Fs opus_int32: Sampling rate in Hz. + * This must be a multiple of 400, or + * inaccurate results will be returned. + * @returns Number of samples per frame. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs) OPUS_ARG_NONNULL(1); + +/** Gets the number of channels from an Opus packet. + * @param [in] data char*: Opus packet + * @returns Number of channels + * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_channels(const unsigned char *data) OPUS_ARG_NONNULL(1); + +/** Gets the number of frames in an Opus packet. + * @param [in] packet char*: Opus packet + * @param [in] len opus_int32: Length of packet + * @returns Number of frames + * @retval OPUS_BAD_ARG Insufficient data was passed to the function + * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len) OPUS_ARG_NONNULL(1); + +/** Gets the number of samples of an Opus packet. + * @param [in] packet char*: Opus packet + * @param [in] len opus_int32: Length of packet + * @param [in] Fs opus_int32: Sampling rate in Hz. + * This must be a multiple of 400, or + * inaccurate results will be returned. + * @returns Number of samples + * @retval OPUS_BAD_ARG Insufficient data was passed to the function + * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len, opus_int32 Fs) OPUS_ARG_NONNULL(1); + +/** Gets the number of samples of an Opus packet. + * @param [in] dec OpusDecoder*: Decoder state + * @param [in] packet char*: Opus packet + * @param [in] len opus_int32: Length of packet + * @returns Number of samples + * @retval OPUS_BAD_ARG Insufficient data was passed to the function + * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], opus_int32 len) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2); + +/** Applies soft-clipping to bring a float signal within the [-1,1] range. If + * the signal is already in that range, nothing is done. If there are values + * outside of [-1,1], then the signal is clipped as smoothly as possible to + * both fit in the range and avoid creating excessive distortion in the + * process. + * @param [in,out] pcm float*: Input PCM and modified PCM + * @param [in] frame_size int Number of samples per channel to process + * @param [in] channels int: Number of channels + * @param [in,out] softclip_mem float*: State memory for the soft clipping process (one float per channel, initialized to zero) + */ +OPUS_EXPORT void opus_pcm_soft_clip(float *pcm, int frame_size, int channels, float *softclip_mem); + + +/**@}*/ + +/** @defgroup opus_repacketizer Repacketizer + * @{ + * + * The repacketizer can be used to merge multiple Opus packets into a single + * packet or alternatively to split Opus packets that have previously been + * merged. Splitting valid Opus packets is always guaranteed to succeed, + * whereas merging valid packets only succeeds if all frames have the same + * mode, bandwidth, and frame size, and when the total duration of the merged + * packet is no more than 120 ms. The 120 ms limit comes from the + * specification and limits decoder memory requirements at a point where + * framing overhead becomes negligible. + * + * The repacketizer currently only operates on elementary Opus + * streams. It will not manipualte multistream packets successfully, except in + * the degenerate case where they consist of data from a single stream. + * + * The repacketizing process starts with creating a repacketizer state, either + * by calling opus_repacketizer_create() or by allocating the memory yourself, + * e.g., + * @code + * OpusRepacketizer *rp; + * rp = (OpusRepacketizer*)malloc(opus_repacketizer_get_size()); + * if (rp != NULL) + * opus_repacketizer_init(rp); + * @endcode + * + * Then the application should submit packets with opus_repacketizer_cat(), + * extract new packets with opus_repacketizer_out() or + * opus_repacketizer_out_range(), and then reset the state for the next set of + * input packets via opus_repacketizer_init(). + * + * For example, to split a sequence of packets into individual frames: + * @code + * unsigned char *data; + * int len; + * while (get_next_packet(&data, &len)) + * { + * unsigned char out[1276]; + * opus_int32 out_len; + * int nb_frames; + * int err; + * int i; + * err = opus_repacketizer_cat(rp, data, len); + * if (err != OPUS_OK) + * { + * release_packet(data); + * return err; + * } + * nb_frames = opus_repacketizer_get_nb_frames(rp); + * for (i = 0; i < nb_frames; i++) + * { + * out_len = opus_repacketizer_out_range(rp, i, i+1, out, sizeof(out)); + * if (out_len < 0) + * { + * release_packet(data); + * return (int)out_len; + * } + * output_next_packet(out, out_len); + * } + * opus_repacketizer_init(rp); + * release_packet(data); + * } + * @endcode + * + * Alternatively, to combine a sequence of frames into packets that each + * contain up to TARGET_DURATION_MS milliseconds of data: + * @code + * // The maximum number of packets with duration TARGET_DURATION_MS occurs + * // when the frame size is 2.5 ms, for a total of (TARGET_DURATION_MS*2/5) + * // packets. + * unsigned char *data[(TARGET_DURATION_MS*2/5)+1]; + * opus_int32 len[(TARGET_DURATION_MS*2/5)+1]; + * int nb_packets; + * unsigned char out[1277*(TARGET_DURATION_MS*2/2)]; + * opus_int32 out_len; + * int prev_toc; + * nb_packets = 0; + * while (get_next_packet(data+nb_packets, len+nb_packets)) + * { + * int nb_frames; + * int err; + * nb_frames = opus_packet_get_nb_frames(data[nb_packets], len[nb_packets]); + * if (nb_frames < 1) + * { + * release_packets(data, nb_packets+1); + * return nb_frames; + * } + * nb_frames += opus_repacketizer_get_nb_frames(rp); + * // If adding the next packet would exceed our target, or it has an + * // incompatible TOC sequence, output the packets we already have before + * // submitting it. + * // N.B., The nb_packets > 0 check ensures we've submitted at least one + * // packet since the last call to opus_repacketizer_init(). Otherwise a + * // single packet longer than TARGET_DURATION_MS would cause us to try to + * // output an (invalid) empty packet. It also ensures that prev_toc has + * // been set to a valid value. Additionally, len[nb_packets] > 0 is + * // guaranteed by the call to opus_packet_get_nb_frames() above, so the + * // reference to data[nb_packets][0] should be valid. + * if (nb_packets > 0 && ( + * ((prev_toc & 0xFC) != (data[nb_packets][0] & 0xFC)) || + * opus_packet_get_samples_per_frame(data[nb_packets], 48000)*nb_frames > + * TARGET_DURATION_MS*48)) + * { + * out_len = opus_repacketizer_out(rp, out, sizeof(out)); + * if (out_len < 0) + * { + * release_packets(data, nb_packets+1); + * return (int)out_len; + * } + * output_next_packet(out, out_len); + * opus_repacketizer_init(rp); + * release_packets(data, nb_packets); + * data[0] = data[nb_packets]; + * len[0] = len[nb_packets]; + * nb_packets = 0; + * } + * err = opus_repacketizer_cat(rp, data[nb_packets], len[nb_packets]); + * if (err != OPUS_OK) + * { + * release_packets(data, nb_packets+1); + * return err; + * } + * prev_toc = data[nb_packets][0]; + * nb_packets++; + * } + * // Output the final, partial packet. + * if (nb_packets > 0) + * { + * out_len = opus_repacketizer_out(rp, out, sizeof(out)); + * release_packets(data, nb_packets); + * if (out_len < 0) + * return (int)out_len; + * output_next_packet(out, out_len); + * } + * @endcode + * + * An alternate way of merging packets is to simply call opus_repacketizer_cat() + * unconditionally until it fails. At that point, the merged packet can be + * obtained with opus_repacketizer_out() and the input packet for which + * opus_repacketizer_cat() needs to be re-added to a newly reinitialized + * repacketizer state. + */ + +typedef struct OpusRepacketizer OpusRepacketizer; + +/** Gets the size of an OpusRepacketizer structure. + * @returns The size in bytes. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_size(void); + +/** (Re)initializes a previously allocated repacketizer state. + * The state must be at least the size returned by opus_repacketizer_get_size(). + * This can be used for applications which use their own allocator instead of + * malloc(). + * It must also be called to reset the queue of packets waiting to be + * repacketized, which is necessary if the maximum packet duration of 120 ms + * is reached or if you wish to submit packets with a different Opus + * configuration (coding mode, audio bandwidth, frame size, or channel count). + * Failure to do so will prevent a new packet from being added with + * opus_repacketizer_cat(). + * @see opus_repacketizer_create + * @see opus_repacketizer_get_size + * @see opus_repacketizer_cat + * @param rp OpusRepacketizer*: The repacketizer state to + * (re)initialize. + * @returns A pointer to the same repacketizer state that was passed in. + */ +OPUS_EXPORT OpusRepacketizer *opus_repacketizer_init(OpusRepacketizer *rp) OPUS_ARG_NONNULL(1); + +/** Allocates memory and initializes the new repacketizer with + * opus_repacketizer_init(). + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusRepacketizer *opus_repacketizer_create(void); + +/** Frees an OpusRepacketizer allocated by + * opus_repacketizer_create(). + * @param[in] rp OpusRepacketizer*: State to be freed. + */ +OPUS_EXPORT void opus_repacketizer_destroy(OpusRepacketizer *rp); + +/** Add a packet to the current repacketizer state. + * This packet must match the configuration of any packets already submitted + * for repacketization since the last call to opus_repacketizer_init(). + * This means that it must have the same coding mode, audio bandwidth, frame + * size, and channel count. + * This can be checked in advance by examining the top 6 bits of the first + * byte of the packet, and ensuring they match the top 6 bits of the first + * byte of any previously submitted packet. + * The total duration of audio in the repacketizer state also must not exceed + * 120 ms, the maximum duration of a single packet, after adding this packet. + * + * The contents of the current repacketizer state can be extracted into new + * packets using opus_repacketizer_out() or opus_repacketizer_out_range(). + * + * In order to add a packet with a different configuration or to add more + * audio beyond 120 ms, you must clear the repacketizer state by calling + * opus_repacketizer_init(). + * If a packet is too large to add to the current repacketizer state, no part + * of it is added, even if it contains multiple frames, some of which might + * fit. + * If you wish to be able to add parts of such packets, you should first use + * another repacketizer to split the packet into pieces and add them + * individually. + * @see opus_repacketizer_out_range + * @see opus_repacketizer_out + * @see opus_repacketizer_init + * @param rp OpusRepacketizer*: The repacketizer state to which to + * add the packet. + * @param[in] data const unsigned char*: The packet data. + * The application must ensure + * this pointer remains valid + * until the next call to + * opus_repacketizer_init() or + * opus_repacketizer_destroy(). + * @param len opus_int32: The number of bytes in the packet data. + * @returns An error code indicating whether or not the operation succeeded. + * @retval #OPUS_OK The packet's contents have been added to the repacketizer + * state. + * @retval #OPUS_INVALID_PACKET The packet did not have a valid TOC sequence, + * the packet's TOC sequence was not compatible + * with previously submitted packets (because + * the coding mode, audio bandwidth, frame size, + * or channel count did not match), or adding + * this packet would increase the total amount of + * audio stored in the repacketizer state to more + * than 120 ms. + */ +OPUS_EXPORT int opus_repacketizer_cat(OpusRepacketizer *rp, const unsigned char *data, opus_int32 len) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2); + + +/** Construct a new packet from data previously submitted to the repacketizer + * state via opus_repacketizer_cat(). + * @param rp OpusRepacketizer*: The repacketizer state from which to + * construct the new packet. + * @param begin int: The index of the first frame in the current + * repacketizer state to include in the output. + * @param end int: One past the index of the last frame in the + * current repacketizer state to include in the + * output. + * @param[out] data const unsigned char*: The buffer in which to + * store the output packet. + * @param maxlen opus_int32: The maximum number of bytes to store in + * the output buffer. In order to guarantee + * success, this should be at least + * 1276 for a single frame, + * or for multiple frames, + * 1277*(end-begin). + * However, 1*(end-begin) plus + * the size of all packet data submitted to + * the repacketizer since the last call to + * opus_repacketizer_init() or + * opus_repacketizer_create() is also + * sufficient, and possibly much smaller. + * @returns The total size of the output packet on success, or an error code + * on failure. + * @retval #OPUS_BAD_ARG [begin,end) was an invalid range of + * frames (begin < 0, begin >= end, or end > + * opus_repacketizer_get_nb_frames()). + * @retval #OPUS_BUFFER_TOO_SMALL \a maxlen was insufficient to contain the + * complete output packet. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_repacketizer_out_range(OpusRepacketizer *rp, int begin, int end, unsigned char *data, opus_int32 maxlen) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4); + +/** Return the total number of frames contained in packet data submitted to + * the repacketizer state so far via opus_repacketizer_cat() since the last + * call to opus_repacketizer_init() or opus_repacketizer_create(). + * This defines the valid range of packets that can be extracted with + * opus_repacketizer_out_range() or opus_repacketizer_out(). + * @param rp OpusRepacketizer*: The repacketizer state containing the + * frames. + * @returns The total number of frames contained in the packet data submitted + * to the repacketizer state. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_nb_frames(OpusRepacketizer *rp) OPUS_ARG_NONNULL(1); + +/** Construct a new packet from data previously submitted to the repacketizer + * state via opus_repacketizer_cat(). + * This is a convenience routine that returns all the data submitted so far + * in a single packet. + * It is equivalent to calling + * @code + * opus_repacketizer_out_range(rp, 0, opus_repacketizer_get_nb_frames(rp), + * data, maxlen) + * @endcode + * @param rp OpusRepacketizer*: The repacketizer state from which to + * construct the new packet. + * @param[out] data const unsigned char*: The buffer in which to + * store the output packet. + * @param maxlen opus_int32: The maximum number of bytes to store in + * the output buffer. In order to guarantee + * success, this should be at least + * 1277*opus_repacketizer_get_nb_frames(rp). + * However, + * 1*opus_repacketizer_get_nb_frames(rp) + * plus the size of all packet data + * submitted to the repacketizer since the + * last call to opus_repacketizer_init() or + * opus_repacketizer_create() is also + * sufficient, and possibly much smaller. + * @returns The total size of the output packet on success, or an error code + * on failure. + * @retval #OPUS_BUFFER_TOO_SMALL \a maxlen was insufficient to contain the + * complete output packet. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_repacketizer_out(OpusRepacketizer *rp, unsigned char *data, opus_int32 maxlen) OPUS_ARG_NONNULL(1); + +/** Pads a given Opus packet to a larger size (possibly changing the TOC sequence). + * @param[in,out] data const unsigned char*: The buffer containing the + * packet to pad. + * @param len opus_int32: The size of the packet. + * This must be at least 1. + * @param new_len opus_int32: The desired size of the packet after padding. + * This must be at least as large as len. + * @returns an error code + * @retval #OPUS_OK \a on success. + * @retval #OPUS_BAD_ARG \a len was less than 1 or new_len was less than len. + * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet. + */ +OPUS_EXPORT int opus_packet_pad(unsigned char *data, opus_int32 len, opus_int32 new_len); + +/** Remove all padding from a given Opus packet and rewrite the TOC sequence to + * minimize space usage. + * @param[in,out] data const unsigned char*: The buffer containing the + * packet to strip. + * @param len opus_int32: The size of the packet. + * This must be at least 1. + * @returns The new size of the output packet on success, or an error code + * on failure. + * @retval #OPUS_BAD_ARG \a len was less than 1. + * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_packet_unpad(unsigned char *data, opus_int32 len); + +/** Pads a given Opus multi-stream packet to a larger size (possibly changing the TOC sequence). + * @param[in,out] data const unsigned char*: The buffer containing the + * packet to pad. + * @param len opus_int32: The size of the packet. + * This must be at least 1. + * @param new_len opus_int32: The desired size of the packet after padding. + * This must be at least 1. + * @param nb_streams opus_int32: The number of streams (not channels) in the packet. + * This must be at least as large as len. + * @returns an error code + * @retval #OPUS_OK \a on success. + * @retval #OPUS_BAD_ARG \a len was less than 1. + * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet. + */ +OPUS_EXPORT int opus_multistream_packet_pad(unsigned char *data, opus_int32 len, opus_int32 new_len, int nb_streams); + +/** Remove all padding from a given Opus multi-stream packet and rewrite the TOC sequence to + * minimize space usage. + * @param[in,out] data const unsigned char*: The buffer containing the + * packet to strip. + * @param len opus_int32: The size of the packet. + * This must be at least 1. + * @param nb_streams opus_int32: The number of streams (not channels) in the packet. + * This must be at least 1. + * @returns The new size of the output packet on success, or an error code + * on failure. + * @retval #OPUS_BAD_ARG \a len was less than 1 or new_len was less than len. + * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_packet_unpad(unsigned char *data, opus_int32 len, int nb_streams); + +/**@}*/ + +#ifdef __cplusplus +} +#endif + +#endif /* OPUS_H */ diff --git a/libs/include/opus/opus_defines.h b/libs/include/opus/opus_defines.h new file mode 100644 index 0000000..d141418 --- /dev/null +++ b/libs/include/opus/opus_defines.h @@ -0,0 +1,799 @@ +/* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited + Written by Jean-Marc Valin and Koen Vos */ +/* + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/** + * @file opus_defines.h + * @brief Opus reference implementation constants + */ + +#ifndef OPUS_DEFINES_H +#define OPUS_DEFINES_H + +#include "opus_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** @defgroup opus_errorcodes Error codes + * @{ + */ +/** No error @hideinitializer*/ +#define OPUS_OK 0 +/** One or more invalid/out of range arguments @hideinitializer*/ +#define OPUS_BAD_ARG -1 +/** Not enough bytes allocated in the buffer @hideinitializer*/ +#define OPUS_BUFFER_TOO_SMALL -2 +/** An internal error was detected @hideinitializer*/ +#define OPUS_INTERNAL_ERROR -3 +/** The compressed data passed is corrupted @hideinitializer*/ +#define OPUS_INVALID_PACKET -4 +/** Invalid/unsupported request number @hideinitializer*/ +#define OPUS_UNIMPLEMENTED -5 +/** An encoder or decoder structure is invalid or already freed @hideinitializer*/ +#define OPUS_INVALID_STATE -6 +/** Memory allocation has failed @hideinitializer*/ +#define OPUS_ALLOC_FAIL -7 +/**@}*/ + +/** @cond OPUS_INTERNAL_DOC */ +/**Export control for opus functions */ + +#ifndef OPUS_EXPORT +# if defined(WIN32) +# if defined(OPUS_BUILD) && defined(DLL_EXPORT) +# define OPUS_EXPORT __declspec(dllexport) +# else +# define OPUS_EXPORT +# endif +# elif defined(__GNUC__) && defined(OPUS_BUILD) +# define OPUS_EXPORT __attribute__ ((visibility ("default"))) +# else +# define OPUS_EXPORT +# endif +#endif + +# if !defined(OPUS_GNUC_PREREQ) +# if defined(__GNUC__)&&defined(__GNUC_MINOR__) +# define OPUS_GNUC_PREREQ(_maj,_min) \ + ((__GNUC__<<16)+__GNUC_MINOR__>=((_maj)<<16)+(_min)) +# else +# define OPUS_GNUC_PREREQ(_maj,_min) 0 +# endif +# endif + +#if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) ) +# if OPUS_GNUC_PREREQ(3,0) +# define OPUS_RESTRICT __restrict__ +# elif (defined(_MSC_VER) && _MSC_VER >= 1400) +# define OPUS_RESTRICT __restrict +# else +# define OPUS_RESTRICT +# endif +#else +# define OPUS_RESTRICT restrict +#endif + +#if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) ) +# if OPUS_GNUC_PREREQ(2,7) +# define OPUS_INLINE __inline__ +# elif (defined(_MSC_VER)) +# define OPUS_INLINE __inline +# else +# define OPUS_INLINE +# endif +#else +# define OPUS_INLINE inline +#endif + +/**Warning attributes for opus functions + * NONNULL is not used in OPUS_BUILD to avoid the compiler optimizing out + * some paranoid null checks. */ +#if defined(__GNUC__) && OPUS_GNUC_PREREQ(3, 4) +# define OPUS_WARN_UNUSED_RESULT __attribute__ ((__warn_unused_result__)) +#else +# define OPUS_WARN_UNUSED_RESULT +#endif +#if !defined(OPUS_BUILD) && defined(__GNUC__) && OPUS_GNUC_PREREQ(3, 4) +# define OPUS_ARG_NONNULL(_x) __attribute__ ((__nonnull__(_x))) +#else +# define OPUS_ARG_NONNULL(_x) +#endif + +/** These are the actual Encoder CTL ID numbers. + * They should not be used directly by applications. + * In general, SETs should be even and GETs should be odd.*/ +#define OPUS_SET_APPLICATION_REQUEST 4000 +#define OPUS_GET_APPLICATION_REQUEST 4001 +#define OPUS_SET_BITRATE_REQUEST 4002 +#define OPUS_GET_BITRATE_REQUEST 4003 +#define OPUS_SET_MAX_BANDWIDTH_REQUEST 4004 +#define OPUS_GET_MAX_BANDWIDTH_REQUEST 4005 +#define OPUS_SET_VBR_REQUEST 4006 +#define OPUS_GET_VBR_REQUEST 4007 +#define OPUS_SET_BANDWIDTH_REQUEST 4008 +#define OPUS_GET_BANDWIDTH_REQUEST 4009 +#define OPUS_SET_COMPLEXITY_REQUEST 4010 +#define OPUS_GET_COMPLEXITY_REQUEST 4011 +#define OPUS_SET_INBAND_FEC_REQUEST 4012 +#define OPUS_GET_INBAND_FEC_REQUEST 4013 +#define OPUS_SET_PACKET_LOSS_PERC_REQUEST 4014 +#define OPUS_GET_PACKET_LOSS_PERC_REQUEST 4015 +#define OPUS_SET_DTX_REQUEST 4016 +#define OPUS_GET_DTX_REQUEST 4017 +#define OPUS_SET_VBR_CONSTRAINT_REQUEST 4020 +#define OPUS_GET_VBR_CONSTRAINT_REQUEST 4021 +#define OPUS_SET_FORCE_CHANNELS_REQUEST 4022 +#define OPUS_GET_FORCE_CHANNELS_REQUEST 4023 +#define OPUS_SET_SIGNAL_REQUEST 4024 +#define OPUS_GET_SIGNAL_REQUEST 4025 +#define OPUS_GET_LOOKAHEAD_REQUEST 4027 +/* #define OPUS_RESET_STATE 4028 */ +#define OPUS_GET_SAMPLE_RATE_REQUEST 4029 +#define OPUS_GET_FINAL_RANGE_REQUEST 4031 +#define OPUS_GET_PITCH_REQUEST 4033 +#define OPUS_SET_GAIN_REQUEST 4034 +#define OPUS_GET_GAIN_REQUEST 4045 /* Should have been 4035 */ +#define OPUS_SET_LSB_DEPTH_REQUEST 4036 +#define OPUS_GET_LSB_DEPTH_REQUEST 4037 +#define OPUS_GET_LAST_PACKET_DURATION_REQUEST 4039 +#define OPUS_SET_EXPERT_FRAME_DURATION_REQUEST 4040 +#define OPUS_GET_EXPERT_FRAME_DURATION_REQUEST 4041 +#define OPUS_SET_PREDICTION_DISABLED_REQUEST 4042 +#define OPUS_GET_PREDICTION_DISABLED_REQUEST 4043 +/* Don't use 4045, it's already taken by OPUS_GET_GAIN_REQUEST */ +#define OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST 4046 +#define OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST 4047 +#define OPUS_GET_IN_DTX_REQUEST 4049 + +/** Defines for the presence of extended APIs. */ +#define OPUS_HAVE_OPUS_PROJECTION_H + +/* Macros to trigger compilation errors when the wrong types are provided to a CTL */ +#define __opus_check_int(x) (((void)((x) == (opus_int32)0)), (opus_int32)(x)) +#define __opus_check_int_ptr(ptr) ((ptr) + ((ptr) - (opus_int32*)(ptr))) +#define __opus_check_uint_ptr(ptr) ((ptr) + ((ptr) - (opus_uint32*)(ptr))) +#define __opus_check_val16_ptr(ptr) ((ptr) + ((ptr) - (opus_val16*)(ptr))) +/** @endcond */ + +/** @defgroup opus_ctlvalues Pre-defined values for CTL interface + * @see opus_genericctls, opus_encoderctls + * @{ + */ +/* Values for the various encoder CTLs */ +#define OPUS_AUTO -1000 /**opus_int32: Allowed values: 0-10, inclusive. + * + * @hideinitializer */ +#define OPUS_SET_COMPLEXITY(x) OPUS_SET_COMPLEXITY_REQUEST, __opus_check_int(x) +/** Gets the encoder's complexity configuration. + * @see OPUS_SET_COMPLEXITY + * @param[out] x opus_int32 *: Returns a value in the range 0-10, + * inclusive. + * @hideinitializer */ +#define OPUS_GET_COMPLEXITY(x) OPUS_GET_COMPLEXITY_REQUEST, __opus_check_int_ptr(x) + +/** Configures the bitrate in the encoder. + * Rates from 500 to 512000 bits per second are meaningful, as well as the + * special values #OPUS_AUTO and #OPUS_BITRATE_MAX. + * The value #OPUS_BITRATE_MAX can be used to cause the codec to use as much + * rate as it can, which is useful for controlling the rate by adjusting the + * output buffer size. + * @see OPUS_GET_BITRATE + * @param[in] x opus_int32: Bitrate in bits per second. The default + * is determined based on the number of + * channels and the input sampling rate. + * @hideinitializer */ +#define OPUS_SET_BITRATE(x) OPUS_SET_BITRATE_REQUEST, __opus_check_int(x) +/** Gets the encoder's bitrate configuration. + * @see OPUS_SET_BITRATE + * @param[out] x opus_int32 *: Returns the bitrate in bits per second. + * The default is determined based on the + * number of channels and the input + * sampling rate. + * @hideinitializer */ +#define OPUS_GET_BITRATE(x) OPUS_GET_BITRATE_REQUEST, __opus_check_int_ptr(x) + +/** Enables or disables variable bitrate (VBR) in the encoder. + * The configured bitrate may not be met exactly because frames must + * be an integer number of bytes in length. + * @see OPUS_GET_VBR + * @see OPUS_SET_VBR_CONSTRAINT + * @param[in] x opus_int32: Allowed values: + *
+ *
0
Hard CBR. For LPC/hybrid modes at very low bit-rate, this can + * cause noticeable quality degradation.
+ *
1
VBR (default). The exact type of VBR is controlled by + * #OPUS_SET_VBR_CONSTRAINT.
+ *
+ * @hideinitializer */ +#define OPUS_SET_VBR(x) OPUS_SET_VBR_REQUEST, __opus_check_int(x) +/** Determine if variable bitrate (VBR) is enabled in the encoder. + * @see OPUS_SET_VBR + * @see OPUS_GET_VBR_CONSTRAINT + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
0
Hard CBR.
+ *
1
VBR (default). The exact type of VBR may be retrieved via + * #OPUS_GET_VBR_CONSTRAINT.
+ *
+ * @hideinitializer */ +#define OPUS_GET_VBR(x) OPUS_GET_VBR_REQUEST, __opus_check_int_ptr(x) + +/** Enables or disables constrained VBR in the encoder. + * This setting is ignored when the encoder is in CBR mode. + * @warning Only the MDCT mode of Opus currently heeds the constraint. + * Speech mode ignores it completely, hybrid mode may fail to obey it + * if the LPC layer uses more bitrate than the constraint would have + * permitted. + * @see OPUS_GET_VBR_CONSTRAINT + * @see OPUS_SET_VBR + * @param[in] x opus_int32: Allowed values: + *
+ *
0
Unconstrained VBR.
+ *
1
Constrained VBR (default). This creates a maximum of one + * frame of buffering delay assuming a transport with a + * serialization speed of the nominal bitrate.
+ *
+ * @hideinitializer */ +#define OPUS_SET_VBR_CONSTRAINT(x) OPUS_SET_VBR_CONSTRAINT_REQUEST, __opus_check_int(x) +/** Determine if constrained VBR is enabled in the encoder. + * @see OPUS_SET_VBR_CONSTRAINT + * @see OPUS_GET_VBR + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
0
Unconstrained VBR.
+ *
1
Constrained VBR (default).
+ *
+ * @hideinitializer */ +#define OPUS_GET_VBR_CONSTRAINT(x) OPUS_GET_VBR_CONSTRAINT_REQUEST, __opus_check_int_ptr(x) + +/** Configures mono/stereo forcing in the encoder. + * This can force the encoder to produce packets encoded as either mono or + * stereo, regardless of the format of the input audio. This is useful when + * the caller knows that the input signal is currently a mono source embedded + * in a stereo stream. + * @see OPUS_GET_FORCE_CHANNELS + * @param[in] x opus_int32: Allowed values: + *
+ *
#OPUS_AUTO
Not forced (default)
+ *
1
Forced mono
+ *
2
Forced stereo
+ *
+ * @hideinitializer */ +#define OPUS_SET_FORCE_CHANNELS(x) OPUS_SET_FORCE_CHANNELS_REQUEST, __opus_check_int(x) +/** Gets the encoder's forced channel configuration. + * @see OPUS_SET_FORCE_CHANNELS + * @param[out] x opus_int32 *: + *
+ *
#OPUS_AUTO
Not forced (default)
+ *
1
Forced mono
+ *
2
Forced stereo
+ *
+ * @hideinitializer */ +#define OPUS_GET_FORCE_CHANNELS(x) OPUS_GET_FORCE_CHANNELS_REQUEST, __opus_check_int_ptr(x) + +/** Configures the maximum bandpass that the encoder will select automatically. + * Applications should normally use this instead of #OPUS_SET_BANDWIDTH + * (leaving that set to the default, #OPUS_AUTO). This allows the + * application to set an upper bound based on the type of input it is + * providing, but still gives the encoder the freedom to reduce the bandpass + * when the bitrate becomes too low, for better overall quality. + * @see OPUS_GET_MAX_BANDWIDTH + * @param[in] x opus_int32: Allowed values: + *
+ *
OPUS_BANDWIDTH_NARROWBAND
4 kHz passband
+ *
OPUS_BANDWIDTH_MEDIUMBAND
6 kHz passband
+ *
OPUS_BANDWIDTH_WIDEBAND
8 kHz passband
+ *
OPUS_BANDWIDTH_SUPERWIDEBAND
12 kHz passband
+ *
OPUS_BANDWIDTH_FULLBAND
20 kHz passband (default)
+ *
+ * @hideinitializer */ +#define OPUS_SET_MAX_BANDWIDTH(x) OPUS_SET_MAX_BANDWIDTH_REQUEST, __opus_check_int(x) + +/** Gets the encoder's configured maximum allowed bandpass. + * @see OPUS_SET_MAX_BANDWIDTH + * @param[out] x opus_int32 *: Allowed values: + *
+ *
#OPUS_BANDWIDTH_NARROWBAND
4 kHz passband
+ *
#OPUS_BANDWIDTH_MEDIUMBAND
6 kHz passband
+ *
#OPUS_BANDWIDTH_WIDEBAND
8 kHz passband
+ *
#OPUS_BANDWIDTH_SUPERWIDEBAND
12 kHz passband
+ *
#OPUS_BANDWIDTH_FULLBAND
20 kHz passband (default)
+ *
+ * @hideinitializer */ +#define OPUS_GET_MAX_BANDWIDTH(x) OPUS_GET_MAX_BANDWIDTH_REQUEST, __opus_check_int_ptr(x) + +/** Sets the encoder's bandpass to a specific value. + * This prevents the encoder from automatically selecting the bandpass based + * on the available bitrate. If an application knows the bandpass of the input + * audio it is providing, it should normally use #OPUS_SET_MAX_BANDWIDTH + * instead, which still gives the encoder the freedom to reduce the bandpass + * when the bitrate becomes too low, for better overall quality. + * @see OPUS_GET_BANDWIDTH + * @param[in] x opus_int32: Allowed values: + *
+ *
#OPUS_AUTO
(default)
+ *
#OPUS_BANDWIDTH_NARROWBAND
4 kHz passband
+ *
#OPUS_BANDWIDTH_MEDIUMBAND
6 kHz passband
+ *
#OPUS_BANDWIDTH_WIDEBAND
8 kHz passband
+ *
#OPUS_BANDWIDTH_SUPERWIDEBAND
12 kHz passband
+ *
#OPUS_BANDWIDTH_FULLBAND
20 kHz passband
+ *
+ * @hideinitializer */ +#define OPUS_SET_BANDWIDTH(x) OPUS_SET_BANDWIDTH_REQUEST, __opus_check_int(x) + +/** Configures the type of signal being encoded. + * This is a hint which helps the encoder's mode selection. + * @see OPUS_GET_SIGNAL + * @param[in] x opus_int32: Allowed values: + *
+ *
#OPUS_AUTO
(default)
+ *
#OPUS_SIGNAL_VOICE
Bias thresholds towards choosing LPC or Hybrid modes.
+ *
#OPUS_SIGNAL_MUSIC
Bias thresholds towards choosing MDCT modes.
+ *
+ * @hideinitializer */ +#define OPUS_SET_SIGNAL(x) OPUS_SET_SIGNAL_REQUEST, __opus_check_int(x) +/** Gets the encoder's configured signal type. + * @see OPUS_SET_SIGNAL + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
#OPUS_AUTO
(default)
+ *
#OPUS_SIGNAL_VOICE
Bias thresholds towards choosing LPC or Hybrid modes.
+ *
#OPUS_SIGNAL_MUSIC
Bias thresholds towards choosing MDCT modes.
+ *
+ * @hideinitializer */ +#define OPUS_GET_SIGNAL(x) OPUS_GET_SIGNAL_REQUEST, __opus_check_int_ptr(x) + + +/** Configures the encoder's intended application. + * The initial value is a mandatory argument to the encoder_create function. + * @see OPUS_GET_APPLICATION + * @param[in] x opus_int32: Returns one of the following values: + *
+ *
#OPUS_APPLICATION_VOIP
+ *
Process signal for improved speech intelligibility.
+ *
#OPUS_APPLICATION_AUDIO
+ *
Favor faithfulness to the original input.
+ *
#OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ *
Configure the minimum possible coding delay by disabling certain modes + * of operation.
+ *
+ * @hideinitializer */ +#define OPUS_SET_APPLICATION(x) OPUS_SET_APPLICATION_REQUEST, __opus_check_int(x) +/** Gets the encoder's configured application. + * @see OPUS_SET_APPLICATION + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
#OPUS_APPLICATION_VOIP
+ *
Process signal for improved speech intelligibility.
+ *
#OPUS_APPLICATION_AUDIO
+ *
Favor faithfulness to the original input.
+ *
#OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ *
Configure the minimum possible coding delay by disabling certain modes + * of operation.
+ *
+ * @hideinitializer */ +#define OPUS_GET_APPLICATION(x) OPUS_GET_APPLICATION_REQUEST, __opus_check_int_ptr(x) + +/** Gets the total samples of delay added by the entire codec. + * This can be queried by the encoder and then the provided number of samples can be + * skipped on from the start of the decoder's output to provide time aligned input + * and output. From the perspective of a decoding application the real data begins this many + * samples late. + * + * The decoder contribution to this delay is identical for all decoders, but the + * encoder portion of the delay may vary from implementation to implementation, + * version to version, or even depend on the encoder's initial configuration. + * Applications needing delay compensation should call this CTL rather than + * hard-coding a value. + * @param[out] x opus_int32 *: Number of lookahead samples + * @hideinitializer */ +#define OPUS_GET_LOOKAHEAD(x) OPUS_GET_LOOKAHEAD_REQUEST, __opus_check_int_ptr(x) + +/** Configures the encoder's use of inband forward error correction (FEC). + * @note This is only applicable to the LPC layer + * @see OPUS_GET_INBAND_FEC + * @param[in] x opus_int32: Allowed values: + *
+ *
0
Disable inband FEC (default).
+ *
1
Enable inband FEC.
+ *
+ * @hideinitializer */ +#define OPUS_SET_INBAND_FEC(x) OPUS_SET_INBAND_FEC_REQUEST, __opus_check_int(x) +/** Gets encoder's configured use of inband forward error correction. + * @see OPUS_SET_INBAND_FEC + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
0
Inband FEC disabled (default).
+ *
1
Inband FEC enabled.
+ *
+ * @hideinitializer */ +#define OPUS_GET_INBAND_FEC(x) OPUS_GET_INBAND_FEC_REQUEST, __opus_check_int_ptr(x) + +/** Configures the encoder's expected packet loss percentage. + * Higher values trigger progressively more loss resistant behavior in the encoder + * at the expense of quality at a given bitrate in the absence of packet loss, but + * greater quality under loss. + * @see OPUS_GET_PACKET_LOSS_PERC + * @param[in] x opus_int32: Loss percentage in the range 0-100, inclusive (default: 0). + * @hideinitializer */ +#define OPUS_SET_PACKET_LOSS_PERC(x) OPUS_SET_PACKET_LOSS_PERC_REQUEST, __opus_check_int(x) +/** Gets the encoder's configured packet loss percentage. + * @see OPUS_SET_PACKET_LOSS_PERC + * @param[out] x opus_int32 *: Returns the configured loss percentage + * in the range 0-100, inclusive (default: 0). + * @hideinitializer */ +#define OPUS_GET_PACKET_LOSS_PERC(x) OPUS_GET_PACKET_LOSS_PERC_REQUEST, __opus_check_int_ptr(x) + +/** Configures the encoder's use of discontinuous transmission (DTX). + * @note This is only applicable to the LPC layer + * @see OPUS_GET_DTX + * @param[in] x opus_int32: Allowed values: + *
+ *
0
Disable DTX (default).
+ *
1
Enabled DTX.
+ *
+ * @hideinitializer */ +#define OPUS_SET_DTX(x) OPUS_SET_DTX_REQUEST, __opus_check_int(x) +/** Gets encoder's configured use of discontinuous transmission. + * @see OPUS_SET_DTX + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
0
DTX disabled (default).
+ *
1
DTX enabled.
+ *
+ * @hideinitializer */ +#define OPUS_GET_DTX(x) OPUS_GET_DTX_REQUEST, __opus_check_int_ptr(x) +/** Configures the depth of signal being encoded. + * + * This is a hint which helps the encoder identify silence and near-silence. + * It represents the number of significant bits of linear intensity below + * which the signal contains ignorable quantization or other noise. + * + * For example, OPUS_SET_LSB_DEPTH(14) would be an appropriate setting + * for G.711 u-law input. OPUS_SET_LSB_DEPTH(16) would be appropriate + * for 16-bit linear pcm input with opus_encode_float(). + * + * When using opus_encode() instead of opus_encode_float(), or when libopus + * is compiled for fixed-point, the encoder uses the minimum of the value + * set here and the value 16. + * + * @see OPUS_GET_LSB_DEPTH + * @param[in] x opus_int32: Input precision in bits, between 8 and 24 + * (default: 24). + * @hideinitializer */ +#define OPUS_SET_LSB_DEPTH(x) OPUS_SET_LSB_DEPTH_REQUEST, __opus_check_int(x) +/** Gets the encoder's configured signal depth. + * @see OPUS_SET_LSB_DEPTH + * @param[out] x opus_int32 *: Input precision in bits, between 8 and + * 24 (default: 24). + * @hideinitializer */ +#define OPUS_GET_LSB_DEPTH(x) OPUS_GET_LSB_DEPTH_REQUEST, __opus_check_int_ptr(x) + +/** Configures the encoder's use of variable duration frames. + * When variable duration is enabled, the encoder is free to use a shorter frame + * size than the one requested in the opus_encode*() call. + * It is then the user's responsibility + * to verify how much audio was encoded by checking the ToC byte of the encoded + * packet. The part of the audio that was not encoded needs to be resent to the + * encoder for the next call. Do not use this option unless you really + * know what you are doing. + * @see OPUS_GET_EXPERT_FRAME_DURATION + * @param[in] x opus_int32: Allowed values: + *
+ *
OPUS_FRAMESIZE_ARG
Select frame size from the argument (default).
+ *
OPUS_FRAMESIZE_2_5_MS
Use 2.5 ms frames.
+ *
OPUS_FRAMESIZE_5_MS
Use 5 ms frames.
+ *
OPUS_FRAMESIZE_10_MS
Use 10 ms frames.
+ *
OPUS_FRAMESIZE_20_MS
Use 20 ms frames.
+ *
OPUS_FRAMESIZE_40_MS
Use 40 ms frames.
+ *
OPUS_FRAMESIZE_60_MS
Use 60 ms frames.
+ *
OPUS_FRAMESIZE_80_MS
Use 80 ms frames.
+ *
OPUS_FRAMESIZE_100_MS
Use 100 ms frames.
+ *
OPUS_FRAMESIZE_120_MS
Use 120 ms frames.
+ *
+ * @hideinitializer */ +#define OPUS_SET_EXPERT_FRAME_DURATION(x) OPUS_SET_EXPERT_FRAME_DURATION_REQUEST, __opus_check_int(x) +/** Gets the encoder's configured use of variable duration frames. + * @see OPUS_SET_EXPERT_FRAME_DURATION + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
OPUS_FRAMESIZE_ARG
Select frame size from the argument (default).
+ *
OPUS_FRAMESIZE_2_5_MS
Use 2.5 ms frames.
+ *
OPUS_FRAMESIZE_5_MS
Use 5 ms frames.
+ *
OPUS_FRAMESIZE_10_MS
Use 10 ms frames.
+ *
OPUS_FRAMESIZE_20_MS
Use 20 ms frames.
+ *
OPUS_FRAMESIZE_40_MS
Use 40 ms frames.
+ *
OPUS_FRAMESIZE_60_MS
Use 60 ms frames.
+ *
OPUS_FRAMESIZE_80_MS
Use 80 ms frames.
+ *
OPUS_FRAMESIZE_100_MS
Use 100 ms frames.
+ *
OPUS_FRAMESIZE_120_MS
Use 120 ms frames.
+ *
+ * @hideinitializer */ +#define OPUS_GET_EXPERT_FRAME_DURATION(x) OPUS_GET_EXPERT_FRAME_DURATION_REQUEST, __opus_check_int_ptr(x) + +/** If set to 1, disables almost all use of prediction, making frames almost + * completely independent. This reduces quality. + * @see OPUS_GET_PREDICTION_DISABLED + * @param[in] x opus_int32: Allowed values: + *
+ *
0
Enable prediction (default).
+ *
1
Disable prediction.
+ *
+ * @hideinitializer */ +#define OPUS_SET_PREDICTION_DISABLED(x) OPUS_SET_PREDICTION_DISABLED_REQUEST, __opus_check_int(x) +/** Gets the encoder's configured prediction status. + * @see OPUS_SET_PREDICTION_DISABLED + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
0
Prediction enabled (default).
+ *
1
Prediction disabled.
+ *
+ * @hideinitializer */ +#define OPUS_GET_PREDICTION_DISABLED(x) OPUS_GET_PREDICTION_DISABLED_REQUEST, __opus_check_int_ptr(x) + +/**@}*/ + +/** @defgroup opus_genericctls Generic CTLs + * + * These macros are used with the \c opus_decoder_ctl and + * \c opus_encoder_ctl calls to generate a particular + * request. + * + * When called on an \c OpusDecoder they apply to that + * particular decoder instance. When called on an + * \c OpusEncoder they apply to the corresponding setting + * on that encoder instance, if present. + * + * Some usage examples: + * + * @code + * int ret; + * opus_int32 pitch; + * ret = opus_decoder_ctl(dec_ctx, OPUS_GET_PITCH(&pitch)); + * if (ret == OPUS_OK) return ret; + * + * opus_encoder_ctl(enc_ctx, OPUS_RESET_STATE); + * opus_decoder_ctl(dec_ctx, OPUS_RESET_STATE); + * + * opus_int32 enc_bw, dec_bw; + * opus_encoder_ctl(enc_ctx, OPUS_GET_BANDWIDTH(&enc_bw)); + * opus_decoder_ctl(dec_ctx, OPUS_GET_BANDWIDTH(&dec_bw)); + * if (enc_bw != dec_bw) { + * printf("packet bandwidth mismatch!\n"); + * } + * @endcode + * + * @see opus_encoder, opus_decoder_ctl, opus_encoder_ctl, opus_decoderctls, opus_encoderctls + * @{ + */ + +/** Resets the codec state to be equivalent to a freshly initialized state. + * This should be called when switching streams in order to prevent + * the back to back decoding from giving different results from + * one at a time decoding. + * @hideinitializer */ +#define OPUS_RESET_STATE 4028 + +/** Gets the final state of the codec's entropy coder. + * This is used for testing purposes, + * The encoder and decoder state should be identical after coding a payload + * (assuming no data corruption or software bugs) + * + * @param[out] x opus_uint32 *: Entropy coder state + * + * @hideinitializer */ +#define OPUS_GET_FINAL_RANGE(x) OPUS_GET_FINAL_RANGE_REQUEST, __opus_check_uint_ptr(x) + +/** Gets the encoder's configured bandpass or the decoder's last bandpass. + * @see OPUS_SET_BANDWIDTH + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
#OPUS_AUTO
(default)
+ *
#OPUS_BANDWIDTH_NARROWBAND
4 kHz passband
+ *
#OPUS_BANDWIDTH_MEDIUMBAND
6 kHz passband
+ *
#OPUS_BANDWIDTH_WIDEBAND
8 kHz passband
+ *
#OPUS_BANDWIDTH_SUPERWIDEBAND
12 kHz passband
+ *
#OPUS_BANDWIDTH_FULLBAND
20 kHz passband
+ *
+ * @hideinitializer */ +#define OPUS_GET_BANDWIDTH(x) OPUS_GET_BANDWIDTH_REQUEST, __opus_check_int_ptr(x) + +/** Gets the sampling rate the encoder or decoder was initialized with. + * This simply returns the Fs value passed to opus_encoder_init() + * or opus_decoder_init(). + * @param[out] x opus_int32 *: Sampling rate of encoder or decoder. + * @hideinitializer + */ +#define OPUS_GET_SAMPLE_RATE(x) OPUS_GET_SAMPLE_RATE_REQUEST, __opus_check_int_ptr(x) + +/** If set to 1, disables the use of phase inversion for intensity stereo, + * improving the quality of mono downmixes, but slightly reducing normal + * stereo quality. Disabling phase inversion in the decoder does not comply + * with RFC 6716, although it does not cause any interoperability issue and + * is expected to become part of the Opus standard once RFC 6716 is updated + * by draft-ietf-codec-opus-update. + * @see OPUS_GET_PHASE_INVERSION_DISABLED + * @param[in] x opus_int32: Allowed values: + *
+ *
0
Enable phase inversion (default).
+ *
1
Disable phase inversion.
+ *
+ * @hideinitializer */ +#define OPUS_SET_PHASE_INVERSION_DISABLED(x) OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST, __opus_check_int(x) +/** Gets the encoder's configured phase inversion status. + * @see OPUS_SET_PHASE_INVERSION_DISABLED + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
0
Stereo phase inversion enabled (default).
+ *
1
Stereo phase inversion disabled.
+ *
+ * @hideinitializer */ +#define OPUS_GET_PHASE_INVERSION_DISABLED(x) OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST, __opus_check_int_ptr(x) +/** Gets the DTX state of the encoder. + * Returns whether the last encoded frame was either a comfort noise update + * during DTX or not encoded because of DTX. + * @param[out] x opus_int32 *: Returns one of the following values: + *
+ *
0
The encoder is not in DTX.
+ *
1
The encoder is in DTX.
+ *
+ * @hideinitializer */ +#define OPUS_GET_IN_DTX(x) OPUS_GET_IN_DTX_REQUEST, __opus_check_int_ptr(x) + +/**@}*/ + +/** @defgroup opus_decoderctls Decoder related CTLs + * @see opus_genericctls, opus_encoderctls, opus_decoder + * @{ + */ + +/** Configures decoder gain adjustment. + * Scales the decoded output by a factor specified in Q8 dB units. + * This has a maximum range of -32768 to 32767 inclusive, and returns + * OPUS_BAD_ARG otherwise. The default is zero indicating no adjustment. + * This setting survives decoder reset. + * + * gain = pow(10, x/(20.0*256)) + * + * @param[in] x opus_int32: Amount to scale PCM signal by in Q8 dB units. + * @hideinitializer */ +#define OPUS_SET_GAIN(x) OPUS_SET_GAIN_REQUEST, __opus_check_int(x) +/** Gets the decoder's configured gain adjustment. @see OPUS_SET_GAIN + * + * @param[out] x opus_int32 *: Amount to scale PCM signal by in Q8 dB units. + * @hideinitializer */ +#define OPUS_GET_GAIN(x) OPUS_GET_GAIN_REQUEST, __opus_check_int_ptr(x) + +/** Gets the duration (in samples) of the last packet successfully decoded or concealed. + * @param[out] x opus_int32 *: Number of samples (at current sampling rate). + * @hideinitializer */ +#define OPUS_GET_LAST_PACKET_DURATION(x) OPUS_GET_LAST_PACKET_DURATION_REQUEST, __opus_check_int_ptr(x) + +/** Gets the pitch of the last decoded frame, if available. + * This can be used for any post-processing algorithm requiring the use of pitch, + * e.g. time stretching/shortening. If the last frame was not voiced, or if the + * pitch was not coded in the frame, then zero is returned. + * + * This CTL is only implemented for decoder instances. + * + * @param[out] x opus_int32 *: pitch period at 48 kHz (or 0 if not available) + * + * @hideinitializer */ +#define OPUS_GET_PITCH(x) OPUS_GET_PITCH_REQUEST, __opus_check_int_ptr(x) + +/**@}*/ + +/** @defgroup opus_libinfo Opus library information functions + * @{ + */ + +/** Converts an opus error code into a human readable string. + * + * @param[in] error int: Error number + * @returns Error string + */ +OPUS_EXPORT const char *opus_strerror(int error); + +/** Gets the libopus version string. + * + * Applications may look for the substring "-fixed" in the version string to + * determine whether they have a fixed-point or floating-point build at + * runtime. + * + * @returns Version string + */ +OPUS_EXPORT const char *opus_get_version_string(void); +/**@}*/ + +#ifdef __cplusplus +} +#endif + +#endif /* OPUS_DEFINES_H */ diff --git a/libs/include/opus/opus_multistream.h b/libs/include/opus/opus_multistream.h new file mode 100644 index 0000000..babcee6 --- /dev/null +++ b/libs/include/opus/opus_multistream.h @@ -0,0 +1,660 @@ +/* Copyright (c) 2011 Xiph.Org Foundation + Written by Jean-Marc Valin */ +/* + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/** + * @file opus_multistream.h + * @brief Opus reference implementation multistream API + */ + +#ifndef OPUS_MULTISTREAM_H +#define OPUS_MULTISTREAM_H + +#include "opus.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** @cond OPUS_INTERNAL_DOC */ + +/** Macros to trigger compilation errors when the wrong types are provided to a + * CTL. */ +/**@{*/ +#define __opus_check_encstate_ptr(ptr) ((ptr) + ((ptr) - (OpusEncoder**)(ptr))) +#define __opus_check_decstate_ptr(ptr) ((ptr) + ((ptr) - (OpusDecoder**)(ptr))) +/**@}*/ + +/** These are the actual encoder and decoder CTL ID numbers. + * They should not be used directly by applications. + * In general, SETs should be even and GETs should be odd.*/ +/**@{*/ +#define OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST 5120 +#define OPUS_MULTISTREAM_GET_DECODER_STATE_REQUEST 5122 +/**@}*/ + +/** @endcond */ + +/** @defgroup opus_multistream_ctls Multistream specific encoder and decoder CTLs + * + * These are convenience macros that are specific to the + * opus_multistream_encoder_ctl() and opus_multistream_decoder_ctl() + * interface. + * The CTLs from @ref opus_genericctls, @ref opus_encoderctls, and + * @ref opus_decoderctls may be applied to a multistream encoder or decoder as + * well. + * In addition, you may retrieve the encoder or decoder state for an specific + * stream via #OPUS_MULTISTREAM_GET_ENCODER_STATE or + * #OPUS_MULTISTREAM_GET_DECODER_STATE and apply CTLs to it individually. + */ +/**@{*/ + +/** Gets the encoder state for an individual stream of a multistream encoder. + * @param[in] x opus_int32: The index of the stream whose encoder you + * wish to retrieve. + * This must be non-negative and less than + * the streams parameter used + * to initialize the encoder. + * @param[out] y OpusEncoder**: Returns a pointer to the given + * encoder state. + * @retval OPUS_BAD_ARG The index of the requested stream was out of range. + * @hideinitializer + */ +#define OPUS_MULTISTREAM_GET_ENCODER_STATE(x,y) OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST, __opus_check_int(x), __opus_check_encstate_ptr(y) + +/** Gets the decoder state for an individual stream of a multistream decoder. + * @param[in] x opus_int32: The index of the stream whose decoder you + * wish to retrieve. + * This must be non-negative and less than + * the streams parameter used + * to initialize the decoder. + * @param[out] y OpusDecoder**: Returns a pointer to the given + * decoder state. + * @retval OPUS_BAD_ARG The index of the requested stream was out of range. + * @hideinitializer + */ +#define OPUS_MULTISTREAM_GET_DECODER_STATE(x,y) OPUS_MULTISTREAM_GET_DECODER_STATE_REQUEST, __opus_check_int(x), __opus_check_decstate_ptr(y) + +/**@}*/ + +/** @defgroup opus_multistream Opus Multistream API + * @{ + * + * The multistream API allows individual Opus streams to be combined into a + * single packet, enabling support for up to 255 channels. Unlike an + * elementary Opus stream, the encoder and decoder must negotiate the channel + * configuration before the decoder can successfully interpret the data in the + * packets produced by the encoder. Some basic information, such as packet + * duration, can be computed without any special negotiation. + * + * The format for multistream Opus packets is defined in + * RFC 7845 + * and is based on the self-delimited Opus framing described in Appendix B of + * RFC 6716. + * Normal Opus packets are just a degenerate case of multistream Opus packets, + * and can be encoded or decoded with the multistream API by setting + * streams to 1 when initializing the encoder or + * decoder. + * + * Multistream Opus streams can contain up to 255 elementary Opus streams. + * These may be either "uncoupled" or "coupled", indicating that the decoder + * is configured to decode them to either 1 or 2 channels, respectively. + * The streams are ordered so that all coupled streams appear at the + * beginning. + * + * A mapping table defines which decoded channel i + * should be used for each input/output (I/O) channel j. This table is + * typically provided as an unsigned char array. + * Let i = mapping[j] be the index for I/O channel j. + * If i < 2*coupled_streams, then I/O channel j is + * encoded as the left channel of stream (i/2) if i + * is even, or as the right channel of stream (i/2) if + * i is odd. Otherwise, I/O channel j is encoded as + * mono in stream (i - coupled_streams), unless it has the special + * value 255, in which case it is omitted from the encoding entirely (the + * decoder will reproduce it as silence). Each value i must either + * be the special value 255 or be less than streams + coupled_streams. + * + * The output channels specified by the encoder + * should use the + * Vorbis + * channel ordering. A decoder may wish to apply an additional permutation + * to the mapping the encoder used to achieve a different output channel + * order (e.g. for outputing in WAV order). + * + * Each multistream packet contains an Opus packet for each stream, and all of + * the Opus packets in a single multistream packet must have the same + * duration. Therefore the duration of a multistream packet can be extracted + * from the TOC sequence of the first stream, which is located at the + * beginning of the packet, just like an elementary Opus stream: + * + * @code + * int nb_samples; + * int nb_frames; + * nb_frames = opus_packet_get_nb_frames(data, len); + * if (nb_frames < 1) + * return nb_frames; + * nb_samples = opus_packet_get_samples_per_frame(data, 48000) * nb_frames; + * @endcode + * + * The general encoding and decoding process proceeds exactly the same as in + * the normal @ref opus_encoder and @ref opus_decoder APIs. + * See their documentation for an overview of how to use the corresponding + * multistream functions. + */ + +/** Opus multistream encoder state. + * This contains the complete state of a multistream Opus encoder. + * It is position independent and can be freely copied. + * @see opus_multistream_encoder_create + * @see opus_multistream_encoder_init + */ +typedef struct OpusMSEncoder OpusMSEncoder; + +/** Opus multistream decoder state. + * This contains the complete state of a multistream Opus decoder. + * It is position independent and can be freely copied. + * @see opus_multistream_decoder_create + * @see opus_multistream_decoder_init + */ +typedef struct OpusMSDecoder OpusMSDecoder; + +/**\name Multistream encoder functions */ +/**@{*/ + +/** Gets the size of an OpusMSEncoder structure. + * @param streams int: The total number of streams to encode from the + * input. + * This must be no more than 255. + * @param coupled_streams int: Number of coupled (2 channel) streams + * to encode. + * This must be no larger than the total + * number of streams. + * Additionally, The total number of + * encoded channels (streams + + * coupled_streams) must be no + * more than 255. + * @returns The size in bytes on success, or a negative error code + * (see @ref opus_errorcodes) on error. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_encoder_get_size( + int streams, + int coupled_streams +); + +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_surround_encoder_get_size( + int channels, + int mapping_family +); + + +/** Allocates and initializes a multistream encoder state. + * Call opus_multistream_encoder_destroy() to release + * this object when finished. + * @param Fs opus_int32: Sampling rate of the input signal (in Hz). + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param channels int: Number of channels in the input signal. + * This must be at most 255. + * It may be greater than the number of + * coded channels (streams + + * coupled_streams). + * @param streams int: The total number of streams to encode from the + * input. + * This must be no more than the number of channels. + * @param coupled_streams int: Number of coupled (2 channel) streams + * to encode. + * This must be no larger than the total + * number of streams. + * Additionally, The total number of + * encoded channels (streams + + * coupled_streams) must be no + * more than the number of input channels. + * @param[in] mapping const unsigned char[channels]: Mapping from + * encoded channels to input channels, as described in + * @ref opus_multistream. As an extra constraint, the + * multistream encoder does not allow encoding coupled + * streams for which one channel is unused since this + * is never a good idea. + * @param application int: The target encoder application. + * This must be one of the following: + *
+ *
#OPUS_APPLICATION_VOIP
+ *
Process signal for improved speech intelligibility.
+ *
#OPUS_APPLICATION_AUDIO
+ *
Favor faithfulness to the original input.
+ *
#OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ *
Configure the minimum possible coding delay by disabling certain modes + * of operation.
+ *
+ * @param[out] error int *: Returns #OPUS_OK on success, or an error + * code (see @ref opus_errorcodes) on + * failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusMSEncoder *opus_multistream_encoder_create( + opus_int32 Fs, + int channels, + int streams, + int coupled_streams, + const unsigned char *mapping, + int application, + int *error +) OPUS_ARG_NONNULL(5); + +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusMSEncoder *opus_multistream_surround_encoder_create( + opus_int32 Fs, + int channels, + int mapping_family, + int *streams, + int *coupled_streams, + unsigned char *mapping, + int application, + int *error +) OPUS_ARG_NONNULL(4) OPUS_ARG_NONNULL(5) OPUS_ARG_NONNULL(6); + +/** Initialize a previously allocated multistream encoder state. + * The memory pointed to by \a st must be at least the size returned by + * opus_multistream_encoder_get_size(). + * This is intended for applications which use their own allocator instead of + * malloc. + * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL. + * @see opus_multistream_encoder_create + * @see opus_multistream_encoder_get_size + * @param st OpusMSEncoder*: Multistream encoder state to initialize. + * @param Fs opus_int32: Sampling rate of the input signal (in Hz). + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param channels int: Number of channels in the input signal. + * This must be at most 255. + * It may be greater than the number of + * coded channels (streams + + * coupled_streams). + * @param streams int: The total number of streams to encode from the + * input. + * This must be no more than the number of channels. + * @param coupled_streams int: Number of coupled (2 channel) streams + * to encode. + * This must be no larger than the total + * number of streams. + * Additionally, The total number of + * encoded channels (streams + + * coupled_streams) must be no + * more than the number of input channels. + * @param[in] mapping const unsigned char[channels]: Mapping from + * encoded channels to input channels, as described in + * @ref opus_multistream. As an extra constraint, the + * multistream encoder does not allow encoding coupled + * streams for which one channel is unused since this + * is never a good idea. + * @param application int: The target encoder application. + * This must be one of the following: + *
+ *
#OPUS_APPLICATION_VOIP
+ *
Process signal for improved speech intelligibility.
+ *
#OPUS_APPLICATION_AUDIO
+ *
Favor faithfulness to the original input.
+ *
#OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ *
Configure the minimum possible coding delay by disabling certain modes + * of operation.
+ *
+ * @returns #OPUS_OK on success, or an error code (see @ref opus_errorcodes) + * on failure. + */ +OPUS_EXPORT int opus_multistream_encoder_init( + OpusMSEncoder *st, + opus_int32 Fs, + int channels, + int streams, + int coupled_streams, + const unsigned char *mapping, + int application +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(6); + +OPUS_EXPORT int opus_multistream_surround_encoder_init( + OpusMSEncoder *st, + opus_int32 Fs, + int channels, + int mapping_family, + int *streams, + int *coupled_streams, + unsigned char *mapping, + int application +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(5) OPUS_ARG_NONNULL(6) OPUS_ARG_NONNULL(7); + +/** Encodes a multistream Opus frame. + * @param st OpusMSEncoder*: Multistream encoder state. + * @param[in] pcm const opus_int16*: The input signal as interleaved + * samples. + * This must contain + * frame_size*channels + * samples. + * @param frame_size int: Number of samples per channel in the input + * signal. + * This must be an Opus frame size for the + * encoder's sampling rate. + * For example, at 48 kHz the permitted values + * are 120, 240, 480, 960, 1920, and 2880. + * Passing in a duration of less than 10 ms + * (480 samples at 48 kHz) will prevent the + * encoder from using the LPC or hybrid modes. + * @param[out] data unsigned char*: Output payload. + * This must contain storage for at + * least \a max_data_bytes. + * @param [in] max_data_bytes opus_int32: Size of the allocated + * memory for the output + * payload. This may be + * used to impose an upper limit on + * the instant bitrate, but should + * not be used as the only bitrate + * control. Use #OPUS_SET_BITRATE to + * control the bitrate. + * @returns The length of the encoded packet (in bytes) on success or a + * negative error code (see @ref opus_errorcodes) on failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_multistream_encode( + OpusMSEncoder *st, + const opus_int16 *pcm, + int frame_size, + unsigned char *data, + opus_int32 max_data_bytes +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4); + +/** Encodes a multistream Opus frame from floating point input. + * @param st OpusMSEncoder*: Multistream encoder state. + * @param[in] pcm const float*: The input signal as interleaved + * samples with a normal range of + * +/-1.0. + * Samples with a range beyond +/-1.0 + * are supported but will be clipped by + * decoders using the integer API and + * should only be used if it is known + * that the far end supports extended + * dynamic range. + * This must contain + * frame_size*channels + * samples. + * @param frame_size int: Number of samples per channel in the input + * signal. + * This must be an Opus frame size for the + * encoder's sampling rate. + * For example, at 48 kHz the permitted values + * are 120, 240, 480, 960, 1920, and 2880. + * Passing in a duration of less than 10 ms + * (480 samples at 48 kHz) will prevent the + * encoder from using the LPC or hybrid modes. + * @param[out] data unsigned char*: Output payload. + * This must contain storage for at + * least \a max_data_bytes. + * @param [in] max_data_bytes opus_int32: Size of the allocated + * memory for the output + * payload. This may be + * used to impose an upper limit on + * the instant bitrate, but should + * not be used as the only bitrate + * control. Use #OPUS_SET_BITRATE to + * control the bitrate. + * @returns The length of the encoded packet (in bytes) on success or a + * negative error code (see @ref opus_errorcodes) on failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_multistream_encode_float( + OpusMSEncoder *st, + const float *pcm, + int frame_size, + unsigned char *data, + opus_int32 max_data_bytes +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4); + +/** Frees an OpusMSEncoder allocated by + * opus_multistream_encoder_create(). + * @param st OpusMSEncoder*: Multistream encoder state to be freed. + */ +OPUS_EXPORT void opus_multistream_encoder_destroy(OpusMSEncoder *st); + +/** Perform a CTL function on a multistream Opus encoder. + * + * Generally the request and subsequent arguments are generated by a + * convenience macro. + * @param st OpusMSEncoder*: Multistream encoder state. + * @param request This and all remaining parameters should be replaced by one + * of the convenience macros in @ref opus_genericctls, + * @ref opus_encoderctls, or @ref opus_multistream_ctls. + * @see opus_genericctls + * @see opus_encoderctls + * @see opus_multistream_ctls + */ +OPUS_EXPORT int opus_multistream_encoder_ctl(OpusMSEncoder *st, int request, ...) OPUS_ARG_NONNULL(1); + +/**@}*/ + +/**\name Multistream decoder functions */ +/**@{*/ + +/** Gets the size of an OpusMSDecoder structure. + * @param streams int: The total number of streams coded in the + * input. + * This must be no more than 255. + * @param coupled_streams int: Number streams to decode as coupled + * (2 channel) streams. + * This must be no larger than the total + * number of streams. + * Additionally, The total number of + * coded channels (streams + + * coupled_streams) must be no + * more than 255. + * @returns The size in bytes on success, or a negative error code + * (see @ref opus_errorcodes) on error. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_decoder_get_size( + int streams, + int coupled_streams +); + +/** Allocates and initializes a multistream decoder state. + * Call opus_multistream_decoder_destroy() to release + * this object when finished. + * @param Fs opus_int32: Sampling rate to decode at (in Hz). + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param channels int: Number of channels to output. + * This must be at most 255. + * It may be different from the number of coded + * channels (streams + + * coupled_streams). + * @param streams int: The total number of streams coded in the + * input. + * This must be no more than 255. + * @param coupled_streams int: Number of streams to decode as coupled + * (2 channel) streams. + * This must be no larger than the total + * number of streams. + * Additionally, The total number of + * coded channels (streams + + * coupled_streams) must be no + * more than 255. + * @param[in] mapping const unsigned char[channels]: Mapping from + * coded channels to output channels, as described in + * @ref opus_multistream. + * @param[out] error int *: Returns #OPUS_OK on success, or an error + * code (see @ref opus_errorcodes) on + * failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusMSDecoder *opus_multistream_decoder_create( + opus_int32 Fs, + int channels, + int streams, + int coupled_streams, + const unsigned char *mapping, + int *error +) OPUS_ARG_NONNULL(5); + +/** Intialize a previously allocated decoder state object. + * The memory pointed to by \a st must be at least the size returned by + * opus_multistream_encoder_get_size(). + * This is intended for applications which use their own allocator instead of + * malloc. + * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL. + * @see opus_multistream_decoder_create + * @see opus_multistream_deocder_get_size + * @param st OpusMSEncoder*: Multistream encoder state to initialize. + * @param Fs opus_int32: Sampling rate to decode at (in Hz). + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param channels int: Number of channels to output. + * This must be at most 255. + * It may be different from the number of coded + * channels (streams + + * coupled_streams). + * @param streams int: The total number of streams coded in the + * input. + * This must be no more than 255. + * @param coupled_streams int: Number of streams to decode as coupled + * (2 channel) streams. + * This must be no larger than the total + * number of streams. + * Additionally, The total number of + * coded channels (streams + + * coupled_streams) must be no + * more than 255. + * @param[in] mapping const unsigned char[channels]: Mapping from + * coded channels to output channels, as described in + * @ref opus_multistream. + * @returns #OPUS_OK on success, or an error code (see @ref opus_errorcodes) + * on failure. + */ +OPUS_EXPORT int opus_multistream_decoder_init( + OpusMSDecoder *st, + opus_int32 Fs, + int channels, + int streams, + int coupled_streams, + const unsigned char *mapping +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(6); + +/** Decode a multistream Opus packet. + * @param st OpusMSDecoder*: Multistream decoder state. + * @param[in] data const unsigned char*: Input payload. + * Use a NULL + * pointer to indicate packet + * loss. + * @param len opus_int32: Number of bytes in payload. + * @param[out] pcm opus_int16*: Output signal, with interleaved + * samples. + * This must contain room for + * frame_size*channels + * samples. + * @param frame_size int: The number of samples per channel of + * available space in \a pcm. + * If this is less than the maximum packet duration + * (120 ms; 5760 for 48kHz), this function will not be capable + * of decoding some packets. In the case of PLC (data==NULL) + * or FEC (decode_fec=1), then frame_size needs to be exactly + * the duration of audio that is missing, otherwise the + * decoder will not be in the optimal state to decode the + * next incoming packet. For the PLC and FEC cases, frame_size + * must be a multiple of 2.5 ms. + * @param decode_fec int: Flag (0 or 1) to request that any in-band + * forward error correction data be decoded. + * If no such data is available, the frame is + * decoded as if it were lost. + * @returns Number of samples decoded on success or a negative error code + * (see @ref opus_errorcodes) on failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_multistream_decode( + OpusMSDecoder *st, + const unsigned char *data, + opus_int32 len, + opus_int16 *pcm, + int frame_size, + int decode_fec +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4); + +/** Decode a multistream Opus packet with floating point output. + * @param st OpusMSDecoder*: Multistream decoder state. + * @param[in] data const unsigned char*: Input payload. + * Use a NULL + * pointer to indicate packet + * loss. + * @param len opus_int32: Number of bytes in payload. + * @param[out] pcm opus_int16*: Output signal, with interleaved + * samples. + * This must contain room for + * frame_size*channels + * samples. + * @param frame_size int: The number of samples per channel of + * available space in \a pcm. + * If this is less than the maximum packet duration + * (120 ms; 5760 for 48kHz), this function will not be capable + * of decoding some packets. In the case of PLC (data==NULL) + * or FEC (decode_fec=1), then frame_size needs to be exactly + * the duration of audio that is missing, otherwise the + * decoder will not be in the optimal state to decode the + * next incoming packet. For the PLC and FEC cases, frame_size + * must be a multiple of 2.5 ms. + * @param decode_fec int: Flag (0 or 1) to request that any in-band + * forward error correction data be decoded. + * If no such data is available, the frame is + * decoded as if it were lost. + * @returns Number of samples decoded on success or a negative error code + * (see @ref opus_errorcodes) on failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_multistream_decode_float( + OpusMSDecoder *st, + const unsigned char *data, + opus_int32 len, + float *pcm, + int frame_size, + int decode_fec +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4); + +/** Perform a CTL function on a multistream Opus decoder. + * + * Generally the request and subsequent arguments are generated by a + * convenience macro. + * @param st OpusMSDecoder*: Multistream decoder state. + * @param request This and all remaining parameters should be replaced by one + * of the convenience macros in @ref opus_genericctls, + * @ref opus_decoderctls, or @ref opus_multistream_ctls. + * @see opus_genericctls + * @see opus_decoderctls + * @see opus_multistream_ctls + */ +OPUS_EXPORT int opus_multistream_decoder_ctl(OpusMSDecoder *st, int request, ...) OPUS_ARG_NONNULL(1); + +/** Frees an OpusMSDecoder allocated by + * opus_multistream_decoder_create(). + * @param st OpusMSDecoder: Multistream decoder state to be freed. + */ +OPUS_EXPORT void opus_multistream_decoder_destroy(OpusMSDecoder *st); + +/**@}*/ + +/**@}*/ + +#ifdef __cplusplus +} +#endif + +#endif /* OPUS_MULTISTREAM_H */ diff --git a/libs/include/opus/opus_projection.h b/libs/include/opus/opus_projection.h new file mode 100644 index 0000000..9dabf4e --- /dev/null +++ b/libs/include/opus/opus_projection.h @@ -0,0 +1,568 @@ +/* Copyright (c) 2017 Google Inc. + Written by Andrew Allen */ +/* + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/** + * @file opus_projection.h + * @brief Opus projection reference API + */ + +#ifndef OPUS_PROJECTION_H +#define OPUS_PROJECTION_H + +#include "opus_multistream.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** @cond OPUS_INTERNAL_DOC */ + +/** These are the actual encoder and decoder CTL ID numbers. + * They should not be used directly by applications.c + * In general, SETs should be even and GETs should be odd.*/ +/**@{*/ +#define OPUS_PROJECTION_GET_DEMIXING_MATRIX_GAIN_REQUEST 6001 +#define OPUS_PROJECTION_GET_DEMIXING_MATRIX_SIZE_REQUEST 6003 +#define OPUS_PROJECTION_GET_DEMIXING_MATRIX_REQUEST 6005 +/**@}*/ + + +/** @endcond */ + +/** @defgroup opus_projection_ctls Projection specific encoder and decoder CTLs + * + * These are convenience macros that are specific to the + * opus_projection_encoder_ctl() and opus_projection_decoder_ctl() + * interface. + * The CTLs from @ref opus_genericctls, @ref opus_encoderctls, + * @ref opus_decoderctls, and @ref opus_multistream_ctls may be applied to a + * projection encoder or decoder as well. + */ +/**@{*/ + +/** Gets the gain (in dB. S7.8-format) of the demixing matrix from the encoder. + * @param[out] x opus_int32 *: Returns the gain (in dB. S7.8-format) + * of the demixing matrix. + * @hideinitializer + */ +#define OPUS_PROJECTION_GET_DEMIXING_MATRIX_GAIN(x) OPUS_PROJECTION_GET_DEMIXING_MATRIX_GAIN_REQUEST, __opus_check_int_ptr(x) + + +/** Gets the size in bytes of the demixing matrix from the encoder. + * @param[out] x opus_int32 *: Returns the size in bytes of the + * demixing matrix. + * @hideinitializer + */ +#define OPUS_PROJECTION_GET_DEMIXING_MATRIX_SIZE(x) OPUS_PROJECTION_GET_DEMIXING_MATRIX_SIZE_REQUEST, __opus_check_int_ptr(x) + + +/** Copies the demixing matrix to the supplied pointer location. + * @param[out] x unsigned char *: Returns the demixing matrix to the + * supplied pointer location. + * @param y opus_int32: The size in bytes of the reserved memory at the + * pointer location. + * @hideinitializer + */ +#define OPUS_PROJECTION_GET_DEMIXING_MATRIX(x,y) OPUS_PROJECTION_GET_DEMIXING_MATRIX_REQUEST, x, __opus_check_int(y) + + +/**@}*/ + +/** Opus projection encoder state. + * This contains the complete state of a projection Opus encoder. + * It is position independent and can be freely copied. + * @see opus_projection_ambisonics_encoder_create + */ +typedef struct OpusProjectionEncoder OpusProjectionEncoder; + + +/** Opus projection decoder state. + * This contains the complete state of a projection Opus decoder. + * It is position independent and can be freely copied. + * @see opus_projection_decoder_create + * @see opus_projection_decoder_init + */ +typedef struct OpusProjectionDecoder OpusProjectionDecoder; + + +/**\name Projection encoder functions */ +/**@{*/ + +/** Gets the size of an OpusProjectionEncoder structure. + * @param channels int: The total number of input channels to encode. + * This must be no more than 255. + * @param mapping_family int: The mapping family to use for selecting + * the appropriate projection. + * @returns The size in bytes on success, or a negative error code + * (see @ref opus_errorcodes) on error. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_projection_ambisonics_encoder_get_size( + int channels, + int mapping_family +); + + +/** Allocates and initializes a projection encoder state. + * Call opus_projection_encoder_destroy() to release + * this object when finished. + * @param Fs opus_int32: Sampling rate of the input signal (in Hz). + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param channels int: Number of channels in the input signal. + * This must be at most 255. + * It may be greater than the number of + * coded channels (streams + + * coupled_streams). + * @param mapping_family int: The mapping family to use for selecting + * the appropriate projection. + * @param[out] streams int *: The total number of streams that will + * be encoded from the input. + * @param[out] coupled_streams int *: Number of coupled (2 channel) + * streams that will be encoded from the input. + * @param application int: The target encoder application. + * This must be one of the following: + *
+ *
#OPUS_APPLICATION_VOIP
+ *
Process signal for improved speech intelligibility.
+ *
#OPUS_APPLICATION_AUDIO
+ *
Favor faithfulness to the original input.
+ *
#OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ *
Configure the minimum possible coding delay by disabling certain modes + * of operation.
+ *
+ * @param[out] error int *: Returns #OPUS_OK on success, or an error + * code (see @ref opus_errorcodes) on + * failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusProjectionEncoder *opus_projection_ambisonics_encoder_create( + opus_int32 Fs, + int channels, + int mapping_family, + int *streams, + int *coupled_streams, + int application, + int *error +) OPUS_ARG_NONNULL(4) OPUS_ARG_NONNULL(5); + + +/** Initialize a previously allocated projection encoder state. + * The memory pointed to by \a st must be at least the size returned by + * opus_projection_ambisonics_encoder_get_size(). + * This is intended for applications which use their own allocator instead of + * malloc. + * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL. + * @see opus_projection_ambisonics_encoder_create + * @see opus_projection_ambisonics_encoder_get_size + * @param st OpusProjectionEncoder*: Projection encoder state to initialize. + * @param Fs opus_int32: Sampling rate of the input signal (in Hz). + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param channels int: Number of channels in the input signal. + * This must be at most 255. + * It may be greater than the number of + * coded channels (streams + + * coupled_streams). + * @param streams int: The total number of streams to encode from the + * input. + * This must be no more than the number of channels. + * @param coupled_streams int: Number of coupled (2 channel) streams + * to encode. + * This must be no larger than the total + * number of streams. + * Additionally, The total number of + * encoded channels (streams + + * coupled_streams) must be no + * more than the number of input channels. + * @param application int: The target encoder application. + * This must be one of the following: + *
+ *
#OPUS_APPLICATION_VOIP
+ *
Process signal for improved speech intelligibility.
+ *
#OPUS_APPLICATION_AUDIO
+ *
Favor faithfulness to the original input.
+ *
#OPUS_APPLICATION_RESTRICTED_LOWDELAY
+ *
Configure the minimum possible coding delay by disabling certain modes + * of operation.
+ *
+ * @returns #OPUS_OK on success, or an error code (see @ref opus_errorcodes) + * on failure. + */ +OPUS_EXPORT int opus_projection_ambisonics_encoder_init( + OpusProjectionEncoder *st, + opus_int32 Fs, + int channels, + int mapping_family, + int *streams, + int *coupled_streams, + int application +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(5) OPUS_ARG_NONNULL(6); + + +/** Encodes a projection Opus frame. + * @param st OpusProjectionEncoder*: Projection encoder state. + * @param[in] pcm const opus_int16*: The input signal as interleaved + * samples. + * This must contain + * frame_size*channels + * samples. + * @param frame_size int: Number of samples per channel in the input + * signal. + * This must be an Opus frame size for the + * encoder's sampling rate. + * For example, at 48 kHz the permitted values + * are 120, 240, 480, 960, 1920, and 2880. + * Passing in a duration of less than 10 ms + * (480 samples at 48 kHz) will prevent the + * encoder from using the LPC or hybrid modes. + * @param[out] data unsigned char*: Output payload. + * This must contain storage for at + * least \a max_data_bytes. + * @param [in] max_data_bytes opus_int32: Size of the allocated + * memory for the output + * payload. This may be + * used to impose an upper limit on + * the instant bitrate, but should + * not be used as the only bitrate + * control. Use #OPUS_SET_BITRATE to + * control the bitrate. + * @returns The length of the encoded packet (in bytes) on success or a + * negative error code (see @ref opus_errorcodes) on failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_projection_encode( + OpusProjectionEncoder *st, + const opus_int16 *pcm, + int frame_size, + unsigned char *data, + opus_int32 max_data_bytes +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4); + + +/** Encodes a projection Opus frame from floating point input. + * @param st OpusProjectionEncoder*: Projection encoder state. + * @param[in] pcm const float*: The input signal as interleaved + * samples with a normal range of + * +/-1.0. + * Samples with a range beyond +/-1.0 + * are supported but will be clipped by + * decoders using the integer API and + * should only be used if it is known + * that the far end supports extended + * dynamic range. + * This must contain + * frame_size*channels + * samples. + * @param frame_size int: Number of samples per channel in the input + * signal. + * This must be an Opus frame size for the + * encoder's sampling rate. + * For example, at 48 kHz the permitted values + * are 120, 240, 480, 960, 1920, and 2880. + * Passing in a duration of less than 10 ms + * (480 samples at 48 kHz) will prevent the + * encoder from using the LPC or hybrid modes. + * @param[out] data unsigned char*: Output payload. + * This must contain storage for at + * least \a max_data_bytes. + * @param [in] max_data_bytes opus_int32: Size of the allocated + * memory for the output + * payload. This may be + * used to impose an upper limit on + * the instant bitrate, but should + * not be used as the only bitrate + * control. Use #OPUS_SET_BITRATE to + * control the bitrate. + * @returns The length of the encoded packet (in bytes) on success or a + * negative error code (see @ref opus_errorcodes) on failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_projection_encode_float( + OpusProjectionEncoder *st, + const float *pcm, + int frame_size, + unsigned char *data, + opus_int32 max_data_bytes +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4); + + +/** Frees an OpusProjectionEncoder allocated by + * opus_projection_ambisonics_encoder_create(). + * @param st OpusProjectionEncoder*: Projection encoder state to be freed. + */ +OPUS_EXPORT void opus_projection_encoder_destroy(OpusProjectionEncoder *st); + + +/** Perform a CTL function on a projection Opus encoder. + * + * Generally the request and subsequent arguments are generated by a + * convenience macro. + * @param st OpusProjectionEncoder*: Projection encoder state. + * @param request This and all remaining parameters should be replaced by one + * of the convenience macros in @ref opus_genericctls, + * @ref opus_encoderctls, @ref opus_multistream_ctls, or + * @ref opus_projection_ctls + * @see opus_genericctls + * @see opus_encoderctls + * @see opus_multistream_ctls + * @see opus_projection_ctls + */ +OPUS_EXPORT int opus_projection_encoder_ctl(OpusProjectionEncoder *st, int request, ...) OPUS_ARG_NONNULL(1); + + +/**@}*/ + +/**\name Projection decoder functions */ +/**@{*/ + +/** Gets the size of an OpusProjectionDecoder structure. + * @param channels int: The total number of output channels. + * This must be no more than 255. + * @param streams int: The total number of streams coded in the + * input. + * This must be no more than 255. + * @param coupled_streams int: Number streams to decode as coupled + * (2 channel) streams. + * This must be no larger than the total + * number of streams. + * Additionally, The total number of + * coded channels (streams + + * coupled_streams) must be no + * more than 255. + * @returns The size in bytes on success, or a negative error code + * (see @ref opus_errorcodes) on error. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_projection_decoder_get_size( + int channels, + int streams, + int coupled_streams +); + + +/** Allocates and initializes a projection decoder state. + * Call opus_projection_decoder_destroy() to release + * this object when finished. + * @param Fs opus_int32: Sampling rate to decode at (in Hz). + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param channels int: Number of channels to output. + * This must be at most 255. + * It may be different from the number of coded + * channels (streams + + * coupled_streams). + * @param streams int: The total number of streams coded in the + * input. + * This must be no more than 255. + * @param coupled_streams int: Number of streams to decode as coupled + * (2 channel) streams. + * This must be no larger than the total + * number of streams. + * Additionally, The total number of + * coded channels (streams + + * coupled_streams) must be no + * more than 255. + * @param[in] demixing_matrix const unsigned char[demixing_matrix_size]: Demixing matrix + * that mapping from coded channels to output channels, + * as described in @ref opus_projection and + * @ref opus_projection_ctls. + * @param demixing_matrix_size opus_int32: The size in bytes of the + * demixing matrix, as + * described in @ref + * opus_projection_ctls. + * @param[out] error int *: Returns #OPUS_OK on success, or an error + * code (see @ref opus_errorcodes) on + * failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusProjectionDecoder *opus_projection_decoder_create( + opus_int32 Fs, + int channels, + int streams, + int coupled_streams, + unsigned char *demixing_matrix, + opus_int32 demixing_matrix_size, + int *error +) OPUS_ARG_NONNULL(5); + + +/** Intialize a previously allocated projection decoder state object. + * The memory pointed to by \a st must be at least the size returned by + * opus_projection_decoder_get_size(). + * This is intended for applications which use their own allocator instead of + * malloc. + * To reset a previously initialized state, use the #OPUS_RESET_STATE CTL. + * @see opus_projection_decoder_create + * @see opus_projection_deocder_get_size + * @param st OpusProjectionDecoder*: Projection encoder state to initialize. + * @param Fs opus_int32: Sampling rate to decode at (in Hz). + * This must be one of 8000, 12000, 16000, + * 24000, or 48000. + * @param channels int: Number of channels to output. + * This must be at most 255. + * It may be different from the number of coded + * channels (streams + + * coupled_streams). + * @param streams int: The total number of streams coded in the + * input. + * This must be no more than 255. + * @param coupled_streams int: Number of streams to decode as coupled + * (2 channel) streams. + * This must be no larger than the total + * number of streams. + * Additionally, The total number of + * coded channels (streams + + * coupled_streams) must be no + * more than 255. + * @param[in] demixing_matrix const unsigned char[demixing_matrix_size]: Demixing matrix + * that mapping from coded channels to output channels, + * as described in @ref opus_projection and + * @ref opus_projection_ctls. + * @param demixing_matrix_size opus_int32: The size in bytes of the + * demixing matrix, as + * described in @ref + * opus_projection_ctls. + * @returns #OPUS_OK on success, or an error code (see @ref opus_errorcodes) + * on failure. + */ +OPUS_EXPORT int opus_projection_decoder_init( + OpusProjectionDecoder *st, + opus_int32 Fs, + int channels, + int streams, + int coupled_streams, + unsigned char *demixing_matrix, + opus_int32 demixing_matrix_size +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(6); + + +/** Decode a projection Opus packet. + * @param st OpusProjectionDecoder*: Projection decoder state. + * @param[in] data const unsigned char*: Input payload. + * Use a NULL + * pointer to indicate packet + * loss. + * @param len opus_int32: Number of bytes in payload. + * @param[out] pcm opus_int16*: Output signal, with interleaved + * samples. + * This must contain room for + * frame_size*channels + * samples. + * @param frame_size int: The number of samples per channel of + * available space in \a pcm. + * If this is less than the maximum packet duration + * (120 ms; 5760 for 48kHz), this function will not be capable + * of decoding some packets. In the case of PLC (data==NULL) + * or FEC (decode_fec=1), then frame_size needs to be exactly + * the duration of audio that is missing, otherwise the + * decoder will not be in the optimal state to decode the + * next incoming packet. For the PLC and FEC cases, frame_size + * must be a multiple of 2.5 ms. + * @param decode_fec int: Flag (0 or 1) to request that any in-band + * forward error correction data be decoded. + * If no such data is available, the frame is + * decoded as if it were lost. + * @returns Number of samples decoded on success or a negative error code + * (see @ref opus_errorcodes) on failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_projection_decode( + OpusProjectionDecoder *st, + const unsigned char *data, + opus_int32 len, + opus_int16 *pcm, + int frame_size, + int decode_fec +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4); + + +/** Decode a projection Opus packet with floating point output. + * @param st OpusProjectionDecoder*: Projection decoder state. + * @param[in] data const unsigned char*: Input payload. + * Use a NULL + * pointer to indicate packet + * loss. + * @param len opus_int32: Number of bytes in payload. + * @param[out] pcm opus_int16*: Output signal, with interleaved + * samples. + * This must contain room for + * frame_size*channels + * samples. + * @param frame_size int: The number of samples per channel of + * available space in \a pcm. + * If this is less than the maximum packet duration + * (120 ms; 5760 for 48kHz), this function will not be capable + * of decoding some packets. In the case of PLC (data==NULL) + * or FEC (decode_fec=1), then frame_size needs to be exactly + * the duration of audio that is missing, otherwise the + * decoder will not be in the optimal state to decode the + * next incoming packet. For the PLC and FEC cases, frame_size + * must be a multiple of 2.5 ms. + * @param decode_fec int: Flag (0 or 1) to request that any in-band + * forward error correction data be decoded. + * If no such data is available, the frame is + * decoded as if it were lost. + * @returns Number of samples decoded on success or a negative error code + * (see @ref opus_errorcodes) on failure. + */ +OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_projection_decode_float( + OpusProjectionDecoder *st, + const unsigned char *data, + opus_int32 len, + float *pcm, + int frame_size, + int decode_fec +) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4); + + +/** Perform a CTL function on a projection Opus decoder. + * + * Generally the request and subsequent arguments are generated by a + * convenience macro. + * @param st OpusProjectionDecoder*: Projection decoder state. + * @param request This and all remaining parameters should be replaced by one + * of the convenience macros in @ref opus_genericctls, + * @ref opus_decoderctls, @ref opus_multistream_ctls, or + * @ref opus_projection_ctls. + * @see opus_genericctls + * @see opus_decoderctls + * @see opus_multistream_ctls + * @see opus_projection_ctls + */ +OPUS_EXPORT int opus_projection_decoder_ctl(OpusProjectionDecoder *st, int request, ...) OPUS_ARG_NONNULL(1); + + +/** Frees an OpusProjectionDecoder allocated by + * opus_projection_decoder_create(). + * @param st OpusProjectionDecoder: Projection decoder state to be freed. + */ +OPUS_EXPORT void opus_projection_decoder_destroy(OpusProjectionDecoder *st); + + +/**@}*/ + +/**@}*/ + +#ifdef __cplusplus +} +#endif + +#endif /* OPUS_PROJECTION_H */ diff --git a/libs/include/opus/opus_types.h b/libs/include/opus/opus_types.h new file mode 100644 index 0000000..7cf6755 --- /dev/null +++ b/libs/include/opus/opus_types.h @@ -0,0 +1,166 @@ +/* (C) COPYRIGHT 1994-2002 Xiph.Org Foundation */ +/* Modified by Jean-Marc Valin */ +/* + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +/* opus_types.h based on ogg_types.h from libogg */ + +/** + @file opus_types.h + @brief Opus reference implementation types +*/ +#ifndef OPUS_TYPES_H +#define OPUS_TYPES_H + +#define opus_int int /* used for counters etc; at least 16 bits */ +#define opus_int64 long long +#define opus_int8 signed char + +#define opus_uint unsigned int /* used for counters etc; at least 16 bits */ +#define opus_uint64 unsigned long long +#define opus_uint8 unsigned char + +/* Use the real stdint.h if it's there (taken from Paul Hsieh's pstdint.h) */ +#if (defined(__STDC__) && __STDC__ && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || (defined(__GNUC__) && (defined(_STDINT_H) || defined(_STDINT_H_)) || defined (HAVE_STDINT_H)) +#include +# undef opus_int64 +# undef opus_int8 +# undef opus_uint64 +# undef opus_uint8 + typedef int8_t opus_int8; + typedef uint8_t opus_uint8; + typedef int16_t opus_int16; + typedef uint16_t opus_uint16; + typedef int32_t opus_int32; + typedef uint32_t opus_uint32; + typedef int64_t opus_int64; + typedef uint64_t opus_uint64; +#elif defined(_WIN32) + +# if defined(__CYGWIN__) +# include <_G_config.h> + typedef _G_int32_t opus_int32; + typedef _G_uint32_t opus_uint32; + typedef _G_int16 opus_int16; + typedef _G_uint16 opus_uint16; +# elif defined(__MINGW32__) + typedef short opus_int16; + typedef unsigned short opus_uint16; + typedef int opus_int32; + typedef unsigned int opus_uint32; +# elif defined(__MWERKS__) + typedef int opus_int32; + typedef unsigned int opus_uint32; + typedef short opus_int16; + typedef unsigned short opus_uint16; +# else + /* MSVC/Borland */ + typedef __int32 opus_int32; + typedef unsigned __int32 opus_uint32; + typedef __int16 opus_int16; + typedef unsigned __int16 opus_uint16; +# endif + +#elif defined(__MACOS__) + +# include + typedef SInt16 opus_int16; + typedef UInt16 opus_uint16; + typedef SInt32 opus_int32; + typedef UInt32 opus_uint32; + +#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */ + +# include + typedef int16_t opus_int16; + typedef u_int16_t opus_uint16; + typedef int32_t opus_int32; + typedef u_int32_t opus_uint32; + +#elif defined(__BEOS__) + + /* Be */ +# include + typedef int16 opus_int16; + typedef u_int16 opus_uint16; + typedef int32_t opus_int32; + typedef u_int32_t opus_uint32; + +#elif defined (__EMX__) + + /* OS/2 GCC */ + typedef short opus_int16; + typedef unsigned short opus_uint16; + typedef int opus_int32; + typedef unsigned int opus_uint32; + +#elif defined (DJGPP) + + /* DJGPP */ + typedef short opus_int16; + typedef unsigned short opus_uint16; + typedef int opus_int32; + typedef unsigned int opus_uint32; + +#elif defined(R5900) + + /* PS2 EE */ + typedef int opus_int32; + typedef unsigned opus_uint32; + typedef short opus_int16; + typedef unsigned short opus_uint16; + +#elif defined(__SYMBIAN32__) + + /* Symbian GCC */ + typedef signed short opus_int16; + typedef unsigned short opus_uint16; + typedef signed int opus_int32; + typedef unsigned int opus_uint32; + +#elif defined(CONFIG_TI_C54X) || defined (CONFIG_TI_C55X) + + typedef short opus_int16; + typedef unsigned short opus_uint16; + typedef long opus_int32; + typedef unsigned long opus_uint32; + +#elif defined(CONFIG_TI_C6X) + + typedef short opus_int16; + typedef unsigned short opus_uint16; + typedef int opus_int32; + typedef unsigned int opus_uint32; + +#else + + /* Give up, take a reasonable guess */ + typedef short opus_int16; + typedef unsigned short opus_uint16; + typedef int opus_int32; + typedef unsigned int opus_uint32; + +#endif + +#endif /* OPUS_TYPES_H */ diff --git a/libs/include/opus/opusfile.h b/libs/include/opus/opusfile.h new file mode 100644 index 0000000..e3a3dc8 --- /dev/null +++ b/libs/include/opus/opusfile.h @@ -0,0 +1,2164 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE libopusfile SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE libopusfile SOURCE CODE IS (C) COPYRIGHT 1994-2012 * + * by the Xiph.Org Foundation and contributors http://www.xiph.org/ * + * * + ******************************************************************** + + function: stdio-based convenience library for opening/seeking/decoding + last mod: $Id: vorbisfile.h 17182 2010-04-29 03:48:32Z xiphmont $ + + ********************************************************************/ +#if !defined(_opusfile_h) +# define _opusfile_h (1) + +/**\mainpage + \section Introduction + + This is the documentation for the libopusfile C API. + + The libopusfile package provides a convenient high-level API for + decoding and basic manipulation of all Ogg Opus audio streams. + libopusfile is implemented as a layer on top of Xiph.Org's + reference + libogg + and + libopus + libraries. + + libopusfile provides several sets of built-in routines for + file/stream access, and may also use custom stream I/O routines provided by + the embedded environment. + There are built-in I/O routines provided for ANSI-compliant + stdio (FILE *), memory buffers, and URLs + (including URLs, plus optionally and URLs). + + \section Organization + + The main API is divided into several sections: + - \ref stream_open_close + - \ref stream_info + - \ref stream_decoding + - \ref stream_seeking + + Several additional sections are not tied to the main API. + - \ref stream_callbacks + - \ref header_info + - \ref error_codes + + \section Overview + + The libopusfile API always decodes files to 48 kHz. + The original sample rate is not preserved by the lossy compression, though + it is stored in the header to allow you to resample to it after decoding + (the libopusfile API does not currently provide a resampler, + but the + the + Speex resampler is a good choice if you need one). + In general, if you are playing back the audio, you should leave it at + 48 kHz, provided your audio hardware supports it. + When decoding to a file, it may be worth resampling back to the original + sample rate, so as not to surprise users who might not expect the sample + rate to change after encoding to Opus and decoding. + + Opus files can contain anywhere from 1 to 255 channels of audio. + The channel mappings for up to 8 channels are the same as the + Vorbis + mappings. + A special stereo API can convert everything to 2 channels, making it simple + to support multichannel files in an application which only has stereo + output. + Although the libopusfile ABI provides support for the theoretical + maximum number of channels, the current implementation does not support + files with more than 8 channels, as they do not have well-defined channel + mappings. + + Like all Ogg files, Opus files may be "chained". + That is, multiple Opus files may be combined into a single, longer file just + by concatenating the original files. + This is commonly done in internet radio streaming, as it allows the title + and artist to be updated each time the song changes, since each link in the + chain includes its own set of metadata. + + libopusfile fully supports chained files. + It will decode the first Opus stream found in each link of a chained file + (ignoring any other streams that might be concurrently multiplexed with it, + such as a video stream). + + The channel count can also change between links. + If your application is not prepared to deal with this, it can use the stereo + API to ensure the audio from all links will always get decoded into a + common format. + Since libopusfile always decodes to 48 kHz, you do not have to + worry about the sample rate changing between links (as was possible with + Vorbis). + This makes application support for chained files with libopusfile + very easy.*/ + +# if defined(__cplusplus) +extern "C" { +# endif + +# include +# include +# include +# include + +/**@cond PRIVATE*/ + +/*Enable special features for gcc and gcc-compatible compilers.*/ +# if !defined(OP_GNUC_PREREQ) +# if defined(__GNUC__)&&defined(__GNUC_MINOR__) +# define OP_GNUC_PREREQ(_maj,_min) \ + ((__GNUC__<<16)+__GNUC_MINOR__>=((_maj)<<16)+(_min)) +# else +# define OP_GNUC_PREREQ(_maj,_min) 0 +# endif +# endif + +# if OP_GNUC_PREREQ(4,0) +# pragma GCC visibility push(default) +# endif + +typedef struct OpusHead OpusHead; +typedef struct OpusTags OpusTags; +typedef struct OpusPictureTag OpusPictureTag; +typedef struct OpusServerInfo OpusServerInfo; +typedef struct OpusFileCallbacks OpusFileCallbacks; +typedef struct OggOpusFile OggOpusFile; + +/*Warning attributes for libopusfile functions.*/ +# if OP_GNUC_PREREQ(3,4) +# define OP_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) +# else +# define OP_WARN_UNUSED_RESULT +# endif +# if OP_GNUC_PREREQ(3,4) +# define OP_ARG_NONNULL(_x) __attribute__((__nonnull__(_x))) +# else +# define OP_ARG_NONNULL(_x) +# endif + +/**@endcond*/ + +/**\defgroup error_codes Error Codes*/ +/*@{*/ +/**\name List of possible error codes + Many of the functions in this library return a negative error code when a + function fails. + This list provides a brief explanation of the common errors. + See each individual function for more details on what a specific error code + means in that context.*/ +/*@{*/ + +/**A request did not succeed.*/ +#define OP_FALSE (-1) +/*Currently not used externally.*/ +#define OP_EOF (-2) +/**There was a hole in the page sequence numbers (e.g., a page was corrupt or + missing).*/ +#define OP_HOLE (-3) +/**An underlying read, seek, or tell operation failed when it should have + succeeded.*/ +#define OP_EREAD (-128) +/**A NULL pointer was passed where one was unexpected, or an + internal memory allocation failed, or an internal library error was + encountered.*/ +#define OP_EFAULT (-129) +/**The stream used a feature that is not implemented, such as an unsupported + channel family.*/ +#define OP_EIMPL (-130) +/**One or more parameters to a function were invalid.*/ +#define OP_EINVAL (-131) +/**A purported Ogg Opus stream did not begin with an Ogg page, a purported + header packet did not start with one of the required strings, "OpusHead" or + "OpusTags", or a link in a chained file was encountered that did not + contain any logical Opus streams.*/ +#define OP_ENOTFORMAT (-132) +/**A required header packet was not properly formatted, contained illegal + values, or was missing altogether.*/ +#define OP_EBADHEADER (-133) +/**The ID header contained an unrecognized version number.*/ +#define OP_EVERSION (-134) +/*Currently not used at all.*/ +#define OP_ENOTAUDIO (-135) +/**An audio packet failed to decode properly. + This is usually caused by a multistream Ogg packet where the durations of + the individual Opus packets contained in it are not all the same.*/ +#define OP_EBADPACKET (-136) +/**We failed to find data we had seen before, or the bitstream structure was + sufficiently malformed that seeking to the target destination was + impossible.*/ +#define OP_EBADLINK (-137) +/**An operation that requires seeking was requested on an unseekable stream.*/ +#define OP_ENOSEEK (-138) +/**The first or last granule position of a link failed basic validity checks.*/ +#define OP_EBADTIMESTAMP (-139) + +/*@}*/ +/*@}*/ + +/**\defgroup header_info Header Information*/ +/*@{*/ + +/**The maximum number of channels in an Ogg Opus stream.*/ +#define OPUS_CHANNEL_COUNT_MAX (255) + +/**Ogg Opus bitstream information. + This contains the basic playback parameters for a stream, and corresponds to + the initial ID header packet of an Ogg Opus stream.*/ +struct OpusHead{ + /**The Ogg Opus format version, in the range 0...255. + The top 4 bits represent a "major" version, and the bottom four bits + represent backwards-compatible "minor" revisions. + The current specification describes version 1. + This library will recognize versions up through 15 as backwards compatible + with the current specification. + An earlier draft of the specification described a version 0, but the only + difference between version 1 and version 0 is that version 0 did + not specify the semantics for handling the version field.*/ + int version; + /**The number of channels, in the range 1...255.*/ + int channel_count; + /**The number of samples that should be discarded from the beginning of the + stream.*/ + unsigned pre_skip; + /**The sampling rate of the original input. + All Opus audio is coded at 48 kHz, and should also be decoded at 48 kHz + for playback (unless the target hardware does not support this sampling + rate). + However, this field may be used to resample the audio back to the original + sampling rate, for example, when saving the output to a file.*/ + opus_uint32 input_sample_rate; + /**The gain to apply to the decoded output, in dB, as a Q8 value in the range + -32768...32767. + The libopusfile API will automatically apply this gain to the + decoded output before returning it, scaling it by + pow(10,output_gain/(20.0*256)). + You can adjust this behavior with op_set_gain_offset().*/ + int output_gain; + /**The channel mapping family, in the range 0...255. + Channel mapping family 0 covers mono or stereo in a single stream. + Channel mapping family 1 covers 1 to 8 channels in one or more streams, + using the Vorbis speaker assignments. + Channel mapping family 255 covers 1 to 255 channels in one or more + streams, but without any defined speaker assignment.*/ + int mapping_family; + /**The number of Opus streams in each Ogg packet, in the range 1...255.*/ + int stream_count; + /**The number of coupled Opus streams in each Ogg packet, in the range + 0...127. + This must satisfy 0 <= coupled_count <= stream_count and + coupled_count + stream_count <= 255. + The coupled streams appear first, before all uncoupled streams, in an Ogg + Opus packet.*/ + int coupled_count; + /**The mapping from coded stream channels to output channels. + Let index=mapping[k] be the value for channel k. + If index<2*coupled_count, then it refers to the left channel + from stream (index/2) if even, and the right channel from + stream (index/2) if odd. + Otherwise, it refers to the output of the uncoupled stream + (index-coupled_count).*/ + unsigned char mapping[OPUS_CHANNEL_COUNT_MAX]; +}; + +/**The metadata from an Ogg Opus stream. + + This structure holds the in-stream metadata corresponding to the 'comment' + header packet of an Ogg Opus stream. + The comment header is meant to be used much like someone jotting a quick + note on the label of a CD. + It should be a short, to the point text note that can be more than a couple + words, but not more than a short paragraph. + + The metadata is stored as a series of (tag, value) pairs, in length-encoded + string vectors, using the same format as Vorbis (without the final "framing + bit"), Theora, and Speex, except for the packet header. + The first occurrence of the '=' character delimits the tag and value. + A particular tag may occur more than once, and order is significant. + The character set encoding for the strings is always UTF-8, but the tag + names are limited to ASCII, and treated as case-insensitive. + See the Vorbis + comment header specification for details. + + In filling in this structure, libopusfile will null-terminate the + #user_comments strings for safety. + However, the bitstream format itself treats them as 8-bit clean vectors, + possibly containing NUL characters, so the #comment_lengths array should be + treated as their authoritative length. + + This structure is binary and source-compatible with a + vorbis_comment, and pointers to it may be freely cast to + vorbis_comment pointers, and vice versa. + It is provided as a separate type to avoid introducing a compile-time + dependency on the libvorbis headers.*/ +struct OpusTags{ + /**The array of comment string vectors.*/ + char **user_comments; + /**An array of the corresponding length of each vector, in bytes.*/ + int *comment_lengths; + /**The total number of comment streams.*/ + int comments; + /**The null-terminated vendor string. + This identifies the software used to encode the stream.*/ + char *vendor; +}; + +/**\name Picture tag image formats*/ +/*@{*/ + +/**The MIME type was not recognized, or the image data did not match the + declared MIME type.*/ +#define OP_PIC_FORMAT_UNKNOWN (-1) +/**The MIME type indicates the image data is really a URL.*/ +#define OP_PIC_FORMAT_URL (0) +/**The image is a JPEG.*/ +#define OP_PIC_FORMAT_JPEG (1) +/**The image is a PNG.*/ +#define OP_PIC_FORMAT_PNG (2) +/**The image is a GIF.*/ +#define OP_PIC_FORMAT_GIF (3) + +/*@}*/ + +/**The contents of a METADATA_BLOCK_PICTURE tag.*/ +struct OpusPictureTag{ + /**The picture type according to the ID3v2 APIC frame: +
    +
  1. Other
    2. +
  2. 32x32 pixels 'file icon' (PNG only)
    3. +
  3. Other file icon
    4. +
  4. Cover (front)
    5. +
  5. Cover (back)
    6. +
  6. Leaflet page
    7. +
  7. Media (e.g. label side of CD)
    8. +
  8. Lead artist/lead performer/soloist
    9. +
  9. Artist/performer
    10. +
  10. Conductor
    11. +
  11. Band/Orchestra
    12. +
  12. Composer
    13. +
  13. Lyricist/text writer
    14. +
  14. Recording Location
    15. +
  15. During recording
    16. +
  16. During performance
    17. +
  17. Movie/video screen capture
    18. +
  18. A bright colored fish
    19. +
  19. Illustration
    20. +
  20. Band/artist logotype
    21. +
  21. Publisher/Studio logotype
    22. +
+ Others are reserved and should not be used. + There may only be one each of picture type 1 and 2 in a file.*/ + opus_int32 type; + /**The MIME type of the picture, in printable ASCII characters 0x20-0x7E. + The MIME type may also be "-->" to signify that the data part + is a URL pointing to the picture instead of the picture data itself. + In this case, a terminating NUL is appended to the URL string in #data, + but #data_length is set to the length of the string excluding that + terminating NUL.*/ + char *mime_type; + /**The description of the picture, in UTF-8.*/ + char *description; + /**The width of the picture in pixels.*/ + opus_uint32 width; + /**The height of the picture in pixels.*/ + opus_uint32 height; + /**The color depth of the picture in bits-per-pixel (not + bits-per-channel).*/ + opus_uint32 depth; + /**For indexed-color pictures (e.g., GIF), the number of colors used, or 0 + for non-indexed pictures.*/ + opus_uint32 colors; + /**The length of the picture data in bytes.*/ + opus_uint32 data_length; + /**The binary picture data.*/ + unsigned char *data; + /**The format of the picture data, if known. + One of +
    +
  • #OP_PIC_FORMAT_UNKNOWN,
    • +
  • #OP_PIC_FORMAT_URL,
    • +
  • #OP_PIC_FORMAT_JPEG,
    • +
  • #OP_PIC_FORMAT_PNG, or
    • +
  • #OP_PIC_FORMAT_GIF.
    • +
*/ + int format; +}; + +/**\name Functions for manipulating header data + + These functions manipulate the #OpusHead and #OpusTags structures, + which describe the audio parameters and tag-value metadata, respectively. + These can be used to query the headers returned by libopusfile, or + to parse Opus headers from sources other than an Ogg Opus stream, provided + they use the same format.*/ +/*@{*/ + +/**Parses the contents of the ID header packet of an Ogg Opus stream. + \param[out] _head Returns the contents of the parsed packet. + The contents of this structure are untouched on error. + This may be NULL to merely test the header + for validity. + \param[in] _data The contents of the ID header packet. + \param _len The number of bytes of data in the ID header packet. + \return 0 on success or a negative value on error. + \retval #OP_ENOTFORMAT If the data does not start with the "OpusHead" + string. + \retval #OP_EVERSION If the version field signaled a version this library + does not know how to parse. + \retval #OP_EIMPL If the channel mapping family was 255, which general + purpose players should not attempt to play. + \retval #OP_EBADHEADER If the contents of the packet otherwise violate the + Ogg Opus specification: +
    +
  • Insufficient data,
    • +
  • Too much data for the known minor versions,
    • +
  • An unrecognized channel mapping family,
    • +
  • Zero channels or too many channels,
    • +
  • Zero coded streams,
    • +
  • Too many coupled streams, or
    • +
  • An invalid channel mapping index.
    • +
*/ +OP_WARN_UNUSED_RESULT int opus_head_parse(OpusHead *_head, + const unsigned char *_data,size_t _len) OP_ARG_NONNULL(2); + +/**Converts a granule position to a sample offset for a given Ogg Opus stream. + The sample offset is simply _gp-_head->pre_skip. + Granule position values smaller than OpusHead#pre_skip correspond to audio + that should never be played, and thus have no associated sample offset. + This function returns -1 for such values. + This function also correctly handles extremely large granule positions, + which may have wrapped around to a negative number when stored in a signed + ogg_int64_t value. + \param _head The #OpusHead information from the ID header of the stream. + \param _gp The granule position to convert. + \return The sample offset associated with the given granule position + (counting at a 48 kHz sampling rate), or the special value -1 on + error (i.e., the granule position was smaller than the pre-skip + amount).*/ +ogg_int64_t opus_granule_sample(const OpusHead *_head,ogg_int64_t _gp) + OP_ARG_NONNULL(1); + +/**Parses the contents of the 'comment' header packet of an Ogg Opus stream. + \param[out] _tags An uninitialized #OpusTags structure. + This returns the contents of the parsed packet. + The contents of this structure are untouched on error. + This may be NULL to merely test the header + for validity. + \param[in] _data The contents of the 'comment' header packet. + \param _len The number of bytes of data in the 'info' header packet. + \retval 0 Success. + \retval #OP_ENOTFORMAT If the data does not start with the "OpusTags" + string. + \retval #OP_EBADHEADER If the contents of the packet otherwise violate the + Ogg Opus specification. + \retval #OP_EFAULT If there wasn't enough memory to store the tags.*/ +OP_WARN_UNUSED_RESULT int opus_tags_parse(OpusTags *_tags, + const unsigned char *_data,size_t _len) OP_ARG_NONNULL(2); + +/**Performs a deep copy of an #OpusTags structure. + \param _dst The #OpusTags structure to copy into. + If this function fails, the contents of this structure remain + untouched. + \param _src The #OpusTags structure to copy from. + \retval 0 Success. + \retval #OP_EFAULT If there wasn't enough memory to copy the tags.*/ +int opus_tags_copy(OpusTags *_dst,const OpusTags *_src) OP_ARG_NONNULL(1); + +/**Initializes an #OpusTags structure. + This should be called on a freshly allocated #OpusTags structure before + attempting to use it. + \param _tags The #OpusTags structure to initialize.*/ +void opus_tags_init(OpusTags *_tags) OP_ARG_NONNULL(1); + +/**Add a (tag, value) pair to an initialized #OpusTags structure. + \note Neither opus_tags_add() nor opus_tags_add_comment() support values + containing embedded NULs, although the bitstream format does support them. + To add such tags, you will need to manipulate the #OpusTags structure + directly. + \param _tags The #OpusTags structure to add the (tag, value) pair to. + \param _tag A NUL-terminated, case-insensitive, ASCII string containing + the tag to add (without an '=' character). + \param _value A NUL-terminated UTF-8 containing the corresponding value. + \return 0 on success, or a negative value on failure. + \retval #OP_EFAULT An internal memory allocation failed.*/ +int opus_tags_add(OpusTags *_tags,const char *_tag,const char *_value) + OP_ARG_NONNULL(1) OP_ARG_NONNULL(2) OP_ARG_NONNULL(3); + +/**Add a comment to an initialized #OpusTags structure. + \note Neither opus_tags_add_comment() nor opus_tags_add() support comments + containing embedded NULs, although the bitstream format does support them. + To add such tags, you will need to manipulate the #OpusTags structure + directly. + \param _tags The #OpusTags structure to add the comment to. + \param _comment A NUL-terminated UTF-8 string containing the comment in + "TAG=value" form. + \return 0 on success, or a negative value on failure. + \retval #OP_EFAULT An internal memory allocation failed.*/ +int opus_tags_add_comment(OpusTags *_tags,const char *_comment) + OP_ARG_NONNULL(1) OP_ARG_NONNULL(2); + +/**Replace the binary suffix data at the end of the packet (if any). + \param _tags An initialized #OpusTags structure. + \param _data A buffer of binary data to append after the encoded user + comments. + The least significant bit of the first byte of this data must + be set (to ensure the data is preserved by other editors). + \param _len The number of bytes of binary data to append. + This may be zero to remove any existing binary suffix data. + \return 0 on success, or a negative value on error. + \retval #OP_EINVAL \a _len was negative, or \a _len was positive but + \a _data was NULL or the least significant + bit of the first byte was not set. + \retval #OP_EFAULT An internal memory allocation failed.*/ +int opus_tags_set_binary_suffix(OpusTags *_tags, + const unsigned char *_data,int _len) OP_ARG_NONNULL(1); + +/**Look up a comment value by its tag. + \param _tags An initialized #OpusTags structure. + \param _tag The tag to look up. + \param _count The instance of the tag. + The same tag can appear multiple times, each with a distinct + value, so an index is required to retrieve them all. + The order in which these values appear is significant and + should be preserved. + Use opus_tags_query_count() to get the legal range for the + \a _count parameter. + \return A pointer to the queried tag's value. + This points directly to data in the #OpusTags structure. + It should not be modified or freed by the application, and + modifications to the structure may invalidate the pointer. + \retval NULL If no matching tag is found.*/ +const char *opus_tags_query(const OpusTags *_tags,const char *_tag,int _count) + OP_ARG_NONNULL(1) OP_ARG_NONNULL(2); + +/**Look up the number of instances of a tag. + Call this first when querying for a specific tag and then iterate over the + number of instances with separate calls to opus_tags_query() to retrieve + all the values for that tag in order. + \param _tags An initialized #OpusTags structure. + \param _tag The tag to look up. + \return The number of instances of this particular tag.*/ +int opus_tags_query_count(const OpusTags *_tags,const char *_tag) + OP_ARG_NONNULL(1) OP_ARG_NONNULL(2); + +/**Retrieve the binary suffix data at the end of the packet (if any). + \param _tags An initialized #OpusTags structure. + \param[out] _len Returns the number of bytes of binary suffix data returned. + \return A pointer to the binary suffix data, or NULL if none + was present.*/ +const unsigned char *opus_tags_get_binary_suffix(const OpusTags *_tags, + int *_len) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2); + +/**Get the album gain from an R128_ALBUM_GAIN tag, if one was specified. + This searches for the first R128_ALBUM_GAIN tag with a valid signed, + 16-bit decimal integer value and returns the value. + This routine is exposed merely for convenience for applications which wish + to do something special with the album gain (i.e., display it). + If you simply wish to apply the album gain instead of the header gain, you + can use op_set_gain_offset() with an #OP_ALBUM_GAIN type and no offset. + \param _tags An initialized #OpusTags structure. + \param[out] _gain_q8 The album gain, in 1/256ths of a dB. + This will lie in the range [-32768,32767], and should + be applied in addition to the header gain. + On error, no value is returned, and the previous + contents remain unchanged. + \return 0 on success, or a negative value on error. + \retval #OP_FALSE There was no album gain available in the given tags.*/ +int opus_tags_get_album_gain(const OpusTags *_tags,int *_gain_q8) + OP_ARG_NONNULL(1) OP_ARG_NONNULL(2); + +/**Get the track gain from an R128_TRACK_GAIN tag, if one was specified. + This searches for the first R128_TRACK_GAIN tag with a valid signed, + 16-bit decimal integer value and returns the value. + This routine is exposed merely for convenience for applications which wish + to do something special with the track gain (i.e., display it). + If you simply wish to apply the track gain instead of the header gain, you + can use op_set_gain_offset() with an #OP_TRACK_GAIN type and no offset. + \param _tags An initialized #OpusTags structure. + \param[out] _gain_q8 The track gain, in 1/256ths of a dB. + This will lie in the range [-32768,32767], and should + be applied in addition to the header gain. + On error, no value is returned, and the previous + contents remain unchanged. + \return 0 on success, or a negative value on error. + \retval #OP_FALSE There was no track gain available in the given tags.*/ +int opus_tags_get_track_gain(const OpusTags *_tags,int *_gain_q8) + OP_ARG_NONNULL(1) OP_ARG_NONNULL(2); + +/**Clears the #OpusTags structure. + This should be called on an #OpusTags structure after it is no longer + needed. + It will free all memory used by the structure members. + \param _tags The #OpusTags structure to clear.*/ +void opus_tags_clear(OpusTags *_tags) OP_ARG_NONNULL(1); + +/**Check if \a _comment is an instance of a \a _tag_name tag. + \see opus_tagncompare + \param _tag_name A NUL-terminated, case-insensitive, ASCII string containing + the name of the tag to check for (without the terminating + '=' character). + \param _comment The comment string to check. + \return An integer less than, equal to, or greater than zero if \a _comment + is found respectively, to be less than, to match, or be greater + than a "tag=value" string whose tag matches \a _tag_name.*/ +int opus_tagcompare(const char *_tag_name,const char *_comment); + +/**Check if \a _comment is an instance of a \a _tag_name tag. + This version is slightly more efficient than opus_tagcompare() if the length + of the tag name is already known (e.g., because it is a constant). + \see opus_tagcompare + \param _tag_name A case-insensitive ASCII string containing the name of the + tag to check for (without the terminating '=' character). + \param _tag_len The number of characters in the tag name. + This must be non-negative. + \param _comment The comment string to check. + \return An integer less than, equal to, or greater than zero if \a _comment + is found respectively, to be less than, to match, or be greater + than a "tag=value" string whose tag matches the first \a _tag_len + characters of \a _tag_name.*/ +int opus_tagncompare(const char *_tag_name,int _tag_len,const char *_comment); + +/**Parse a single METADATA_BLOCK_PICTURE tag. + This decodes the BASE64-encoded content of the tag and returns a structure + with the MIME type, description, image parameters (if known), and the + compressed image data. + If the MIME type indicates the presence of an image format we recognize + (JPEG, PNG, or GIF) and the actual image data contains the magic signature + associated with that format, then the OpusPictureTag::format field will be + set to the corresponding format. + This is provided as a convenience to avoid requiring applications to parse + the MIME type and/or do their own format detection for the commonly used + formats. + In this case, we also attempt to extract the image parameters directly from + the image data (overriding any that were present in the tag, which the + specification says applications are not meant to rely on). + The application must still provide its own support for actually decoding the + image data and, if applicable, retrieving that data from URLs. + \param[out] _pic Returns the parsed picture data. + No sanitation is done on the type, MIME type, or + description fields, so these might return invalid values. + The contents of this structure are left unmodified on + failure. + \param _tag The METADATA_BLOCK_PICTURE tag contents. + The leading "METADATA_BLOCK_PICTURE=" portion is optional, + to allow the function to be used on either directly on the + values in OpusTags::user_comments or on the return value + of opus_tags_query(). + \return 0 on success or a negative value on error. + \retval #OP_ENOTFORMAT The METADATA_BLOCK_PICTURE contents were not valid. + \retval #OP_EFAULT There was not enough memory to store the picture tag + contents.*/ +OP_WARN_UNUSED_RESULT int opus_picture_tag_parse(OpusPictureTag *_pic, + const char *_tag) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2); + +/**Initializes an #OpusPictureTag structure. + This should be called on a freshly allocated #OpusPictureTag structure + before attempting to use it. + \param _pic The #OpusPictureTag structure to initialize.*/ +void opus_picture_tag_init(OpusPictureTag *_pic) OP_ARG_NONNULL(1); + +/**Clears the #OpusPictureTag structure. + This should be called on an #OpusPictureTag structure after it is no longer + needed. + It will free all memory used by the structure members. + \param _pic The #OpusPictureTag structure to clear.*/ +void opus_picture_tag_clear(OpusPictureTag *_pic) OP_ARG_NONNULL(1); + +/*@}*/ + +/*@}*/ + +/**\defgroup url_options URL Reading Options*/ +/*@{*/ +/**\name URL reading options + Options for op_url_stream_create() and associated functions. + These allow you to provide proxy configuration parameters, skip SSL + certificate checks, etc. + Options are processed in order, and if the same option is passed multiple + times, only the value specified by the last occurrence has an effect + (unless otherwise specified). + They may be expanded in the future.*/ +/*@{*/ + +/**@cond PRIVATE*/ + +/*These are the raw numbers used to define the request codes. + They should not be used directly.*/ +#define OP_SSL_SKIP_CERTIFICATE_CHECK_REQUEST (6464) +#define OP_HTTP_PROXY_HOST_REQUEST (6528) +#define OP_HTTP_PROXY_PORT_REQUEST (6592) +#define OP_HTTP_PROXY_USER_REQUEST (6656) +#define OP_HTTP_PROXY_PASS_REQUEST (6720) +#define OP_GET_SERVER_INFO_REQUEST (6784) + +#define OP_URL_OPT(_request) ((_request)+(char *)0) + +/*These macros trigger compilation errors or warnings if the wrong types are + provided to one of the URL options.*/ +#define OP_CHECK_INT(_x) ((void)((_x)==(opus_int32)0),(opus_int32)(_x)) +#define OP_CHECK_CONST_CHAR_PTR(_x) ((_x)+((_x)-(const char *)(_x))) +#define OP_CHECK_SERVER_INFO_PTR(_x) ((_x)+((_x)-(OpusServerInfo *)(_x))) + +/**@endcond*/ + +/**HTTP/Shoutcast/Icecast server information associated with a URL.*/ +struct OpusServerInfo{ + /**The name of the server (icy-name/ice-name). + This is NULL if there was no icy-name or + ice-name header.*/ + char *name; + /**A short description of the server (icy-description/ice-description). + This is NULL if there was no icy-description or + ice-description header.*/ + char *description; + /**The genre the server falls under (icy-genre/ice-genre). + This is NULL if there was no icy-genre or + ice-genre header.*/ + char *genre; + /**The homepage for the server (icy-url/ice-url). + This is NULL if there was no icy-url or + ice-url header.*/ + char *url; + /**The software used by the origin server (Server). + This is NULL if there was no Server header.*/ + char *server; + /**The media type of the entity sent to the recepient (Content-Type). + This is NULL if there was no Content-Type + header.*/ + char *content_type; + /**The nominal stream bitrate in kbps (icy-br/ice-bitrate). + This is -1 if there was no icy-br or + ice-bitrate header.*/ + opus_int32 bitrate_kbps; + /**Flag indicating whether the server is public (1) or not + (0) (icy-pub/ice-public). + This is -1 if there was no icy-pub or + ice-public header.*/ + int is_public; + /**Flag indicating whether the server is using HTTPS instead of HTTP. + This is 0 unless HTTPS is being used. + This may not match the protocol used in the original URL if there were + redirections.*/ + int is_ssl; +}; + +/**Initializes an #OpusServerInfo structure. + All fields are set as if the corresponding header was not available. + \param _info The #OpusServerInfo structure to initialize. + \note If you use this function, you must link against libopusurl.*/ +void opus_server_info_init(OpusServerInfo *_info) OP_ARG_NONNULL(1); + +/**Clears the #OpusServerInfo structure. + This should be called on an #OpusServerInfo structure after it is no longer + needed. + It will free all memory used by the structure members. + \param _info The #OpusServerInfo structure to clear. + \note If you use this function, you must link against libopusurl.*/ +void opus_server_info_clear(OpusServerInfo *_info) OP_ARG_NONNULL(1); + +/**Skip the certificate check when connecting via TLS/SSL (https). + \param _b opus_int32: Whether or not to skip the certificate + check. + The check will be skipped if \a _b is non-zero, and will not be + skipped if \a _b is zero. + \hideinitializer*/ +#define OP_SSL_SKIP_CERTIFICATE_CHECK(_b) \ + OP_URL_OPT(OP_SSL_SKIP_CERTIFICATE_CHECK_REQUEST),OP_CHECK_INT(_b) + +/**Proxy connections through the given host. + If no port is specified via #OP_HTTP_PROXY_PORT, the port number defaults + to 8080 (http-alt). + All proxy parameters are ignored for non-http and non-https URLs. + \param _host const char *: The proxy server hostname. + This may be NULL to disable the use of a proxy + server. + \hideinitializer*/ +#define OP_HTTP_PROXY_HOST(_host) \ + OP_URL_OPT(OP_HTTP_PROXY_HOST_REQUEST),OP_CHECK_CONST_CHAR_PTR(_host) + +/**Use the given port when proxying connections. + This option only has an effect if #OP_HTTP_PROXY_HOST is specified with a + non-NULL \a _host. + If this option is not provided, the proxy port number defaults to 8080 + (http-alt). + All proxy parameters are ignored for non-http and non-https URLs. + \param _port opus_int32: The proxy server port. + This must be in the range 0...65535 (inclusive), or the + URL function this is passed to will fail. + \hideinitializer*/ +#define OP_HTTP_PROXY_PORT(_port) \ + OP_URL_OPT(OP_HTTP_PROXY_PORT_REQUEST),OP_CHECK_INT(_port) + +/**Use the given user name for authentication when proxying connections. + All proxy parameters are ignored for non-http and non-https URLs. + \param _user const char *: The proxy server user name. + This may be NULL to disable proxy + authentication. + A non-NULL value only has an effect + if #OP_HTTP_PROXY_HOST and #OP_HTTP_PROXY_PASS + are also specified with non-NULL + arguments. + \hideinitializer*/ +#define OP_HTTP_PROXY_USER(_user) \ + OP_URL_OPT(OP_HTTP_PROXY_USER_REQUEST),OP_CHECK_CONST_CHAR_PTR(_user) + +/**Use the given password for authentication when proxying connections. + All proxy parameters are ignored for non-http and non-https URLs. + \param _pass const char *: The proxy server password. + This may be NULL to disable proxy + authentication. + A non-NULL value only has an effect + if #OP_HTTP_PROXY_HOST and #OP_HTTP_PROXY_USER + are also specified with non-NULL + arguments. + \hideinitializer*/ +#define OP_HTTP_PROXY_PASS(_pass) \ + OP_URL_OPT(OP_HTTP_PROXY_PASS_REQUEST),OP_CHECK_CONST_CHAR_PTR(_pass) + +/**Parse information about the streaming server (if any) and return it. + Very little validation is done. + In particular, OpusServerInfo::url may not be a valid URL, + OpusServerInfo::bitrate_kbps may not really be in kbps, and + OpusServerInfo::content_type may not be a valid MIME type. + The character set of the string fields is not specified anywhere, and should + not be assumed to be valid UTF-8. + \param _info OpusServerInfo *: Returns information about the server. + If there is any error opening the stream, the + contents of this structure remain + unmodified. + On success, fills in the structure with the + server information that was available, if + any. + After a successful return, the contents of + this structure should be freed by calling + opus_server_info_clear(). + \hideinitializer*/ +#define OP_GET_SERVER_INFO(_info) \ + OP_URL_OPT(OP_GET_SERVER_INFO_REQUEST),OP_CHECK_SERVER_INFO_PTR(_info) + +/*@}*/ +/*@}*/ + +/**\defgroup stream_callbacks Abstract Stream Reading Interface*/ +/*@{*/ +/**\name Functions for reading from streams + These functions define the interface used to read from and seek in a stream + of data. + A stream does not need to implement seeking, but the decoder will not be + able to seek if it does not do so. + These functions also include some convenience routines for working with + standard FILE pointers, complete streams stored in a single + block of memory, or URLs.*/ +/*@{*/ + +/**Reads up to \a _nbytes bytes of data from \a _stream. + \param _stream The stream to read from. + \param[out] _ptr The buffer to store the data in. + \param _nbytes The maximum number of bytes to read. + This function may return fewer, though it will not + return zero unless it reaches end-of-file. + \return The number of bytes successfully read, or a negative value on + error.*/ +typedef int (*op_read_func)(void *_stream,unsigned char *_ptr,int _nbytes); + +/**Sets the position indicator for \a _stream. + The new position, measured in bytes, is obtained by adding \a _offset + bytes to the position specified by \a _whence. + If \a _whence is set to SEEK_SET, SEEK_CUR, or + SEEK_END, the offset is relative to the start of the stream, + the current position indicator, or end-of-file, respectively. + \retval 0 Success. + \retval -1 Seeking is not supported or an error occurred. + errno need not be set.*/ +typedef int (*op_seek_func)(void *_stream,opus_int64 _offset,int _whence); + +/**Obtains the current value of the position indicator for \a _stream. + \return The current position indicator.*/ +typedef opus_int64 (*op_tell_func)(void *_stream); + +/**Closes the underlying stream. + \retval 0 Success. + \retval EOF An error occurred. + errno need not be set.*/ +typedef int (*op_close_func)(void *_stream); + +/**The callbacks used to access non-FILE stream resources. + The function prototypes are basically the same as for the stdio functions + fread(), fseek(), ftell(), and + fclose(). + The differences are that the FILE * arguments have been + replaced with a void *, which is to be used as a pointer to + whatever internal data these functions might need, that #seek and #tell + take and return 64-bit offsets, and that #seek must return -1 if + the stream is unseekable.*/ +struct OpusFileCallbacks{ + /**Used to read data from the stream. + This must not be NULL.*/ + op_read_func read; + /**Used to seek in the stream. + This may be NULL if seeking is not implemented.*/ + op_seek_func seek; + /**Used to return the current read position in the stream. + This may be NULL if seeking is not implemented.*/ + op_tell_func tell; + /**Used to close the stream when the decoder is freed. + This may be NULL to leave the stream open.*/ + op_close_func close; +}; + +/**Opens a stream with fopen() and fills in a set of callbacks + that can be used to access it. + This is useful to avoid writing your own portable 64-bit seeking wrappers, + and also avoids cross-module linking issues on Windows, where a + FILE * must be accessed by routines defined in the same module + that opened it. + \param[out] _cb The callbacks to use for this file. + If there is an error opening the file, nothing will be + filled in here. + \param _path The path to the file to open. + On Windows, this string must be UTF-8 (to allow access to + files whose names cannot be represented in the current + MBCS code page). + All other systems use the native character encoding. + \param _mode The mode to open the file in. + \return A stream handle to use with the callbacks, or NULL on + error.*/ +OP_WARN_UNUSED_RESULT void *op_fopen(OpusFileCallbacks *_cb, + const char *_path,const char *_mode) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2) + OP_ARG_NONNULL(3); + +/**Opens a stream with fdopen() and fills in a set of callbacks + that can be used to access it. + This is useful to avoid writing your own portable 64-bit seeking wrappers, + and also avoids cross-module linking issues on Windows, where a + FILE * must be accessed by routines defined in the same module + that opened it. + \param[out] _cb The callbacks to use for this file. + If there is an error opening the file, nothing will be + filled in here. + \param _fd The file descriptor to open. + \param _mode The mode to open the file in. + \return A stream handle to use with the callbacks, or NULL on + error.*/ +OP_WARN_UNUSED_RESULT void *op_fdopen(OpusFileCallbacks *_cb, + int _fd,const char *_mode) OP_ARG_NONNULL(1) OP_ARG_NONNULL(3); + +/**Opens a stream with freopen() and fills in a set of callbacks + that can be used to access it. + This is useful to avoid writing your own portable 64-bit seeking wrappers, + and also avoids cross-module linking issues on Windows, where a + FILE * must be accessed by routines defined in the same module + that opened it. + \param[out] _cb The callbacks to use for this file. + If there is an error opening the file, nothing will be + filled in here. + \param _path The path to the file to open. + On Windows, this string must be UTF-8 (to allow access + to files whose names cannot be represented in the + current MBCS code page). + All other systems use the native character encoding. + \param _mode The mode to open the file in. + \param _stream A stream previously returned by op_fopen(), op_fdopen(), + or op_freopen(). + \return A stream handle to use with the callbacks, or NULL on + error.*/ +OP_WARN_UNUSED_RESULT void *op_freopen(OpusFileCallbacks *_cb, + const char *_path,const char *_mode,void *_stream) OP_ARG_NONNULL(1) + OP_ARG_NONNULL(2) OP_ARG_NONNULL(3) OP_ARG_NONNULL(4); + +/**Creates a stream that reads from the given block of memory. + This block of memory must contain the complete stream to decode. + This is useful for caching small streams (e.g., sound effects) in RAM. + \param[out] _cb The callbacks to use for this stream. + If there is an error creating the stream, nothing will be + filled in here. + \param _data The block of memory to read from. + \param _size The size of the block of memory. + \return A stream handle to use with the callbacks, or NULL on + error.*/ +OP_WARN_UNUSED_RESULT void *op_mem_stream_create(OpusFileCallbacks *_cb, + const unsigned char *_data,size_t _size) OP_ARG_NONNULL(1); + +/**Creates a stream that reads from the given URL. + This function behaves identically to op_url_stream_create(), except that it + takes a va_list instead of a variable number of arguments. + It does not call the va_end macro, and because it invokes the + va_arg macro, the value of \a _ap is undefined after the call. + \note If you use this function, you must link against libopusurl. + \param[out] _cb The callbacks to use for this stream. + If there is an error creating the stream, nothing will + be filled in here. + \param _url The URL to read from. + Currently only the , , and + schemes are supported. + Both and may be disabled at compile + time, in which case opening such URLs will always fail. + Currently this only supports URIs. + IRIs should be converted to UTF-8 and URL-escaped, with + internationalized domain names encoded in punycode, + before passing them to this function. + \param[in,out] _ap A list of the \ref url_options "optional flags" to use. + This is a variable-length list of options terminated + with NULL. + \return A stream handle to use with the callbacks, or NULL on + error.*/ +OP_WARN_UNUSED_RESULT void *op_url_stream_vcreate(OpusFileCallbacks *_cb, + const char *_url,va_list _ap) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2); + +/**Creates a stream that reads from the given URL. + \note If you use this function, you must link against libopusurl. + \param[out] _cb The callbacks to use for this stream. + If there is an error creating the stream, nothing will be + filled in here. + \param _url The URL to read from. + Currently only the , , and schemes + are supported. + Both and may be disabled at compile time, + in which case opening such URLs will always fail. + Currently this only supports URIs. + IRIs should be converted to UTF-8 and URL-escaped, with + internationalized domain names encoded in punycode, before + passing them to this function. + \param ... The \ref url_options "optional flags" to use. + This is a variable-length list of options terminated with + NULL. + \return A stream handle to use with the callbacks, or NULL on + error.*/ +OP_WARN_UNUSED_RESULT void *op_url_stream_create(OpusFileCallbacks *_cb, + const char *_url,...) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2); + +/*@}*/ +/*@}*/ + +/**\defgroup stream_open_close Opening and Closing*/ +/*@{*/ +/**\name Functions for opening and closing streams + + These functions allow you to test a stream to see if it is Opus, open it, + and close it. + Several flavors are provided for each of the built-in stream types, plus a + more general version which takes a set of application-provided callbacks.*/ +/*@{*/ + +/**Test to see if this is an Opus stream. + For good results, you will need at least 57 bytes (for a pure Opus-only + stream). + Something like 512 bytes will give more reliable results for multiplexed + streams. + This function is meant to be a quick-rejection filter. + Its purpose is not to guarantee that a stream is a valid Opus stream, but to + ensure that it looks enough like Opus that it isn't going to be recognized + as some other format (except possibly an Opus stream that is also + multiplexed with other codecs, such as video). + \param[out] _head The parsed ID header contents. + You may pass NULL if you do not need + this information. + If the function fails, the contents of this structure + remain untouched. + \param _initial_data An initial buffer of data from the start of the + stream. + \param _initial_bytes The number of bytes in \a _initial_data. + \return 0 if the data appears to be Opus, or a negative value on error. + \retval #OP_FALSE There was not enough data to tell if this was an Opus + stream or not. + \retval #OP_EFAULT An internal memory allocation failed. + \retval #OP_EIMPL The stream used a feature that is not implemented, + such as an unsupported channel family. + \retval #OP_ENOTFORMAT If the data did not contain a recognizable ID + header for an Opus stream. + \retval #OP_EVERSION If the version field signaled a version this library + does not know how to parse. + \retval #OP_EBADHEADER The ID header was not properly formatted or contained + illegal values.*/ +int op_test(OpusHead *_head, + const unsigned char *_initial_data,size_t _initial_bytes); + +/**Open a stream from the given file path. + \param _path The path to the file to open. + \param[out] _error Returns 0 on success, or a failure code on error. + You may pass in NULL if you don't want the + failure code. + The failure code will be #OP_EFAULT if the file could not + be opened, or one of the other failure codes from + op_open_callbacks() otherwise. + \return A freshly opened \c OggOpusFile, or NULL on error.*/ +OP_WARN_UNUSED_RESULT OggOpusFile *op_open_file(const char *_path,int *_error) + OP_ARG_NONNULL(1); + +/**Open a stream from a memory buffer. + \param _data The memory buffer to open. + \param _size The number of bytes in the buffer. + \param[out] _error Returns 0 on success, or a failure code on error. + You may pass in NULL if you don't want the + failure code. + See op_open_callbacks() for a full list of failure codes. + \return A freshly opened \c OggOpusFile, or NULL on error.*/ +OP_WARN_UNUSED_RESULT OggOpusFile *op_open_memory(const unsigned char *_data, + size_t _size,int *_error); + +/**Open a stream from a URL. + This function behaves identically to op_open_url(), except that it + takes a va_list instead of a variable number of arguments. + It does not call the va_end macro, and because it invokes the + va_arg macro, the value of \a _ap is undefined after the call. + \note If you use this function, you must link against libopusurl. + \param _url The URL to open. + Currently only the , , and + schemes are supported. + Both and may be disabled at compile + time, in which case opening such URLs will always + fail. + Currently this only supports URIs. + IRIs should be converted to UTF-8 and URL-escaped, + with internationalized domain names encoded in + punycode, before passing them to this function. + \param[out] _error Returns 0 on success, or a failure code on error. + You may pass in NULL if you don't want + the failure code. + See op_open_callbacks() for a full list of failure + codes. + \param[in,out] _ap A list of the \ref url_options "optional flags" to + use. + This is a variable-length list of options terminated + with NULL. + \return A freshly opened \c OggOpusFile, or NULL on error.*/ +OP_WARN_UNUSED_RESULT OggOpusFile *op_vopen_url(const char *_url, + int *_error,va_list _ap) OP_ARG_NONNULL(1); + +/**Open a stream from a URL. + \note If you use this function, you must link against libopusurl. + \param _url The URL to open. + Currently only the , , and schemes + are supported. + Both and may be disabled at compile + time, in which case opening such URLs will always fail. + Currently this only supports URIs. + IRIs should be converted to UTF-8 and URL-escaped, with + internationalized domain names encoded in punycode, + before passing them to this function. + \param[out] _error Returns 0 on success, or a failure code on error. + You may pass in NULL if you don't want the + failure code. + See op_open_callbacks() for a full list of failure codes. + \param ... The \ref url_options "optional flags" to use. + This is a variable-length list of options terminated with + NULL. + \return A freshly opened \c OggOpusFile, or NULL on error.*/ +OP_WARN_UNUSED_RESULT OggOpusFile *op_open_url(const char *_url, + int *_error,...) OP_ARG_NONNULL(1); + +/**Open a stream using the given set of callbacks to access it. + \param _stream The stream to read from (e.g., a FILE *). + This value will be passed verbatim as the first + argument to all of the callbacks. + \param _cb The callbacks with which to access the stream. + read() must + be implemented. + seek() and + tell() may + be NULL, or may always return -1 to + indicate a stream is unseekable, but if + seek() is + implemented and succeeds on a particular stream, then + tell() must + also. + close() may + be NULL, but if it is not, it will be + called when the \c OggOpusFile is destroyed by + op_free(). + It will not be called if op_open_callbacks() fails + with an error. + \param _initial_data An initial buffer of data from the start of the + stream. + Applications can read some number of bytes from the + start of the stream to help identify this as an Opus + stream, and then provide them here to allow the + stream to be opened, even if it is unseekable. + \param _initial_bytes The number of bytes in \a _initial_data. + If the stream is seekable, its current position (as + reported by + tell() + at the start of this function) must be equal to + \a _initial_bytes. + Otherwise, seeking to absolute positions will + generate inconsistent results. + \param[out] _error Returns 0 on success, or a failure code on error. + You may pass in NULL if you don't want + the failure code. + The failure code will be one of +
+
#OP_EREAD
+
An underlying read, seek, or tell operation + failed when it should have succeeded, or we failed + to find data in the stream we had seen before.
+
#OP_EFAULT
+
There was a memory allocation failure, or an + internal library error.
+
#OP_EIMPL
+
The stream used a feature that is not + implemented, such as an unsupported channel + family.
+
#OP_EINVAL
+
seek() + was implemented and succeeded on this source, but + tell() + did not, or the starting position indicator was + not equal to \a _initial_bytes.
+
#OP_ENOTFORMAT
+
The stream contained a link that did not have + any logical Opus streams in it.
+
#OP_EBADHEADER
+
A required header packet was not properly + formatted, contained illegal values, or was missing + altogether.
+
#OP_EVERSION
+
An ID header contained an unrecognized version + number.
+
#OP_EBADLINK
+
We failed to find data we had seen before after + seeking.
+
#OP_EBADTIMESTAMP
+
The first or last timestamp in a link failed + basic validity checks.
+
+ \return A freshly opened \c OggOpusFile, or NULL on error. + libopusfile does not take ownership of the stream + if the call fails. + The calling application is responsible for closing the stream if + this call returns an error.*/ +OP_WARN_UNUSED_RESULT OggOpusFile *op_open_callbacks(void *_stream, + const OpusFileCallbacks *_cb,const unsigned char *_initial_data, + size_t _initial_bytes,int *_error) OP_ARG_NONNULL(2); + +/**Partially open a stream from the given file path. + \see op_test_callbacks + \param _path The path to the file to open. + \param[out] _error Returns 0 on success, or a failure code on error. + You may pass in NULL if you don't want the + failure code. + The failure code will be #OP_EFAULT if the file could not + be opened, or one of the other failure codes from + op_open_callbacks() otherwise. + \return A partially opened \c OggOpusFile, or NULL on error.*/ +OP_WARN_UNUSED_RESULT OggOpusFile *op_test_file(const char *_path,int *_error) + OP_ARG_NONNULL(1); + +/**Partially open a stream from a memory buffer. + \see op_test_callbacks + \param _data The memory buffer to open. + \param _size The number of bytes in the buffer. + \param[out] _error Returns 0 on success, or a failure code on error. + You may pass in NULL if you don't want the + failure code. + See op_open_callbacks() for a full list of failure codes. + \return A partially opened \c OggOpusFile, or NULL on error.*/ +OP_WARN_UNUSED_RESULT OggOpusFile *op_test_memory(const unsigned char *_data, + size_t _size,int *_error); + +/**Partially open a stream from a URL. + This function behaves identically to op_test_url(), except that it + takes a va_list instead of a variable number of arguments. + It does not call the va_end macro, and because it invokes the + va_arg macro, the value of \a _ap is undefined after the call. + \note If you use this function, you must link against libopusurl. + \see op_test_url + \see op_test_callbacks + \param _url The URL to open. + Currently only the , , and + schemes are supported. + Both and may be disabled at compile + time, in which case opening such URLs will always + fail. + Currently this only supports URIs. + IRIs should be converted to UTF-8 and URL-escaped, + with internationalized domain names encoded in + punycode, before passing them to this function. + \param[out] _error Returns 0 on success, or a failure code on error. + You may pass in NULL if you don't want + the failure code. + See op_open_callbacks() for a full list of failure + codes. + \param[in,out] _ap A list of the \ref url_options "optional flags" to + use. + This is a variable-length list of options terminated + with NULL. + \return A partially opened \c OggOpusFile, or NULL on error.*/ +OP_WARN_UNUSED_RESULT OggOpusFile *op_vtest_url(const char *_url, + int *_error,va_list _ap) OP_ARG_NONNULL(1); + +/**Partially open a stream from a URL. + \note If you use this function, you must link against libopusurl. + \see op_test_callbacks + \param _url The URL to open. + Currently only the , , and + schemes are supported. + Both and may be disabled at compile + time, in which case opening such URLs will always fail. + Currently this only supports URIs. + IRIs should be converted to UTF-8 and URL-escaped, with + internationalized domain names encoded in punycode, + before passing them to this function. + \param[out] _error Returns 0 on success, or a failure code on error. + You may pass in NULL if you don't want the + failure code. + See op_open_callbacks() for a full list of failure + codes. + \param ... The \ref url_options "optional flags" to use. + This is a variable-length list of options terminated + with NULL. + \return A partially opened \c OggOpusFile, or NULL on error.*/ +OP_WARN_UNUSED_RESULT OggOpusFile *op_test_url(const char *_url, + int *_error,...) OP_ARG_NONNULL(1); + +/**Partially open a stream using the given set of callbacks to access it. + This tests for Opusness and loads the headers for the first link. + It does not seek (although it tests for seekability). + You can query a partially open stream for the few pieces of basic + information returned by op_serialno(), op_channel_count(), op_head(), and + op_tags() (but only for the first link). + You may also determine if it is seekable via a call to op_seekable(). + You cannot read audio from the stream, seek, get the size or duration, + get information from links other than the first one, or even get the total + number of links until you finish opening the stream with op_test_open(). + If you do not need to do any of these things, you can dispose of it with + op_free() instead. + + This function is provided mostly to simplify porting existing code that used + libvorbisfile. + For new code, you are likely better off using op_test() instead, which + is less resource-intensive, requires less data to succeed, and imposes a + hard limit on the amount of data it examines (important for unseekable + streams, where all such data must be buffered until you are sure of the + stream type). + \param _stream The stream to read from (e.g., a FILE *). + This value will be passed verbatim as the first + argument to all of the callbacks. + \param _cb The callbacks with which to access the stream. + read() must + be implemented. + seek() and + tell() may + be NULL, or may always return -1 to + indicate a stream is unseekable, but if + seek() is + implemented and succeeds on a particular stream, then + tell() must + also. + close() may + be NULL, but if it is not, it will be + called when the \c OggOpusFile is destroyed by + op_free(). + It will not be called if op_open_callbacks() fails + with an error. + \param _initial_data An initial buffer of data from the start of the + stream. + Applications can read some number of bytes from the + start of the stream to help identify this as an Opus + stream, and then provide them here to allow the + stream to be tested more thoroughly, even if it is + unseekable. + \param _initial_bytes The number of bytes in \a _initial_data. + If the stream is seekable, its current position (as + reported by + tell() + at the start of this function) must be equal to + \a _initial_bytes. + Otherwise, seeking to absolute positions will + generate inconsistent results. + \param[out] _error Returns 0 on success, or a failure code on error. + You may pass in NULL if you don't want + the failure code. + See op_open_callbacks() for a full list of failure + codes. + \return A partially opened \c OggOpusFile, or NULL on error. + libopusfile does not take ownership of the stream + if the call fails. + The calling application is responsible for closing the stream if + this call returns an error.*/ +OP_WARN_UNUSED_RESULT OggOpusFile *op_test_callbacks(void *_stream, + const OpusFileCallbacks *_cb,const unsigned char *_initial_data, + size_t _initial_bytes,int *_error) OP_ARG_NONNULL(2); + +/**Finish opening a stream partially opened with op_test_callbacks() or one of + the associated convenience functions. + If this function fails, you are still responsible for freeing the + \c OggOpusFile with op_free(). + \param _of The \c OggOpusFile to finish opening. + \return 0 on success, or a negative value on error. + \retval #OP_EREAD An underlying read, seek, or tell operation failed + when it should have succeeded. + \retval #OP_EFAULT There was a memory allocation failure, or an + internal library error. + \retval #OP_EIMPL The stream used a feature that is not implemented, + such as an unsupported channel family. + \retval #OP_EINVAL The stream was not partially opened with + op_test_callbacks() or one of the associated + convenience functions. + \retval #OP_ENOTFORMAT The stream contained a link that did not have any + logical Opus streams in it. + \retval #OP_EBADHEADER A required header packet was not properly + formatted, contained illegal values, or was + missing altogether. + \retval #OP_EVERSION An ID header contained an unrecognized version + number. + \retval #OP_EBADLINK We failed to find data we had seen before after + seeking. + \retval #OP_EBADTIMESTAMP The first or last timestamp in a link failed basic + validity checks.*/ +int op_test_open(OggOpusFile *_of) OP_ARG_NONNULL(1); + +/**Release all memory used by an \c OggOpusFile. + \param _of The \c OggOpusFile to free.*/ +void op_free(OggOpusFile *_of); + +/*@}*/ +/*@}*/ + +/**\defgroup stream_info Stream Information*/ +/*@{*/ +/**\name Functions for obtaining information about streams + + These functions allow you to get basic information about a stream, including + seekability, the number of links (for chained streams), plus the size, + duration, bitrate, header parameters, and meta information for each link + (or, where available, the stream as a whole). + Some of these (size, duration) are only available for seekable streams. + You can also query the current stream position, link, and playback time, + and instantaneous bitrate during playback. + + Some of these functions may be used successfully on the partially open + streams returned by op_test_callbacks() or one of the associated + convenience functions. + Their documention will indicate so explicitly.*/ +/*@{*/ + +/**Returns whether or not the stream being read is seekable. + This is true if +
    +
  1. The seek() and + tell() callbacks are both + non-NULL,
    2. +
  2. The seek() callback was + successfully executed at least once, and
    3. +
  3. The tell() callback was + successfully able to report the position indicator afterwards.
    4. +
+ This function may be called on partially-opened streams. + \param _of The \c OggOpusFile whose seekable status is to be returned. + \return A non-zero value if seekable, and 0 if unseekable.*/ +int op_seekable(const OggOpusFile *_of) OP_ARG_NONNULL(1); + +/**Returns the number of links in this chained stream. + This function may be called on partially-opened streams, but it will always + return 1. + The actual number of links is not known until the stream is fully opened. + \param _of The \c OggOpusFile from which to retrieve the link count. + \return For fully-open seekable streams, this returns the total number of + links in the whole stream, which will be at least 1. + For partially-open or unseekable streams, this always returns 1.*/ +int op_link_count(const OggOpusFile *_of) OP_ARG_NONNULL(1); + +/**Get the serial number of the given link in a (possibly-chained) Ogg Opus + stream. + This function may be called on partially-opened streams, but it will always + return the serial number of the Opus stream in the first link. + \param _of The \c OggOpusFile from which to retrieve the serial number. + \param _li The index of the link whose serial number should be retrieved. + Use a negative number to get the serial number of the current + link. + \return The serial number of the given link. + If \a _li is greater than the total number of links, this returns + the serial number of the last link. + If the stream is not seekable, this always returns the serial number + of the current link.*/ +opus_uint32 op_serialno(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1); + +/**Get the channel count of the given link in a (possibly-chained) Ogg Opus + stream. + This is equivalent to op_head(_of,_li)->channel_count, but + is provided for convenience. + This function may be called on partially-opened streams, but it will always + return the channel count of the Opus stream in the first link. + \param _of The \c OggOpusFile from which to retrieve the channel count. + \param _li The index of the link whose channel count should be retrieved. + Use a negative number to get the channel count of the current + link. + \return The channel count of the given link. + If \a _li is greater than the total number of links, this returns + the channel count of the last link. + If the stream is not seekable, this always returns the channel count + of the current link.*/ +int op_channel_count(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1); + +/**Get the total (compressed) size of the stream, or of an individual link in + a (possibly-chained) Ogg Opus stream, including all headers and Ogg muxing + overhead. + \warning If the Opus stream (or link) is concurrently multiplexed with other + logical streams (e.g., video), this returns the size of the entire stream + (or link), not just the number of bytes in the first logical Opus stream. + Returning the latter would require scanning the entire file. + \param _of The \c OggOpusFile from which to retrieve the compressed size. + \param _li The index of the link whose compressed size should be computed. + Use a negative number to get the compressed size of the entire + stream. + \return The compressed size of the entire stream if \a _li is negative, the + compressed size of link \a _li if it is non-negative, or a negative + value on error. + The compressed size of the entire stream may be smaller than that + of the underlying stream if trailing garbage was detected in the + file. + \retval #OP_EINVAL The stream is not seekable (so we can't know the length), + \a _li wasn't less than the total number of links in + the stream, or the stream was only partially open.*/ +opus_int64 op_raw_total(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1); + +/**Get the total PCM length (number of samples at 48 kHz) of the stream, or of + an individual link in a (possibly-chained) Ogg Opus stream. + Users looking for op_time_total() should use op_pcm_total() + instead. + Because timestamps in Opus are fixed at 48 kHz, there is no need for a + separate function to convert this to seconds (and leaving it out avoids + introducing floating point to the API, for those that wish to avoid it). + \param _of The \c OggOpusFile from which to retrieve the PCM offset. + \param _li The index of the link whose PCM length should be computed. + Use a negative number to get the PCM length of the entire stream. + \return The PCM length of the entire stream if \a _li is negative, the PCM + length of link \a _li if it is non-negative, or a negative value on + error. + \retval #OP_EINVAL The stream is not seekable (so we can't know the length), + \a _li wasn't less than the total number of links in + the stream, or the stream was only partially open.*/ +ogg_int64_t op_pcm_total(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1); + +/**Get the ID header information for the given link in a (possibly chained) Ogg + Opus stream. + This function may be called on partially-opened streams, but it will always + return the ID header information of the Opus stream in the first link. + \param _of The \c OggOpusFile from which to retrieve the ID header + information. + \param _li The index of the link whose ID header information should be + retrieved. + Use a negative number to get the ID header information of the + current link. + For an unseekable stream, \a _li is ignored, and the ID header + information for the current link is always returned, if + available. + \return The contents of the ID header for the given link.*/ +const OpusHead *op_head(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1); + +/**Get the comment header information for the given link in a (possibly + chained) Ogg Opus stream. + This function may be called on partially-opened streams, but it will always + return the tags from the Opus stream in the first link. + \param _of The \c OggOpusFile from which to retrieve the comment header + information. + \param _li The index of the link whose comment header information should be + retrieved. + Use a negative number to get the comment header information of + the current link. + For an unseekable stream, \a _li is ignored, and the comment + header information for the current link is always returned, if + available. + \return The contents of the comment header for the given link, or + NULL if this is an unseekable stream that encountered + an invalid link.*/ +const OpusTags *op_tags(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1); + +/**Retrieve the index of the current link. + This is the link that produced the data most recently read by + op_read_float() or its associated functions, or, after a seek, the link + that the seek target landed in. + Reading more data may advance the link index (even on the first read after a + seek). + \param _of The \c OggOpusFile from which to retrieve the current link index. + \return The index of the current link on success, or a negative value on + failure. + For seekable streams, this is a number between 0 (inclusive) and the + value returned by op_link_count() (exclusive). + For unseekable streams, this value starts at 0 and increments by one + each time a new link is encountered (even though op_link_count() + always returns 1). + \retval #OP_EINVAL The stream was only partially open.*/ +int op_current_link(const OggOpusFile *_of) OP_ARG_NONNULL(1); + +/**Computes the bitrate of the stream, or of an individual link in a + (possibly-chained) Ogg Opus stream. + The stream must be seekable to compute the bitrate. + For unseekable streams, use op_bitrate_instant() to get periodic estimates. + \warning If the Opus stream (or link) is concurrently multiplexed with other + logical streams (e.g., video), this uses the size of the entire stream (or + link) to compute the bitrate, not just the number of bytes in the first + logical Opus stream. + Returning the latter requires scanning the entire file, but this may be done + by decoding the whole file and calling op_bitrate_instant() once at the + end. + Install a trivial decoding callback with op_set_decode_callback() if you + wish to skip actual decoding during this process. + \param _of The \c OggOpusFile from which to retrieve the bitrate. + \param _li The index of the link whose bitrate should be computed. + Use a negative number to get the bitrate of the whole stream. + \return The bitrate on success, or a negative value on error. + \retval #OP_EINVAL The stream was only partially open, the stream was not + seekable, or \a _li was larger than the number of + links.*/ +opus_int32 op_bitrate(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1); + +/**Compute the instantaneous bitrate, measured as the ratio of bits to playable + samples decoded since a) the last call to op_bitrate_instant(), b) the last + seek, or c) the start of playback, whichever was most recent. + This will spike somewhat after a seek or at the start/end of a chain + boundary, as pre-skip, pre-roll, and end-trimming causes samples to be + decoded but not played. + \param _of The \c OggOpusFile from which to retrieve the bitrate. + \return The bitrate, in bits per second, or a negative value on error. + \retval #OP_FALSE No data has been decoded since any of the events + described above. + \retval #OP_EINVAL The stream was only partially open.*/ +opus_int32 op_bitrate_instant(OggOpusFile *_of) OP_ARG_NONNULL(1); + +/**Obtain the current value of the position indicator for \a _of. + \param _of The \c OggOpusFile from which to retrieve the position indicator. + \return The byte position that is currently being read from. + \retval #OP_EINVAL The stream was only partially open.*/ +opus_int64 op_raw_tell(const OggOpusFile *_of) OP_ARG_NONNULL(1); + +/**Obtain the PCM offset of the next sample to be read. + If the stream is not properly timestamped, this might not increment by the + proper amount between reads, or even return monotonically increasing + values. + \param _of The \c OggOpusFile from which to retrieve the PCM offset. + \return The PCM offset of the next sample to be read. + \retval #OP_EINVAL The stream was only partially open.*/ +ogg_int64_t op_pcm_tell(const OggOpusFile *_of) OP_ARG_NONNULL(1); + +/*@}*/ +/*@}*/ + +/**\defgroup stream_seeking Seeking*/ +/*@{*/ +/**\name Functions for seeking in Opus streams + + These functions let you seek in Opus streams, if the underlying stream + support it. + Seeking is implemented for all built-in stream I/O routines, though some + individual streams may not be seekable (pipes, live HTTP streams, or HTTP + streams from a server that does not support Range requests). + + op_raw_seek() is the fastest: it is guaranteed to perform at most one + physical seek, but, since the target is a byte position, makes no guarantee + how close to a given time it will come. + op_pcm_seek() provides sample-accurate seeking. + The number of physical seeks it requires is still quite small (often 1 or + 2, even in highly variable bitrate streams). + + Seeking in Opus requires decoding some pre-roll amount before playback to + allow the internal state to converge (as if recovering from packet loss). + This is handled internally by libopusfile, but means there is + little extra overhead for decoding up to the exact position requested + (since it must decode some amount of audio anyway). + It also means that decoding after seeking may not return exactly the same + values as would be obtained by decoding the stream straight through. + However, such differences are expected to be smaller than the loss + introduced by Opus's lossy compression.*/ +/*@{*/ + +/**Seek to a byte offset relative to the compressed data. + This also scans packets to update the PCM cursor. + It will cross a logical bitstream boundary, but only if it can't get any + packets out of the tail of the link to which it seeks. + \param _of The \c OggOpusFile in which to seek. + \param _byte_offset The byte position to seek to. + This must be between 0 and #op_raw_total(\a _of,\c -1) + (inclusive). + \return 0 on success, or a negative error code on failure. + \retval #OP_EREAD The underlying seek operation failed. + \retval #OP_EINVAL The stream was only partially open, or the target was + outside the valid range for the stream. + \retval #OP_ENOSEEK This stream is not seekable. + \retval #OP_EBADLINK Failed to initialize a decoder for a stream for an + unknown reason.*/ +int op_raw_seek(OggOpusFile *_of,opus_int64 _byte_offset) OP_ARG_NONNULL(1); + +/**Seek to the specified PCM offset, such that decoding will begin at exactly + the requested position. + \param _of The \c OggOpusFile in which to seek. + \param _pcm_offset The PCM offset to seek to. + This is in samples at 48 kHz relative to the start of the + stream. + \return 0 on success, or a negative value on error. + \retval #OP_EREAD An underlying read or seek operation failed. + \retval #OP_EINVAL The stream was only partially open, or the target was + outside the valid range for the stream. + \retval #OP_ENOSEEK This stream is not seekable. + \retval #OP_EBADLINK We failed to find data we had seen before, or the + bitstream structure was sufficiently malformed that + seeking to the target destination was impossible.*/ +int op_pcm_seek(OggOpusFile *_of,ogg_int64_t _pcm_offset) OP_ARG_NONNULL(1); + +/*@}*/ +/*@}*/ + +/**\defgroup stream_decoding Decoding*/ +/*@{*/ +/**\name Functions for decoding audio data + + These functions retrieve actual decoded audio data from the stream. + The general functions, op_read() and op_read_float() return 16-bit or + floating-point output, both using native endian ordering. + The number of channels returned can change from link to link in a chained + stream. + There are special functions, op_read_stereo() and op_read_float_stereo(), + which always output two channels, to simplify applications which do not + wish to handle multichannel audio. + These downmix multichannel files to two channels, so they can always return + samples in the same format for every link in a chained file. + + If the rest of your audio processing chain can handle floating point, the + floating-point routines should be preferred, as they prevent clipping and + other issues which might be avoided entirely if, e.g., you scale down the + volume at some other stage. + However, if you intend to consume 16-bit samples directly, the conversion in + libopusfile provides noise-shaping dithering and, if compiled + against libopus 1.1 or later, soft-clipping prevention. + + libopusfile can also be configured at compile time to use the + fixed-point libopus API. + If so, libopusfile's floating-point API may also be disabled. + In that configuration, nothing in libopusfile will use any + floating-point operations, to simplify support on devices without an + adequate FPU. + + \warning HTTPS streams may be be vulnerable to truncation attacks if you do + not check the error return code from op_read_float() or its associated + functions. + If the remote peer does not close the connection gracefully (with a TLS + "close notify" message), these functions will return #OP_EREAD instead of 0 + when they reach the end of the file. + If you are reading from an URL (particularly if seeking is not + supported), you should make sure to check for this error and warn the user + appropriately.*/ +/*@{*/ + +/**Indicates that the decoding callback should produce signed 16-bit + native-endian output samples.*/ +#define OP_DEC_FORMAT_SHORT (7008) +/**Indicates that the decoding callback should produce 32-bit native-endian + float samples.*/ +#define OP_DEC_FORMAT_FLOAT (7040) + +/**Indicates that the decoding callback did not decode anything, and that + libopusfile should decode normally instead.*/ +#define OP_DEC_USE_DEFAULT (6720) + +/**Called to decode an Opus packet. + This should invoke the functional equivalent of opus_multistream_decode() or + opus_multistream_decode_float(), except that it returns 0 on success + instead of the number of decoded samples (which is known a priori). + \param _ctx The application-provided callback context. + \param _decoder The decoder to use to decode the packet. + \param[out] _pcm The buffer to decode into. + This will always have enough room for \a _nchannels of + \a _nsamples samples, which should be placed into this + buffer interleaved. + \param _op The packet to decode. + This will always have its granule position set to a valid + value. + \param _nsamples The number of samples expected from the packet. + \param _nchannels The number of channels expected from the packet. + \param _format The desired sample output format. + This is either #OP_DEC_FORMAT_SHORT or + #OP_DEC_FORMAT_FLOAT. + \param _li The index of the link from which this packet was decoded. + \return A non-negative value on success, or a negative value on error. + Any error codes should be the same as those returned by + opus_multistream_decode() or opus_multistream_decode_float(). + Success codes are as follows: + \retval 0 Decoding was successful. + The application has filled the buffer with + exactly \a _nsamples*\a + _nchannels samples in the requested + format. + \retval #OP_DEC_USE_DEFAULT No decoding was done. + libopusfile should do the decoding + by itself instead.*/ +typedef int (*op_decode_cb_func)(void *_ctx,OpusMSDecoder *_decoder,void *_pcm, + const ogg_packet *_op,int _nsamples,int _nchannels,int _format,int _li); + +/**Sets the packet decode callback function. + If set, this is called once for each packet that needs to be decoded. + This can be used by advanced applications to do additional processing on the + compressed or uncompressed data. + For example, an application might save the final entropy coder state for + debugging and testing purposes, or it might apply additional filters + before the downmixing, dithering, or soft-clipping performed by + libopusfile, so long as these filters do not introduce any + latency. + + A call to this function is no guarantee that the audio will eventually be + delivered to the application. + libopusfile may discard some or all of the decoded audio data + (i.e., at the beginning or end of a link, or after a seek), however the + callback is still required to provide all of it. + \param _of The \c OggOpusFile on which to set the decode callback. + \param _decode_cb The callback function to call. + This may be NULL to disable calling the + callback. + \param _ctx The application-provided context pointer to pass to the + callback on each call.*/ +void op_set_decode_callback(OggOpusFile *_of, + op_decode_cb_func _decode_cb,void *_ctx) OP_ARG_NONNULL(1); + +/**Gain offset type that indicates that the provided offset is relative to the + header gain. + This is the default.*/ +#define OP_HEADER_GAIN (0) + +/**Gain offset type that indicates that the provided offset is relative to the + R128_ALBUM_GAIN value (if any), in addition to the header gain.*/ +#define OP_ALBUM_GAIN (3007) + +/**Gain offset type that indicates that the provided offset is relative to the + R128_TRACK_GAIN value (if any), in addition to the header gain.*/ +#define OP_TRACK_GAIN (3008) + +/**Gain offset type that indicates that the provided offset should be used as + the gain directly, without applying any the header or track gains.*/ +#define OP_ABSOLUTE_GAIN (3009) + +/**Sets the gain to be used for decoded output. + By default, the gain in the header is applied with no additional offset. + The total gain (including header gain and/or track gain, if applicable, and + this offset), will be clamped to [-32768,32767]/256 dB. + This is more than enough to saturate or underflow 16-bit PCM. + \note The new gain will not be applied to any already buffered, decoded + output. + This means you cannot change it sample-by-sample, as at best it will be + updated packet-by-packet. + It is meant for setting a target volume level, rather than applying smooth + fades, etc. + \param _of The \c OggOpusFile on which to set the gain offset. + \param _gain_type One of #OP_HEADER_GAIN, #OP_ALBUM_GAIN, + #OP_TRACK_GAIN, or #OP_ABSOLUTE_GAIN. + \param _gain_offset_q8 The gain offset to apply, in 1/256ths of a dB. + \return 0 on success or a negative value on error. + \retval #OP_EINVAL The \a _gain_type was unrecognized.*/ +int op_set_gain_offset(OggOpusFile *_of, + int _gain_type,opus_int32 _gain_offset_q8) OP_ARG_NONNULL(1); + +/**Sets whether or not dithering is enabled for 16-bit decoding. + By default, when libopusfile is compiled to use floating-point + internally, calling op_read() or op_read_stereo() will first decode to + float, and then convert to fixed-point using noise-shaping dithering. + This flag can be used to disable that dithering. + When the application uses op_read_float() or op_read_float_stereo(), or when + the library has been compiled to decode directly to fixed point, this flag + has no effect. + \param _of The \c OggOpusFile on which to enable or disable dithering. + \param _enabled A non-zero value to enable dithering, or 0 to disable it.*/ +void op_set_dither_enabled(OggOpusFile *_of,int _enabled) OP_ARG_NONNULL(1); + +/**Reads more samples from the stream. + \note Although \a _buf_size must indicate the total number of values that + can be stored in \a _pcm, the return value is the number of samples + per channel. + This is done because +
    +
  1. The channel count cannot be known a priori (reading more samples might + advance us into the next link, with a different channel count), so + \a _buf_size cannot also be in units of samples per channel,
    2. +
  2. Returning the samples per channel matches the libopus API + as closely as we're able,
    3. +
  3. Returning the total number of values instead of samples per channel + would mean the caller would need a division to compute the samples per + channel, and might worry about the possibility of getting back samples + for some channels and not others, and
    4. +
  4. This approach is relatively fool-proof: if an application passes too + small a value to \a _buf_size, they will simply get fewer samples back, + and if they assume the return value is the total number of values, then + they will simply read too few (rather than reading too many and going + off the end of the buffer).
    5. +
+ \param _of The \c OggOpusFile from which to read. + \param[out] _pcm A buffer in which to store the output PCM samples, as + signed native-endian 16-bit values at 48 kHz + with a nominal range of [-32768,32767). + Multiple channels are interleaved using the + Vorbis + channel ordering. + This must have room for at least \a _buf_size values. + \param _buf_size The number of values that can be stored in \a _pcm. + It is recommended that this be large enough for at + least 120 ms of data at 48 kHz per channel (5760 + values per channel). + Smaller buffers will simply return less data, possibly + consuming more memory to buffer the data internally. + libopusfile may return less data than + requested. + If so, there is no guarantee that the remaining data + in \a _pcm will be unmodified. + \param[out] _li The index of the link this data was decoded from. + You may pass NULL if you do not need this + information. + If this function fails (returning a negative value), + this parameter is left unset. + \return The number of samples read per channel on success, or a negative + value on failure. + The channel count can be retrieved on success by calling + op_head(_of,*_li). + The number of samples returned may be 0 if the buffer was too small + to store even a single sample for all channels, or if end-of-file + was reached. + The list of possible failure codes follows. + Most of them can only be returned by unseekable, chained streams + that encounter a new link. + \retval #OP_HOLE There was a hole in the data, and some samples + may have been skipped. + Call this function again to continue decoding + past the hole. + \retval #OP_EREAD An underlying read operation failed. + This may signal a truncation attack from an + source. + \retval #OP_EFAULT An internal memory allocation failed. + \retval #OP_EIMPL An unseekable stream encountered a new link that + used a feature that is not implemented, such as + an unsupported channel family. + \retval #OP_EINVAL The stream was only partially open. + \retval #OP_ENOTFORMAT An unseekable stream encountered a new link that + did not have any logical Opus streams in it. + \retval #OP_EBADHEADER An unseekable stream encountered a new link with a + required header packet that was not properly + formatted, contained illegal values, or was + missing altogether. + \retval #OP_EVERSION An unseekable stream encountered a new link with + an ID header that contained an unrecognized + version number. + \retval #OP_EBADPACKET Failed to properly decode the next packet. + \retval #OP_EBADLINK We failed to find data we had seen before. + \retval #OP_EBADTIMESTAMP An unseekable stream encountered a new link with + a starting timestamp that failed basic validity + checks.*/ +OP_WARN_UNUSED_RESULT int op_read(OggOpusFile *_of, + opus_int16 *_pcm,int _buf_size,int *_li) OP_ARG_NONNULL(1); + +/**Reads more samples from the stream. + \note Although \a _buf_size must indicate the total number of values that + can be stored in \a _pcm, the return value is the number of samples + per channel. +
    +
  1. The channel count cannot be known a priori (reading more samples might + advance us into the next link, with a different channel count), so + \a _buf_size cannot also be in units of samples per channel,
    2. +
  2. Returning the samples per channel matches the libopus API + as closely as we're able,
    3. +
  3. Returning the total number of values instead of samples per channel + would mean the caller would need a division to compute the samples per + channel, and might worry about the possibility of getting back samples + for some channels and not others, and
    4. +
  4. This approach is relatively fool-proof: if an application passes too + small a value to \a _buf_size, they will simply get fewer samples back, + and if they assume the return value is the total number of values, then + they will simply read too few (rather than reading too many and going + off the end of the buffer).
    5. +
+ \param _of The \c OggOpusFile from which to read. + \param[out] _pcm A buffer in which to store the output PCM samples as + signed floats at 48 kHz with a nominal range of + [-1.0,1.0]. + Multiple channels are interleaved using the + Vorbis + channel ordering. + This must have room for at least \a _buf_size floats. + \param _buf_size The number of floats that can be stored in \a _pcm. + It is recommended that this be large enough for at + least 120 ms of data at 48 kHz per channel (5760 + samples per channel). + Smaller buffers will simply return less data, possibly + consuming more memory to buffer the data internally. + If less than \a _buf_size values are returned, + libopusfile makes no guarantee that the + remaining data in \a _pcm will be unmodified. + \param[out] _li The index of the link this data was decoded from. + You may pass NULL if you do not need this + information. + If this function fails (returning a negative value), + this parameter is left unset. + \return The number of samples read per channel on success, or a negative + value on failure. + The channel count can be retrieved on success by calling + op_head(_of,*_li). + The number of samples returned may be 0 if the buffer was too small + to store even a single sample for all channels, or if end-of-file + was reached. + The list of possible failure codes follows. + Most of them can only be returned by unseekable, chained streams + that encounter a new link. + \retval #OP_HOLE There was a hole in the data, and some samples + may have been skipped. + Call this function again to continue decoding + past the hole. + \retval #OP_EREAD An underlying read operation failed. + This may signal a truncation attack from an + source. + \retval #OP_EFAULT An internal memory allocation failed. + \retval #OP_EIMPL An unseekable stream encountered a new link that + used a feature that is not implemented, such as + an unsupported channel family. + \retval #OP_EINVAL The stream was only partially open. + \retval #OP_ENOTFORMAT An unseekable stream encountered a new link that + did not have any logical Opus streams in it. + \retval #OP_EBADHEADER An unseekable stream encountered a new link with a + required header packet that was not properly + formatted, contained illegal values, or was + missing altogether. + \retval #OP_EVERSION An unseekable stream encountered a new link with + an ID header that contained an unrecognized + version number. + \retval #OP_EBADPACKET Failed to properly decode the next packet. + \retval #OP_EBADLINK We failed to find data we had seen before. + \retval #OP_EBADTIMESTAMP An unseekable stream encountered a new link with + a starting timestamp that failed basic validity + checks.*/ +OP_WARN_UNUSED_RESULT int op_read_float(OggOpusFile *_of, + float *_pcm,int _buf_size,int *_li) OP_ARG_NONNULL(1); + +/**Reads more samples from the stream and downmixes to stereo, if necessary. + This function is intended for simple players that want a uniform output + format, even if the channel count changes between links in a chained + stream. + \note \a _buf_size indicates the total number of values that can be stored + in \a _pcm, while the return value is the number of samples per + channel, even though the channel count is known, for consistency with + op_read(). + \param _of The \c OggOpusFile from which to read. + \param[out] _pcm A buffer in which to store the output PCM samples, as + signed native-endian 16-bit values at 48 kHz + with a nominal range of [-32768,32767). + The left and right channels are interleaved in the + buffer. + This must have room for at least \a _buf_size values. + \param _buf_size The number of values that can be stored in \a _pcm. + It is recommended that this be large enough for at + least 120 ms of data at 48 kHz per channel (11520 + values total). + Smaller buffers will simply return less data, possibly + consuming more memory to buffer the data internally. + If less than \a _buf_size values are returned, + libopusfile makes no guarantee that the + remaining data in \a _pcm will be unmodified. + \return The number of samples read per channel on success, or a negative + value on failure. + The number of samples returned may be 0 if the buffer was too small + to store even a single sample for both channels, or if end-of-file + was reached. + The list of possible failure codes follows. + Most of them can only be returned by unseekable, chained streams + that encounter a new link. + \retval #OP_HOLE There was a hole in the data, and some samples + may have been skipped. + Call this function again to continue decoding + past the hole. + \retval #OP_EREAD An underlying read operation failed. + This may signal a truncation attack from an + source. + \retval #OP_EFAULT An internal memory allocation failed. + \retval #OP_EIMPL An unseekable stream encountered a new link that + used a feature that is not implemented, such as + an unsupported channel family. + \retval #OP_EINVAL The stream was only partially open. + \retval #OP_ENOTFORMAT An unseekable stream encountered a new link that + did not have any logical Opus streams in it. + \retval #OP_EBADHEADER An unseekable stream encountered a new link with a + required header packet that was not properly + formatted, contained illegal values, or was + missing altogether. + \retval #OP_EVERSION An unseekable stream encountered a new link with + an ID header that contained an unrecognized + version number. + \retval #OP_EBADPACKET Failed to properly decode the next packet. + \retval #OP_EBADLINK We failed to find data we had seen before. + \retval #OP_EBADTIMESTAMP An unseekable stream encountered a new link with + a starting timestamp that failed basic validity + checks.*/ +OP_WARN_UNUSED_RESULT int op_read_stereo(OggOpusFile *_of, + opus_int16 *_pcm,int _buf_size) OP_ARG_NONNULL(1); + +/**Reads more samples from the stream and downmixes to stereo, if necessary. + This function is intended for simple players that want a uniform output + format, even if the channel count changes between links in a chained + stream. + \note \a _buf_size indicates the total number of values that can be stored + in \a _pcm, while the return value is the number of samples per + channel, even though the channel count is known, for consistency with + op_read_float(). + \param _of The \c OggOpusFile from which to read. + \param[out] _pcm A buffer in which to store the output PCM samples, as + signed floats at 48 kHz with a nominal range of + [-1.0,1.0]. + The left and right channels are interleaved in the + buffer. + This must have room for at least \a _buf_size values. + \param _buf_size The number of values that can be stored in \a _pcm. + It is recommended that this be large enough for at + least 120 ms of data at 48 kHz per channel (11520 + values total). + Smaller buffers will simply return less data, possibly + consuming more memory to buffer the data internally. + If less than \a _buf_size values are returned, + libopusfile makes no guarantee that the + remaining data in \a _pcm will be unmodified. + \return The number of samples read per channel on success, or a negative + value on failure. + The number of samples returned may be 0 if the buffer was too small + to store even a single sample for both channels, or if end-of-file + was reached. + The list of possible failure codes follows. + Most of them can only be returned by unseekable, chained streams + that encounter a new link. + \retval #OP_HOLE There was a hole in the data, and some samples + may have been skipped. + Call this function again to continue decoding + past the hole. + \retval #OP_EREAD An underlying read operation failed. + This may signal a truncation attack from an + source. + \retval #OP_EFAULT An internal memory allocation failed. + \retval #OP_EIMPL An unseekable stream encountered a new link that + used a feature that is not implemented, such as + an unsupported channel family. + \retval #OP_EINVAL The stream was only partially open. + \retval #OP_ENOTFORMAT An unseekable stream encountered a new link that + that did not have any logical Opus streams in it. + \retval #OP_EBADHEADER An unseekable stream encountered a new link with a + required header packet that was not properly + formatted, contained illegal values, or was + missing altogether. + \retval #OP_EVERSION An unseekable stream encountered a new link with + an ID header that contained an unrecognized + version number. + \retval #OP_EBADPACKET Failed to properly decode the next packet. + \retval #OP_EBADLINK We failed to find data we had seen before. + \retval #OP_EBADTIMESTAMP An unseekable stream encountered a new link with + a starting timestamp that failed basic validity + checks.*/ +OP_WARN_UNUSED_RESULT int op_read_float_stereo(OggOpusFile *_of, + float *_pcm,int _buf_size) OP_ARG_NONNULL(1); + +/*@}*/ +/*@}*/ + +# if OP_GNUC_PREREQ(4,0) +# pragma GCC visibility pop +# endif + +# if defined(__cplusplus) +} +# endif + +#endif diff --git a/libs/include/pspusbdevice.h b/libs/include/pspusbdevice.h new file mode 100644 index 0000000..ce8f652 --- /dev/null +++ b/libs/include/pspusbdevice.h @@ -0,0 +1,51 @@ +#ifndef __PSPUSBDEVICE_H__ +#define __PSPUSBDEVICE_H__ + +#if defined (__cplusplus) +extern "C" { +#endif + +/** + * This functions require flash0:/kd/_usbdevice.prx to be loaded/started first. + + * Link with pspusbdevice for user mode access or with pspusbdevice_driver for kernel access +*/ + +#define PSP_USBDEVICE_FLASH0 0 +#define PSP_USBDEVICE_FLASH1 1 +#define PSP_USBDEVICE_FLASH2 2 +#define PSP_USBDEVICE_FLASH3 3 +#define PSP_USBDEVICE_UMD9660 4 + +#define UNASSIGN_MASK_FLASH0 1 +#define UNASSIGN_MASK_FLASH1 2 +#define UNASSIGN_MASK_FLASH2 3 +#define UNASSIGN_MASK_FLASH3 4 + +/** + * Sets the usb device. Call this function when you are about to do the sceUsbStart and sceUsbActivate stuff + * + * @param device - The usb device, one of listed above. + * @param ronly - If non-zero indicates read only access. This parameters is ignored for PSP_USBDEVICE_UMD9660 + * @param unassign_mask - It unassigns automatically the flashes indicated by the mask. + * The flashes will be reassigned automatically after calling pspUsbDeviceFinishDevice + * + * Set this param to 0 if you don't need it (vshctrl doesn't use it). + * + * @returns 0 on success, < 0 on error. +*/ +int pspUsbDeviceSetDevice(u32 device, int ronly, int unassign_mask); + +/** + * Finishes the usb device. Call this function after stoping usbstor driver + * + * @returns 0 in success, < 0 on error +*/ +int pspUsbDeviceFinishDevice(); + +#if defined (__cplusplus) +} +#endif + +#endif + diff --git a/libs/include/rapidjson/allocators.h b/libs/include/rapidjson/allocators.h new file mode 100644 index 0000000..12bc5ba --- /dev/null +++ b/libs/include/rapidjson/allocators.h @@ -0,0 +1,692 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_ALLOCATORS_H_ +#define RAPIDJSON_ALLOCATORS_H_ + +#include "rapidjson.h" +#include "internal/meta.h" + +#include + +#if RAPIDJSON_HAS_CXX11 +#include +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// Allocator + +/*! \class rapidjson::Allocator + \brief Concept for allocating, resizing and freeing memory block. + + Note that Malloc() and Realloc() are non-static but Free() is static. + + So if an allocator need to support Free(), it needs to put its pointer in + the header of memory block. + +\code +concept Allocator { + static const bool kNeedFree; //!< Whether this allocator needs to call Free(). + + // Allocate a memory block. + // \param size of the memory block in bytes. + // \returns pointer to the memory block. + void* Malloc(size_t size); + + // Resize a memory block. + // \param originalPtr The pointer to current memory block. Null pointer is permitted. + // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.) + // \param newSize the new size in bytes. + void* Realloc(void* originalPtr, size_t originalSize, size_t newSize); + + // Free a memory block. + // \param pointer to the memory block. Null pointer is permitted. + static void Free(void *ptr); +}; +\endcode +*/ + + +/*! \def RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY + \ingroup RAPIDJSON_CONFIG + \brief User-defined kDefaultChunkCapacity definition. + + User can define this as any \c size that is a power of 2. +*/ + +#ifndef RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY +#define RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024) +#endif + + +/////////////////////////////////////////////////////////////////////////////// +// CrtAllocator + +//! C-runtime library allocator. +/*! This class is just wrapper for standard C library memory routines. + \note implements Allocator concept +*/ +class CrtAllocator { +public: + static const bool kNeedFree = true; + void* Malloc(size_t size) { + if (size) // behavior of malloc(0) is implementation defined. + return RAPIDJSON_MALLOC(size); + else + return NULL; // standardize to returning NULL. + } + void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) { + (void)originalSize; + if (newSize == 0) { + RAPIDJSON_FREE(originalPtr); + return NULL; + } + return RAPIDJSON_REALLOC(originalPtr, newSize); + } + static void Free(void *ptr) RAPIDJSON_NOEXCEPT { RAPIDJSON_FREE(ptr); } + + bool operator==(const CrtAllocator&) const RAPIDJSON_NOEXCEPT { + return true; + } + bool operator!=(const CrtAllocator&) const RAPIDJSON_NOEXCEPT { + return false; + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// MemoryPoolAllocator + +//! Default memory allocator used by the parser and DOM. +/*! This allocator allocate memory blocks from pre-allocated memory chunks. + + It does not free memory blocks. And Realloc() only allocate new memory. + + The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default. + + User may also supply a buffer as the first chunk. + + If the user-buffer is full then additional chunks are allocated by BaseAllocator. + + The user-buffer is not deallocated by this allocator. + + \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator. + \note implements Allocator concept +*/ +template +class MemoryPoolAllocator { + //! Chunk header for perpending to each chunk. + /*! Chunks are stored as a singly linked list. + */ + struct ChunkHeader { + size_t capacity; //!< Capacity of the chunk in bytes (excluding the header itself). + size_t size; //!< Current size of allocated memory in bytes. + ChunkHeader *next; //!< Next chunk in the linked list. + }; + + struct SharedData { + ChunkHeader *chunkHead; //!< Head of the chunk linked-list. Only the head chunk serves allocation. + BaseAllocator* ownBaseAllocator; //!< base allocator created by this object. + size_t refcount; + bool ownBuffer; + }; + + static const size_t SIZEOF_SHARED_DATA = RAPIDJSON_ALIGN(sizeof(SharedData)); + static const size_t SIZEOF_CHUNK_HEADER = RAPIDJSON_ALIGN(sizeof(ChunkHeader)); + + static inline ChunkHeader *GetChunkHead(SharedData *shared) + { + return reinterpret_cast(reinterpret_cast(shared) + SIZEOF_SHARED_DATA); + } + static inline uint8_t *GetChunkBuffer(SharedData *shared) + { + return reinterpret_cast(shared->chunkHead) + SIZEOF_CHUNK_HEADER; + } + + static const size_t kDefaultChunkCapacity = RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY; //!< Default chunk capacity. + +public: + static const bool kNeedFree = false; //!< Tell users that no need to call Free() with this allocator. (concept Allocator) + static const bool kRefCounted = true; //!< Tell users that this allocator is reference counted on copy + + //! Constructor with chunkSize. + /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize. + \param baseAllocator The allocator for allocating memory chunks. + */ + explicit + MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : + chunk_capacity_(chunkSize), + baseAllocator_(baseAllocator ? baseAllocator : RAPIDJSON_NEW(BaseAllocator)()), + shared_(static_cast(baseAllocator_ ? baseAllocator_->Malloc(SIZEOF_SHARED_DATA + SIZEOF_CHUNK_HEADER) : 0)) + { + RAPIDJSON_ASSERT(baseAllocator_ != 0); + RAPIDJSON_ASSERT(shared_ != 0); + if (baseAllocator) { + shared_->ownBaseAllocator = 0; + } + else { + shared_->ownBaseAllocator = baseAllocator_; + } + shared_->chunkHead = GetChunkHead(shared_); + shared_->chunkHead->capacity = 0; + shared_->chunkHead->size = 0; + shared_->chunkHead->next = 0; + shared_->ownBuffer = true; + shared_->refcount = 1; + } + + //! Constructor with user-supplied buffer. + /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size. + + The user buffer will not be deallocated when this allocator is destructed. + + \param buffer User supplied buffer. + \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader). + \param chunkSize The size of memory chunk. The default is kDefaultChunkSize. + \param baseAllocator The allocator for allocating memory chunks. + */ + MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : + chunk_capacity_(chunkSize), + baseAllocator_(baseAllocator), + shared_(static_cast(AlignBuffer(buffer, size))) + { + RAPIDJSON_ASSERT(size >= SIZEOF_SHARED_DATA + SIZEOF_CHUNK_HEADER); + shared_->chunkHead = GetChunkHead(shared_); + shared_->chunkHead->capacity = size - SIZEOF_SHARED_DATA - SIZEOF_CHUNK_HEADER; + shared_->chunkHead->size = 0; + shared_->chunkHead->next = 0; + shared_->ownBaseAllocator = 0; + shared_->ownBuffer = false; + shared_->refcount = 1; + } + + MemoryPoolAllocator(const MemoryPoolAllocator& rhs) RAPIDJSON_NOEXCEPT : + chunk_capacity_(rhs.chunk_capacity_), + baseAllocator_(rhs.baseAllocator_), + shared_(rhs.shared_) + { + RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0); + ++shared_->refcount; + } + MemoryPoolAllocator& operator=(const MemoryPoolAllocator& rhs) RAPIDJSON_NOEXCEPT + { + RAPIDJSON_NOEXCEPT_ASSERT(rhs.shared_->refcount > 0); + ++rhs.shared_->refcount; + this->~MemoryPoolAllocator(); + baseAllocator_ = rhs.baseAllocator_; + chunk_capacity_ = rhs.chunk_capacity_; + shared_ = rhs.shared_; + return *this; + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + MemoryPoolAllocator(MemoryPoolAllocator&& rhs) RAPIDJSON_NOEXCEPT : + chunk_capacity_(rhs.chunk_capacity_), + baseAllocator_(rhs.baseAllocator_), + shared_(rhs.shared_) + { + RAPIDJSON_NOEXCEPT_ASSERT(rhs.shared_->refcount > 0); + rhs.shared_ = 0; + } + MemoryPoolAllocator& operator=(MemoryPoolAllocator&& rhs) RAPIDJSON_NOEXCEPT + { + RAPIDJSON_NOEXCEPT_ASSERT(rhs.shared_->refcount > 0); + this->~MemoryPoolAllocator(); + baseAllocator_ = rhs.baseAllocator_; + chunk_capacity_ = rhs.chunk_capacity_; + shared_ = rhs.shared_; + rhs.shared_ = 0; + return *this; + } +#endif + + //! Destructor. + /*! This deallocates all memory chunks, excluding the user-supplied buffer. + */ + ~MemoryPoolAllocator() RAPIDJSON_NOEXCEPT { + if (!shared_) { + // do nothing if moved + return; + } + if (shared_->refcount > 1) { + --shared_->refcount; + return; + } + Clear(); + BaseAllocator *a = shared_->ownBaseAllocator; + if (shared_->ownBuffer) { + baseAllocator_->Free(shared_); + } + RAPIDJSON_DELETE(a); + } + + //! Deallocates all memory chunks, excluding the first/user one. + void Clear() RAPIDJSON_NOEXCEPT { + RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0); + for (;;) { + ChunkHeader* c = shared_->chunkHead; + if (!c->next) { + break; + } + shared_->chunkHead = c->next; + baseAllocator_->Free(c); + } + shared_->chunkHead->size = 0; + } + + //! Computes the total capacity of allocated memory chunks. + /*! \return total capacity in bytes. + */ + size_t Capacity() const RAPIDJSON_NOEXCEPT { + RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0); + size_t capacity = 0; + for (ChunkHeader* c = shared_->chunkHead; c != 0; c = c->next) + capacity += c->capacity; + return capacity; + } + + //! Computes the memory blocks allocated. + /*! \return total used bytes. + */ + size_t Size() const RAPIDJSON_NOEXCEPT { + RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0); + size_t size = 0; + for (ChunkHeader* c = shared_->chunkHead; c != 0; c = c->next) + size += c->size; + return size; + } + + //! Whether the allocator is shared. + /*! \return true or false. + */ + bool Shared() const RAPIDJSON_NOEXCEPT { + RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0); + return shared_->refcount > 1; + } + + //! Allocates a memory block. (concept Allocator) + void* Malloc(size_t size) { + RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0); + if (!size) + return NULL; + + size = RAPIDJSON_ALIGN(size); + if (RAPIDJSON_UNLIKELY(shared_->chunkHead->size + size > shared_->chunkHead->capacity)) + if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size)) + return NULL; + + void *buffer = GetChunkBuffer(shared_) + shared_->chunkHead->size; + shared_->chunkHead->size += size; + return buffer; + } + + //! Resizes a memory block (concept Allocator) + void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) { + if (originalPtr == 0) + return Malloc(newSize); + + RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0); + if (newSize == 0) + return NULL; + + originalSize = RAPIDJSON_ALIGN(originalSize); + newSize = RAPIDJSON_ALIGN(newSize); + + // Do not shrink if new size is smaller than original + if (originalSize >= newSize) + return originalPtr; + + // Simply expand it if it is the last allocation and there is sufficient space + if (originalPtr == GetChunkBuffer(shared_) + shared_->chunkHead->size - originalSize) { + size_t increment = static_cast(newSize - originalSize); + if (shared_->chunkHead->size + increment <= shared_->chunkHead->capacity) { + shared_->chunkHead->size += increment; + return originalPtr; + } + } + + // Realloc process: allocate and copy memory, do not free original buffer. + if (void* newBuffer = Malloc(newSize)) { + if (originalSize) + std::memcpy(newBuffer, originalPtr, originalSize); + return newBuffer; + } + else + return NULL; + } + + //! Frees a memory block (concept Allocator) + static void Free(void *ptr) RAPIDJSON_NOEXCEPT { (void)ptr; } // Do nothing + + //! Compare (equality) with another MemoryPoolAllocator + bool operator==(const MemoryPoolAllocator& rhs) const RAPIDJSON_NOEXCEPT { + RAPIDJSON_NOEXCEPT_ASSERT(shared_->refcount > 0); + RAPIDJSON_NOEXCEPT_ASSERT(rhs.shared_->refcount > 0); + return shared_ == rhs.shared_; + } + //! Compare (inequality) with another MemoryPoolAllocator + bool operator!=(const MemoryPoolAllocator& rhs) const RAPIDJSON_NOEXCEPT { + return !operator==(rhs); + } + +private: + //! Creates a new chunk. + /*! \param capacity Capacity of the chunk in bytes. + \return true if success. + */ + bool AddChunk(size_t capacity) { + if (!baseAllocator_) + shared_->ownBaseAllocator = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator)(); + if (ChunkHeader* chunk = static_cast(baseAllocator_->Malloc(SIZEOF_CHUNK_HEADER + capacity))) { + chunk->capacity = capacity; + chunk->size = 0; + chunk->next = shared_->chunkHead; + shared_->chunkHead = chunk; + return true; + } + else + return false; + } + + static inline void* AlignBuffer(void* buf, size_t &size) + { + RAPIDJSON_NOEXCEPT_ASSERT(buf != 0); + const uintptr_t mask = sizeof(void*) - 1; + const uintptr_t ubuf = reinterpret_cast(buf); + if (RAPIDJSON_UNLIKELY(ubuf & mask)) { + const uintptr_t abuf = (ubuf + mask) & ~mask; + RAPIDJSON_ASSERT(size >= abuf - ubuf); + buf = reinterpret_cast(abuf); + size -= abuf - ubuf; + } + return buf; + } + + size_t chunk_capacity_; //!< The minimum capacity of chunk when they are allocated. + BaseAllocator* baseAllocator_; //!< base allocator for allocating memory chunks. + SharedData *shared_; //!< The shared data of the allocator +}; + +namespace internal { + template + struct IsRefCounted : + public FalseType + { }; + template + struct IsRefCounted::Type> : + public TrueType + { }; +} + +template +inline T* Realloc(A& a, T* old_p, size_t old_n, size_t new_n) +{ + RAPIDJSON_NOEXCEPT_ASSERT(old_n <= SIZE_MAX / sizeof(T) && new_n <= SIZE_MAX / sizeof(T)); + return static_cast(a.Realloc(old_p, old_n * sizeof(T), new_n * sizeof(T))); +} + +template +inline T *Malloc(A& a, size_t n = 1) +{ + return Realloc(a, NULL, 0, n); +} + +template +inline void Free(A& a, T *p, size_t n = 1) +{ + static_cast(Realloc(a, p, n, 0)); +} + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) // std::allocator can safely be inherited +#endif + +template +class StdAllocator : + public std::allocator +{ + typedef std::allocator allocator_type; +#if RAPIDJSON_HAS_CXX11 + typedef std::allocator_traits traits_type; +#else + typedef allocator_type traits_type; +#endif + +public: + typedef BaseAllocator BaseAllocatorType; + + StdAllocator() RAPIDJSON_NOEXCEPT : + allocator_type(), + baseAllocator_() + { } + + StdAllocator(const StdAllocator& rhs) RAPIDJSON_NOEXCEPT : + allocator_type(rhs), + baseAllocator_(rhs.baseAllocator_) + { } + + template + StdAllocator(const StdAllocator& rhs) RAPIDJSON_NOEXCEPT : + allocator_type(rhs), + baseAllocator_(rhs.baseAllocator_) + { } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + StdAllocator(StdAllocator&& rhs) RAPIDJSON_NOEXCEPT : + allocator_type(std::move(rhs)), + baseAllocator_(std::move(rhs.baseAllocator_)) + { } +#endif +#if RAPIDJSON_HAS_CXX11 + using propagate_on_container_move_assignment = std::true_type; + using propagate_on_container_swap = std::true_type; +#endif + + /* implicit */ + StdAllocator(const BaseAllocator& allocator) RAPIDJSON_NOEXCEPT : + allocator_type(), + baseAllocator_(allocator) + { } + + ~StdAllocator() RAPIDJSON_NOEXCEPT + { } + + template + struct rebind { + typedef StdAllocator other; + }; + + typedef typename traits_type::size_type size_type; + typedef typename traits_type::difference_type difference_type; + + typedef typename traits_type::value_type value_type; + typedef typename traits_type::pointer pointer; + typedef typename traits_type::const_pointer const_pointer; + +#if RAPIDJSON_HAS_CXX11 + + typedef typename std::add_lvalue_reference::type &reference; + typedef typename std::add_lvalue_reference::type>::type &const_reference; + + pointer address(reference r) const RAPIDJSON_NOEXCEPT + { + return std::addressof(r); + } + const_pointer address(const_reference r) const RAPIDJSON_NOEXCEPT + { + return std::addressof(r); + } + + size_type max_size() const RAPIDJSON_NOEXCEPT + { + return traits_type::max_size(*this); + } + + template + void construct(pointer p, Args&&... args) + { + traits_type::construct(*this, p, std::forward(args)...); + } + void destroy(pointer p) + { + traits_type::destroy(*this, p); + } + +#else // !RAPIDJSON_HAS_CXX11 + + typedef typename allocator_type::reference reference; + typedef typename allocator_type::const_reference const_reference; + + pointer address(reference r) const RAPIDJSON_NOEXCEPT + { + return allocator_type::address(r); + } + const_pointer address(const_reference r) const RAPIDJSON_NOEXCEPT + { + return allocator_type::address(r); + } + + size_type max_size() const RAPIDJSON_NOEXCEPT + { + return allocator_type::max_size(); + } + + void construct(pointer p, const_reference r) + { + allocator_type::construct(p, r); + } + void destroy(pointer p) + { + allocator_type::destroy(p); + } + +#endif // !RAPIDJSON_HAS_CXX11 + + template + U* allocate(size_type n = 1, const void* = 0) + { + return RAPIDJSON_NAMESPACE::Malloc(baseAllocator_, n); + } + template + void deallocate(U* p, size_type n = 1) + { + RAPIDJSON_NAMESPACE::Free(baseAllocator_, p, n); + } + + pointer allocate(size_type n = 1, const void* = 0) + { + return allocate(n); + } + void deallocate(pointer p, size_type n = 1) + { + deallocate(p, n); + } + +#if RAPIDJSON_HAS_CXX11 + using is_always_equal = std::is_empty; +#endif + + template + bool operator==(const StdAllocator& rhs) const RAPIDJSON_NOEXCEPT + { + return baseAllocator_ == rhs.baseAllocator_; + } + template + bool operator!=(const StdAllocator& rhs) const RAPIDJSON_NOEXCEPT + { + return !operator==(rhs); + } + + //! rapidjson Allocator concept + static const bool kNeedFree = BaseAllocator::kNeedFree; + static const bool kRefCounted = internal::IsRefCounted::Value; + void* Malloc(size_t size) + { + return baseAllocator_.Malloc(size); + } + void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) + { + return baseAllocator_.Realloc(originalPtr, originalSize, newSize); + } + static void Free(void *ptr) RAPIDJSON_NOEXCEPT + { + BaseAllocator::Free(ptr); + } + +private: + template + friend class StdAllocator; // access to StdAllocator.* + + BaseAllocator baseAllocator_; +}; + +#if !RAPIDJSON_HAS_CXX17 // std::allocator deprecated in C++17 +template +class StdAllocator : + public std::allocator +{ + typedef std::allocator allocator_type; + +public: + typedef BaseAllocator BaseAllocatorType; + + StdAllocator() RAPIDJSON_NOEXCEPT : + allocator_type(), + baseAllocator_() + { } + + StdAllocator(const StdAllocator& rhs) RAPIDJSON_NOEXCEPT : + allocator_type(rhs), + baseAllocator_(rhs.baseAllocator_) + { } + + template + StdAllocator(const StdAllocator& rhs) RAPIDJSON_NOEXCEPT : + allocator_type(rhs), + baseAllocator_(rhs.baseAllocator_) + { } + + /* implicit */ + StdAllocator(const BaseAllocator& baseAllocator) RAPIDJSON_NOEXCEPT : + allocator_type(), + baseAllocator_(baseAllocator) + { } + + ~StdAllocator() RAPIDJSON_NOEXCEPT + { } + + template + struct rebind { + typedef StdAllocator other; + }; + + typedef typename allocator_type::value_type value_type; + +private: + template + friend class StdAllocator; // access to StdAllocator.* + + BaseAllocator baseAllocator_; +}; +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_ENCODINGS_H_ diff --git a/libs/include/rapidjson/cursorstreamwrapper.h b/libs/include/rapidjson/cursorstreamwrapper.h new file mode 100644 index 0000000..fd6513d --- /dev/null +++ b/libs/include/rapidjson/cursorstreamwrapper.h @@ -0,0 +1,78 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_CURSORSTREAMWRAPPER_H_ +#define RAPIDJSON_CURSORSTREAMWRAPPER_H_ + +#include "stream.h" + +#if defined(__GNUC__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4702) // unreachable code +RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated +#endif + +RAPIDJSON_NAMESPACE_BEGIN + + +//! Cursor stream wrapper for counting line and column number if error exists. +/*! + \tparam InputStream Any stream that implements Stream Concept +*/ +template > +class CursorStreamWrapper : public GenericStreamWrapper { +public: + typedef typename Encoding::Ch Ch; + + CursorStreamWrapper(InputStream& is): + GenericStreamWrapper(is), line_(1), col_(0) {} + + // counting line and column number + Ch Take() { + Ch ch = this->is_.Take(); + if(ch == '\n') { + line_ ++; + col_ = 0; + } else { + col_ ++; + } + return ch; + } + + //! Get the error line number, if error exists. + size_t GetLine() const { return line_; } + //! Get the error column number, if error exists. + size_t GetColumn() const { return col_; } + +private: + size_t line_; //!< Current Line + size_t col_; //!< Current Column +}; + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +RAPIDJSON_DIAG_POP +#endif + +#if defined(__GNUC__) +RAPIDJSON_DIAG_POP +#endif + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_CURSORSTREAMWRAPPER_H_ diff --git a/libs/include/rapidjson/document.h b/libs/include/rapidjson/document.h new file mode 100644 index 0000000..057b37a --- /dev/null +++ b/libs/include/rapidjson/document.h @@ -0,0 +1,3027 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_DOCUMENT_H_ +#define RAPIDJSON_DOCUMENT_H_ + +/*! \file document.h */ + +#include "reader.h" +#include "internal/meta.h" +#include "internal/strfunc.h" +#include "memorystream.h" +#include "encodedstream.h" +#include // placement new +#include +#ifdef __cpp_lib_three_way_comparison +#include +#endif + +RAPIDJSON_DIAG_PUSH +#ifdef __clang__ +RAPIDJSON_DIAG_OFF(padded) +RAPIDJSON_DIAG_OFF(switch-enum) +RAPIDJSON_DIAG_OFF(c++98-compat) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant +RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_OFF(effc++) +#endif // __GNUC__ + +#ifdef GetObject +// see https://github.com/Tencent/rapidjson/issues/1448 +// a former included windows.h might have defined a macro called GetObject, which affects +// GetObject defined here. This ensures the macro does not get applied +#pragma push_macro("GetObject") +#define RAPIDJSON_WINDOWS_GETOBJECT_WORKAROUND_APPLIED +#undef GetObject +#endif + +#ifndef RAPIDJSON_NOMEMBERITERATORCLASS +#include // std::random_access_iterator_tag +#endif + +#if RAPIDJSON_USE_MEMBERSMAP +#include // std::multimap +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +// Forward declaration. +template +class GenericValue; + +template +class GenericDocument; + +/*! \def RAPIDJSON_DEFAULT_ALLOCATOR + \ingroup RAPIDJSON_CONFIG + \brief Allows to choose default allocator. + + User can define this to use CrtAllocator or MemoryPoolAllocator. +*/ +#ifndef RAPIDJSON_DEFAULT_ALLOCATOR +#define RAPIDJSON_DEFAULT_ALLOCATOR MemoryPoolAllocator +#endif + +/*! \def RAPIDJSON_DEFAULT_STACK_ALLOCATOR + \ingroup RAPIDJSON_CONFIG + \brief Allows to choose default stack allocator for Document. + + User can define this to use CrtAllocator or MemoryPoolAllocator. +*/ +#ifndef RAPIDJSON_DEFAULT_STACK_ALLOCATOR +#define RAPIDJSON_DEFAULT_STACK_ALLOCATOR CrtAllocator +#endif + +/*! \def RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY + \ingroup RAPIDJSON_CONFIG + \brief User defined kDefaultObjectCapacity value. + + User can define this as any natural number. +*/ +#ifndef RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY +// number of objects that rapidjson::Value allocates memory for by default +#define RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY 16 +#endif + +/*! \def RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY + \ingroup RAPIDJSON_CONFIG + \brief User defined kDefaultArrayCapacity value. + + User can define this as any natural number. +*/ +#ifndef RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY +// number of array elements that rapidjson::Value allocates memory for by default +#define RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY 16 +#endif + +//! Name-value pair in a JSON object value. +/*! + This class was internal to GenericValue. It used to be a inner struct. + But a compiler (IBM XL C/C++ for AIX) have reported to have problem with that so it moved as a namespace scope struct. + https://code.google.com/p/rapidjson/issues/detail?id=64 +*/ +template +class GenericMember { +public: + GenericValue name; //!< name of member (must be a string) + GenericValue value; //!< value of member. + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move constructor in C++11 + GenericMember(GenericMember&& rhs) RAPIDJSON_NOEXCEPT + : name(std::move(rhs.name)), + value(std::move(rhs.value)) + { + } + + //! Move assignment in C++11 + GenericMember& operator=(GenericMember&& rhs) RAPIDJSON_NOEXCEPT { + return *this = static_cast(rhs); + } +#endif + + //! Assignment with move semantics. + /*! \param rhs Source of the assignment. Its name and value will become a null value after assignment. + */ + GenericMember& operator=(GenericMember& rhs) RAPIDJSON_NOEXCEPT { + if (RAPIDJSON_LIKELY(this != &rhs)) { + name = rhs.name; + value = rhs.value; + } + return *this; + } + + // swap() for std::sort() and other potential use in STL. + friend inline void swap(GenericMember& a, GenericMember& b) RAPIDJSON_NOEXCEPT { + a.name.Swap(b.name); + a.value.Swap(b.value); + } + +private: + //! Copy constructor is not permitted. + GenericMember(const GenericMember& rhs); +}; + +/////////////////////////////////////////////////////////////////////////////// +// GenericMemberIterator + +#ifndef RAPIDJSON_NOMEMBERITERATORCLASS + +//! (Constant) member iterator for a JSON object value +/*! + \tparam Const Is this a constant iterator? + \tparam Encoding Encoding of the value. (Even non-string values need to have the same encoding in a document) + \tparam Allocator Allocator type for allocating memory of object, array and string. + + This class implements a Random Access Iterator for GenericMember elements + of a GenericValue, see ISO/IEC 14882:2003(E) C++ standard, 24.1 [lib.iterator.requirements]. + + \note This iterator implementation is mainly intended to avoid implicit + conversions from iterator values to \c NULL, + e.g. from GenericValue::FindMember. + + \note Define \c RAPIDJSON_NOMEMBERITERATORCLASS to fall back to a + pointer-based implementation, if your platform doesn't provide + the C++ header. + + \see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator + */ +template +class GenericMemberIterator { + + friend class GenericValue; + template friend class GenericMemberIterator; + + typedef GenericMember PlainType; + typedef typename internal::MaybeAddConst::Type ValueType; + +public: + //! Iterator type itself + typedef GenericMemberIterator Iterator; + //! Constant iterator type + typedef GenericMemberIterator ConstIterator; + //! Non-constant iterator type + typedef GenericMemberIterator NonConstIterator; + + /** \name std::iterator_traits support */ + //@{ + typedef ValueType value_type; + typedef ValueType * pointer; + typedef ValueType & reference; + typedef std::ptrdiff_t difference_type; + typedef std::random_access_iterator_tag iterator_category; + //@} + + //! Pointer to (const) GenericMember + typedef pointer Pointer; + //! Reference to (const) GenericMember + typedef reference Reference; + //! Signed integer type (e.g. \c ptrdiff_t) + typedef difference_type DifferenceType; + + //! Default constructor (singular value) + /*! Creates an iterator pointing to no element. + \note All operations, except for comparisons, are undefined on such values. + */ + GenericMemberIterator() : ptr_() {} + + //! Iterator conversions to more const + /*! + \param it (Non-const) iterator to copy from + + Allows the creation of an iterator from another GenericMemberIterator + that is "less const". Especially, creating a non-constant iterator + from a constant iterator are disabled: + \li const -> non-const (not ok) + \li const -> const (ok) + \li non-const -> const (ok) + \li non-const -> non-const (ok) + + \note If the \c Const template parameter is already \c false, this + constructor effectively defines a regular copy-constructor. + Otherwise, the copy constructor is implicitly defined. + */ + GenericMemberIterator(const NonConstIterator & it) : ptr_(it.ptr_) {} + Iterator& operator=(const NonConstIterator & it) { ptr_ = it.ptr_; return *this; } + + //! @name stepping + //@{ + Iterator& operator++(){ ++ptr_; return *this; } + Iterator& operator--(){ --ptr_; return *this; } + Iterator operator++(int){ Iterator old(*this); ++ptr_; return old; } + Iterator operator--(int){ Iterator old(*this); --ptr_; return old; } + //@} + + //! @name increment/decrement + //@{ + Iterator operator+(DifferenceType n) const { return Iterator(ptr_+n); } + Iterator operator-(DifferenceType n) const { return Iterator(ptr_-n); } + + Iterator& operator+=(DifferenceType n) { ptr_+=n; return *this; } + Iterator& operator-=(DifferenceType n) { ptr_-=n; return *this; } + //@} + + //! @name relations + //@{ + template bool operator==(const GenericMemberIterator& that) const { return ptr_ == that.ptr_; } + template bool operator!=(const GenericMemberIterator& that) const { return ptr_ != that.ptr_; } + template bool operator<=(const GenericMemberIterator& that) const { return ptr_ <= that.ptr_; } + template bool operator>=(const GenericMemberIterator& that) const { return ptr_ >= that.ptr_; } + template bool operator< (const GenericMemberIterator& that) const { return ptr_ < that.ptr_; } + template bool operator> (const GenericMemberIterator& that) const { return ptr_ > that.ptr_; } + +#ifdef __cpp_lib_three_way_comparison + template std::strong_ordering operator<=>(const GenericMemberIterator& that) const { return ptr_ <=> that.ptr_; } +#endif + //@} + + //! @name dereference + //@{ + Reference operator*() const { return *ptr_; } + Pointer operator->() const { return ptr_; } + Reference operator[](DifferenceType n) const { return ptr_[n]; } + //@} + + //! Distance + DifferenceType operator-(ConstIterator that) const { return ptr_-that.ptr_; } + +private: + //! Internal constructor from plain pointer + explicit GenericMemberIterator(Pointer p) : ptr_(p) {} + + Pointer ptr_; //!< raw pointer +}; + +#else // RAPIDJSON_NOMEMBERITERATORCLASS + +// class-based member iterator implementation disabled, use plain pointers + +template +class GenericMemberIterator; + +//! non-const GenericMemberIterator +template +class GenericMemberIterator { +public: + //! use plain pointer as iterator type + typedef GenericMember* Iterator; +}; +//! const GenericMemberIterator +template +class GenericMemberIterator { +public: + //! use plain const pointer as iterator type + typedef const GenericMember* Iterator; +}; + +#endif // RAPIDJSON_NOMEMBERITERATORCLASS + +/////////////////////////////////////////////////////////////////////////////// +// GenericStringRef + +//! Reference to a constant string (not taking a copy) +/*! + \tparam CharType character type of the string + + This helper class is used to automatically infer constant string + references for string literals, especially from \c const \b (!) + character arrays. + + The main use is for creating JSON string values without copying the + source string via an \ref Allocator. This requires that the referenced + string pointers have a sufficient lifetime, which exceeds the lifetime + of the associated GenericValue. + + \b Example + \code + Value v("foo"); // ok, no need to copy & calculate length + const char foo[] = "foo"; + v.SetString(foo); // ok + + const char* bar = foo; + // Value x(bar); // not ok, can't rely on bar's lifetime + Value x(StringRef(bar)); // lifetime explicitly guaranteed by user + Value y(StringRef(bar, 3)); // ok, explicitly pass length + \endcode + + \see StringRef, GenericValue::SetString +*/ +template +struct GenericStringRef { + typedef CharType Ch; //!< character type of the string + + //! Create string reference from \c const character array +#ifndef __clang__ // -Wdocumentation + /*! + This constructor implicitly creates a constant string reference from + a \c const character array. It has better performance than + \ref StringRef(const CharType*) by inferring the string \ref length + from the array length, and also supports strings containing null + characters. + + \tparam N length of the string, automatically inferred + + \param str Constant character array, lifetime assumed to be longer + than the use of the string in e.g. a GenericValue + + \post \ref s == str + + \note Constant complexity. + \note There is a hidden, private overload to disallow references to + non-const character arrays to be created via this constructor. + By this, e.g. function-scope arrays used to be filled via + \c snprintf are excluded from consideration. + In such cases, the referenced string should be \b copied to the + GenericValue instead. + */ +#endif + template + GenericStringRef(const CharType (&str)[N]) RAPIDJSON_NOEXCEPT + : s(str), length(N-1) {} + + //! Explicitly create string reference from \c const character pointer +#ifndef __clang__ // -Wdocumentation + /*! + This constructor can be used to \b explicitly create a reference to + a constant string pointer. + + \see StringRef(const CharType*) + + \param str Constant character pointer, lifetime assumed to be longer + than the use of the string in e.g. a GenericValue + + \post \ref s == str + + \note There is a hidden, private overload to disallow references to + non-const character arrays to be created via this constructor. + By this, e.g. function-scope arrays used to be filled via + \c snprintf are excluded from consideration. + In such cases, the referenced string should be \b copied to the + GenericValue instead. + */ +#endif + explicit GenericStringRef(const CharType* str) + : s(str), length(NotNullStrLen(str)) {} + + //! Create constant string reference from pointer and length +#ifndef __clang__ // -Wdocumentation + /*! \param str constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue + \param len length of the string, excluding the trailing NULL terminator + + \post \ref s == str && \ref length == len + \note Constant complexity. + */ +#endif + GenericStringRef(const CharType* str, SizeType len) + : s(RAPIDJSON_LIKELY(str) ? str : emptyString), length(len) { RAPIDJSON_ASSERT(str != 0 || len == 0u); } + + GenericStringRef(const GenericStringRef& rhs) : s(rhs.s), length(rhs.length) {} + + //! implicit conversion to plain CharType pointer + operator const Ch *() const { return s; } + + const Ch* const s; //!< plain CharType pointer + const SizeType length; //!< length of the string (excluding the trailing NULL terminator) + +private: + SizeType NotNullStrLen(const CharType* str) { + RAPIDJSON_ASSERT(str != 0); + return internal::StrLen(str); + } + + /// Empty string - used when passing in a NULL pointer + static const Ch emptyString[]; + + //! Disallow construction from non-const array + template + GenericStringRef(CharType (&str)[N]) /* = delete */; + //! Copy assignment operator not permitted - immutable type + GenericStringRef& operator=(const GenericStringRef& rhs) /* = delete */; +}; + +template +const CharType GenericStringRef::emptyString[] = { CharType() }; + +//! Mark a character pointer as constant string +/*! Mark a plain character pointer as a "string literal". This function + can be used to avoid copying a character string to be referenced as a + value in a JSON GenericValue object, if the string's lifetime is known + to be valid long enough. + \tparam CharType Character type of the string + \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue + \return GenericStringRef string reference object + \relatesalso GenericStringRef + + \see GenericValue::GenericValue(StringRefType), GenericValue::operator=(StringRefType), GenericValue::SetString(StringRefType), GenericValue::PushBack(StringRefType, Allocator&), GenericValue::AddMember +*/ +template +inline GenericStringRef StringRef(const CharType* str) { + return GenericStringRef(str); +} + +//! Mark a character pointer as constant string +/*! Mark a plain character pointer as a "string literal". This function + can be used to avoid copying a character string to be referenced as a + value in a JSON GenericValue object, if the string's lifetime is known + to be valid long enough. + + This version has better performance with supplied length, and also + supports string containing null characters. + + \tparam CharType character type of the string + \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue + \param length The length of source string. + \return GenericStringRef string reference object + \relatesalso GenericStringRef +*/ +template +inline GenericStringRef StringRef(const CharType* str, size_t length) { + return GenericStringRef(str, SizeType(length)); +} + +#if RAPIDJSON_HAS_STDSTRING +//! Mark a string object as constant string +/*! Mark a string object (e.g. \c std::string) as a "string literal". + This function can be used to avoid copying a string to be referenced as a + value in a JSON GenericValue object, if the string's lifetime is known + to be valid long enough. + + \tparam CharType character type of the string + \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue + \return GenericStringRef string reference object + \relatesalso GenericStringRef + \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. +*/ +template +inline GenericStringRef StringRef(const std::basic_string& str) { + return GenericStringRef(str.data(), SizeType(str.size())); +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// GenericValue type traits +namespace internal { + +template +struct IsGenericValueImpl : FalseType {}; + +// select candidates according to nested encoding and allocator types +template struct IsGenericValueImpl::Type, typename Void::Type> + : IsBaseOf, T>::Type {}; + +// helper to match arbitrary GenericValue instantiations, including derived classes +template struct IsGenericValue : IsGenericValueImpl::Type {}; + +} // namespace internal + +/////////////////////////////////////////////////////////////////////////////// +// TypeHelper + +namespace internal { + +template +struct TypeHelper {}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsBool(); } + static bool Get(const ValueType& v) { return v.GetBool(); } + static ValueType& Set(ValueType& v, bool data) { return v.SetBool(data); } + static ValueType& Set(ValueType& v, bool data, typename ValueType::AllocatorType&) { return v.SetBool(data); } +}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsInt(); } + static int Get(const ValueType& v) { return v.GetInt(); } + static ValueType& Set(ValueType& v, int data) { return v.SetInt(data); } + static ValueType& Set(ValueType& v, int data, typename ValueType::AllocatorType&) { return v.SetInt(data); } +}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsUint(); } + static unsigned Get(const ValueType& v) { return v.GetUint(); } + static ValueType& Set(ValueType& v, unsigned data) { return v.SetUint(data); } + static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); } +}; + +#ifdef _MSC_VER +RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int)); +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsInt(); } + static long Get(const ValueType& v) { return v.GetInt(); } + static ValueType& Set(ValueType& v, long data) { return v.SetInt(data); } + static ValueType& Set(ValueType& v, long data, typename ValueType::AllocatorType&) { return v.SetInt(data); } +}; + +RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned)); +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsUint(); } + static unsigned long Get(const ValueType& v) { return v.GetUint(); } + static ValueType& Set(ValueType& v, unsigned long data) { return v.SetUint(data); } + static ValueType& Set(ValueType& v, unsigned long data, typename ValueType::AllocatorType&) { return v.SetUint(data); } +}; +#endif + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsInt64(); } + static int64_t Get(const ValueType& v) { return v.GetInt64(); } + static ValueType& Set(ValueType& v, int64_t data) { return v.SetInt64(data); } + static ValueType& Set(ValueType& v, int64_t data, typename ValueType::AllocatorType&) { return v.SetInt64(data); } +}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsUint64(); } + static uint64_t Get(const ValueType& v) { return v.GetUint64(); } + static ValueType& Set(ValueType& v, uint64_t data) { return v.SetUint64(data); } + static ValueType& Set(ValueType& v, uint64_t data, typename ValueType::AllocatorType&) { return v.SetUint64(data); } +}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsDouble(); } + static double Get(const ValueType& v) { return v.GetDouble(); } + static ValueType& Set(ValueType& v, double data) { return v.SetDouble(data); } + static ValueType& Set(ValueType& v, double data, typename ValueType::AllocatorType&) { return v.SetDouble(data); } +}; + +template +struct TypeHelper { + static bool Is(const ValueType& v) { return v.IsFloat(); } + static float Get(const ValueType& v) { return v.GetFloat(); } + static ValueType& Set(ValueType& v, float data) { return v.SetFloat(data); } + static ValueType& Set(ValueType& v, float data, typename ValueType::AllocatorType&) { return v.SetFloat(data); } +}; + +template +struct TypeHelper { + typedef const typename ValueType::Ch* StringType; + static bool Is(const ValueType& v) { return v.IsString(); } + static StringType Get(const ValueType& v) { return v.GetString(); } + static ValueType& Set(ValueType& v, const StringType data) { return v.SetString(typename ValueType::StringRefType(data)); } + static ValueType& Set(ValueType& v, const StringType data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); } +}; + +#if RAPIDJSON_HAS_STDSTRING +template +struct TypeHelper > { + typedef std::basic_string StringType; + static bool Is(const ValueType& v) { return v.IsString(); } + static StringType Get(const ValueType& v) { return StringType(v.GetString(), v.GetStringLength()); } + static ValueType& Set(ValueType& v, const StringType& data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); } +}; +#endif + +template +struct TypeHelper { + typedef typename ValueType::Array ArrayType; + static bool Is(const ValueType& v) { return v.IsArray(); } + static ArrayType Get(ValueType& v) { return v.GetArray(); } + static ValueType& Set(ValueType& v, ArrayType data) { return v = data; } + static ValueType& Set(ValueType& v, ArrayType data, typename ValueType::AllocatorType&) { return v = data; } +}; + +template +struct TypeHelper { + typedef typename ValueType::ConstArray ArrayType; + static bool Is(const ValueType& v) { return v.IsArray(); } + static ArrayType Get(const ValueType& v) { return v.GetArray(); } +}; + +template +struct TypeHelper { + typedef typename ValueType::Object ObjectType; + static bool Is(const ValueType& v) { return v.IsObject(); } + static ObjectType Get(ValueType& v) { return v.GetObject(); } + static ValueType& Set(ValueType& v, ObjectType data) { return v = data; } + static ValueType& Set(ValueType& v, ObjectType data, typename ValueType::AllocatorType&) { return v = data; } +}; + +template +struct TypeHelper { + typedef typename ValueType::ConstObject ObjectType; + static bool Is(const ValueType& v) { return v.IsObject(); } + static ObjectType Get(const ValueType& v) { return v.GetObject(); } +}; + +} // namespace internal + +// Forward declarations +template class GenericArray; +template class GenericObject; + +/////////////////////////////////////////////////////////////////////////////// +// GenericValue + +//! Represents a JSON value. Use Value for UTF8 encoding and default allocator. +/*! + A JSON value can be one of 7 types. This class is a variant type supporting + these types. + + Use the Value if UTF8 and default allocator + + \tparam Encoding Encoding of the value. (Even non-string values need to have the same encoding in a document) + \tparam Allocator Allocator type for allocating memory of object, array and string. +*/ +template +class GenericValue { +public: + //! Name-value pair in an object. + typedef GenericMember Member; + typedef Encoding EncodingType; //!< Encoding type from template parameter. + typedef Allocator AllocatorType; //!< Allocator type from template parameter. + typedef typename Encoding::Ch Ch; //!< Character type derived from Encoding. + typedef GenericStringRef StringRefType; //!< Reference to a constant string + typedef typename GenericMemberIterator::Iterator MemberIterator; //!< Member iterator for iterating in object. + typedef typename GenericMemberIterator::Iterator ConstMemberIterator; //!< Constant member iterator for iterating in object. + typedef GenericValue* ValueIterator; //!< Value iterator for iterating in array. + typedef const GenericValue* ConstValueIterator; //!< Constant value iterator for iterating in array. + typedef GenericValue ValueType; //!< Value type of itself. + typedef GenericArray Array; + typedef GenericArray ConstArray; + typedef GenericObject Object; + typedef GenericObject ConstObject; + + //!@name Constructors and destructor. + //@{ + + //! Default constructor creates a null value. + GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move constructor in C++11 + GenericValue(GenericValue&& rhs) RAPIDJSON_NOEXCEPT : data_(rhs.data_) { + rhs.data_.f.flags = kNullFlag; // give up contents + } +#endif + +private: + //! Copy constructor is not permitted. + GenericValue(const GenericValue& rhs); + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Moving from a GenericDocument is not permitted. + template + GenericValue(GenericDocument&& rhs); + + //! Move assignment from a GenericDocument is not permitted. + template + GenericValue& operator=(GenericDocument&& rhs); +#endif + +public: + + //! Constructor with JSON value type. + /*! This creates a Value of specified type with default content. + \param type Type of the value. + \note Default content for number is zero. + */ + explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() { + static const uint16_t defaultFlags[] = { + kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag, + kNumberAnyFlag + }; + RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType); + data_.f.flags = defaultFlags[type]; + + // Use ShortString to store empty string. + if (type == kStringType) + data_.ss.SetLength(0); + } + + //! Explicit copy constructor (with allocator) + /*! Creates a copy of a Value by using the given Allocator + \tparam SourceAllocator allocator of \c rhs + \param rhs Value to copy from (read-only) + \param allocator Allocator for allocating copied elements and buffers. Commonly use GenericDocument::GetAllocator(). + \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer) + \see CopyFrom() + */ + template + GenericValue(const GenericValue& rhs, Allocator& allocator, bool copyConstStrings = false) { + switch (rhs.GetType()) { + case kObjectType: + DoCopyMembers(rhs, allocator, copyConstStrings); + break; + case kArrayType: { + SizeType count = rhs.data_.a.size; + GenericValue* le = reinterpret_cast(allocator.Malloc(count * sizeof(GenericValue))); + const GenericValue* re = rhs.GetElementsPointer(); + for (SizeType i = 0; i < count; i++) + new (&le[i]) GenericValue(re[i], allocator, copyConstStrings); + data_.f.flags = kArrayFlag; + data_.a.size = data_.a.capacity = count; + SetElementsPointer(le); + } + break; + case kStringType: + if (rhs.data_.f.flags == kConstStringFlag && !copyConstStrings) { + data_.f.flags = rhs.data_.f.flags; + data_ = *reinterpret_cast(&rhs.data_); + } + else + SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator); + break; + default: + data_.f.flags = rhs.data_.f.flags; + data_ = *reinterpret_cast(&rhs.data_); + break; + } + } + + //! Constructor for boolean value. + /*! \param b Boolean value + \note This constructor is limited to \em real boolean values and rejects + implicitly converted types like arbitrary pointers. Use an explicit cast + to \c bool, if you want to construct a boolean JSON value in such cases. + */ +#ifndef RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen + template + explicit GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame))) RAPIDJSON_NOEXCEPT // See #472 +#else + explicit GenericValue(bool b) RAPIDJSON_NOEXCEPT +#endif + : data_() { + // safe-guard against failing SFINAE + RAPIDJSON_STATIC_ASSERT((internal::IsSame::Value)); + data_.f.flags = b ? kTrueFlag : kFalseFlag; + } + + //! Constructor for int value. + explicit GenericValue(int i) RAPIDJSON_NOEXCEPT : data_() { + data_.n.i64 = i; + data_.f.flags = (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag; + } + + //! Constructor for unsigned value. + explicit GenericValue(unsigned u) RAPIDJSON_NOEXCEPT : data_() { + data_.n.u64 = u; + data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag); + } + + //! Constructor for int64_t value. + explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_() { + data_.n.i64 = i64; + data_.f.flags = kNumberInt64Flag; + if (i64 >= 0) { + data_.f.flags |= kNumberUint64Flag; + if (!(static_cast(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000))) + data_.f.flags |= kUintFlag; + if (!(static_cast(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000))) + data_.f.flags |= kIntFlag; + } + else if (i64 >= static_cast(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000))) + data_.f.flags |= kIntFlag; + } + + //! Constructor for uint64_t value. + explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_() { + data_.n.u64 = u64; + data_.f.flags = kNumberUint64Flag; + if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000))) + data_.f.flags |= kInt64Flag; + if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000))) + data_.f.flags |= kUintFlag; + if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000))) + data_.f.flags |= kIntFlag; + } + + //! Constructor for double value. + explicit GenericValue(double d) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = d; data_.f.flags = kNumberDoubleFlag; } + + //! Constructor for float value. + explicit GenericValue(float f) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = static_cast(f); data_.f.flags = kNumberDoubleFlag; } + + //! Constructor for constant string (i.e. do not make a copy of string) + GenericValue(const Ch* s, SizeType length) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(StringRef(s, length)); } + + //! Constructor for constant string (i.e. do not make a copy of string) + explicit GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(s); } + + //! Constructor for copy-string (i.e. do make a copy of string) + GenericValue(const Ch* s, SizeType length, Allocator& allocator) : data_() { SetStringRaw(StringRef(s, length), allocator); } + + //! Constructor for copy-string (i.e. do make a copy of string) + GenericValue(const Ch*s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); } + +#if RAPIDJSON_HAS_STDSTRING + //! Constructor for copy-string from a string object (i.e. do make a copy of string) + /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. + */ + GenericValue(const std::basic_string& s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); } +#endif + + //! Constructor for Array. + /*! + \param a An array obtained by \c GetArray(). + \note \c Array is always pass-by-value. + \note the source array is moved into this value and the sourec array becomes empty. + */ + GenericValue(Array a) RAPIDJSON_NOEXCEPT : data_(a.value_.data_) { + a.value_.data_ = Data(); + a.value_.data_.f.flags = kArrayFlag; + } + + //! Constructor for Object. + /*! + \param o An object obtained by \c GetObject(). + \note \c Object is always pass-by-value. + \note the source object is moved into this value and the sourec object becomes empty. + */ + GenericValue(Object o) RAPIDJSON_NOEXCEPT : data_(o.value_.data_) { + o.value_.data_ = Data(); + o.value_.data_.f.flags = kObjectFlag; + } + + //! Destructor. + /*! Need to destruct elements of array, members of object, or copy-string. + */ + ~GenericValue() { + // With RAPIDJSON_USE_MEMBERSMAP, the maps need to be destroyed to release + // their Allocator if it's refcounted (e.g. MemoryPoolAllocator). + if (Allocator::kNeedFree || (RAPIDJSON_USE_MEMBERSMAP+0 && + internal::IsRefCounted::Value)) { + switch(data_.f.flags) { + case kArrayFlag: + { + GenericValue* e = GetElementsPointer(); + for (GenericValue* v = e; v != e + data_.a.size; ++v) + v->~GenericValue(); + if (Allocator::kNeedFree) { // Shortcut by Allocator's trait + Allocator::Free(e); + } + } + break; + + case kObjectFlag: + DoFreeMembers(); + break; + + case kCopyStringFlag: + if (Allocator::kNeedFree) { // Shortcut by Allocator's trait + Allocator::Free(const_cast(GetStringPointer())); + } + break; + + default: + break; // Do nothing for other types. + } + } + } + + //@} + + //!@name Assignment operators + //@{ + + //! Assignment with move semantics. + /*! \param rhs Source of the assignment. It will become a null value after assignment. + */ + GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT { + if (RAPIDJSON_LIKELY(this != &rhs)) { + // Can't destroy "this" before assigning "rhs", otherwise "rhs" + // could be used after free if it's an sub-Value of "this", + // hence the temporary danse. + GenericValue temp; + temp.RawAssign(rhs); + this->~GenericValue(); + RawAssign(temp); + } + return *this; + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move assignment in C++11 + GenericValue& operator=(GenericValue&& rhs) RAPIDJSON_NOEXCEPT { + return *this = rhs.Move(); + } +#endif + + //! Assignment of constant string reference (no copy) + /*! \param str Constant string reference to be assigned + \note This overload is needed to avoid clashes with the generic primitive type assignment overload below. + \see GenericStringRef, operator=(T) + */ + GenericValue& operator=(StringRefType str) RAPIDJSON_NOEXCEPT { + GenericValue s(str); + return *this = s; + } + + //! Assignment with primitive types. + /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t + \param value The value to be assigned. + + \note The source type \c T explicitly disallows all pointer types, + especially (\c const) \ref Ch*. This helps avoiding implicitly + referencing character strings with insufficient lifetime, use + \ref SetString(const Ch*, Allocator&) (for copying) or + \ref StringRef() (to explicitly mark the pointer as constant) instead. + All other pointer types would implicitly convert to \c bool, + use \ref SetBool() instead. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer), (GenericValue&)) + operator=(T value) { + GenericValue v(value); + return *this = v; + } + + //! Deep-copy assignment from Value + /*! Assigns a \b copy of the Value to the current Value object + \tparam SourceAllocator Allocator type of \c rhs + \param rhs Value to copy from (read-only) + \param allocator Allocator to use for copying + \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer) + */ + template + GenericValue& CopyFrom(const GenericValue& rhs, Allocator& allocator, bool copyConstStrings = false) { + RAPIDJSON_ASSERT(static_cast(this) != static_cast(&rhs)); + this->~GenericValue(); + new (this) GenericValue(rhs, allocator, copyConstStrings); + return *this; + } + + //! Exchange the contents of this value with those of other. + /*! + \param other Another value. + \note Constant complexity. + */ + GenericValue& Swap(GenericValue& other) RAPIDJSON_NOEXCEPT { + GenericValue temp; + temp.RawAssign(*this); + RawAssign(other); + other.RawAssign(temp); + return *this; + } + + //! free-standing swap function helper + /*! + Helper function to enable support for common swap implementation pattern based on \c std::swap: + \code + void swap(MyClass& a, MyClass& b) { + using std::swap; + swap(a.value, b.value); + // ... + } + \endcode + \see Swap() + */ + friend inline void swap(GenericValue& a, GenericValue& b) RAPIDJSON_NOEXCEPT { a.Swap(b); } + + //! Prepare Value for move semantics + /*! \return *this */ + GenericValue& Move() RAPIDJSON_NOEXCEPT { return *this; } + //@} + + //!@name Equal-to and not-equal-to operators + //@{ + //! Equal-to operator + /*! + \note If an object contains duplicated named member, comparing equality with any object is always \c false. + \note Complexity is quadratic in Object's member number and linear for the rest (number of all values in the subtree and total lengths of all strings). + */ + template + bool operator==(const GenericValue& rhs) const { + typedef GenericValue RhsType; + if (GetType() != rhs.GetType()) + return false; + + switch (GetType()) { + case kObjectType: // Warning: O(n^2) inner-loop + if (data_.o.size != rhs.data_.o.size) + return false; + for (ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) { + typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name); + if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value) + return false; + } + return true; + + case kArrayType: + if (data_.a.size != rhs.data_.a.size) + return false; + for (SizeType i = 0; i < data_.a.size; i++) + if ((*this)[i] != rhs[i]) + return false; + return true; + + case kStringType: + return StringEqual(rhs); + + case kNumberType: + if (IsDouble() || rhs.IsDouble()) { + double a = GetDouble(); // May convert from integer to double. + double b = rhs.GetDouble(); // Ditto + return a >= b && a <= b; // Prevent -Wfloat-equal + } + else + return data_.n.u64 == rhs.data_.n.u64; + + default: + return true; + } + } + + //! Equal-to operator with const C-string pointer + bool operator==(const Ch* rhs) const { return *this == GenericValue(StringRef(rhs)); } + +#if RAPIDJSON_HAS_STDSTRING + //! Equal-to operator with string object + /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. + */ + bool operator==(const std::basic_string& rhs) const { return *this == GenericValue(StringRef(rhs)); } +#endif + + //! Equal-to operator with primitive types + /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c true, \c false + */ + template RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr,internal::IsGenericValue >), (bool)) operator==(const T& rhs) const { return *this == GenericValue(rhs); } + + //! Not-equal-to operator + /*! \return !(*this == rhs) + */ + template + bool operator!=(const GenericValue& rhs) const { return !(*this == rhs); } + + //! Not-equal-to operator with const C-string pointer + bool operator!=(const Ch* rhs) const { return !(*this == rhs); } + + //! Not-equal-to operator with arbitrary types + /*! \return !(*this == rhs) + */ + template RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue), (bool)) operator!=(const T& rhs) const { return !(*this == rhs); } + +#ifndef __cpp_lib_three_way_comparison + //! Equal-to operator with arbitrary types (symmetric version) + /*! \return (rhs == lhs) + */ + template friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue), (bool)) operator==(const T& lhs, const GenericValue& rhs) { return rhs == lhs; } + + //! Not-Equal-to operator with arbitrary types (symmetric version) + /*! \return !(rhs == lhs) + */ + template friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue), (bool)) operator!=(const T& lhs, const GenericValue& rhs) { return !(rhs == lhs); } + //@} +#endif + + //!@name Type + //@{ + + Type GetType() const { return static_cast(data_.f.flags & kTypeMask); } + bool IsNull() const { return data_.f.flags == kNullFlag; } + bool IsFalse() const { return data_.f.flags == kFalseFlag; } + bool IsTrue() const { return data_.f.flags == kTrueFlag; } + bool IsBool() const { return (data_.f.flags & kBoolFlag) != 0; } + bool IsObject() const { return data_.f.flags == kObjectFlag; } + bool IsArray() const { return data_.f.flags == kArrayFlag; } + bool IsNumber() const { return (data_.f.flags & kNumberFlag) != 0; } + bool IsInt() const { return (data_.f.flags & kIntFlag) != 0; } + bool IsUint() const { return (data_.f.flags & kUintFlag) != 0; } + bool IsInt64() const { return (data_.f.flags & kInt64Flag) != 0; } + bool IsUint64() const { return (data_.f.flags & kUint64Flag) != 0; } + bool IsDouble() const { return (data_.f.flags & kDoubleFlag) != 0; } + bool IsString() const { return (data_.f.flags & kStringFlag) != 0; } + + // Checks whether a number can be losslessly converted to a double. + bool IsLosslessDouble() const { + if (!IsNumber()) return false; + if (IsUint64()) { + uint64_t u = GetUint64(); + volatile double d = static_cast(u); + return (d >= 0.0) + && (d < static_cast((std::numeric_limits::max)())) + && (u == static_cast(d)); + } + if (IsInt64()) { + int64_t i = GetInt64(); + volatile double d = static_cast(i); + return (d >= static_cast((std::numeric_limits::min)())) + && (d < static_cast((std::numeric_limits::max)())) + && (i == static_cast(d)); + } + return true; // double, int, uint are always lossless + } + + // Checks whether a number is a float (possible lossy). + bool IsFloat() const { + if ((data_.f.flags & kDoubleFlag) == 0) + return false; + double d = GetDouble(); + return d >= -3.4028234e38 && d <= 3.4028234e38; + } + // Checks whether a number can be losslessly converted to a float. + bool IsLosslessFloat() const { + if (!IsNumber()) return false; + double a = GetDouble(); + if (a < static_cast(-(std::numeric_limits::max)()) + || a > static_cast((std::numeric_limits::max)())) + return false; + double b = static_cast(static_cast(a)); + return a >= b && a <= b; // Prevent -Wfloat-equal + } + + //@} + + //!@name Null + //@{ + + GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; } + + //@} + + //!@name Bool + //@{ + + bool GetBool() const { RAPIDJSON_ASSERT(IsBool()); return data_.f.flags == kTrueFlag; } + //!< Set boolean value + /*! \post IsBool() == true */ + GenericValue& SetBool(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; } + + //@} + + //!@name Object + //@{ + + //! Set this value as an empty object. + /*! \post IsObject() == true */ + GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; } + + //! Get the number of members in the object. + SizeType MemberCount() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size; } + + //! Get the capacity of object. + SizeType MemberCapacity() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.capacity; } + + //! Check whether the object is empty. + bool ObjectEmpty() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; } + + //! Get a value from an object associated with the name. + /*! \pre IsObject() == true + \tparam T Either \c Ch or \c const \c Ch (template used for disambiguation with \ref operator[](SizeType)) + \note In version 0.1x, if the member is not found, this function returns a null value. This makes issue 7. + Since 0.2, if the name is not correct, it will assert. + If user is unsure whether a member exists, user should use HasMember() first. + A better approach is to use FindMember(). + \note Linear time complexity. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr::Type, Ch> >),(GenericValue&)) operator[](T* name) { + GenericValue n(StringRef(name)); + return (*this)[n]; + } + template + RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr::Type, Ch> >),(const GenericValue&)) operator[](T* name) const { return const_cast(*this)[name]; } + + //! Get a value from an object associated with the name. + /*! \pre IsObject() == true + \tparam SourceAllocator Allocator of the \c name value + + \note Compared to \ref operator[](T*), this version is faster because it does not need a StrLen(). + And it can also handle strings with embedded null characters. + + \note Linear time complexity. + */ + template + GenericValue& operator[](const GenericValue& name) { + MemberIterator member = FindMember(name); + if (member != MemberEnd()) + return member->value; + else { + RAPIDJSON_ASSERT(false); // see above note + + // This will generate -Wexit-time-destructors in clang + // static GenericValue NullValue; + // return NullValue; + + // Use static buffer and placement-new to prevent destruction + static char buffer[sizeof(GenericValue)]; + return *new (buffer) GenericValue(); + } + } + template + const GenericValue& operator[](const GenericValue& name) const { return const_cast(*this)[name]; } + +#if RAPIDJSON_HAS_STDSTRING + //! Get a value from an object associated with name (string object). + GenericValue& operator[](const std::basic_string& name) { return (*this)[GenericValue(StringRef(name))]; } + const GenericValue& operator[](const std::basic_string& name) const { return (*this)[GenericValue(StringRef(name))]; } +#endif + + //! Const member iterator + /*! \pre IsObject() == true */ + ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer()); } + //! Const \em past-the-end member iterator + /*! \pre IsObject() == true */ + ConstMemberIterator MemberEnd() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer() + data_.o.size); } + //! Member iterator + /*! \pre IsObject() == true */ + MemberIterator MemberBegin() { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer()); } + //! \em Past-the-end member iterator + /*! \pre IsObject() == true */ + MemberIterator MemberEnd() { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer() + data_.o.size); } + + //! Request the object to have enough capacity to store members. + /*! \param newCapacity The capacity that the object at least need to have. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \note Linear time complexity. + */ + GenericValue& MemberReserve(SizeType newCapacity, Allocator &allocator) { + RAPIDJSON_ASSERT(IsObject()); + DoReserveMembers(newCapacity, allocator); + return *this; + } + + //! Check whether a member exists in the object. + /*! + \param name Member name to be searched. + \pre IsObject() == true + \return Whether a member with that name exists. + \note It is better to use FindMember() directly if you need the obtain the value as well. + \note Linear time complexity. + */ + bool HasMember(const Ch* name) const { return FindMember(name) != MemberEnd(); } + +#if RAPIDJSON_HAS_STDSTRING + //! Check whether a member exists in the object with string object. + /*! + \param name Member name to be searched. + \pre IsObject() == true + \return Whether a member with that name exists. + \note It is better to use FindMember() directly if you need the obtain the value as well. + \note Linear time complexity. + */ + bool HasMember(const std::basic_string& name) const { return FindMember(name) != MemberEnd(); } +#endif + + //! Check whether a member exists in the object with GenericValue name. + /*! + This version is faster because it does not need a StrLen(). It can also handle string with null character. + \param name Member name to be searched. + \pre IsObject() == true + \return Whether a member with that name exists. + \note It is better to use FindMember() directly if you need the obtain the value as well. + \note Linear time complexity. + */ + template + bool HasMember(const GenericValue& name) const { return FindMember(name) != MemberEnd(); } + + //! Find member by name. + /*! + \param name Member name to be searched. + \pre IsObject() == true + \return Iterator to member, if it exists. + Otherwise returns \ref MemberEnd(). + + \note Earlier versions of Rapidjson returned a \c NULL pointer, in case + the requested member doesn't exist. For consistency with e.g. + \c std::map, this has been changed to MemberEnd() now. + \note Linear time complexity. + */ + MemberIterator FindMember(const Ch* name) { + GenericValue n(StringRef(name)); + return FindMember(n); + } + + ConstMemberIterator FindMember(const Ch* name) const { return const_cast(*this).FindMember(name); } + + //! Find member by name. + /*! + This version is faster because it does not need a StrLen(). It can also handle string with null character. + \param name Member name to be searched. + \pre IsObject() == true + \return Iterator to member, if it exists. + Otherwise returns \ref MemberEnd(). + + \note Earlier versions of Rapidjson returned a \c NULL pointer, in case + the requested member doesn't exist. For consistency with e.g. + \c std::map, this has been changed to MemberEnd() now. + \note Linear time complexity. + */ + template + MemberIterator FindMember(const GenericValue& name) { + RAPIDJSON_ASSERT(IsObject()); + RAPIDJSON_ASSERT(name.IsString()); + return DoFindMember(name); + } + template ConstMemberIterator FindMember(const GenericValue& name) const { return const_cast(*this).FindMember(name); } + +#if RAPIDJSON_HAS_STDSTRING + //! Find member by string object name. + /*! + \param name Member name to be searched. + \pre IsObject() == true + \return Iterator to member, if it exists. + Otherwise returns \ref MemberEnd(). + */ + MemberIterator FindMember(const std::basic_string& name) { return FindMember(GenericValue(StringRef(name))); } + ConstMemberIterator FindMember(const std::basic_string& name) const { return FindMember(GenericValue(StringRef(name))); } +#endif + + //! Add a member (name-value pair) to the object. + /*! \param name A string value as name of member. + \param value Value of any type. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \note The ownership of \c name and \c value will be transferred to this object on success. + \pre IsObject() && name.IsString() + \post name.IsNull() && value.IsNull() + \note Amortized Constant time complexity. + */ + GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) { + RAPIDJSON_ASSERT(IsObject()); + RAPIDJSON_ASSERT(name.IsString()); + DoAddMember(name, value, allocator); + return *this; + } + + //! Add a constant string value as member (name-value pair) to the object. + /*! \param name A string value as name of member. + \param value constant string reference as value of member. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \pre IsObject() + \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below. + \note Amortized Constant time complexity. + */ + GenericValue& AddMember(GenericValue& name, StringRefType value, Allocator& allocator) { + GenericValue v(value); + return AddMember(name, v, allocator); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Add a string object as member (name-value pair) to the object. + /*! \param name A string value as name of member. + \param value constant string reference as value of member. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \pre IsObject() + \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below. + \note Amortized Constant time complexity. + */ + GenericValue& AddMember(GenericValue& name, std::basic_string& value, Allocator& allocator) { + GenericValue v(value, allocator); + return AddMember(name, v, allocator); + } +#endif + + //! Add any primitive value as member (name-value pair) to the object. + /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t + \param name A string value as name of member. + \param value Value of primitive type \c T as value of member + \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \pre IsObject() + + \note The source type \c T explicitly disallows all pointer types, + especially (\c const) \ref Ch*. This helps avoiding implicitly + referencing character strings with insufficient lifetime, use + \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref + AddMember(StringRefType, StringRefType, Allocator&). + All other pointer types would implicitly convert to \c bool, + use an explicit cast instead, if needed. + \note Amortized Constant time complexity. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (GenericValue&)) + AddMember(GenericValue& name, T value, Allocator& allocator) { + GenericValue v(value); + return AddMember(name, v, allocator); + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericValue& AddMember(GenericValue&& name, GenericValue&& value, Allocator& allocator) { + return AddMember(name, value, allocator); + } + GenericValue& AddMember(GenericValue&& name, GenericValue& value, Allocator& allocator) { + return AddMember(name, value, allocator); + } + GenericValue& AddMember(GenericValue& name, GenericValue&& value, Allocator& allocator) { + return AddMember(name, value, allocator); + } + GenericValue& AddMember(StringRefType name, GenericValue&& value, Allocator& allocator) { + GenericValue n(name); + return AddMember(n, value, allocator); + } +#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS + + + //! Add a member (name-value pair) to the object. + /*! \param name A constant string reference as name of member. + \param value Value of any type. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \note The ownership of \c value will be transferred to this object on success. + \pre IsObject() + \post value.IsNull() + \note Amortized Constant time complexity. + */ + GenericValue& AddMember(StringRefType name, GenericValue& value, Allocator& allocator) { + GenericValue n(name); + return AddMember(n, value, allocator); + } + + //! Add a constant string value as member (name-value pair) to the object. + /*! \param name A constant string reference as name of member. + \param value constant string reference as value of member. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \pre IsObject() + \note This overload is needed to avoid clashes with the generic primitive type AddMember(StringRefType,T,Allocator&) overload below. + \note Amortized Constant time complexity. + */ + GenericValue& AddMember(StringRefType name, StringRefType value, Allocator& allocator) { + GenericValue v(value); + return AddMember(name, v, allocator); + } + + //! Add any primitive value as member (name-value pair) to the object. + /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t + \param name A constant string reference as name of member. + \param value Value of primitive type \c T as value of member + \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \pre IsObject() + + \note The source type \c T explicitly disallows all pointer types, + especially (\c const) \ref Ch*. This helps avoiding implicitly + referencing character strings with insufficient lifetime, use + \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref + AddMember(StringRefType, StringRefType, Allocator&). + All other pointer types would implicitly convert to \c bool, + use an explicit cast instead, if needed. + \note Amortized Constant time complexity. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (GenericValue&)) + AddMember(StringRefType name, T value, Allocator& allocator) { + GenericValue n(name); + return AddMember(n, value, allocator); + } + + //! Remove all members in the object. + /*! This function do not deallocate memory in the object, i.e. the capacity is unchanged. + \note Linear time complexity. + */ + void RemoveAllMembers() { + RAPIDJSON_ASSERT(IsObject()); + DoClearMembers(); + } + + //! Remove a member in object by its name. + /*! \param name Name of member to be removed. + \return Whether the member existed. + \note This function may reorder the object members. Use \ref + EraseMember(ConstMemberIterator) if you need to preserve the + relative order of the remaining members. + \note Linear time complexity. + */ + bool RemoveMember(const Ch* name) { + GenericValue n(StringRef(name)); + return RemoveMember(n); + } + +#if RAPIDJSON_HAS_STDSTRING + bool RemoveMember(const std::basic_string& name) { return RemoveMember(GenericValue(StringRef(name))); } +#endif + + template + bool RemoveMember(const GenericValue& name) { + MemberIterator m = FindMember(name); + if (m != MemberEnd()) { + RemoveMember(m); + return true; + } + else + return false; + } + + //! Remove a member in object by iterator. + /*! \param m member iterator (obtained by FindMember() or MemberBegin()). + \return the new iterator after removal. + \note This function may reorder the object members. Use \ref + EraseMember(ConstMemberIterator) if you need to preserve the + relative order of the remaining members. + \note Constant time complexity. + */ + MemberIterator RemoveMember(MemberIterator m) { + RAPIDJSON_ASSERT(IsObject()); + RAPIDJSON_ASSERT(data_.o.size > 0); + RAPIDJSON_ASSERT(GetMembersPointer() != 0); + RAPIDJSON_ASSERT(m >= MemberBegin() && m < MemberEnd()); + return DoRemoveMember(m); + } + + //! Remove a member from an object by iterator. + /*! \param pos iterator to the member to remove + \pre IsObject() == true && \ref MemberBegin() <= \c pos < \ref MemberEnd() + \return Iterator following the removed element. + If the iterator \c pos refers to the last element, the \ref MemberEnd() iterator is returned. + \note This function preserves the relative order of the remaining object + members. If you do not need this, use the more efficient \ref RemoveMember(MemberIterator). + \note Linear time complexity. + */ + MemberIterator EraseMember(ConstMemberIterator pos) { + return EraseMember(pos, pos +1); + } + + //! Remove members in the range [first, last) from an object. + /*! \param first iterator to the first member to remove + \param last iterator following the last member to remove + \pre IsObject() == true && \ref MemberBegin() <= \c first <= \c last <= \ref MemberEnd() + \return Iterator following the last removed element. + \note This function preserves the relative order of the remaining object + members. + \note Linear time complexity. + */ + MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) { + RAPIDJSON_ASSERT(IsObject()); + RAPIDJSON_ASSERT(data_.o.size > 0); + RAPIDJSON_ASSERT(GetMembersPointer() != 0); + RAPIDJSON_ASSERT(first >= MemberBegin()); + RAPIDJSON_ASSERT(first <= last); + RAPIDJSON_ASSERT(last <= MemberEnd()); + return DoEraseMembers(first, last); + } + + //! Erase a member in object by its name. + /*! \param name Name of member to be removed. + \return Whether the member existed. + \note Linear time complexity. + */ + bool EraseMember(const Ch* name) { + GenericValue n(StringRef(name)); + return EraseMember(n); + } + +#if RAPIDJSON_HAS_STDSTRING + bool EraseMember(const std::basic_string& name) { return EraseMember(GenericValue(StringRef(name))); } +#endif + + template + bool EraseMember(const GenericValue& name) { + MemberIterator m = FindMember(name); + if (m != MemberEnd()) { + EraseMember(m); + return true; + } + else + return false; + } + + Object GetObject() { RAPIDJSON_ASSERT(IsObject()); return Object(*this); } + Object GetObj() { RAPIDJSON_ASSERT(IsObject()); return Object(*this); } + ConstObject GetObject() const { RAPIDJSON_ASSERT(IsObject()); return ConstObject(*this); } + ConstObject GetObj() const { RAPIDJSON_ASSERT(IsObject()); return ConstObject(*this); } + + //@} + + //!@name Array + //@{ + + //! Set this value as an empty array. + /*! \post IsArray == true */ + GenericValue& SetArray() { this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; } + + //! Get the number of elements in array. + SizeType Size() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size; } + + //! Get the capacity of array. + SizeType Capacity() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; } + + //! Check whether the array is empty. + bool Empty() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; } + + //! Remove all elements in the array. + /*! This function do not deallocate memory in the array, i.e. the capacity is unchanged. + \note Linear time complexity. + */ + void Clear() { + RAPIDJSON_ASSERT(IsArray()); + GenericValue* e = GetElementsPointer(); + for (GenericValue* v = e; v != e + data_.a.size; ++v) + v->~GenericValue(); + data_.a.size = 0; + } + + //! Get an element from array by index. + /*! \pre IsArray() == true + \param index Zero-based index of element. + \see operator[](T*) + */ + GenericValue& operator[](SizeType index) { + RAPIDJSON_ASSERT(IsArray()); + RAPIDJSON_ASSERT(index < data_.a.size); + return GetElementsPointer()[index]; + } + const GenericValue& operator[](SizeType index) const { return const_cast(*this)[index]; } + + //! Element iterator + /*! \pre IsArray() == true */ + ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer(); } + //! \em Past-the-end element iterator + /*! \pre IsArray() == true */ + ValueIterator End() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer() + data_.a.size; } + //! Constant element iterator + /*! \pre IsArray() == true */ + ConstValueIterator Begin() const { return const_cast(*this).Begin(); } + //! Constant \em past-the-end element iterator + /*! \pre IsArray() == true */ + ConstValueIterator End() const { return const_cast(*this).End(); } + + //! Request the array to have enough capacity to store elements. + /*! \param newCapacity The capacity that the array at least need to have. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \note Linear time complexity. + */ + GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) { + RAPIDJSON_ASSERT(IsArray()); + if (newCapacity > data_.a.capacity) { + SetElementsPointer(reinterpret_cast(allocator.Realloc(GetElementsPointer(), data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue)))); + data_.a.capacity = newCapacity; + } + return *this; + } + + //! Append a GenericValue at the end of the array. + /*! \param value Value to be appended. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \pre IsArray() == true + \post value.IsNull() == true + \return The value itself for fluent API. + \note The ownership of \c value will be transferred to this array on success. + \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient. + \note Amortized constant time complexity. + */ + GenericValue& PushBack(GenericValue& value, Allocator& allocator) { + RAPIDJSON_ASSERT(IsArray()); + if (data_.a.size >= data_.a.capacity) + Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : (data_.a.capacity + (data_.a.capacity + 1) / 2), allocator); + GetElementsPointer()[data_.a.size++].RawAssign(value); + return *this; + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericValue& PushBack(GenericValue&& value, Allocator& allocator) { + return PushBack(value, allocator); + } +#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS + + //! Append a constant string reference at the end of the array. + /*! \param value Constant string reference to be appended. + \param allocator Allocator for reallocating memory. It must be the same one used previously. Commonly use GenericDocument::GetAllocator(). + \pre IsArray() == true + \return The value itself for fluent API. + \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient. + \note Amortized constant time complexity. + \see GenericStringRef + */ + GenericValue& PushBack(StringRefType value, Allocator& allocator) { + return (*this).template PushBack(value, allocator); + } + + //! Append a primitive value at the end of the array. + /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t + \param value Value of primitive type T to be appended. + \param allocator Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator(). + \pre IsArray() == true + \return The value itself for fluent API. + \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient. + + \note The source type \c T explicitly disallows all pointer types, + especially (\c const) \ref Ch*. This helps avoiding implicitly + referencing character strings with insufficient lifetime, use + \ref PushBack(GenericValue&, Allocator&) or \ref + PushBack(StringRefType, Allocator&). + All other pointer types would implicitly convert to \c bool, + use an explicit cast instead, if needed. + \note Amortized constant time complexity. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (GenericValue&)) + PushBack(T value, Allocator& allocator) { + GenericValue v(value); + return PushBack(v, allocator); + } + + //! Remove the last element in the array. + /*! + \note Constant time complexity. + */ + GenericValue& PopBack() { + RAPIDJSON_ASSERT(IsArray()); + RAPIDJSON_ASSERT(!Empty()); + GetElementsPointer()[--data_.a.size].~GenericValue(); + return *this; + } + + //! Remove an element of array by iterator. + /*! + \param pos iterator to the element to remove + \pre IsArray() == true && \ref Begin() <= \c pos < \ref End() + \return Iterator following the removed element. If the iterator pos refers to the last element, the End() iterator is returned. + \note Linear time complexity. + */ + ValueIterator Erase(ConstValueIterator pos) { + return Erase(pos, pos + 1); + } + + //! Remove elements in the range [first, last) of the array. + /*! + \param first iterator to the first element to remove + \param last iterator following the last element to remove + \pre IsArray() == true && \ref Begin() <= \c first <= \c last <= \ref End() + \return Iterator following the last removed element. + \note Linear time complexity. + */ + ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) { + RAPIDJSON_ASSERT(IsArray()); + RAPIDJSON_ASSERT(data_.a.size > 0); + RAPIDJSON_ASSERT(GetElementsPointer() != 0); + RAPIDJSON_ASSERT(first >= Begin()); + RAPIDJSON_ASSERT(first <= last); + RAPIDJSON_ASSERT(last <= End()); + ValueIterator pos = Begin() + (first - Begin()); + for (ValueIterator itr = pos; itr != last; ++itr) + itr->~GenericValue(); + std::memmove(static_cast(pos), last, static_cast(End() - last) * sizeof(GenericValue)); + data_.a.size -= static_cast(last - first); + return pos; + } + + Array GetArray() { RAPIDJSON_ASSERT(IsArray()); return Array(*this); } + ConstArray GetArray() const { RAPIDJSON_ASSERT(IsArray()); return ConstArray(*this); } + + //@} + + //!@name Number + //@{ + + int GetInt() const { RAPIDJSON_ASSERT(data_.f.flags & kIntFlag); return data_.n.i.i; } + unsigned GetUint() const { RAPIDJSON_ASSERT(data_.f.flags & kUintFlag); return data_.n.u.u; } + int64_t GetInt64() const { RAPIDJSON_ASSERT(data_.f.flags & kInt64Flag); return data_.n.i64; } + uint64_t GetUint64() const { RAPIDJSON_ASSERT(data_.f.flags & kUint64Flag); return data_.n.u64; } + + //! Get the value as double type. + /*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessDouble() to check whether the converison is lossless. + */ + double GetDouble() const { + RAPIDJSON_ASSERT(IsNumber()); + if ((data_.f.flags & kDoubleFlag) != 0) return data_.n.d; // exact type, no conversion. + if ((data_.f.flags & kIntFlag) != 0) return data_.n.i.i; // int -> double + if ((data_.f.flags & kUintFlag) != 0) return data_.n.u.u; // unsigned -> double + if ((data_.f.flags & kInt64Flag) != 0) return static_cast(data_.n.i64); // int64_t -> double (may lose precision) + RAPIDJSON_ASSERT((data_.f.flags & kUint64Flag) != 0); return static_cast(data_.n.u64); // uint64_t -> double (may lose precision) + } + + //! Get the value as float type. + /*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessFloat() to check whether the converison is lossless. + */ + float GetFloat() const { + return static_cast(GetDouble()); + } + + GenericValue& SetInt(int i) { this->~GenericValue(); new (this) GenericValue(i); return *this; } + GenericValue& SetUint(unsigned u) { this->~GenericValue(); new (this) GenericValue(u); return *this; } + GenericValue& SetInt64(int64_t i64) { this->~GenericValue(); new (this) GenericValue(i64); return *this; } + GenericValue& SetUint64(uint64_t u64) { this->~GenericValue(); new (this) GenericValue(u64); return *this; } + GenericValue& SetDouble(double d) { this->~GenericValue(); new (this) GenericValue(d); return *this; } + GenericValue& SetFloat(float f) { this->~GenericValue(); new (this) GenericValue(static_cast(f)); return *this; } + + //@} + + //!@name String + //@{ + + const Ch* GetString() const { RAPIDJSON_ASSERT(IsString()); return DataString(data_); } + + //! Get the length of string. + /*! Since rapidjson permits "\\u0000" in the json string, strlen(v.GetString()) may not equal to v.GetStringLength(). + */ + SizeType GetStringLength() const { RAPIDJSON_ASSERT(IsString()); return DataStringLength(data_); } + + //! Set this value as a string without copying source string. + /*! This version has better performance with supplied length, and also support string containing null character. + \param s source string pointer. + \param length The length of source string, excluding the trailing null terminator. + \return The value itself for fluent API. + \post IsString() == true && GetString() == s && GetStringLength() == length + \see SetString(StringRefType) + */ + GenericValue& SetString(const Ch* s, SizeType length) { return SetString(StringRef(s, length)); } + + //! Set this value as a string without copying source string. + /*! \param s source string reference + \return The value itself for fluent API. + \post IsString() == true && GetString() == s && GetStringLength() == s.length + */ + GenericValue& SetString(StringRefType s) { this->~GenericValue(); SetStringRaw(s); return *this; } + + //! Set this value as a string by copying from source string. + /*! This version has better performance with supplied length, and also support string containing null character. + \param s source string. + \param length The length of source string, excluding the trailing null terminator. + \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length + */ + GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { return SetString(StringRef(s, length), allocator); } + + //! Set this value as a string by copying from source string. + /*! \param s source string. + \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length + */ + GenericValue& SetString(const Ch* s, Allocator& allocator) { return SetString(StringRef(s), allocator); } + + //! Set this value as a string by copying from source string. + /*! \param s source string reference + \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \post IsString() == true && GetString() != s.s && strcmp(GetString(),s) == 0 && GetStringLength() == length + */ + GenericValue& SetString(StringRefType s, Allocator& allocator) { this->~GenericValue(); SetStringRaw(s, allocator); return *this; } + +#if RAPIDJSON_HAS_STDSTRING + //! Set this value as a string by copying from source string. + /*! \param s source string. + \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator(). + \return The value itself for fluent API. + \post IsString() == true && GetString() != s.data() && strcmp(GetString(),s.data() == 0 && GetStringLength() == s.size() + \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. + */ + GenericValue& SetString(const std::basic_string& s, Allocator& allocator) { return SetString(StringRef(s), allocator); } +#endif + + //@} + + //!@name Array + //@{ + + //! Templated version for checking whether this value is type T. + /*! + \tparam T Either \c bool, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c float, \c const \c char*, \c std::basic_string + */ + template + bool Is() const { return internal::TypeHelper::Is(*this); } + + template + T Get() const { return internal::TypeHelper::Get(*this); } + + template + T Get() { return internal::TypeHelper::Get(*this); } + + template + ValueType& Set(const T& data) { return internal::TypeHelper::Set(*this, data); } + + template + ValueType& Set(const T& data, AllocatorType& allocator) { return internal::TypeHelper::Set(*this, data, allocator); } + + //@} + + //! Generate events of this value to a Handler. + /*! This function adopts the GoF visitor pattern. + Typical usage is to output this JSON value as JSON text via Writer, which is a Handler. + It can also be used to deep clone this value via GenericDocument, which is also a Handler. + \tparam Handler type of handler. + \param handler An object implementing concept Handler. + */ + template + bool Accept(Handler& handler) const { + switch(GetType()) { + case kNullType: return handler.Null(); + case kFalseType: return handler.Bool(false); + case kTrueType: return handler.Bool(true); + + case kObjectType: + if (RAPIDJSON_UNLIKELY(!handler.StartObject())) + return false; + for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++m) { + RAPIDJSON_ASSERT(m->name.IsString()); // User may change the type of name by MemberIterator. + if (RAPIDJSON_UNLIKELY(!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.data_.f.flags & kCopyFlag) != 0))) + return false; + if (RAPIDJSON_UNLIKELY(!m->value.Accept(handler))) + return false; + } + return handler.EndObject(data_.o.size); + + case kArrayType: + if (RAPIDJSON_UNLIKELY(!handler.StartArray())) + return false; + for (const GenericValue* v = Begin(); v != End(); ++v) + if (RAPIDJSON_UNLIKELY(!v->Accept(handler))) + return false; + return handler.EndArray(data_.a.size); + + case kStringType: + return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0); + + default: + RAPIDJSON_ASSERT(GetType() == kNumberType); + if (IsDouble()) return handler.Double(data_.n.d); + else if (IsInt()) return handler.Int(data_.n.i.i); + else if (IsUint()) return handler.Uint(data_.n.u.u); + else if (IsInt64()) return handler.Int64(data_.n.i64); + else return handler.Uint64(data_.n.u64); + } + } + +private: + template friend class GenericValue; + template friend class GenericDocument; + + enum { + kBoolFlag = 0x0008, + kNumberFlag = 0x0010, + kIntFlag = 0x0020, + kUintFlag = 0x0040, + kInt64Flag = 0x0080, + kUint64Flag = 0x0100, + kDoubleFlag = 0x0200, + kStringFlag = 0x0400, + kCopyFlag = 0x0800, + kInlineStrFlag = 0x1000, + + // Initial flags of different types. + kNullFlag = kNullType, + // These casts are added to suppress the warning on MSVC about bitwise operations between enums of different types. + kTrueFlag = static_cast(kTrueType) | static_cast(kBoolFlag), + kFalseFlag = static_cast(kFalseType) | static_cast(kBoolFlag), + kNumberIntFlag = static_cast(kNumberType) | static_cast(kNumberFlag | kIntFlag | kInt64Flag), + kNumberUintFlag = static_cast(kNumberType) | static_cast(kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag), + kNumberInt64Flag = static_cast(kNumberType) | static_cast(kNumberFlag | kInt64Flag), + kNumberUint64Flag = static_cast(kNumberType) | static_cast(kNumberFlag | kUint64Flag), + kNumberDoubleFlag = static_cast(kNumberType) | static_cast(kNumberFlag | kDoubleFlag), + kNumberAnyFlag = static_cast(kNumberType) | static_cast(kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag), + kConstStringFlag = static_cast(kStringType) | static_cast(kStringFlag), + kCopyStringFlag = static_cast(kStringType) | static_cast(kStringFlag | kCopyFlag), + kShortStringFlag = static_cast(kStringType) | static_cast(kStringFlag | kCopyFlag | kInlineStrFlag), + kObjectFlag = kObjectType, + kArrayFlag = kArrayType, + + kTypeMask = 0x07 + }; + + static const SizeType kDefaultArrayCapacity = RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY; + static const SizeType kDefaultObjectCapacity = RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY; + + struct Flag { +#if RAPIDJSON_48BITPOINTER_OPTIMIZATION + char payload[sizeof(SizeType) * 2 + 6]; // 2 x SizeType + lower 48-bit pointer +#elif RAPIDJSON_64BIT + char payload[sizeof(SizeType) * 2 + sizeof(void*) + 6]; // 6 padding bytes +#else + char payload[sizeof(SizeType) * 2 + sizeof(void*) + 2]; // 2 padding bytes +#endif + uint16_t flags; + }; + + struct String { + SizeType length; + SizeType hashcode; //!< reserved + const Ch* str; + }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode + + // implementation detail: ShortString can represent zero-terminated strings up to MaxSize chars + // (excluding the terminating zero) and store a value to determine the length of the contained + // string in the last character str[LenPos] by storing "MaxSize - length" there. If the string + // to store has the maximal length of MaxSize then str[LenPos] will be 0 and therefore act as + // the string terminator as well. For getting the string length back from that value just use + // "MaxSize - str[LenPos]". + // This allows to store 13-chars strings in 32-bit mode, 21-chars strings in 64-bit mode, + // 13-chars strings for RAPIDJSON_48BITPOINTER_OPTIMIZATION=1 inline (for `UTF8`-encoded strings). + struct ShortString { + enum { MaxChars = sizeof(static_cast(0)->payload) / sizeof(Ch), MaxSize = MaxChars - 1, LenPos = MaxSize }; + Ch str[MaxChars]; + + inline static bool Usable(SizeType len) { return (MaxSize >= len); } + inline void SetLength(SizeType len) { str[LenPos] = static_cast(MaxSize - len); } + inline SizeType GetLength() const { return static_cast(MaxSize - str[LenPos]); } + }; // at most as many bytes as "String" above => 12 bytes in 32-bit mode, 16 bytes in 64-bit mode + + // By using proper binary layout, retrieval of different integer types do not need conversions. + union Number { +#if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN + struct I { + int i; + char padding[4]; + }i; + struct U { + unsigned u; + char padding2[4]; + }u; +#else + struct I { + char padding[4]; + int i; + }i; + struct U { + char padding2[4]; + unsigned u; + }u; +#endif + int64_t i64; + uint64_t u64; + double d; + }; // 8 bytes + + struct ObjectData { + SizeType size; + SizeType capacity; + Member* members; + }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode + + struct ArrayData { + SizeType size; + SizeType capacity; + GenericValue* elements; + }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode + + union Data { + String s; + ShortString ss; + Number n; + ObjectData o; + ArrayData a; + Flag f; + }; // 16 bytes in 32-bit mode, 24 bytes in 64-bit mode, 16 bytes in 64-bit with RAPIDJSON_48BITPOINTER_OPTIMIZATION + + static RAPIDJSON_FORCEINLINE const Ch* DataString(const Data& data) { + return (data.f.flags & kInlineStrFlag) ? data.ss.str : RAPIDJSON_GETPOINTER(Ch, data.s.str); + } + static RAPIDJSON_FORCEINLINE SizeType DataStringLength(const Data& data) { + return (data.f.flags & kInlineStrFlag) ? data.ss.GetLength() : data.s.length; + } + + RAPIDJSON_FORCEINLINE const Ch* GetStringPointer() const { return RAPIDJSON_GETPOINTER(Ch, data_.s.str); } + RAPIDJSON_FORCEINLINE const Ch* SetStringPointer(const Ch* str) { return RAPIDJSON_SETPOINTER(Ch, data_.s.str, str); } + RAPIDJSON_FORCEINLINE GenericValue* GetElementsPointer() const { return RAPIDJSON_GETPOINTER(GenericValue, data_.a.elements); } + RAPIDJSON_FORCEINLINE GenericValue* SetElementsPointer(GenericValue* elements) { return RAPIDJSON_SETPOINTER(GenericValue, data_.a.elements, elements); } + RAPIDJSON_FORCEINLINE Member* GetMembersPointer() const { return RAPIDJSON_GETPOINTER(Member, data_.o.members); } + RAPIDJSON_FORCEINLINE Member* SetMembersPointer(Member* members) { return RAPIDJSON_SETPOINTER(Member, data_.o.members, members); } + +#if RAPIDJSON_USE_MEMBERSMAP + + struct MapTraits { + struct Less { + bool operator()(const Data& s1, const Data& s2) const { + SizeType n1 = DataStringLength(s1), n2 = DataStringLength(s2); + int cmp = std::memcmp(DataString(s1), DataString(s2), sizeof(Ch) * (n1 < n2 ? n1 : n2)); + return cmp < 0 || (cmp == 0 && n1 < n2); + } + }; + typedef std::pair Pair; + typedef std::multimap > Map; + typedef typename Map::iterator Iterator; + }; + typedef typename MapTraits::Map Map; + typedef typename MapTraits::Less MapLess; + typedef typename MapTraits::Pair MapPair; + typedef typename MapTraits::Iterator MapIterator; + + // + // Layout of the members' map/array, re(al)located according to the needed capacity: + // + // {Map*}<>{capacity}<>{Member[capacity]}<>{MapIterator[capacity]} + // + // (where <> stands for the RAPIDJSON_ALIGN-ment, if needed) + // + + static RAPIDJSON_FORCEINLINE size_t GetMapLayoutSize(SizeType capacity) { + return RAPIDJSON_ALIGN(sizeof(Map*)) + + RAPIDJSON_ALIGN(sizeof(SizeType)) + + RAPIDJSON_ALIGN(capacity * sizeof(Member)) + + capacity * sizeof(MapIterator); + } + + static RAPIDJSON_FORCEINLINE SizeType &GetMapCapacity(Map* &map) { + return *reinterpret_cast(reinterpret_cast(&map) + + RAPIDJSON_ALIGN(sizeof(Map*))); + } + + static RAPIDJSON_FORCEINLINE Member* GetMapMembers(Map* &map) { + return reinterpret_cast(reinterpret_cast(&map) + + RAPIDJSON_ALIGN(sizeof(Map*)) + + RAPIDJSON_ALIGN(sizeof(SizeType))); + } + + static RAPIDJSON_FORCEINLINE MapIterator* GetMapIterators(Map* &map) { + return reinterpret_cast(reinterpret_cast(&map) + + RAPIDJSON_ALIGN(sizeof(Map*)) + + RAPIDJSON_ALIGN(sizeof(SizeType)) + + RAPIDJSON_ALIGN(GetMapCapacity(map) * sizeof(Member))); + } + + static RAPIDJSON_FORCEINLINE Map* &GetMap(Member* members) { + RAPIDJSON_ASSERT(members != 0); + return *reinterpret_cast(reinterpret_cast(members) - + RAPIDJSON_ALIGN(sizeof(SizeType)) - + RAPIDJSON_ALIGN(sizeof(Map*))); + } + + // Some compilers' debug mechanisms want all iterators to be destroyed, for their accounting.. + RAPIDJSON_FORCEINLINE MapIterator DropMapIterator(MapIterator& rhs) { +#if RAPIDJSON_HAS_CXX11 + MapIterator ret = std::move(rhs); +#else + MapIterator ret = rhs; +#endif + rhs.~MapIterator(); + return ret; + } + + Map* &DoReallocMap(Map** oldMap, SizeType newCapacity, Allocator& allocator) { + Map **newMap = static_cast(allocator.Malloc(GetMapLayoutSize(newCapacity))); + GetMapCapacity(*newMap) = newCapacity; + if (!oldMap) { + *newMap = new (allocator.Malloc(sizeof(Map))) Map(MapLess(), allocator); + } + else { + *newMap = *oldMap; + size_t count = (*oldMap)->size(); + std::memcpy(static_cast(GetMapMembers(*newMap)), + static_cast(GetMapMembers(*oldMap)), + count * sizeof(Member)); + MapIterator *oldIt = GetMapIterators(*oldMap), + *newIt = GetMapIterators(*newMap); + while (count--) { + new (&newIt[count]) MapIterator(DropMapIterator(oldIt[count])); + } + Allocator::Free(oldMap); + } + return *newMap; + } + + RAPIDJSON_FORCEINLINE Member* DoAllocMembers(SizeType capacity, Allocator& allocator) { + return GetMapMembers(DoReallocMap(0, capacity, allocator)); + } + + void DoReserveMembers(SizeType newCapacity, Allocator& allocator) { + ObjectData& o = data_.o; + if (newCapacity > o.capacity) { + Member* oldMembers = GetMembersPointer(); + Map **oldMap = oldMembers ? &GetMap(oldMembers) : 0, + *&newMap = DoReallocMap(oldMap, newCapacity, allocator); + RAPIDJSON_SETPOINTER(Member, o.members, GetMapMembers(newMap)); + o.capacity = newCapacity; + } + } + + template + MemberIterator DoFindMember(const GenericValue& name) { + if (Member* members = GetMembersPointer()) { + Map* &map = GetMap(members); + MapIterator mit = map->find(reinterpret_cast(name.data_)); + if (mit != map->end()) { + return MemberIterator(&members[mit->second]); + } + } + return MemberEnd(); + } + + void DoClearMembers() { + if (Member* members = GetMembersPointer()) { + Map* &map = GetMap(members); + MapIterator* mit = GetMapIterators(map); + for (SizeType i = 0; i < data_.o.size; i++) { + map->erase(DropMapIterator(mit[i])); + members[i].~Member(); + } + data_.o.size = 0; + } + } + + void DoFreeMembers() { + if (Member* members = GetMembersPointer()) { + GetMap(members)->~Map(); + for (SizeType i = 0; i < data_.o.size; i++) { + members[i].~Member(); + } + if (Allocator::kNeedFree) { // Shortcut by Allocator's trait + Map** map = &GetMap(members); + Allocator::Free(*map); + Allocator::Free(map); + } + } + } + +#else // !RAPIDJSON_USE_MEMBERSMAP + + RAPIDJSON_FORCEINLINE Member* DoAllocMembers(SizeType capacity, Allocator& allocator) { + return Malloc(allocator, capacity); + } + + void DoReserveMembers(SizeType newCapacity, Allocator& allocator) { + ObjectData& o = data_.o; + if (newCapacity > o.capacity) { + Member* newMembers = Realloc(allocator, GetMembersPointer(), o.capacity, newCapacity); + RAPIDJSON_SETPOINTER(Member, o.members, newMembers); + o.capacity = newCapacity; + } + } + + template + MemberIterator DoFindMember(const GenericValue& name) { + MemberIterator member = MemberBegin(); + for ( ; member != MemberEnd(); ++member) + if (name.StringEqual(member->name)) + break; + return member; + } + + void DoClearMembers() { + for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m) + m->~Member(); + data_.o.size = 0; + } + + void DoFreeMembers() { + for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m) + m->~Member(); + Allocator::Free(GetMembersPointer()); + } + +#endif // !RAPIDJSON_USE_MEMBERSMAP + + void DoAddMember(GenericValue& name, GenericValue& value, Allocator& allocator) { + ObjectData& o = data_.o; + if (o.size >= o.capacity) + DoReserveMembers(o.capacity ? (o.capacity + (o.capacity + 1) / 2) : kDefaultObjectCapacity, allocator); + Member* members = GetMembersPointer(); + Member* m = members + o.size; + m->name.RawAssign(name); + m->value.RawAssign(value); +#if RAPIDJSON_USE_MEMBERSMAP + Map* &map = GetMap(members); + MapIterator* mit = GetMapIterators(map); + new (&mit[o.size]) MapIterator(map->insert(MapPair(m->name.data_, o.size))); +#endif + ++o.size; + } + + MemberIterator DoRemoveMember(MemberIterator m) { + ObjectData& o = data_.o; + Member* members = GetMembersPointer(); +#if RAPIDJSON_USE_MEMBERSMAP + Map* &map = GetMap(members); + MapIterator* mit = GetMapIterators(map); + SizeType mpos = static_cast(&*m - members); + map->erase(DropMapIterator(mit[mpos])); +#endif + MemberIterator last(members + (o.size - 1)); + if (o.size > 1 && m != last) { +#if RAPIDJSON_USE_MEMBERSMAP + new (&mit[mpos]) MapIterator(DropMapIterator(mit[&*last - members])); + mit[mpos]->second = mpos; +#endif + *m = *last; // Move the last one to this place + } + else { + m->~Member(); // Only one left, just destroy + } + --o.size; + return m; + } + + MemberIterator DoEraseMembers(ConstMemberIterator first, ConstMemberIterator last) { + ObjectData& o = data_.o; + MemberIterator beg = MemberBegin(), + pos = beg + (first - beg), + end = MemberEnd(); +#if RAPIDJSON_USE_MEMBERSMAP + Map* &map = GetMap(GetMembersPointer()); + MapIterator* mit = GetMapIterators(map); +#endif + for (MemberIterator itr = pos; itr != last; ++itr) { +#if RAPIDJSON_USE_MEMBERSMAP + map->erase(DropMapIterator(mit[itr - beg])); +#endif + itr->~Member(); + } +#if RAPIDJSON_USE_MEMBERSMAP + if (first != last) { + // Move remaining members/iterators + MemberIterator next = pos + (last - first); + for (MemberIterator itr = pos; next != end; ++itr, ++next) { + std::memcpy(static_cast(&*itr), &*next, sizeof(Member)); + SizeType mpos = static_cast(itr - beg); + new (&mit[mpos]) MapIterator(DropMapIterator(mit[next - beg])); + mit[mpos]->second = mpos; + } + } +#else + std::memmove(static_cast(&*pos), &*last, + static_cast(end - last) * sizeof(Member)); +#endif + o.size -= static_cast(last - first); + return pos; + } + + template + void DoCopyMembers(const GenericValue& rhs, Allocator& allocator, bool copyConstStrings) { + RAPIDJSON_ASSERT(rhs.GetType() == kObjectType); + + data_.f.flags = kObjectFlag; + SizeType count = rhs.data_.o.size; + Member* lm = DoAllocMembers(count, allocator); + const typename GenericValue::Member* rm = rhs.GetMembersPointer(); +#if RAPIDJSON_USE_MEMBERSMAP + Map* &map = GetMap(lm); + MapIterator* mit = GetMapIterators(map); +#endif + for (SizeType i = 0; i < count; i++) { + new (&lm[i].name) GenericValue(rm[i].name, allocator, copyConstStrings); + new (&lm[i].value) GenericValue(rm[i].value, allocator, copyConstStrings); +#if RAPIDJSON_USE_MEMBERSMAP + new (&mit[i]) MapIterator(map->insert(MapPair(lm[i].name.data_, i))); +#endif + } + data_.o.size = data_.o.capacity = count; + SetMembersPointer(lm); + } + + // Initialize this value as array with initial data, without calling destructor. + void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) { + data_.f.flags = kArrayFlag; + if (count) { + GenericValue* e = static_cast(allocator.Malloc(count * sizeof(GenericValue))); + SetElementsPointer(e); + std::memcpy(static_cast(e), values, count * sizeof(GenericValue)); + } + else + SetElementsPointer(0); + data_.a.size = data_.a.capacity = count; + } + + //! Initialize this value as object with initial data, without calling destructor. + void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) { + data_.f.flags = kObjectFlag; + if (count) { + Member* m = DoAllocMembers(count, allocator); + SetMembersPointer(m); + std::memcpy(static_cast(m), members, count * sizeof(Member)); +#if RAPIDJSON_USE_MEMBERSMAP + Map* &map = GetMap(m); + MapIterator* mit = GetMapIterators(map); + for (SizeType i = 0; i < count; i++) { + new (&mit[i]) MapIterator(map->insert(MapPair(m[i].name.data_, i))); + } +#endif + } + else + SetMembersPointer(0); + data_.o.size = data_.o.capacity = count; + } + + //! Initialize this value as constant string, without calling destructor. + void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT { + data_.f.flags = kConstStringFlag; + SetStringPointer(s); + data_.s.length = s.length; + } + + //! Initialize this value as copy string with initial data, without calling destructor. + void SetStringRaw(StringRefType s, Allocator& allocator) { + Ch* str = 0; + if (ShortString::Usable(s.length)) { + data_.f.flags = kShortStringFlag; + data_.ss.SetLength(s.length); + str = data_.ss.str; + } else { + data_.f.flags = kCopyStringFlag; + data_.s.length = s.length; + str = static_cast(allocator.Malloc((s.length + 1) * sizeof(Ch))); + SetStringPointer(str); + } + std::memcpy(str, s, s.length * sizeof(Ch)); + str[s.length] = '\0'; + } + + //! Assignment without calling destructor + void RawAssign(GenericValue& rhs) RAPIDJSON_NOEXCEPT { + data_ = rhs.data_; + // data_.f.flags = rhs.data_.f.flags; + rhs.data_.f.flags = kNullFlag; + } + + template + bool StringEqual(const GenericValue& rhs) const { + RAPIDJSON_ASSERT(IsString()); + RAPIDJSON_ASSERT(rhs.IsString()); + + const SizeType len1 = GetStringLength(); + const SizeType len2 = rhs.GetStringLength(); + if(len1 != len2) { return false; } + + const Ch* const str1 = GetString(); + const Ch* const str2 = rhs.GetString(); + if(str1 == str2) { return true; } // fast path for constant string + + return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0); + } + + Data data_; +}; + +//! GenericValue with UTF8 encoding +typedef GenericValue > Value; + +/////////////////////////////////////////////////////////////////////////////// +// GenericDocument + +//! A document for parsing JSON text as DOM. +/*! + \note implements Handler concept + \tparam Encoding Encoding for both parsing and string storage. + \tparam Allocator Allocator for allocating memory for the DOM + \tparam StackAllocator Allocator for allocating memory for stack during parsing. + \warning Although GenericDocument inherits from GenericValue, the API does \b not provide any virtual functions, especially no virtual destructor. To avoid memory leaks, do not \c delete a GenericDocument object via a pointer to a GenericValue. +*/ +template +class GenericDocument : public GenericValue { +public: + typedef typename Encoding::Ch Ch; //!< Character type derived from Encoding. + typedef GenericValue ValueType; //!< Value type of the document. + typedef Allocator AllocatorType; //!< Allocator type from template parameter. + + //! Constructor + /*! Creates an empty document of specified type. + \param type Mandatory type of object to create. + \param allocator Optional allocator for allocating memory. + \param stackCapacity Optional initial capacity of stack in bytes. + \param stackAllocator Optional allocator for allocating memory for stack. + */ + explicit GenericDocument(Type type, Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) : + GenericValue(type), allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_() + { + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + } + + //! Constructor + /*! Creates an empty document which type is Null. + \param allocator Optional allocator for allocating memory. + \param stackCapacity Optional initial capacity of stack in bytes. + \param stackAllocator Optional allocator for allocating memory for stack. + */ + GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) : + allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_() + { + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move constructor in C++11 + GenericDocument(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT + : ValueType(std::forward(rhs)), // explicit cast to avoid prohibited move from Document + allocator_(rhs.allocator_), + ownAllocator_(rhs.ownAllocator_), + stack_(std::move(rhs.stack_)), + parseResult_(rhs.parseResult_) + { + rhs.allocator_ = 0; + rhs.ownAllocator_ = 0; + rhs.parseResult_ = ParseResult(); + } +#endif + + ~GenericDocument() { + // Clear the ::ValueType before ownAllocator is destroyed, ~ValueType() + // runs last and may access its elements or members which would be freed + // with an allocator like MemoryPoolAllocator (CrtAllocator does not + // free its data when destroyed, but MemoryPoolAllocator does). + if (ownAllocator_) { + ValueType::SetNull(); + } + Destroy(); + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move assignment in C++11 + GenericDocument& operator=(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT + { + // The cast to ValueType is necessary here, because otherwise it would + // attempt to call GenericValue's templated assignment operator. + ValueType::operator=(std::forward(rhs)); + + // Calling the destructor here would prematurely call stack_'s destructor + Destroy(); + + allocator_ = rhs.allocator_; + ownAllocator_ = rhs.ownAllocator_; + stack_ = std::move(rhs.stack_); + parseResult_ = rhs.parseResult_; + + rhs.allocator_ = 0; + rhs.ownAllocator_ = 0; + rhs.parseResult_ = ParseResult(); + + return *this; + } +#endif + + //! Exchange the contents of this document with those of another. + /*! + \param rhs Another document. + \note Constant complexity. + \see GenericValue::Swap + */ + GenericDocument& Swap(GenericDocument& rhs) RAPIDJSON_NOEXCEPT { + ValueType::Swap(rhs); + stack_.Swap(rhs.stack_); + internal::Swap(allocator_, rhs.allocator_); + internal::Swap(ownAllocator_, rhs.ownAllocator_); + internal::Swap(parseResult_, rhs.parseResult_); + return *this; + } + + // Allow Swap with ValueType. + // Refer to Effective C++ 3rd Edition/Item 33: Avoid hiding inherited names. + using ValueType::Swap; + + //! free-standing swap function helper + /*! + Helper function to enable support for common swap implementation pattern based on \c std::swap: + \code + void swap(MyClass& a, MyClass& b) { + using std::swap; + swap(a.doc, b.doc); + // ... + } + \endcode + \see Swap() + */ + friend inline void swap(GenericDocument& a, GenericDocument& b) RAPIDJSON_NOEXCEPT { a.Swap(b); } + + //! Populate this document by a generator which produces SAX events. + /*! \tparam Generator A functor with bool f(Handler) prototype. + \param g Generator functor which sends SAX events to the parameter. + \return The document itself for fluent API. + */ + template + GenericDocument& Populate(Generator& g) { + ClearStackOnExit scope(*this); + if (g(*this)) { + RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object + ValueType::operator=(*stack_.template Pop(1));// Move value from stack to document + } + return *this; + } + + //!@name Parse from stream + //!@{ + + //! Parse JSON text from an input stream (with Encoding conversion) + /*! \tparam parseFlags Combination of \ref ParseFlag. + \tparam SourceEncoding Encoding of input stream + \tparam InputStream Type of input stream, implementing Stream concept + \param is Input stream to be parsed. + \return The document itself for fluent API. + */ + template + GenericDocument& ParseStream(InputStream& is) { + GenericReader reader( + stack_.HasAllocator() ? &stack_.GetAllocator() : 0); + ClearStackOnExit scope(*this); + parseResult_ = reader.template Parse(is, *this); + if (parseResult_) { + RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object + ValueType::operator=(*stack_.template Pop(1));// Move value from stack to document + } + return *this; + } + + //! Parse JSON text from an input stream + /*! \tparam parseFlags Combination of \ref ParseFlag. + \tparam InputStream Type of input stream, implementing Stream concept + \param is Input stream to be parsed. + \return The document itself for fluent API. + */ + template + GenericDocument& ParseStream(InputStream& is) { + return ParseStream(is); + } + + //! Parse JSON text from an input stream (with \ref kParseDefaultFlags) + /*! \tparam InputStream Type of input stream, implementing Stream concept + \param is Input stream to be parsed. + \return The document itself for fluent API. + */ + template + GenericDocument& ParseStream(InputStream& is) { + return ParseStream(is); + } + //!@} + + //!@name Parse in-place from mutable string + //!@{ + + //! Parse JSON text from a mutable string + /*! \tparam parseFlags Combination of \ref ParseFlag. + \param str Mutable zero-terminated string to be parsed. + \return The document itself for fluent API. + */ + template + GenericDocument& ParseInsitu(Ch* str) { + GenericInsituStringStream s(str); + return ParseStream(s); + } + + //! Parse JSON text from a mutable string (with \ref kParseDefaultFlags) + /*! \param str Mutable zero-terminated string to be parsed. + \return The document itself for fluent API. + */ + GenericDocument& ParseInsitu(Ch* str) { + return ParseInsitu(str); + } + //!@} + + //!@name Parse from read-only string + //!@{ + + //! Parse JSON text from a read-only string (with Encoding conversion) + /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag). + \tparam SourceEncoding Transcoding from input Encoding + \param str Read-only zero-terminated string to be parsed. + */ + template + GenericDocument& Parse(const typename SourceEncoding::Ch* str) { + RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag)); + GenericStringStream s(str); + return ParseStream(s); + } + + //! Parse JSON text from a read-only string + /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag). + \param str Read-only zero-terminated string to be parsed. + */ + template + GenericDocument& Parse(const Ch* str) { + return Parse(str); + } + + //! Parse JSON text from a read-only string (with \ref kParseDefaultFlags) + /*! \param str Read-only zero-terminated string to be parsed. + */ + GenericDocument& Parse(const Ch* str) { + return Parse(str); + } + + template + GenericDocument& Parse(const typename SourceEncoding::Ch* str, size_t length) { + RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag)); + MemoryStream ms(reinterpret_cast(str), length * sizeof(typename SourceEncoding::Ch)); + EncodedInputStream is(ms); + ParseStream(is); + return *this; + } + + template + GenericDocument& Parse(const Ch* str, size_t length) { + return Parse(str, length); + } + + GenericDocument& Parse(const Ch* str, size_t length) { + return Parse(str, length); + } + +#if RAPIDJSON_HAS_STDSTRING + template + GenericDocument& Parse(const std::basic_string& str) { + // c_str() is constant complexity according to standard. Should be faster than Parse(const char*, size_t) + return Parse(str.c_str()); + } + + template + GenericDocument& Parse(const std::basic_string& str) { + return Parse(str.c_str()); + } + + GenericDocument& Parse(const std::basic_string& str) { + return Parse(str); + } +#endif // RAPIDJSON_HAS_STDSTRING + + //!@} + + //!@name Handling parse errors + //!@{ + + //! Whether a parse error has occurred in the last parsing. + bool HasParseError() const { return parseResult_.IsError(); } + + //! Get the \ref ParseErrorCode of last parsing. + ParseErrorCode GetParseError() const { return parseResult_.Code(); } + + //! Get the position of last parsing error in input, 0 otherwise. + size_t GetErrorOffset() const { return parseResult_.Offset(); } + + //! Implicit conversion to get the last parse result +#ifndef __clang // -Wdocumentation + /*! \return \ref ParseResult of the last parse operation + + \code + Document doc; + ParseResult ok = doc.Parse(json); + if (!ok) + printf( "JSON parse error: %s (%u)\n", GetParseError_En(ok.Code()), ok.Offset()); + \endcode + */ +#endif + operator ParseResult() const { return parseResult_; } + //!@} + + //! Get the allocator of this document. + Allocator& GetAllocator() { + RAPIDJSON_ASSERT(allocator_); + return *allocator_; + } + + //! Get the capacity of stack in bytes. + size_t GetStackCapacity() const { return stack_.GetCapacity(); } + +private: + // clear stack on any exit from ParseStream, e.g. due to exception + struct ClearStackOnExit { + explicit ClearStackOnExit(GenericDocument& d) : d_(d) {} + ~ClearStackOnExit() { d_.ClearStack(); } + private: + ClearStackOnExit(const ClearStackOnExit&); + ClearStackOnExit& operator=(const ClearStackOnExit&); + GenericDocument& d_; + }; + + // callers of the following private Handler functions + // template friend class GenericReader; // for parsing + template friend class GenericValue; // for deep copying + +public: + // Implementation of Handler + bool Null() { new (stack_.template Push()) ValueType(); return true; } + bool Bool(bool b) { new (stack_.template Push()) ValueType(b); return true; } + bool Int(int i) { new (stack_.template Push()) ValueType(i); return true; } + bool Uint(unsigned i) { new (stack_.template Push()) ValueType(i); return true; } + bool Int64(int64_t i) { new (stack_.template Push()) ValueType(i); return true; } + bool Uint64(uint64_t i) { new (stack_.template Push()) ValueType(i); return true; } + bool Double(double d) { new (stack_.template Push()) ValueType(d); return true; } + + bool RawNumber(const Ch* str, SizeType length, bool copy) { + if (copy) + new (stack_.template Push()) ValueType(str, length, GetAllocator()); + else + new (stack_.template Push()) ValueType(str, length); + return true; + } + + bool String(const Ch* str, SizeType length, bool copy) { + if (copy) + new (stack_.template Push()) ValueType(str, length, GetAllocator()); + else + new (stack_.template Push()) ValueType(str, length); + return true; + } + + bool StartObject() { new (stack_.template Push()) ValueType(kObjectType); return true; } + + bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); } + + bool EndObject(SizeType memberCount) { + typename ValueType::Member* members = stack_.template Pop(memberCount); + stack_.template Top()->SetObjectRaw(members, memberCount, GetAllocator()); + return true; + } + + bool StartArray() { new (stack_.template Push()) ValueType(kArrayType); return true; } + + bool EndArray(SizeType elementCount) { + ValueType* elements = stack_.template Pop(elementCount); + stack_.template Top()->SetArrayRaw(elements, elementCount, GetAllocator()); + return true; + } + +private: + //! Prohibit copying + GenericDocument(const GenericDocument&); + //! Prohibit assignment + GenericDocument& operator=(const GenericDocument&); + + void ClearStack() { + if (Allocator::kNeedFree) + while (stack_.GetSize() > 0) // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects) + (stack_.template Pop(1))->~ValueType(); + else + stack_.Clear(); + stack_.ShrinkToFit(); + } + + void Destroy() { + RAPIDJSON_DELETE(ownAllocator_); + } + + static const size_t kDefaultStackCapacity = 1024; + Allocator* allocator_; + Allocator* ownAllocator_; + internal::Stack stack_; + ParseResult parseResult_; +}; + +//! GenericDocument with UTF8 encoding +typedef GenericDocument > Document; + + +//! Helper class for accessing Value of array type. +/*! + Instance of this helper class is obtained by \c GenericValue::GetArray(). + In addition to all APIs for array type, it provides range-based for loop if \c RAPIDJSON_HAS_CXX11_RANGE_FOR=1. +*/ +template +class GenericArray { +public: + typedef GenericArray ConstArray; + typedef GenericArray Array; + typedef ValueT PlainType; + typedef typename internal::MaybeAddConst::Type ValueType; + typedef ValueType* ValueIterator; // This may be const or non-const iterator + typedef const ValueT* ConstValueIterator; + typedef typename ValueType::AllocatorType AllocatorType; + typedef typename ValueType::StringRefType StringRefType; + + template + friend class GenericValue; + + GenericArray(const GenericArray& rhs) : value_(rhs.value_) {} + GenericArray& operator=(const GenericArray& rhs) { value_ = rhs.value_; return *this; } + ~GenericArray() {} + + operator ValueType&() const { return value_; } + SizeType Size() const { return value_.Size(); } + SizeType Capacity() const { return value_.Capacity(); } + bool Empty() const { return value_.Empty(); } + void Clear() const { value_.Clear(); } + ValueType& operator[](SizeType index) const { return value_[index]; } + ValueIterator Begin() const { return value_.Begin(); } + ValueIterator End() const { return value_.End(); } + GenericArray Reserve(SizeType newCapacity, AllocatorType &allocator) const { value_.Reserve(newCapacity, allocator); return *this; } + GenericArray PushBack(ValueType& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; } +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericArray PushBack(ValueType&& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; } +#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericArray PushBack(StringRefType value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; } + template RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (const GenericArray&)) PushBack(T value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; } + GenericArray PopBack() const { value_.PopBack(); return *this; } + ValueIterator Erase(ConstValueIterator pos) const { return value_.Erase(pos); } + ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) const { return value_.Erase(first, last); } + +#if RAPIDJSON_HAS_CXX11_RANGE_FOR + ValueIterator begin() const { return value_.Begin(); } + ValueIterator end() const { return value_.End(); } +#endif + +private: + GenericArray(); + GenericArray(ValueType& value) : value_(value) {} + ValueType& value_; +}; + +//! Helper class for accessing Value of object type. +/*! + Instance of this helper class is obtained by \c GenericValue::GetObject(). + In addition to all APIs for array type, it provides range-based for loop if \c RAPIDJSON_HAS_CXX11_RANGE_FOR=1. +*/ +template +class GenericObject { +public: + typedef GenericObject ConstObject; + typedef GenericObject Object; + typedef ValueT PlainType; + typedef typename internal::MaybeAddConst::Type ValueType; + typedef GenericMemberIterator MemberIterator; // This may be const or non-const iterator + typedef GenericMemberIterator ConstMemberIterator; + typedef typename ValueType::AllocatorType AllocatorType; + typedef typename ValueType::StringRefType StringRefType; + typedef typename ValueType::EncodingType EncodingType; + typedef typename ValueType::Ch Ch; + + template + friend class GenericValue; + + GenericObject(const GenericObject& rhs) : value_(rhs.value_) {} + GenericObject& operator=(const GenericObject& rhs) { value_ = rhs.value_; return *this; } + ~GenericObject() {} + + operator ValueType&() const { return value_; } + SizeType MemberCount() const { return value_.MemberCount(); } + SizeType MemberCapacity() const { return value_.MemberCapacity(); } + bool ObjectEmpty() const { return value_.ObjectEmpty(); } + template ValueType& operator[](T* name) const { return value_[name]; } + template ValueType& operator[](const GenericValue& name) const { return value_[name]; } +#if RAPIDJSON_HAS_STDSTRING + ValueType& operator[](const std::basic_string& name) const { return value_[name]; } +#endif + MemberIterator MemberBegin() const { return value_.MemberBegin(); } + MemberIterator MemberEnd() const { return value_.MemberEnd(); } + GenericObject MemberReserve(SizeType newCapacity, AllocatorType &allocator) const { value_.MemberReserve(newCapacity, allocator); return *this; } + bool HasMember(const Ch* name) const { return value_.HasMember(name); } +#if RAPIDJSON_HAS_STDSTRING + bool HasMember(const std::basic_string& name) const { return value_.HasMember(name); } +#endif + template bool HasMember(const GenericValue& name) const { return value_.HasMember(name); } + MemberIterator FindMember(const Ch* name) const { return value_.FindMember(name); } + template MemberIterator FindMember(const GenericValue& name) const { return value_.FindMember(name); } +#if RAPIDJSON_HAS_STDSTRING + MemberIterator FindMember(const std::basic_string& name) const { return value_.FindMember(name); } +#endif + GenericObject AddMember(ValueType& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + GenericObject AddMember(ValueType& name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } +#if RAPIDJSON_HAS_STDSTRING + GenericObject AddMember(ValueType& name, std::basic_string& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } +#endif + template RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (ValueType&)) AddMember(ValueType& name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericObject AddMember(ValueType&& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + GenericObject AddMember(ValueType&& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + GenericObject AddMember(ValueType& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + GenericObject AddMember(StringRefType name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } +#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericObject AddMember(StringRefType name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + GenericObject AddMember(StringRefType name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + template RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (GenericObject)) AddMember(StringRefType name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; } + void RemoveAllMembers() { value_.RemoveAllMembers(); } + bool RemoveMember(const Ch* name) const { return value_.RemoveMember(name); } +#if RAPIDJSON_HAS_STDSTRING + bool RemoveMember(const std::basic_string& name) const { return value_.RemoveMember(name); } +#endif + template bool RemoveMember(const GenericValue& name) const { return value_.RemoveMember(name); } + MemberIterator RemoveMember(MemberIterator m) const { return value_.RemoveMember(m); } + MemberIterator EraseMember(ConstMemberIterator pos) const { return value_.EraseMember(pos); } + MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) const { return value_.EraseMember(first, last); } + bool EraseMember(const Ch* name) const { return value_.EraseMember(name); } +#if RAPIDJSON_HAS_STDSTRING + bool EraseMember(const std::basic_string& name) const { return EraseMember(ValueType(StringRef(name))); } +#endif + template bool EraseMember(const GenericValue& name) const { return value_.EraseMember(name); } + +#if RAPIDJSON_HAS_CXX11_RANGE_FOR + MemberIterator begin() const { return value_.MemberBegin(); } + MemberIterator end() const { return value_.MemberEnd(); } +#endif + +private: + GenericObject(); + GenericObject(ValueType& value) : value_(value) {} + ValueType& value_; +}; + +RAPIDJSON_NAMESPACE_END +RAPIDJSON_DIAG_POP + +#ifdef RAPIDJSON_WINDOWS_GETOBJECT_WORKAROUND_APPLIED +#pragma pop_macro("GetObject") +#undef RAPIDJSON_WINDOWS_GETOBJECT_WORKAROUND_APPLIED +#endif + +#endif // RAPIDJSON_DOCUMENT_H_ diff --git a/libs/include/rapidjson/encodedstream.h b/libs/include/rapidjson/encodedstream.h new file mode 100644 index 0000000..cf046b8 --- /dev/null +++ b/libs/include/rapidjson/encodedstream.h @@ -0,0 +1,299 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_ENCODEDSTREAM_H_ +#define RAPIDJSON_ENCODEDSTREAM_H_ + +#include "stream.h" +#include "memorystream.h" + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Input byte stream wrapper with a statically bound encoding. +/*! + \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE. + \tparam InputByteStream Type of input byte stream. For example, FileReadStream. +*/ +template +class EncodedInputStream { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); +public: + typedef typename Encoding::Ch Ch; + + EncodedInputStream(InputByteStream& is) : is_(is) { + current_ = Encoding::TakeBOM(is_); + } + + Ch Peek() const { return current_; } + Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; } + size_t Tell() const { return is_.Tell(); } + + // Not implemented + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + EncodedInputStream(const EncodedInputStream&); + EncodedInputStream& operator=(const EncodedInputStream&); + + InputByteStream& is_; + Ch current_; +}; + +//! Specialized for UTF8 MemoryStream. +template <> +class EncodedInputStream, MemoryStream> { +public: + typedef UTF8<>::Ch Ch; + + EncodedInputStream(MemoryStream& is) : is_(is) { + if (static_cast(is_.Peek()) == 0xEFu) is_.Take(); + if (static_cast(is_.Peek()) == 0xBBu) is_.Take(); + if (static_cast(is_.Peek()) == 0xBFu) is_.Take(); + } + Ch Peek() const { return is_.Peek(); } + Ch Take() { return is_.Take(); } + size_t Tell() const { return is_.Tell(); } + + // Not implemented + void Put(Ch) {} + void Flush() {} + Ch* PutBegin() { return 0; } + size_t PutEnd(Ch*) { return 0; } + + MemoryStream& is_; + +private: + EncodedInputStream(const EncodedInputStream&); + EncodedInputStream& operator=(const EncodedInputStream&); +}; + +//! Output byte stream wrapper with statically bound encoding. +/*! + \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE. + \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream. +*/ +template +class EncodedOutputStream { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); +public: + typedef typename Encoding::Ch Ch; + + EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) { + if (putBOM) + Encoding::PutBOM(os_); + } + + void Put(Ch c) { Encoding::Put(os_, c); } + void Flush() { os_.Flush(); } + + // Not implemented + Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;} + Ch Take() { RAPIDJSON_ASSERT(false); return 0;} + size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + EncodedOutputStream(const EncodedOutputStream&); + EncodedOutputStream& operator=(const EncodedOutputStream&); + + OutputByteStream& os_; +}; + +#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8::x, UTF16LE::x, UTF16BE::x, UTF32LE::x, UTF32BE::x + +//! Input stream wrapper with dynamically bound encoding and automatic encoding detection. +/*! + \tparam CharType Type of character for reading. + \tparam InputByteStream type of input byte stream to be wrapped. +*/ +template +class AutoUTFInputStream { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); +public: + typedef CharType Ch; + + //! Constructor. + /*! + \param is input stream to be wrapped. + \param type UTF encoding type if it is not detected from the stream. + */ + AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) { + RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE); + DetectType(); + static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) }; + takeFunc_ = f[type_]; + current_ = takeFunc_(*is_); + } + + UTFType GetType() const { return type_; } + bool HasBOM() const { return hasBOM_; } + + Ch Peek() const { return current_; } + Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; } + size_t Tell() const { return is_->Tell(); } + + // Not implemented + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + AutoUTFInputStream(const AutoUTFInputStream&); + AutoUTFInputStream& operator=(const AutoUTFInputStream&); + + // Detect encoding type with BOM or RFC 4627 + void DetectType() { + // BOM (Byte Order Mark): + // 00 00 FE FF UTF-32BE + // FF FE 00 00 UTF-32LE + // FE FF UTF-16BE + // FF FE UTF-16LE + // EF BB BF UTF-8 + + const unsigned char* c = reinterpret_cast(is_->Peek4()); + if (!c) + return; + + unsigned bom = static_cast(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24)); + hasBOM_ = false; + if (bom == 0xFFFE0000) { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); } + else if (bom == 0x0000FEFF) { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); } + else if ((bom & 0xFFFF) == 0xFFFE) { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take(); } + else if ((bom & 0xFFFF) == 0xFEFF) { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take(); } + else if ((bom & 0xFFFFFF) == 0xBFBBEF) { type_ = kUTF8; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); } + + // RFC 4627: Section 3 + // "Since the first two characters of a JSON text will always be ASCII + // characters [RFC0020], it is possible to determine whether an octet + // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking + // at the pattern of nulls in the first four octets." + // 00 00 00 xx UTF-32BE + // 00 xx 00 xx UTF-16BE + // xx 00 00 00 UTF-32LE + // xx 00 xx 00 UTF-16LE + // xx xx xx xx UTF-8 + + if (!hasBOM_) { + int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0); + switch (pattern) { + case 0x08: type_ = kUTF32BE; break; + case 0x0A: type_ = kUTF16BE; break; + case 0x01: type_ = kUTF32LE; break; + case 0x05: type_ = kUTF16LE; break; + case 0x0F: type_ = kUTF8; break; + default: break; // Use type defined by user. + } + } + + // Runtime check whether the size of character type is sufficient. It only perform checks with assertion. + if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2); + if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4); + } + + typedef Ch (*TakeFunc)(InputByteStream& is); + InputByteStream* is_; + UTFType type_; + Ch current_; + TakeFunc takeFunc_; + bool hasBOM_; +}; + +//! Output stream wrapper with dynamically bound encoding and automatic encoding detection. +/*! + \tparam CharType Type of character for writing. + \tparam OutputByteStream type of output byte stream to be wrapped. +*/ +template +class AutoUTFOutputStream { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); +public: + typedef CharType Ch; + + //! Constructor. + /*! + \param os output stream to be wrapped. + \param type UTF encoding type. + \param putBOM Whether to write BOM at the beginning of the stream. + */ + AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) { + RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE); + + // Runtime check whether the size of character type is sufficient. It only perform checks with assertion. + if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2); + if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4); + + static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) }; + putFunc_ = f[type_]; + + if (putBOM) + PutBOM(); + } + + UTFType GetType() const { return type_; } + + void Put(Ch c) { putFunc_(*os_, c); } + void Flush() { os_->Flush(); } + + // Not implemented + Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;} + Ch Take() { RAPIDJSON_ASSERT(false); return 0;} + size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + AutoUTFOutputStream(const AutoUTFOutputStream&); + AutoUTFOutputStream& operator=(const AutoUTFOutputStream&); + + void PutBOM() { + typedef void (*PutBOMFunc)(OutputByteStream&); + static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) }; + f[type_](*os_); + } + + typedef void (*PutFunc)(OutputByteStream&, Ch); + + OutputByteStream* os_; + UTFType type_; + PutFunc putFunc_; +}; + +#undef RAPIDJSON_ENCODINGS_FUNC + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_FILESTREAM_H_ diff --git a/libs/include/rapidjson/encodings.h b/libs/include/rapidjson/encodings.h new file mode 100644 index 0000000..50ad18b --- /dev/null +++ b/libs/include/rapidjson/encodings.h @@ -0,0 +1,716 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_ENCODINGS_H_ +#define RAPIDJSON_ENCODINGS_H_ + +#include "rapidjson.h" + +#if defined(_MSC_VER) && !defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data +RAPIDJSON_DIAG_OFF(4702) // unreachable code +#elif defined(__GNUC__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +RAPIDJSON_DIAG_OFF(overflow) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// Encoding + +/*! \class rapidjson::Encoding + \brief Concept for encoding of Unicode characters. + +\code +concept Encoding { + typename Ch; //! Type of character. A "character" is actually a code unit in unicode's definition. + + enum { supportUnicode = 1 }; // or 0 if not supporting unicode + + //! \brief Encode a Unicode codepoint to an output stream. + //! \param os Output stream. + //! \param codepoint An unicode codepoint, ranging from 0x0 to 0x10FFFF inclusively. + template + static void Encode(OutputStream& os, unsigned codepoint); + + //! \brief Decode a Unicode codepoint from an input stream. + //! \param is Input stream. + //! \param codepoint Output of the unicode codepoint. + //! \return true if a valid codepoint can be decoded from the stream. + template + static bool Decode(InputStream& is, unsigned* codepoint); + + //! \brief Validate one Unicode codepoint from an encoded stream. + //! \param is Input stream to obtain codepoint. + //! \param os Output for copying one codepoint. + //! \return true if it is valid. + //! \note This function just validating and copying the codepoint without actually decode it. + template + static bool Validate(InputStream& is, OutputStream& os); + + // The following functions are deal with byte streams. + + //! Take a character from input byte stream, skip BOM if exist. + template + static CharType TakeBOM(InputByteStream& is); + + //! Take a character from input byte stream. + template + static Ch Take(InputByteStream& is); + + //! Put BOM to output byte stream. + template + static void PutBOM(OutputByteStream& os); + + //! Put a character to output byte stream. + template + static void Put(OutputByteStream& os, Ch c); +}; +\endcode +*/ + +/////////////////////////////////////////////////////////////////////////////// +// UTF8 + +//! UTF-8 encoding. +/*! http://en.wikipedia.org/wiki/UTF-8 + http://tools.ietf.org/html/rfc3629 + \tparam CharType Code unit for storing 8-bit UTF-8 data. Default is char. + \note implements Encoding concept +*/ +template +struct UTF8 { + typedef CharType Ch; + + enum { supportUnicode = 1 }; + + template + static void Encode(OutputStream& os, unsigned codepoint) { + if (codepoint <= 0x7F) + os.Put(static_cast(codepoint & 0xFF)); + else if (codepoint <= 0x7FF) { + os.Put(static_cast(0xC0 | ((codepoint >> 6) & 0xFF))); + os.Put(static_cast(0x80 | ((codepoint & 0x3F)))); + } + else if (codepoint <= 0xFFFF) { + os.Put(static_cast(0xE0 | ((codepoint >> 12) & 0xFF))); + os.Put(static_cast(0x80 | ((codepoint >> 6) & 0x3F))); + os.Put(static_cast(0x80 | (codepoint & 0x3F))); + } + else { + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + os.Put(static_cast(0xF0 | ((codepoint >> 18) & 0xFF))); + os.Put(static_cast(0x80 | ((codepoint >> 12) & 0x3F))); + os.Put(static_cast(0x80 | ((codepoint >> 6) & 0x3F))); + os.Put(static_cast(0x80 | (codepoint & 0x3F))); + } + } + + template + static void EncodeUnsafe(OutputStream& os, unsigned codepoint) { + if (codepoint <= 0x7F) + PutUnsafe(os, static_cast(codepoint & 0xFF)); + else if (codepoint <= 0x7FF) { + PutUnsafe(os, static_cast(0xC0 | ((codepoint >> 6) & 0xFF))); + PutUnsafe(os, static_cast(0x80 | ((codepoint & 0x3F)))); + } + else if (codepoint <= 0xFFFF) { + PutUnsafe(os, static_cast(0xE0 | ((codepoint >> 12) & 0xFF))); + PutUnsafe(os, static_cast(0x80 | ((codepoint >> 6) & 0x3F))); + PutUnsafe(os, static_cast(0x80 | (codepoint & 0x3F))); + } + else { + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + PutUnsafe(os, static_cast(0xF0 | ((codepoint >> 18) & 0xFF))); + PutUnsafe(os, static_cast(0x80 | ((codepoint >> 12) & 0x3F))); + PutUnsafe(os, static_cast(0x80 | ((codepoint >> 6) & 0x3F))); + PutUnsafe(os, static_cast(0x80 | (codepoint & 0x3F))); + } + } + + template + static bool Decode(InputStream& is, unsigned* codepoint) { +#define RAPIDJSON_COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast(c) & 0x3Fu) +#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast(c)) & mask) != 0) +#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70) + typename InputStream::Ch c = is.Take(); + if (!(c & 0x80)) { + *codepoint = static_cast(c); + return true; + } + + unsigned char type = GetRange(static_cast(c)); + if (type >= 32) { + *codepoint = 0; + } else { + *codepoint = (0xFFu >> type) & static_cast(c); + } + bool result = true; + switch (type) { + case 2: RAPIDJSON_TAIL(); return result; + case 3: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 4: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x50); RAPIDJSON_TAIL(); return result; + case 5: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x10); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 6: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 10: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x20); RAPIDJSON_TAIL(); return result; + case 11: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x60); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + default: return false; + } +#undef RAPIDJSON_COPY +#undef RAPIDJSON_TRANS +#undef RAPIDJSON_TAIL + } + + template + static bool Validate(InputStream& is, OutputStream& os) { +#define RAPIDJSON_COPY() os.Put(c = is.Take()) +#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast(c)) & mask) != 0) +#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70) + Ch c; + RAPIDJSON_COPY(); + if (!(c & 0x80)) + return true; + + bool result = true; + switch (GetRange(static_cast(c))) { + case 2: RAPIDJSON_TAIL(); return result; + case 3: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 4: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x50); RAPIDJSON_TAIL(); return result; + case 5: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x10); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 6: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + case 10: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x20); RAPIDJSON_TAIL(); return result; + case 11: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x60); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result; + default: return false; + } +#undef RAPIDJSON_COPY +#undef RAPIDJSON_TRANS +#undef RAPIDJSON_TAIL + } + + static unsigned char GetRange(unsigned char c) { + // Referring to DFA of http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ + // With new mapping 1 -> 0x10, 7 -> 0x20, 9 -> 0x40, such that AND operation can test multiple types. + static const unsigned char type[] = { + 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,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,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,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, + 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, + 8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8, + }; + return type[c]; + } + + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + typename InputByteStream::Ch c = Take(is); + if (static_cast(c) != 0xEFu) return c; + c = is.Take(); + if (static_cast(c) != 0xBBu) return c; + c = is.Take(); + if (static_cast(c) != 0xBFu) return c; + c = is.Take(); + return c; + } + + template + static Ch Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + return static_cast(is.Take()); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(0xEFu)); + os.Put(static_cast(0xBBu)); + os.Put(static_cast(0xBFu)); + } + + template + static void Put(OutputByteStream& os, Ch c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(c)); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// UTF16 + +//! UTF-16 encoding. +/*! http://en.wikipedia.org/wiki/UTF-16 + http://tools.ietf.org/html/rfc2781 + \tparam CharType Type for storing 16-bit UTF-16 data. Default is wchar_t. C++11 may use char16_t instead. + \note implements Encoding concept + + \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness. + For streaming, use UTF16LE and UTF16BE, which handle endianness. +*/ +template +struct UTF16 { + typedef CharType Ch; + RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 2); + + enum { supportUnicode = 1 }; + + template + static void Encode(OutputStream& os, unsigned codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2); + if (codepoint <= 0xFFFF) { + RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair + os.Put(static_cast(codepoint)); + } + else { + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + unsigned v = codepoint - 0x10000; + os.Put(static_cast((v >> 10) | 0xD800)); + os.Put(static_cast((v & 0x3FF) | 0xDC00)); + } + } + + + template + static void EncodeUnsafe(OutputStream& os, unsigned codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2); + if (codepoint <= 0xFFFF) { + RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair + PutUnsafe(os, static_cast(codepoint)); + } + else { + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + unsigned v = codepoint - 0x10000; + PutUnsafe(os, static_cast((v >> 10) | 0xD800)); + PutUnsafe(os, static_cast((v & 0x3FF) | 0xDC00)); + } + } + + template + static bool Decode(InputStream& is, unsigned* codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2); + typename InputStream::Ch c = is.Take(); + if (c < 0xD800 || c > 0xDFFF) { + *codepoint = static_cast(c); + return true; + } + else if (c <= 0xDBFF) { + *codepoint = (static_cast(c) & 0x3FF) << 10; + c = is.Take(); + *codepoint |= (static_cast(c) & 0x3FF); + *codepoint += 0x10000; + return c >= 0xDC00 && c <= 0xDFFF; + } + return false; + } + + template + static bool Validate(InputStream& is, OutputStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2); + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2); + typename InputStream::Ch c; + os.Put(static_cast(c = is.Take())); + if (c < 0xD800 || c > 0xDFFF) + return true; + else if (c <= 0xDBFF) { + os.Put(c = is.Take()); + return c >= 0xDC00 && c <= 0xDFFF; + } + return false; + } +}; + +//! UTF-16 little endian encoding. +template +struct UTF16LE : UTF16 { + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + CharType c = Take(is); + return static_cast(c) == 0xFEFFu ? Take(is) : c; + } + + template + static CharType Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + unsigned c = static_cast(is.Take()); + c |= static_cast(static_cast(is.Take())) << 8; + return static_cast(c); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(0xFFu)); + os.Put(static_cast(0xFEu)); + } + + template + static void Put(OutputByteStream& os, CharType c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(static_cast(c) & 0xFFu)); + os.Put(static_cast((static_cast(c) >> 8) & 0xFFu)); + } +}; + +//! UTF-16 big endian encoding. +template +struct UTF16BE : UTF16 { + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + CharType c = Take(is); + return static_cast(c) == 0xFEFFu ? Take(is) : c; + } + + template + static CharType Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + unsigned c = static_cast(static_cast(is.Take())) << 8; + c |= static_cast(static_cast(is.Take())); + return static_cast(c); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(0xFEu)); + os.Put(static_cast(0xFFu)); + } + + template + static void Put(OutputByteStream& os, CharType c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast((static_cast(c) >> 8) & 0xFFu)); + os.Put(static_cast(static_cast(c) & 0xFFu)); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// UTF32 + +//! UTF-32 encoding. +/*! http://en.wikipedia.org/wiki/UTF-32 + \tparam CharType Type for storing 32-bit UTF-32 data. Default is unsigned. C++11 may use char32_t instead. + \note implements Encoding concept + + \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness. + For streaming, use UTF32LE and UTF32BE, which handle endianness. +*/ +template +struct UTF32 { + typedef CharType Ch; + RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 4); + + enum { supportUnicode = 1 }; + + template + static void Encode(OutputStream& os, unsigned codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4); + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + os.Put(codepoint); + } + + template + static void EncodeUnsafe(OutputStream& os, unsigned codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4); + RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); + PutUnsafe(os, codepoint); + } + + template + static bool Decode(InputStream& is, unsigned* codepoint) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4); + Ch c = is.Take(); + *codepoint = c; + return c <= 0x10FFFF; + } + + template + static bool Validate(InputStream& is, OutputStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4); + Ch c; + os.Put(c = is.Take()); + return c <= 0x10FFFF; + } +}; + +//! UTF-32 little endian enocoding. +template +struct UTF32LE : UTF32 { + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + CharType c = Take(is); + return static_cast(c) == 0x0000FEFFu ? Take(is) : c; + } + + template + static CharType Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + unsigned c = static_cast(is.Take()); + c |= static_cast(static_cast(is.Take())) << 8; + c |= static_cast(static_cast(is.Take())) << 16; + c |= static_cast(static_cast(is.Take())) << 24; + return static_cast(c); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(0xFFu)); + os.Put(static_cast(0xFEu)); + os.Put(static_cast(0x00u)); + os.Put(static_cast(0x00u)); + } + + template + static void Put(OutputByteStream& os, CharType c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(c & 0xFFu)); + os.Put(static_cast((c >> 8) & 0xFFu)); + os.Put(static_cast((c >> 16) & 0xFFu)); + os.Put(static_cast((c >> 24) & 0xFFu)); + } +}; + +//! UTF-32 big endian encoding. +template +struct UTF32BE : UTF32 { + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + CharType c = Take(is); + return static_cast(c) == 0x0000FEFFu ? Take(is) : c; + } + + template + static CharType Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + unsigned c = static_cast(static_cast(is.Take())) << 24; + c |= static_cast(static_cast(is.Take())) << 16; + c |= static_cast(static_cast(is.Take())) << 8; + c |= static_cast(static_cast(is.Take())); + return static_cast(c); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(0x00u)); + os.Put(static_cast(0x00u)); + os.Put(static_cast(0xFEu)); + os.Put(static_cast(0xFFu)); + } + + template + static void Put(OutputByteStream& os, CharType c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast((c >> 24) & 0xFFu)); + os.Put(static_cast((c >> 16) & 0xFFu)); + os.Put(static_cast((c >> 8) & 0xFFu)); + os.Put(static_cast(c & 0xFFu)); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// ASCII + +//! ASCII encoding. +/*! http://en.wikipedia.org/wiki/ASCII + \tparam CharType Code unit for storing 7-bit ASCII data. Default is char. + \note implements Encoding concept +*/ +template +struct ASCII { + typedef CharType Ch; + + enum { supportUnicode = 0 }; + + template + static void Encode(OutputStream& os, unsigned codepoint) { + RAPIDJSON_ASSERT(codepoint <= 0x7F); + os.Put(static_cast(codepoint & 0xFF)); + } + + template + static void EncodeUnsafe(OutputStream& os, unsigned codepoint) { + RAPIDJSON_ASSERT(codepoint <= 0x7F); + PutUnsafe(os, static_cast(codepoint & 0xFF)); + } + + template + static bool Decode(InputStream& is, unsigned* codepoint) { + uint8_t c = static_cast(is.Take()); + *codepoint = c; + return c <= 0X7F; + } + + template + static bool Validate(InputStream& is, OutputStream& os) { + uint8_t c = static_cast(is.Take()); + os.Put(static_cast(c)); + return c <= 0x7F; + } + + template + static CharType TakeBOM(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + uint8_t c = static_cast(Take(is)); + return static_cast(c); + } + + template + static Ch Take(InputByteStream& is) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1); + return static_cast(is.Take()); + } + + template + static void PutBOM(OutputByteStream& os) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + (void)os; + } + + template + static void Put(OutputByteStream& os, Ch c) { + RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1); + os.Put(static_cast(c)); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// AutoUTF + +//! Runtime-specified UTF encoding type of a stream. +enum UTFType { + kUTF8 = 0, //!< UTF-8. + kUTF16LE = 1, //!< UTF-16 little endian. + kUTF16BE = 2, //!< UTF-16 big endian. + kUTF32LE = 3, //!< UTF-32 little endian. + kUTF32BE = 4 //!< UTF-32 big endian. +}; + +//! Dynamically select encoding according to stream's runtime-specified UTF encoding type. +/*! \note This class can be used with AutoUTFInputtStream and AutoUTFOutputStream, which provides GetType(). +*/ +template +struct AutoUTF { + typedef CharType Ch; + + enum { supportUnicode = 1 }; + +#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8::x, UTF16LE::x, UTF16BE::x, UTF32LE::x, UTF32BE::x + + template + static RAPIDJSON_FORCEINLINE void Encode(OutputStream& os, unsigned codepoint) { + typedef void (*EncodeFunc)(OutputStream&, unsigned); + static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Encode) }; + (*f[os.GetType()])(os, codepoint); + } + + template + static RAPIDJSON_FORCEINLINE void EncodeUnsafe(OutputStream& os, unsigned codepoint) { + typedef void (*EncodeFunc)(OutputStream&, unsigned); + static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(EncodeUnsafe) }; + (*f[os.GetType()])(os, codepoint); + } + + template + static RAPIDJSON_FORCEINLINE bool Decode(InputStream& is, unsigned* codepoint) { + typedef bool (*DecodeFunc)(InputStream&, unsigned*); + static const DecodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Decode) }; + return (*f[is.GetType()])(is, codepoint); + } + + template + static RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) { + typedef bool (*ValidateFunc)(InputStream&, OutputStream&); + static const ValidateFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Validate) }; + return (*f[is.GetType()])(is, os); + } + +#undef RAPIDJSON_ENCODINGS_FUNC +}; + +/////////////////////////////////////////////////////////////////////////////// +// Transcoder + +//! Encoding conversion. +template +struct Transcoder { + //! Take one Unicode codepoint from source encoding, convert it to target encoding and put it to the output stream. + template + static RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) { + unsigned codepoint; + if (!SourceEncoding::Decode(is, &codepoint)) + return false; + TargetEncoding::Encode(os, codepoint); + return true; + } + + template + static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) { + unsigned codepoint; + if (!SourceEncoding::Decode(is, &codepoint)) + return false; + TargetEncoding::EncodeUnsafe(os, codepoint); + return true; + } + + //! Validate one Unicode codepoint from an encoded stream. + template + static RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) { + return Transcode(is, os); // Since source/target encoding is different, must transcode. + } +}; + +// Forward declaration. +template +inline void PutUnsafe(Stream& stream, typename Stream::Ch c); + +//! Specialization of Transcoder with same source and target encoding. +template +struct Transcoder { + template + static RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) { + os.Put(is.Take()); // Just copy one code unit. This semantic is different from primary template class. + return true; + } + + template + static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) { + PutUnsafe(os, is.Take()); // Just copy one code unit. This semantic is different from primary template class. + return true; + } + + template + static RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) { + return Encoding::Validate(is, os); // source/target encoding are the same + } +}; + +RAPIDJSON_NAMESPACE_END + +#if defined(__GNUC__) || (defined(_MSC_VER) && !defined(__clang__)) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_ENCODINGS_H_ diff --git a/libs/include/rapidjson/error/en.h b/libs/include/rapidjson/error/en.h new file mode 100644 index 0000000..5d2e57b --- /dev/null +++ b/libs/include/rapidjson/error/en.h @@ -0,0 +1,122 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_ERROR_EN_H_ +#define RAPIDJSON_ERROR_EN_H_ + +#include "error.h" + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(switch-enum) +RAPIDJSON_DIAG_OFF(covered-switch-default) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Maps error code of parsing into error message. +/*! + \ingroup RAPIDJSON_ERRORS + \param parseErrorCode Error code obtained in parsing. + \return the error message. + \note User can make a copy of this function for localization. + Using switch-case is safer for future modification of error codes. +*/ +inline const RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErrorCode) { + switch (parseErrorCode) { + case kParseErrorNone: return RAPIDJSON_ERROR_STRING("No error."); + + case kParseErrorDocumentEmpty: return RAPIDJSON_ERROR_STRING("The document is empty."); + case kParseErrorDocumentRootNotSingular: return RAPIDJSON_ERROR_STRING("The document root must not be followed by other values."); + + case kParseErrorValueInvalid: return RAPIDJSON_ERROR_STRING("Invalid value."); + + case kParseErrorObjectMissName: return RAPIDJSON_ERROR_STRING("Missing a name for object member."); + case kParseErrorObjectMissColon: return RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member."); + case kParseErrorObjectMissCommaOrCurlyBracket: return RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member."); + + case kParseErrorArrayMissCommaOrSquareBracket: return RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element."); + + case kParseErrorStringUnicodeEscapeInvalidHex: return RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string."); + case kParseErrorStringUnicodeSurrogateInvalid: return RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid."); + case kParseErrorStringEscapeInvalid: return RAPIDJSON_ERROR_STRING("Invalid escape character in string."); + case kParseErrorStringMissQuotationMark: return RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string."); + case kParseErrorStringInvalidEncoding: return RAPIDJSON_ERROR_STRING("Invalid encoding in string."); + + case kParseErrorNumberTooBig: return RAPIDJSON_ERROR_STRING("Number too big to be stored in double."); + case kParseErrorNumberMissFraction: return RAPIDJSON_ERROR_STRING("Miss fraction part in number."); + case kParseErrorNumberMissExponent: return RAPIDJSON_ERROR_STRING("Miss exponent in number."); + + case kParseErrorTermination: return RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error."); + case kParseErrorUnspecificSyntaxError: return RAPIDJSON_ERROR_STRING("Unspecific syntax error."); + + default: return RAPIDJSON_ERROR_STRING("Unknown error."); + } +} + +//! Maps error code of validation into error message. +/*! + \ingroup RAPIDJSON_ERRORS + \param validateErrorCode Error code obtained from validator. + \return the error message. + \note User can make a copy of this function for localization. + Using switch-case is safer for future modification of error codes. +*/ +inline const RAPIDJSON_ERROR_CHARTYPE* GetValidateError_En(ValidateErrorCode validateErrorCode) { + switch (validateErrorCode) { + case kValidateErrors: return RAPIDJSON_ERROR_STRING("One or more validation errors have occurred"); + case kValidateErrorNone: return RAPIDJSON_ERROR_STRING("No error."); + + case kValidateErrorMultipleOf: return RAPIDJSON_ERROR_STRING("Number '%actual' is not a multiple of the 'multipleOf' value '%expected'."); + case kValidateErrorMaximum: return RAPIDJSON_ERROR_STRING("Number '%actual' is greater than the 'maximum' value '%expected'."); + case kValidateErrorExclusiveMaximum: return RAPIDJSON_ERROR_STRING("Number '%actual' is greater than or equal to the 'exclusiveMaximum' value '%expected'."); + case kValidateErrorMinimum: return RAPIDJSON_ERROR_STRING("Number '%actual' is less than the 'minimum' value '%expected'."); + case kValidateErrorExclusiveMinimum: return RAPIDJSON_ERROR_STRING("Number '%actual' is less than or equal to the 'exclusiveMinimum' value '%expected'."); + + case kValidateErrorMaxLength: return RAPIDJSON_ERROR_STRING("String '%actual' is longer than the 'maxLength' value '%expected'."); + case kValidateErrorMinLength: return RAPIDJSON_ERROR_STRING("String '%actual' is shorter than the 'minLength' value '%expected'."); + case kValidateErrorPattern: return RAPIDJSON_ERROR_STRING("String '%actual' does not match the 'pattern' regular expression."); + + case kValidateErrorMaxItems: return RAPIDJSON_ERROR_STRING("Array of length '%actual' is longer than the 'maxItems' value '%expected'."); + case kValidateErrorMinItems: return RAPIDJSON_ERROR_STRING("Array of length '%actual' is shorter than the 'minItems' value '%expected'."); + case kValidateErrorUniqueItems: return RAPIDJSON_ERROR_STRING("Array has duplicate items at indices '%duplicates' but 'uniqueItems' is true."); + case kValidateErrorAdditionalItems: return RAPIDJSON_ERROR_STRING("Array has an additional item at index '%disallowed' that is not allowed by the schema."); + + case kValidateErrorMaxProperties: return RAPIDJSON_ERROR_STRING("Object has '%actual' members which is more than 'maxProperties' value '%expected'."); + case kValidateErrorMinProperties: return RAPIDJSON_ERROR_STRING("Object has '%actual' members which is less than 'minProperties' value '%expected'."); + case kValidateErrorRequired: return RAPIDJSON_ERROR_STRING("Object is missing the following members required by the schema: '%missing'."); + case kValidateErrorAdditionalProperties: return RAPIDJSON_ERROR_STRING("Object has an additional member '%disallowed' that is not allowed by the schema."); + case kValidateErrorPatternProperties: return RAPIDJSON_ERROR_STRING("Object has 'patternProperties' that are not allowed by the schema."); + case kValidateErrorDependencies: return RAPIDJSON_ERROR_STRING("Object has missing property or schema dependencies, refer to following errors."); + + case kValidateErrorEnum: return RAPIDJSON_ERROR_STRING("Property has a value that is not one of its allowed enumerated values."); + case kValidateErrorType: return RAPIDJSON_ERROR_STRING("Property has a type '%actual' that is not in the following list: '%expected'."); + + case kValidateErrorOneOf: return RAPIDJSON_ERROR_STRING("Property did not match any of the sub-schemas specified by 'oneOf', refer to following errors."); + case kValidateErrorOneOfMatch: return RAPIDJSON_ERROR_STRING("Property matched more than one of the sub-schemas specified by 'oneOf'."); + case kValidateErrorAllOf: return RAPIDJSON_ERROR_STRING("Property did not match all of the sub-schemas specified by 'allOf', refer to following errors."); + case kValidateErrorAnyOf: return RAPIDJSON_ERROR_STRING("Property did not match any of the sub-schemas specified by 'anyOf', refer to following errors."); + case kValidateErrorNot: return RAPIDJSON_ERROR_STRING("Property matched the sub-schema specified by 'not'."); + + default: return RAPIDJSON_ERROR_STRING("Unknown error."); + } +} + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_ERROR_EN_H_ diff --git a/libs/include/rapidjson/error/error.h b/libs/include/rapidjson/error/error.h new file mode 100644 index 0000000..6270da1 --- /dev/null +++ b/libs/include/rapidjson/error/error.h @@ -0,0 +1,216 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_ERROR_ERROR_H_ +#define RAPIDJSON_ERROR_ERROR_H_ + +#include "../rapidjson.h" + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +#endif + +/*! \file error.h */ + +/*! \defgroup RAPIDJSON_ERRORS RapidJSON error handling */ + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_ERROR_CHARTYPE + +//! Character type of error messages. +/*! \ingroup RAPIDJSON_ERRORS + The default character type is \c char. + On Windows, user can define this macro as \c TCHAR for supporting both + unicode/non-unicode settings. +*/ +#ifndef RAPIDJSON_ERROR_CHARTYPE +#define RAPIDJSON_ERROR_CHARTYPE char +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_ERROR_STRING + +//! Macro for converting string literial to \ref RAPIDJSON_ERROR_CHARTYPE[]. +/*! \ingroup RAPIDJSON_ERRORS + By default this conversion macro does nothing. + On Windows, user can define this macro as \c _T(x) for supporting both + unicode/non-unicode settings. +*/ +#ifndef RAPIDJSON_ERROR_STRING +#define RAPIDJSON_ERROR_STRING(x) x +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// ParseErrorCode + +//! Error code of parsing. +/*! \ingroup RAPIDJSON_ERRORS + \see GenericReader::Parse, GenericReader::GetParseErrorCode +*/ +enum ParseErrorCode { + kParseErrorNone = 0, //!< No error. + + kParseErrorDocumentEmpty, //!< The document is empty. + kParseErrorDocumentRootNotSingular, //!< The document root must not follow by other values. + + kParseErrorValueInvalid, //!< Invalid value. + + kParseErrorObjectMissName, //!< Missing a name for object member. + kParseErrorObjectMissColon, //!< Missing a colon after a name of object member. + kParseErrorObjectMissCommaOrCurlyBracket, //!< Missing a comma or '}' after an object member. + + kParseErrorArrayMissCommaOrSquareBracket, //!< Missing a comma or ']' after an array element. + + kParseErrorStringUnicodeEscapeInvalidHex, //!< Incorrect hex digit after \\u escape in string. + kParseErrorStringUnicodeSurrogateInvalid, //!< The surrogate pair in string is invalid. + kParseErrorStringEscapeInvalid, //!< Invalid escape character in string. + kParseErrorStringMissQuotationMark, //!< Missing a closing quotation mark in string. + kParseErrorStringInvalidEncoding, //!< Invalid encoding in string. + + kParseErrorNumberTooBig, //!< Number too big to be stored in double. + kParseErrorNumberMissFraction, //!< Miss fraction part in number. + kParseErrorNumberMissExponent, //!< Miss exponent in number. + + kParseErrorTermination, //!< Parsing was terminated. + kParseErrorUnspecificSyntaxError //!< Unspecific syntax error. +}; + +//! Result of parsing (wraps ParseErrorCode) +/*! + \ingroup RAPIDJSON_ERRORS + \code + Document doc; + ParseResult ok = doc.Parse("[42]"); + if (!ok) { + fprintf(stderr, "JSON parse error: %s (%u)", + GetParseError_En(ok.Code()), ok.Offset()); + exit(EXIT_FAILURE); + } + \endcode + \see GenericReader::Parse, GenericDocument::Parse +*/ +struct ParseResult { + //!! Unspecified boolean type + typedef bool (ParseResult::*BooleanType)() const; +public: + //! Default constructor, no error. + ParseResult() : code_(kParseErrorNone), offset_(0) {} + //! Constructor to set an error. + ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {} + + //! Get the error code. + ParseErrorCode Code() const { return code_; } + //! Get the error offset, if \ref IsError(), 0 otherwise. + size_t Offset() const { return offset_; } + + //! Explicit conversion to \c bool, returns \c true, iff !\ref IsError(). + operator BooleanType() const { return !IsError() ? &ParseResult::IsError : NULL; } + //! Whether the result is an error. + bool IsError() const { return code_ != kParseErrorNone; } + + bool operator==(const ParseResult& that) const { return code_ == that.code_; } + bool operator==(ParseErrorCode code) const { return code_ == code; } + friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; } + + bool operator!=(const ParseResult& that) const { return !(*this == that); } + bool operator!=(ParseErrorCode code) const { return !(*this == code); } + friend bool operator!=(ParseErrorCode code, const ParseResult & err) { return err != code; } + + //! Reset error code. + void Clear() { Set(kParseErrorNone); } + //! Update error code and offset. + void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; } + +private: + ParseErrorCode code_; + size_t offset_; +}; + +//! Function pointer type of GetParseError(). +/*! \ingroup RAPIDJSON_ERRORS + + This is the prototype for \c GetParseError_X(), where \c X is a locale. + User can dynamically change locale in runtime, e.g.: +\code + GetParseErrorFunc GetParseError = GetParseError_En; // or whatever + const RAPIDJSON_ERROR_CHARTYPE* s = GetParseError(document.GetParseErrorCode()); +\endcode +*/ +typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode); + +/////////////////////////////////////////////////////////////////////////////// +// ValidateErrorCode + +//! Error codes when validating. +/*! \ingroup RAPIDJSON_ERRORS + \see GenericSchemaValidator +*/ +enum ValidateErrorCode { + kValidateErrors = -1, //!< Top level error code when kValidateContinueOnErrorsFlag set. + kValidateErrorNone = 0, //!< No error. + + kValidateErrorMultipleOf, //!< Number is not a multiple of the 'multipleOf' value. + kValidateErrorMaximum, //!< Number is greater than the 'maximum' value. + kValidateErrorExclusiveMaximum, //!< Number is greater than or equal to the 'maximum' value. + kValidateErrorMinimum, //!< Number is less than the 'minimum' value. + kValidateErrorExclusiveMinimum, //!< Number is less than or equal to the 'minimum' value. + + kValidateErrorMaxLength, //!< String is longer than the 'maxLength' value. + kValidateErrorMinLength, //!< String is longer than the 'maxLength' value. + kValidateErrorPattern, //!< String does not match the 'pattern' regular expression. + + kValidateErrorMaxItems, //!< Array is longer than the 'maxItems' value. + kValidateErrorMinItems, //!< Array is shorter than the 'minItems' value. + kValidateErrorUniqueItems, //!< Array has duplicate items but 'uniqueItems' is true. + kValidateErrorAdditionalItems, //!< Array has additional items that are not allowed by the schema. + + kValidateErrorMaxProperties, //!< Object has more members than 'maxProperties' value. + kValidateErrorMinProperties, //!< Object has less members than 'minProperties' value. + kValidateErrorRequired, //!< Object is missing one or more members required by the schema. + kValidateErrorAdditionalProperties, //!< Object has additional members that are not allowed by the schema. + kValidateErrorPatternProperties, //!< See other errors. + kValidateErrorDependencies, //!< Object has missing property or schema dependencies. + + kValidateErrorEnum, //!< Property has a value that is not one of its allowed enumerated values + kValidateErrorType, //!< Property has a type that is not allowed by the schema.. + + kValidateErrorOneOf, //!< Property did not match any of the sub-schemas specified by 'oneOf'. + kValidateErrorOneOfMatch, //!< Property matched more than one of the sub-schemas specified by 'oneOf'. + kValidateErrorAllOf, //!< Property did not match all of the sub-schemas specified by 'allOf'. + kValidateErrorAnyOf, //!< Property did not match any of the sub-schemas specified by 'anyOf'. + kValidateErrorNot //!< Property matched the sub-schema specified by 'not'. +}; + +//! Function pointer type of GetValidateError(). +/*! \ingroup RAPIDJSON_ERRORS + + This is the prototype for \c GetValidateError_X(), where \c X is a locale. + User can dynamically change locale in runtime, e.g.: +\code + GetValidateErrorFunc GetValidateError = GetValidateError_En; // or whatever + const RAPIDJSON_ERROR_CHARTYPE* s = GetValidateError(validator.GetInvalidSchemaCode()); +\endcode +*/ +typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetValidateErrorFunc)(ValidateErrorCode); + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_ERROR_ERROR_H_ diff --git a/libs/include/rapidjson/filereadstream.h b/libs/include/rapidjson/filereadstream.h new file mode 100644 index 0000000..f8bb43c --- /dev/null +++ b/libs/include/rapidjson/filereadstream.h @@ -0,0 +1,99 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_FILEREADSTREAM_H_ +#define RAPIDJSON_FILEREADSTREAM_H_ + +#include "stream.h" +#include + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +RAPIDJSON_DIAG_OFF(unreachable-code) +RAPIDJSON_DIAG_OFF(missing-noreturn) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! File byte stream for input using fread(). +/*! + \note implements Stream concept +*/ +class FileReadStream { +public: + typedef char Ch; //!< Character type (byte). + + //! Constructor. + /*! + \param fp File pointer opened for read. + \param buffer user-supplied buffer. + \param bufferSize size of buffer in bytes. Must >=4 bytes. + */ + FileReadStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { + RAPIDJSON_ASSERT(fp_ != 0); + RAPIDJSON_ASSERT(bufferSize >= 4); + Read(); + } + + Ch Peek() const { return *current_; } + Ch Take() { Ch c = *current_; Read(); return c; } + size_t Tell() const { return count_ + static_cast(current_ - buffer_); } + + // Not implemented + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + + // For encoding detection only. + const Ch* Peek4() const { + return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0; + } + +private: + void Read() { + if (current_ < bufferLast_) + ++current_; + else if (!eof_) { + count_ += readCount_; + readCount_ = std::fread(buffer_, 1, bufferSize_, fp_); + bufferLast_ = buffer_ + readCount_ - 1; + current_ = buffer_; + + if (readCount_ < bufferSize_) { + buffer_[readCount_] = '\0'; + ++bufferLast_; + eof_ = true; + } + } + } + + std::FILE* fp_; + Ch *buffer_; + size_t bufferSize_; + Ch *bufferLast_; + Ch *current_; + size_t readCount_; + size_t count_; //!< Number of characters read + bool eof_; +}; + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_FILESTREAM_H_ diff --git a/libs/include/rapidjson/filewritestream.h b/libs/include/rapidjson/filewritestream.h new file mode 100644 index 0000000..5d89588 --- /dev/null +++ b/libs/include/rapidjson/filewritestream.h @@ -0,0 +1,104 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_FILEWRITESTREAM_H_ +#define RAPIDJSON_FILEWRITESTREAM_H_ + +#include "stream.h" +#include + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(unreachable-code) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Wrapper of C file stream for output using fwrite(). +/*! + \note implements Stream concept +*/ +class FileWriteStream { +public: + typedef char Ch; //!< Character type. Only support char. + + FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { + RAPIDJSON_ASSERT(fp_ != 0); + } + + void Put(char c) { + if (current_ >= bufferEnd_) + Flush(); + + *current_++ = c; + } + + void PutN(char c, size_t n) { + size_t avail = static_cast(bufferEnd_ - current_); + while (n > avail) { + std::memset(current_, c, avail); + current_ += avail; + Flush(); + n -= avail; + avail = static_cast(bufferEnd_ - current_); + } + + if (n > 0) { + std::memset(current_, c, n); + current_ += n; + } + } + + void Flush() { + if (current_ != buffer_) { + size_t result = std::fwrite(buffer_, 1, static_cast(current_ - buffer_), fp_); + if (result < static_cast(current_ - buffer_)) { + // failure deliberately ignored at this time + // added to avoid warn_unused_result build errors + } + current_ = buffer_; + } + } + + // Not implemented + char Peek() const { RAPIDJSON_ASSERT(false); return 0; } + char Take() { RAPIDJSON_ASSERT(false); return 0; } + size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; } + char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + // Prohibit copy constructor & assignment operator. + FileWriteStream(const FileWriteStream&); + FileWriteStream& operator=(const FileWriteStream&); + + std::FILE* fp_; + char *buffer_; + char *bufferEnd_; + char *current_; +}; + +//! Implement specialized version of PutN() with memset() for better performance. +template<> +inline void PutN(FileWriteStream& stream, char c, size_t n) { + stream.PutN(c, n); +} + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_FILESTREAM_H_ diff --git a/libs/include/rapidjson/fwd.h b/libs/include/rapidjson/fwd.h new file mode 100644 index 0000000..d62f77f --- /dev/null +++ b/libs/include/rapidjson/fwd.h @@ -0,0 +1,151 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_FWD_H_ +#define RAPIDJSON_FWD_H_ + +#include "rapidjson.h" + +RAPIDJSON_NAMESPACE_BEGIN + +// encodings.h + +template struct UTF8; +template struct UTF16; +template struct UTF16BE; +template struct UTF16LE; +template struct UTF32; +template struct UTF32BE; +template struct UTF32LE; +template struct ASCII; +template struct AutoUTF; + +template +struct Transcoder; + +// allocators.h + +class CrtAllocator; + +template +class MemoryPoolAllocator; + +// stream.h + +template +struct GenericStringStream; + +typedef GenericStringStream > StringStream; + +template +struct GenericInsituStringStream; + +typedef GenericInsituStringStream > InsituStringStream; + +// stringbuffer.h + +template +class GenericStringBuffer; + +typedef GenericStringBuffer, CrtAllocator> StringBuffer; + +// filereadstream.h + +class FileReadStream; + +// filewritestream.h + +class FileWriteStream; + +// memorybuffer.h + +template +struct GenericMemoryBuffer; + +typedef GenericMemoryBuffer MemoryBuffer; + +// memorystream.h + +struct MemoryStream; + +// reader.h + +template +struct BaseReaderHandler; + +template +class GenericReader; + +typedef GenericReader, UTF8, CrtAllocator> Reader; + +// writer.h + +template +class Writer; + +// prettywriter.h + +template +class PrettyWriter; + +// document.h + +template +class GenericMember; + +template +class GenericMemberIterator; + +template +struct GenericStringRef; + +template +class GenericValue; + +typedef GenericValue, MemoryPoolAllocator > Value; + +template +class GenericDocument; + +typedef GenericDocument, MemoryPoolAllocator, CrtAllocator> Document; + +// pointer.h + +template +class GenericPointer; + +typedef GenericPointer Pointer; + +// schema.h + +template +class IGenericRemoteSchemaDocumentProvider; + +template +class GenericSchemaDocument; + +typedef GenericSchemaDocument SchemaDocument; +typedef IGenericRemoteSchemaDocumentProvider IRemoteSchemaDocumentProvider; + +template < + typename SchemaDocumentType, + typename OutputHandler, + typename StateAllocator> +class GenericSchemaValidator; + +typedef GenericSchemaValidator, void>, CrtAllocator> SchemaValidator; + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_RAPIDJSONFWD_H_ diff --git a/libs/include/rapidjson/internal/biginteger.h b/libs/include/rapidjson/internal/biginteger.h new file mode 100644 index 0000000..1245578 --- /dev/null +++ b/libs/include/rapidjson/internal/biginteger.h @@ -0,0 +1,290 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_BIGINTEGER_H_ +#define RAPIDJSON_BIGINTEGER_H_ + +#include "../rapidjson.h" + +#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && defined(_M_AMD64) +#include // for _umul128 +#pragma intrinsic(_umul128) +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +class BigInteger { +public: + typedef uint64_t Type; + + BigInteger(const BigInteger& rhs) : count_(rhs.count_) { + std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type)); + } + + explicit BigInteger(uint64_t u) : count_(1) { + digits_[0] = u; + } + + BigInteger(const char* decimals, size_t length) : count_(1) { + RAPIDJSON_ASSERT(length > 0); + digits_[0] = 0; + size_t i = 0; + const size_t kMaxDigitPerIteration = 19; // 2^64 = 18446744073709551616 > 10^19 + while (length >= kMaxDigitPerIteration) { + AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration); + length -= kMaxDigitPerIteration; + i += kMaxDigitPerIteration; + } + + if (length > 0) + AppendDecimal64(decimals + i, decimals + i + length); + } + + BigInteger& operator=(const BigInteger &rhs) + { + if (this != &rhs) { + count_ = rhs.count_; + std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type)); + } + return *this; + } + + BigInteger& operator=(uint64_t u) { + digits_[0] = u; + count_ = 1; + return *this; + } + + BigInteger& operator+=(uint64_t u) { + Type backup = digits_[0]; + digits_[0] += u; + for (size_t i = 0; i < count_ - 1; i++) { + if (digits_[i] >= backup) + return *this; // no carry + backup = digits_[i + 1]; + digits_[i + 1] += 1; + } + + // Last carry + if (digits_[count_ - 1] < backup) + PushBack(1); + + return *this; + } + + BigInteger& operator*=(uint64_t u) { + if (u == 0) return *this = 0; + if (u == 1) return *this; + if (*this == 1) return *this = u; + + uint64_t k = 0; + for (size_t i = 0; i < count_; i++) { + uint64_t hi; + digits_[i] = MulAdd64(digits_[i], u, k, &hi); + k = hi; + } + + if (k > 0) + PushBack(k); + + return *this; + } + + BigInteger& operator*=(uint32_t u) { + if (u == 0) return *this = 0; + if (u == 1) return *this; + if (*this == 1) return *this = u; + + uint64_t k = 0; + for (size_t i = 0; i < count_; i++) { + const uint64_t c = digits_[i] >> 32; + const uint64_t d = digits_[i] & 0xFFFFFFFF; + const uint64_t uc = u * c; + const uint64_t ud = u * d; + const uint64_t p0 = ud + k; + const uint64_t p1 = uc + (p0 >> 32); + digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32); + k = p1 >> 32; + } + + if (k > 0) + PushBack(k); + + return *this; + } + + BigInteger& operator<<=(size_t shift) { + if (IsZero() || shift == 0) return *this; + + size_t offset = shift / kTypeBit; + size_t interShift = shift % kTypeBit; + RAPIDJSON_ASSERT(count_ + offset <= kCapacity); + + if (interShift == 0) { + std::memmove(digits_ + offset, digits_, count_ * sizeof(Type)); + count_ += offset; + } + else { + digits_[count_] = 0; + for (size_t i = count_; i > 0; i--) + digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift)); + digits_[offset] = digits_[0] << interShift; + count_ += offset; + if (digits_[count_]) + count_++; + } + + std::memset(digits_, 0, offset * sizeof(Type)); + + return *this; + } + + bool operator==(const BigInteger& rhs) const { + return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0; + } + + bool operator==(const Type rhs) const { + return count_ == 1 && digits_[0] == rhs; + } + + BigInteger& MultiplyPow5(unsigned exp) { + static const uint32_t kPow5[12] = { + 5, + 5 * 5, + 5 * 5 * 5, + 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5, + 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 + }; + if (exp == 0) return *this; + for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27 + for (; exp >= 13; exp -= 13) *this *= static_cast(1220703125u); // 5^13 + if (exp > 0) *this *= kPow5[exp - 1]; + return *this; + } + + // Compute absolute difference of this and rhs. + // Assume this != rhs + bool Difference(const BigInteger& rhs, BigInteger* out) const { + int cmp = Compare(rhs); + RAPIDJSON_ASSERT(cmp != 0); + const BigInteger *a, *b; // Makes a > b + bool ret; + if (cmp < 0) { a = &rhs; b = this; ret = true; } + else { a = this; b = &rhs; ret = false; } + + Type borrow = 0; + for (size_t i = 0; i < a->count_; i++) { + Type d = a->digits_[i] - borrow; + if (i < b->count_) + d -= b->digits_[i]; + borrow = (d > a->digits_[i]) ? 1 : 0; + out->digits_[i] = d; + if (d != 0) + out->count_ = i + 1; + } + + return ret; + } + + int Compare(const BigInteger& rhs) const { + if (count_ != rhs.count_) + return count_ < rhs.count_ ? -1 : 1; + + for (size_t i = count_; i-- > 0;) + if (digits_[i] != rhs.digits_[i]) + return digits_[i] < rhs.digits_[i] ? -1 : 1; + + return 0; + } + + size_t GetCount() const { return count_; } + Type GetDigit(size_t index) const { RAPIDJSON_ASSERT(index < count_); return digits_[index]; } + bool IsZero() const { return count_ == 1 && digits_[0] == 0; } + +private: + void AppendDecimal64(const char* begin, const char* end) { + uint64_t u = ParseUint64(begin, end); + if (IsZero()) + *this = u; + else { + unsigned exp = static_cast(end - begin); + (MultiplyPow5(exp) <<= exp) += u; // *this = *this * 10^exp + u + } + } + + void PushBack(Type digit) { + RAPIDJSON_ASSERT(count_ < kCapacity); + digits_[count_++] = digit; + } + + static uint64_t ParseUint64(const char* begin, const char* end) { + uint64_t r = 0; + for (const char* p = begin; p != end; ++p) { + RAPIDJSON_ASSERT(*p >= '0' && *p <= '9'); + r = r * 10u + static_cast(*p - '0'); + } + return r; + } + + // Assume a * b + k < 2^128 + static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t* outHigh) { +#if defined(_MSC_VER) && defined(_M_AMD64) + uint64_t low = _umul128(a, b, outHigh) + k; + if (low < k) + (*outHigh)++; + return low; +#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__) + __extension__ typedef unsigned __int128 uint128; + uint128 p = static_cast(a) * static_cast(b); + p += k; + *outHigh = static_cast(p >> 64); + return static_cast(p); +#else + const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32; + uint64_t x0 = a0 * b0, x1 = a0 * b1, x2 = a1 * b0, x3 = a1 * b1; + x1 += (x0 >> 32); // can't give carry + x1 += x2; + if (x1 < x2) + x3 += (static_cast(1) << 32); + uint64_t lo = (x1 << 32) + (x0 & 0xFFFFFFFF); + uint64_t hi = x3 + (x1 >> 32); + + lo += k; + if (lo < k) + hi++; + *outHigh = hi; + return lo; +#endif + } + + static const size_t kBitCount = 3328; // 64bit * 54 > 10^1000 + static const size_t kCapacity = kBitCount / sizeof(Type); + static const size_t kTypeBit = sizeof(Type) * 8; + + Type digits_[kCapacity]; + size_t count_; +}; + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_BIGINTEGER_H_ diff --git a/libs/include/rapidjson/internal/clzll.h b/libs/include/rapidjson/internal/clzll.h new file mode 100644 index 0000000..8fc5118 --- /dev/null +++ b/libs/include/rapidjson/internal/clzll.h @@ -0,0 +1,71 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_CLZLL_H_ +#define RAPIDJSON_CLZLL_H_ + +#include "../rapidjson.h" + +#if defined(_MSC_VER) && !defined(UNDER_CE) +#include +#if defined(_WIN64) +#pragma intrinsic(_BitScanReverse64) +#else +#pragma intrinsic(_BitScanReverse) +#endif +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +inline uint32_t clzll(uint64_t x) { + // Passing 0 to __builtin_clzll is UB in GCC and results in an + // infinite loop in the software implementation. + RAPIDJSON_ASSERT(x != 0); + +#if defined(_MSC_VER) && !defined(UNDER_CE) + unsigned long r = 0; +#if defined(_WIN64) + _BitScanReverse64(&r, x); +#else + // Scan the high 32 bits. + if (_BitScanReverse(&r, static_cast(x >> 32))) + return 63 - (r + 32); + + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x & 0xFFFFFFFF)); +#endif // _WIN64 + + return 63 - r; +#elif (defined(__GNUC__) && __GNUC__ >= 4) || RAPIDJSON_HAS_BUILTIN(__builtin_clzll) + // __builtin_clzll wrapper + return static_cast(__builtin_clzll(x)); +#else + // naive version + uint32_t r = 0; + while (!(x & (static_cast(1) << 63))) { + x <<= 1; + ++r; + } + + return r; +#endif // _MSC_VER +} + +#define RAPIDJSON_CLZLL RAPIDJSON_NAMESPACE::internal::clzll + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_CLZLL_H_ diff --git a/libs/include/rapidjson/internal/diyfp.h b/libs/include/rapidjson/internal/diyfp.h new file mode 100644 index 0000000..a40797e --- /dev/null +++ b/libs/include/rapidjson/internal/diyfp.h @@ -0,0 +1,257 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +// This is a C++ header-only implementation of Grisu2 algorithm from the publication: +// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with +// integers." ACM Sigplan Notices 45.6 (2010): 233-243. + +#ifndef RAPIDJSON_DIYFP_H_ +#define RAPIDJSON_DIYFP_H_ + +#include "../rapidjson.h" +#include "clzll.h" +#include + +#if defined(_MSC_VER) && defined(_M_AMD64) && !defined(__INTEL_COMPILER) +#include +#pragma intrinsic(_umul128) +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +#endif + +struct DiyFp { + DiyFp() : f(), e() {} + + DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {} + + explicit DiyFp(double d) { + union { + double d; + uint64_t u64; + } u = { d }; + + int biased_e = static_cast((u.u64 & kDpExponentMask) >> kDpSignificandSize); + uint64_t significand = (u.u64 & kDpSignificandMask); + if (biased_e != 0) { + f = significand + kDpHiddenBit; + e = biased_e - kDpExponentBias; + } + else { + f = significand; + e = kDpMinExponent + 1; + } + } + + DiyFp operator-(const DiyFp& rhs) const { + return DiyFp(f - rhs.f, e); + } + + DiyFp operator*(const DiyFp& rhs) const { +#if defined(_MSC_VER) && defined(_M_AMD64) + uint64_t h; + uint64_t l = _umul128(f, rhs.f, &h); + if (l & (uint64_t(1) << 63)) // rounding + h++; + return DiyFp(h, e + rhs.e + 64); +#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__) + __extension__ typedef unsigned __int128 uint128; + uint128 p = static_cast(f) * static_cast(rhs.f); + uint64_t h = static_cast(p >> 64); + uint64_t l = static_cast(p); + if (l & (uint64_t(1) << 63)) // rounding + h++; + return DiyFp(h, e + rhs.e + 64); +#else + const uint64_t M32 = 0xFFFFFFFF; + const uint64_t a = f >> 32; + const uint64_t b = f & M32; + const uint64_t c = rhs.f >> 32; + const uint64_t d = rhs.f & M32; + const uint64_t ac = a * c; + const uint64_t bc = b * c; + const uint64_t ad = a * d; + const uint64_t bd = b * d; + uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32); + tmp += 1U << 31; /// mult_round + return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64); +#endif + } + + DiyFp Normalize() const { + int s = static_cast(clzll(f)); + return DiyFp(f << s, e - s); + } + + DiyFp NormalizeBoundary() const { + DiyFp res = *this; + while (!(res.f & (kDpHiddenBit << 1))) { + res.f <<= 1; + res.e--; + } + res.f <<= (kDiySignificandSize - kDpSignificandSize - 2); + res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2); + return res; + } + + void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const { + DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary(); + DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1); + mi.f <<= mi.e - pl.e; + mi.e = pl.e; + *plus = pl; + *minus = mi; + } + + double ToDouble() const { + union { + double d; + uint64_t u64; + }u; + RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask); + if (e < kDpDenormalExponent) { + // Underflow. + return 0.0; + } + if (e >= kDpMaxExponent) { + // Overflow. + return std::numeric_limits::infinity(); + } + const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 : + static_cast(e + kDpExponentBias); + u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize); + return u.d; + } + + static const int kDiySignificandSize = 64; + static const int kDpSignificandSize = 52; + static const int kDpExponentBias = 0x3FF + kDpSignificandSize; + static const int kDpMaxExponent = 0x7FF - kDpExponentBias; + static const int kDpMinExponent = -kDpExponentBias; + static const int kDpDenormalExponent = -kDpExponentBias + 1; + static const uint64_t kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000); + static const uint64_t kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF); + static const uint64_t kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000); + + uint64_t f; + int e; +}; + +inline DiyFp GetCachedPowerByIndex(size_t index) { + // 10^-348, 10^-340, ..., 10^340 + static const uint64_t kCachedPowers_F[] = { + RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76), + RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea), + RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df), + RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f), + RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c), + RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5), + RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d), + RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637), + RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7), + RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5), + RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b), + RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996), + RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6), + RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8), + RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053), + RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd), + RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94), + RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b), + RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac), + RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3), + RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb), + RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c), + RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000), + RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984), + RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70), + RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245), + RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8), + RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a), + RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea), + RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85), + RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2), + RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3), + RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25), + RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece), + RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5), + RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a), + RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c), + RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a), + RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129), + RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429), + RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d), + RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841), + RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9), + RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b) + }; + static const int16_t kCachedPowers_E[] = { + -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, + -954, -927, -901, -874, -847, -821, -794, -768, -741, -715, + -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, + -422, -396, -369, -343, -316, -289, -263, -236, -210, -183, + -157, -130, -103, -77, -50, -24, 3, 30, 56, 83, + 109, 136, 162, 189, 216, 242, 269, 295, 322, 348, + 375, 402, 428, 455, 481, 508, 534, 561, 588, 614, + 641, 667, 694, 720, 747, 774, 800, 827, 853, 880, + 907, 933, 960, 986, 1013, 1039, 1066 + }; + RAPIDJSON_ASSERT(index < 87); + return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]); +} + +inline DiyFp GetCachedPower(int e, int* K) { + + //int k = static_cast(ceil((-61 - e) * 0.30102999566398114)) + 374; + double dk = (-61 - e) * 0.30102999566398114 + 347; // dk must be positive, so can do ceiling in positive + int k = static_cast(dk); + if (dk - k > 0.0) + k++; + + unsigned index = static_cast((k >> 3) + 1); + *K = -(-348 + static_cast(index << 3)); // decimal exponent no need lookup table + + return GetCachedPowerByIndex(index); +} + +inline DiyFp GetCachedPower10(int exp, int *outExp) { + RAPIDJSON_ASSERT(exp >= -348); + unsigned index = static_cast(exp + 348) / 8u; + *outExp = -348 + static_cast(index) * 8; + return GetCachedPowerByIndex(index); +} + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +RAPIDJSON_DIAG_OFF(padded) +#endif + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_DIYFP_H_ diff --git a/libs/include/rapidjson/internal/dtoa.h b/libs/include/rapidjson/internal/dtoa.h new file mode 100644 index 0000000..621402f --- /dev/null +++ b/libs/include/rapidjson/internal/dtoa.h @@ -0,0 +1,245 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +// This is a C++ header-only implementation of Grisu2 algorithm from the publication: +// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with +// integers." ACM Sigplan Notices 45.6 (2010): 233-243. + +#ifndef RAPIDJSON_DTOA_ +#define RAPIDJSON_DTOA_ + +#include "itoa.h" // GetDigitsLut() +#include "diyfp.h" +#include "ieee754.h" + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +RAPIDJSON_DIAG_OFF(array-bounds) // some gcc versions generate wrong warnings https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124 +#endif + +inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) { + while (rest < wp_w && delta - rest >= ten_kappa && + (rest + ten_kappa < wp_w || /// closer + wp_w - rest > rest + ten_kappa - wp_w)) { + buffer[len - 1]--; + rest += ten_kappa; + } +} + +inline int CountDecimalDigit32(uint32_t n) { + // Simple pure C++ implementation was faster than __builtin_clz version in this situation. + if (n < 10) return 1; + if (n < 100) return 2; + if (n < 1000) return 3; + if (n < 10000) return 4; + if (n < 100000) return 5; + if (n < 1000000) return 6; + if (n < 10000000) return 7; + if (n < 100000000) return 8; + // Will not reach 10 digits in DigitGen() + //if (n < 1000000000) return 9; + //return 10; + return 9; +} + +inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) { + static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 }; + const DiyFp one(uint64_t(1) << -Mp.e, Mp.e); + const DiyFp wp_w = Mp - W; + uint32_t p1 = static_cast(Mp.f >> -one.e); + uint64_t p2 = Mp.f & (one.f - 1); + int kappa = CountDecimalDigit32(p1); // kappa in [0, 9] + *len = 0; + + while (kappa > 0) { + uint32_t d = 0; + switch (kappa) { + case 9: d = p1 / 100000000; p1 %= 100000000; break; + case 8: d = p1 / 10000000; p1 %= 10000000; break; + case 7: d = p1 / 1000000; p1 %= 1000000; break; + case 6: d = p1 / 100000; p1 %= 100000; break; + case 5: d = p1 / 10000; p1 %= 10000; break; + case 4: d = p1 / 1000; p1 %= 1000; break; + case 3: d = p1 / 100; p1 %= 100; break; + case 2: d = p1 / 10; p1 %= 10; break; + case 1: d = p1; p1 = 0; break; + default:; + } + if (d || *len) + buffer[(*len)++] = static_cast('0' + static_cast(d)); + kappa--; + uint64_t tmp = (static_cast(p1) << -one.e) + p2; + if (tmp <= delta) { + *K += kappa; + GrisuRound(buffer, *len, delta, tmp, static_cast(kPow10[kappa]) << -one.e, wp_w.f); + return; + } + } + + // kappa = 0 + for (;;) { + p2 *= 10; + delta *= 10; + char d = static_cast(p2 >> -one.e); + if (d || *len) + buffer[(*len)++] = static_cast('0' + d); + p2 &= one.f - 1; + kappa--; + if (p2 < delta) { + *K += kappa; + int index = -kappa; + GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 9 ? kPow10[index] : 0)); + return; + } + } +} + +inline void Grisu2(double value, char* buffer, int* length, int* K) { + const DiyFp v(value); + DiyFp w_m, w_p; + v.NormalizedBoundaries(&w_m, &w_p); + + const DiyFp c_mk = GetCachedPower(w_p.e, K); + const DiyFp W = v.Normalize() * c_mk; + DiyFp Wp = w_p * c_mk; + DiyFp Wm = w_m * c_mk; + Wm.f++; + Wp.f--; + DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K); +} + +inline char* WriteExponent(int K, char* buffer) { + if (K < 0) { + *buffer++ = '-'; + K = -K; + } + + if (K >= 100) { + *buffer++ = static_cast('0' + static_cast(K / 100)); + K %= 100; + const char* d = GetDigitsLut() + K * 2; + *buffer++ = d[0]; + *buffer++ = d[1]; + } + else if (K >= 10) { + const char* d = GetDigitsLut() + K * 2; + *buffer++ = d[0]; + *buffer++ = d[1]; + } + else + *buffer++ = static_cast('0' + static_cast(K)); + + return buffer; +} + +inline char* Prettify(char* buffer, int length, int k, int maxDecimalPlaces) { + const int kk = length + k; // 10^(kk-1) <= v < 10^kk + + if (0 <= k && kk <= 21) { + // 1234e7 -> 12340000000 + for (int i = length; i < kk; i++) + buffer[i] = '0'; + buffer[kk] = '.'; + buffer[kk + 1] = '0'; + return &buffer[kk + 2]; + } + else if (0 < kk && kk <= 21) { + // 1234e-2 -> 12.34 + std::memmove(&buffer[kk + 1], &buffer[kk], static_cast(length - kk)); + buffer[kk] = '.'; + if (0 > k + maxDecimalPlaces) { + // When maxDecimalPlaces = 2, 1.2345 -> 1.23, 1.102 -> 1.1 + // Remove extra trailing zeros (at least one) after truncation. + for (int i = kk + maxDecimalPlaces; i > kk + 1; i--) + if (buffer[i] != '0') + return &buffer[i + 1]; + return &buffer[kk + 2]; // Reserve one zero + } + else + return &buffer[length + 1]; + } + else if (-6 < kk && kk <= 0) { + // 1234e-6 -> 0.001234 + const int offset = 2 - kk; + std::memmove(&buffer[offset], &buffer[0], static_cast(length)); + buffer[0] = '0'; + buffer[1] = '.'; + for (int i = 2; i < offset; i++) + buffer[i] = '0'; + if (length - kk > maxDecimalPlaces) { + // When maxDecimalPlaces = 2, 0.123 -> 0.12, 0.102 -> 0.1 + // Remove extra trailing zeros (at least one) after truncation. + for (int i = maxDecimalPlaces + 1; i > 2; i--) + if (buffer[i] != '0') + return &buffer[i + 1]; + return &buffer[3]; // Reserve one zero + } + else + return &buffer[length + offset]; + } + else if (kk < -maxDecimalPlaces) { + // Truncate to zero + buffer[0] = '0'; + buffer[1] = '.'; + buffer[2] = '0'; + return &buffer[3]; + } + else if (length == 1) { + // 1e30 + buffer[1] = 'e'; + return WriteExponent(kk - 1, &buffer[2]); + } + else { + // 1234e30 -> 1.234e33 + std::memmove(&buffer[2], &buffer[1], static_cast(length - 1)); + buffer[1] = '.'; + buffer[length + 1] = 'e'; + return WriteExponent(kk - 1, &buffer[0 + length + 2]); + } +} + +inline char* dtoa(double value, char* buffer, int maxDecimalPlaces = 324) { + RAPIDJSON_ASSERT(maxDecimalPlaces >= 1); + Double d(value); + if (d.IsZero()) { + if (d.Sign()) + *buffer++ = '-'; // -0.0, Issue #289 + buffer[0] = '0'; + buffer[1] = '.'; + buffer[2] = '0'; + return &buffer[3]; + } + else { + if (value < 0) { + *buffer++ = '-'; + value = -value; + } + int length, K; + Grisu2(value, buffer, &length, &K); + return Prettify(buffer, length, K, maxDecimalPlaces); + } +} + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_DTOA_ diff --git a/libs/include/rapidjson/internal/ieee754.h b/libs/include/rapidjson/internal/ieee754.h new file mode 100644 index 0000000..68c9e96 --- /dev/null +++ b/libs/include/rapidjson/internal/ieee754.h @@ -0,0 +1,78 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_IEEE754_ +#define RAPIDJSON_IEEE754_ + +#include "../rapidjson.h" + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +class Double { +public: + Double() {} + Double(double d) : d_(d) {} + Double(uint64_t u) : u_(u) {} + + double Value() const { return d_; } + uint64_t Uint64Value() const { return u_; } + + double NextPositiveDouble() const { + RAPIDJSON_ASSERT(!Sign()); + return Double(u_ + 1).Value(); + } + + bool Sign() const { return (u_ & kSignMask) != 0; } + uint64_t Significand() const { return u_ & kSignificandMask; } + int Exponent() const { return static_cast(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); } + + bool IsNan() const { return (u_ & kExponentMask) == kExponentMask && Significand() != 0; } + bool IsInf() const { return (u_ & kExponentMask) == kExponentMask && Significand() == 0; } + bool IsNanOrInf() const { return (u_ & kExponentMask) == kExponentMask; } + bool IsNormal() const { return (u_ & kExponentMask) != 0 || Significand() == 0; } + bool IsZero() const { return (u_ & (kExponentMask | kSignificandMask)) == 0; } + + uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); } + int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; } + uint64_t ToBias() const { return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask; } + + static int EffectiveSignificandSize(int order) { + if (order >= -1021) + return 53; + else if (order <= -1074) + return 0; + else + return order + 1074; + } + +private: + static const int kSignificandSize = 52; + static const int kExponentBias = 0x3FF; + static const int kDenormalExponent = 1 - kExponentBias; + static const uint64_t kSignMask = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000); + static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000); + static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF); + static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000); + + union { + double d_; + uint64_t u_; + }; +}; + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_IEEE754_ diff --git a/libs/include/rapidjson/internal/itoa.h b/libs/include/rapidjson/internal/itoa.h new file mode 100644 index 0000000..9fe8c93 --- /dev/null +++ b/libs/include/rapidjson/internal/itoa.h @@ -0,0 +1,308 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_ITOA_ +#define RAPIDJSON_ITOA_ + +#include "../rapidjson.h" + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +inline const char* GetDigitsLut() { + static const char cDigitsLut[200] = { + '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9', + '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9', + '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9', + '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9', + '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9', + '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9', + '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9', + '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9', + '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9', + '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9' + }; + return cDigitsLut; +} + +inline char* u32toa(uint32_t value, char* buffer) { + RAPIDJSON_ASSERT(buffer != 0); + + const char* cDigitsLut = GetDigitsLut(); + + if (value < 10000) { + const uint32_t d1 = (value / 100) << 1; + const uint32_t d2 = (value % 100) << 1; + + if (value >= 1000) + *buffer++ = cDigitsLut[d1]; + if (value >= 100) + *buffer++ = cDigitsLut[d1 + 1]; + if (value >= 10) + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + } + else if (value < 100000000) { + // value = bbbbcccc + const uint32_t b = value / 10000; + const uint32_t c = value % 10000; + + const uint32_t d1 = (b / 100) << 1; + const uint32_t d2 = (b % 100) << 1; + + const uint32_t d3 = (c / 100) << 1; + const uint32_t d4 = (c % 100) << 1; + + if (value >= 10000000) + *buffer++ = cDigitsLut[d1]; + if (value >= 1000000) + *buffer++ = cDigitsLut[d1 + 1]; + if (value >= 100000) + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + + *buffer++ = cDigitsLut[d3]; + *buffer++ = cDigitsLut[d3 + 1]; + *buffer++ = cDigitsLut[d4]; + *buffer++ = cDigitsLut[d4 + 1]; + } + else { + // value = aabbbbcccc in decimal + + const uint32_t a = value / 100000000; // 1 to 42 + value %= 100000000; + + if (a >= 10) { + const unsigned i = a << 1; + *buffer++ = cDigitsLut[i]; + *buffer++ = cDigitsLut[i + 1]; + } + else + *buffer++ = static_cast('0' + static_cast(a)); + + const uint32_t b = value / 10000; // 0 to 9999 + const uint32_t c = value % 10000; // 0 to 9999 + + const uint32_t d1 = (b / 100) << 1; + const uint32_t d2 = (b % 100) << 1; + + const uint32_t d3 = (c / 100) << 1; + const uint32_t d4 = (c % 100) << 1; + + *buffer++ = cDigitsLut[d1]; + *buffer++ = cDigitsLut[d1 + 1]; + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + *buffer++ = cDigitsLut[d3]; + *buffer++ = cDigitsLut[d3 + 1]; + *buffer++ = cDigitsLut[d4]; + *buffer++ = cDigitsLut[d4 + 1]; + } + return buffer; +} + +inline char* i32toa(int32_t value, char* buffer) { + RAPIDJSON_ASSERT(buffer != 0); + uint32_t u = static_cast(value); + if (value < 0) { + *buffer++ = '-'; + u = ~u + 1; + } + + return u32toa(u, buffer); +} + +inline char* u64toa(uint64_t value, char* buffer) { + RAPIDJSON_ASSERT(buffer != 0); + const char* cDigitsLut = GetDigitsLut(); + const uint64_t kTen8 = 100000000; + const uint64_t kTen9 = kTen8 * 10; + const uint64_t kTen10 = kTen8 * 100; + const uint64_t kTen11 = kTen8 * 1000; + const uint64_t kTen12 = kTen8 * 10000; + const uint64_t kTen13 = kTen8 * 100000; + const uint64_t kTen14 = kTen8 * 1000000; + const uint64_t kTen15 = kTen8 * 10000000; + const uint64_t kTen16 = kTen8 * kTen8; + + if (value < kTen8) { + uint32_t v = static_cast(value); + if (v < 10000) { + const uint32_t d1 = (v / 100) << 1; + const uint32_t d2 = (v % 100) << 1; + + if (v >= 1000) + *buffer++ = cDigitsLut[d1]; + if (v >= 100) + *buffer++ = cDigitsLut[d1 + 1]; + if (v >= 10) + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + } + else { + // value = bbbbcccc + const uint32_t b = v / 10000; + const uint32_t c = v % 10000; + + const uint32_t d1 = (b / 100) << 1; + const uint32_t d2 = (b % 100) << 1; + + const uint32_t d3 = (c / 100) << 1; + const uint32_t d4 = (c % 100) << 1; + + if (value >= 10000000) + *buffer++ = cDigitsLut[d1]; + if (value >= 1000000) + *buffer++ = cDigitsLut[d1 + 1]; + if (value >= 100000) + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + + *buffer++ = cDigitsLut[d3]; + *buffer++ = cDigitsLut[d3 + 1]; + *buffer++ = cDigitsLut[d4]; + *buffer++ = cDigitsLut[d4 + 1]; + } + } + else if (value < kTen16) { + const uint32_t v0 = static_cast(value / kTen8); + const uint32_t v1 = static_cast(value % kTen8); + + const uint32_t b0 = v0 / 10000; + const uint32_t c0 = v0 % 10000; + + const uint32_t d1 = (b0 / 100) << 1; + const uint32_t d2 = (b0 % 100) << 1; + + const uint32_t d3 = (c0 / 100) << 1; + const uint32_t d4 = (c0 % 100) << 1; + + const uint32_t b1 = v1 / 10000; + const uint32_t c1 = v1 % 10000; + + const uint32_t d5 = (b1 / 100) << 1; + const uint32_t d6 = (b1 % 100) << 1; + + const uint32_t d7 = (c1 / 100) << 1; + const uint32_t d8 = (c1 % 100) << 1; + + if (value >= kTen15) + *buffer++ = cDigitsLut[d1]; + if (value >= kTen14) + *buffer++ = cDigitsLut[d1 + 1]; + if (value >= kTen13) + *buffer++ = cDigitsLut[d2]; + if (value >= kTen12) + *buffer++ = cDigitsLut[d2 + 1]; + if (value >= kTen11) + *buffer++ = cDigitsLut[d3]; + if (value >= kTen10) + *buffer++ = cDigitsLut[d3 + 1]; + if (value >= kTen9) + *buffer++ = cDigitsLut[d4]; + + *buffer++ = cDigitsLut[d4 + 1]; + *buffer++ = cDigitsLut[d5]; + *buffer++ = cDigitsLut[d5 + 1]; + *buffer++ = cDigitsLut[d6]; + *buffer++ = cDigitsLut[d6 + 1]; + *buffer++ = cDigitsLut[d7]; + *buffer++ = cDigitsLut[d7 + 1]; + *buffer++ = cDigitsLut[d8]; + *buffer++ = cDigitsLut[d8 + 1]; + } + else { + const uint32_t a = static_cast(value / kTen16); // 1 to 1844 + value %= kTen16; + + if (a < 10) + *buffer++ = static_cast('0' + static_cast(a)); + else if (a < 100) { + const uint32_t i = a << 1; + *buffer++ = cDigitsLut[i]; + *buffer++ = cDigitsLut[i + 1]; + } + else if (a < 1000) { + *buffer++ = static_cast('0' + static_cast(a / 100)); + + const uint32_t i = (a % 100) << 1; + *buffer++ = cDigitsLut[i]; + *buffer++ = cDigitsLut[i + 1]; + } + else { + const uint32_t i = (a / 100) << 1; + const uint32_t j = (a % 100) << 1; + *buffer++ = cDigitsLut[i]; + *buffer++ = cDigitsLut[i + 1]; + *buffer++ = cDigitsLut[j]; + *buffer++ = cDigitsLut[j + 1]; + } + + const uint32_t v0 = static_cast(value / kTen8); + const uint32_t v1 = static_cast(value % kTen8); + + const uint32_t b0 = v0 / 10000; + const uint32_t c0 = v0 % 10000; + + const uint32_t d1 = (b0 / 100) << 1; + const uint32_t d2 = (b0 % 100) << 1; + + const uint32_t d3 = (c0 / 100) << 1; + const uint32_t d4 = (c0 % 100) << 1; + + const uint32_t b1 = v1 / 10000; + const uint32_t c1 = v1 % 10000; + + const uint32_t d5 = (b1 / 100) << 1; + const uint32_t d6 = (b1 % 100) << 1; + + const uint32_t d7 = (c1 / 100) << 1; + const uint32_t d8 = (c1 % 100) << 1; + + *buffer++ = cDigitsLut[d1]; + *buffer++ = cDigitsLut[d1 + 1]; + *buffer++ = cDigitsLut[d2]; + *buffer++ = cDigitsLut[d2 + 1]; + *buffer++ = cDigitsLut[d3]; + *buffer++ = cDigitsLut[d3 + 1]; + *buffer++ = cDigitsLut[d4]; + *buffer++ = cDigitsLut[d4 + 1]; + *buffer++ = cDigitsLut[d5]; + *buffer++ = cDigitsLut[d5 + 1]; + *buffer++ = cDigitsLut[d6]; + *buffer++ = cDigitsLut[d6 + 1]; + *buffer++ = cDigitsLut[d7]; + *buffer++ = cDigitsLut[d7 + 1]; + *buffer++ = cDigitsLut[d8]; + *buffer++ = cDigitsLut[d8 + 1]; + } + + return buffer; +} + +inline char* i64toa(int64_t value, char* buffer) { + RAPIDJSON_ASSERT(buffer != 0); + uint64_t u = static_cast(value); + if (value < 0) { + *buffer++ = '-'; + u = ~u + 1; + } + + return u64toa(u, buffer); +} + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_ITOA_ diff --git a/libs/include/rapidjson/internal/meta.h b/libs/include/rapidjson/internal/meta.h new file mode 100644 index 0000000..27092dc --- /dev/null +++ b/libs/include/rapidjson/internal/meta.h @@ -0,0 +1,186 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_INTERNAL_META_H_ +#define RAPIDJSON_INTERNAL_META_H_ + +#include "../rapidjson.h" + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#if defined(_MSC_VER) && !defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(6334) +#endif + +#if RAPIDJSON_HAS_CXX11_TYPETRAITS +#include +#endif + +//@cond RAPIDJSON_INTERNAL +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +// Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching +template struct Void { typedef void Type; }; + +/////////////////////////////////////////////////////////////////////////////// +// BoolType, TrueType, FalseType +// +template struct BoolType { + static const bool Value = Cond; + typedef BoolType Type; +}; +typedef BoolType TrueType; +typedef BoolType FalseType; + + +/////////////////////////////////////////////////////////////////////////////// +// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr +// + +template struct SelectIfImpl { template struct Apply { typedef T1 Type; }; }; +template <> struct SelectIfImpl { template struct Apply { typedef T2 Type; }; }; +template struct SelectIfCond : SelectIfImpl::template Apply {}; +template struct SelectIf : SelectIfCond {}; + +template struct AndExprCond : FalseType {}; +template <> struct AndExprCond : TrueType {}; +template struct OrExprCond : TrueType {}; +template <> struct OrExprCond : FalseType {}; + +template struct BoolExpr : SelectIf::Type {}; +template struct NotExpr : SelectIf::Type {}; +template struct AndExpr : AndExprCond::Type {}; +template struct OrExpr : OrExprCond::Type {}; + + +/////////////////////////////////////////////////////////////////////////////// +// AddConst, MaybeAddConst, RemoveConst +template struct AddConst { typedef const T Type; }; +template struct MaybeAddConst : SelectIfCond {}; +template struct RemoveConst { typedef T Type; }; +template struct RemoveConst { typedef T Type; }; + + +/////////////////////////////////////////////////////////////////////////////// +// IsSame, IsConst, IsMoreConst, IsPointer +// +template struct IsSame : FalseType {}; +template struct IsSame : TrueType {}; + +template struct IsConst : FalseType {}; +template struct IsConst : TrueType {}; + +template +struct IsMoreConst + : AndExpr::Type, typename RemoveConst::Type>, + BoolType::Value >= IsConst::Value> >::Type {}; + +template struct IsPointer : FalseType {}; +template struct IsPointer : TrueType {}; + +/////////////////////////////////////////////////////////////////////////////// +// IsBaseOf +// +#if RAPIDJSON_HAS_CXX11_TYPETRAITS + +template struct IsBaseOf + : BoolType< ::std::is_base_of::value> {}; + +#else // simplified version adopted from Boost + +template struct IsBaseOfImpl { + RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0); + RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0); + + typedef char (&Yes)[1]; + typedef char (&No) [2]; + + template + static Yes Check(const D*, T); + static No Check(const B*, int); + + struct Host { + operator const B*() const; + operator const D*(); + }; + + enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) }; +}; + +template struct IsBaseOf + : OrExpr, BoolExpr > >::Type {}; + +#endif // RAPIDJSON_HAS_CXX11_TYPETRAITS + + +////////////////////////////////////////////////////////////////////////// +// EnableIf / DisableIf +// +template struct EnableIfCond { typedef T Type; }; +template struct EnableIfCond { /* empty */ }; + +template struct DisableIfCond { typedef T Type; }; +template struct DisableIfCond { /* empty */ }; + +template +struct EnableIf : EnableIfCond {}; + +template +struct DisableIf : DisableIfCond {}; + +// SFINAE helpers +struct SfinaeTag {}; +template struct RemoveSfinaeTag; +template struct RemoveSfinaeTag { typedef T Type; }; + +#define RAPIDJSON_REMOVEFPTR_(type) \ + typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \ + < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type + +#define RAPIDJSON_ENABLEIF(cond) \ + typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \ + ::Type * = NULL + +#define RAPIDJSON_DISABLEIF(cond) \ + typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \ + ::Type * = NULL + +#define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \ + typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \ + ::Type + +#define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \ + typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \ + ::Type + +} // namespace internal +RAPIDJSON_NAMESPACE_END +//@endcond + +#if defined(_MSC_VER) && !defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_INTERNAL_META_H_ diff --git a/libs/include/rapidjson/internal/pow10.h b/libs/include/rapidjson/internal/pow10.h new file mode 100644 index 0000000..eae1a43 --- /dev/null +++ b/libs/include/rapidjson/internal/pow10.h @@ -0,0 +1,55 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_POW10_ +#define RAPIDJSON_POW10_ + +#include "../rapidjson.h" + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +//! Computes integer powers of 10 in double (10.0^n). +/*! This function uses lookup table for fast and accurate results. + \param n non-negative exponent. Must <= 308. + \return 10.0^n +*/ +inline double Pow10(int n) { + static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes + 1e+0, + 1e+1, 1e+2, 1e+3, 1e+4, 1e+5, 1e+6, 1e+7, 1e+8, 1e+9, 1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, + 1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40, + 1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60, + 1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80, + 1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100, + 1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120, + 1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140, + 1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160, + 1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180, + 1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200, + 1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220, + 1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240, + 1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260, + 1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280, + 1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300, + 1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308 + }; + RAPIDJSON_ASSERT(n >= 0 && n <= 308); + return e[n]; +} + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_POW10_ diff --git a/libs/include/rapidjson/internal/regex.h b/libs/include/rapidjson/internal/regex.h new file mode 100644 index 0000000..6446c40 --- /dev/null +++ b/libs/include/rapidjson/internal/regex.h @@ -0,0 +1,739 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_INTERNAL_REGEX_H_ +#define RAPIDJSON_INTERNAL_REGEX_H_ + +#include "../allocators.h" +#include "../stream.h" +#include "stack.h" + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +RAPIDJSON_DIAG_OFF(switch-enum) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#ifndef RAPIDJSON_REGEX_VERBOSE +#define RAPIDJSON_REGEX_VERBOSE 0 +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +/////////////////////////////////////////////////////////////////////////////// +// DecodedStream + +template +class DecodedStream { +public: + DecodedStream(SourceStream& ss) : ss_(ss), codepoint_() { Decode(); } + unsigned Peek() { return codepoint_; } + unsigned Take() { + unsigned c = codepoint_; + if (c) // No further decoding when '\0' + Decode(); + return c; + } + +private: + void Decode() { + if (!Encoding::Decode(ss_, &codepoint_)) + codepoint_ = 0; + } + + SourceStream& ss_; + unsigned codepoint_; +}; + +/////////////////////////////////////////////////////////////////////////////// +// GenericRegex + +static const SizeType kRegexInvalidState = ~SizeType(0); //!< Represents an invalid index in GenericRegex::State::out, out1 +static const SizeType kRegexInvalidRange = ~SizeType(0); + +template +class GenericRegexSearch; + +//! Regular expression engine with subset of ECMAscript grammar. +/*! + Supported regular expression syntax: + - \c ab Concatenation + - \c a|b Alternation + - \c a? Zero or one + - \c a* Zero or more + - \c a+ One or more + - \c a{3} Exactly 3 times + - \c a{3,} At least 3 times + - \c a{3,5} 3 to 5 times + - \c (ab) Grouping + - \c ^a At the beginning + - \c a$ At the end + - \c . Any character + - \c [abc] Character classes + - \c [a-c] Character class range + - \c [a-z0-9_] Character class combination + - \c [^abc] Negated character classes + - \c [^a-c] Negated character class range + - \c [\b] Backspace (U+0008) + - \c \\| \\\\ ... Escape characters + - \c \\f Form feed (U+000C) + - \c \\n Line feed (U+000A) + - \c \\r Carriage return (U+000D) + - \c \\t Tab (U+0009) + - \c \\v Vertical tab (U+000B) + + \note This is a Thompson NFA engine, implemented with reference to + Cox, Russ. "Regular Expression Matching Can Be Simple And Fast (but is slow in Java, Perl, PHP, Python, Ruby,...).", + https://swtch.com/~rsc/regexp/regexp1.html +*/ +template +class GenericRegex { +public: + typedef Encoding EncodingType; + typedef typename Encoding::Ch Ch; + template friend class GenericRegexSearch; + + GenericRegex(const Ch* source, Allocator* allocator = 0) : + ownAllocator_(allocator ? 0 : RAPIDJSON_NEW(Allocator)()), allocator_(allocator ? allocator : ownAllocator_), + states_(allocator_, 256), ranges_(allocator_, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(), + anchorBegin_(), anchorEnd_() + { + GenericStringStream ss(source); + DecodedStream, Encoding> ds(ss); + Parse(ds); + } + + ~GenericRegex() + { + RAPIDJSON_DELETE(ownAllocator_); + } + + bool IsValid() const { + return root_ != kRegexInvalidState; + } + +private: + enum Operator { + kZeroOrOne, + kZeroOrMore, + kOneOrMore, + kConcatenation, + kAlternation, + kLeftParenthesis + }; + + static const unsigned kAnyCharacterClass = 0xFFFFFFFF; //!< For '.' + static const unsigned kRangeCharacterClass = 0xFFFFFFFE; + static const unsigned kRangeNegationFlag = 0x80000000; + + struct Range { + unsigned start; // + unsigned end; + SizeType next; + }; + + struct State { + SizeType out; //!< Equals to kInvalid for matching state + SizeType out1; //!< Equals to non-kInvalid for split + SizeType rangeStart; + unsigned codepoint; + }; + + struct Frag { + Frag(SizeType s, SizeType o, SizeType m) : start(s), out(o), minIndex(m) {} + SizeType start; + SizeType out; //!< link-list of all output states + SizeType minIndex; + }; + + State& GetState(SizeType index) { + RAPIDJSON_ASSERT(index < stateCount_); + return states_.template Bottom()[index]; + } + + const State& GetState(SizeType index) const { + RAPIDJSON_ASSERT(index < stateCount_); + return states_.template Bottom()[index]; + } + + Range& GetRange(SizeType index) { + RAPIDJSON_ASSERT(index < rangeCount_); + return ranges_.template Bottom()[index]; + } + + const Range& GetRange(SizeType index) const { + RAPIDJSON_ASSERT(index < rangeCount_); + return ranges_.template Bottom()[index]; + } + + template + void Parse(DecodedStream& ds) { + Stack operandStack(allocator_, 256); // Frag + Stack operatorStack(allocator_, 256); // Operator + Stack atomCountStack(allocator_, 256); // unsigned (Atom per parenthesis) + + *atomCountStack.template Push() = 0; + + unsigned codepoint; + while (ds.Peek() != 0) { + switch (codepoint = ds.Take()) { + case '^': + anchorBegin_ = true; + break; + + case '$': + anchorEnd_ = true; + break; + + case '|': + while (!operatorStack.Empty() && *operatorStack.template Top() < kAlternation) + if (!Eval(operandStack, *operatorStack.template Pop(1))) + return; + *operatorStack.template Push() = kAlternation; + *atomCountStack.template Top() = 0; + break; + + case '(': + *operatorStack.template Push() = kLeftParenthesis; + *atomCountStack.template Push() = 0; + break; + + case ')': + while (!operatorStack.Empty() && *operatorStack.template Top() != kLeftParenthesis) + if (!Eval(operandStack, *operatorStack.template Pop(1))) + return; + if (operatorStack.Empty()) + return; + operatorStack.template Pop(1); + atomCountStack.template Pop(1); + ImplicitConcatenation(atomCountStack, operatorStack); + break; + + case '?': + if (!Eval(operandStack, kZeroOrOne)) + return; + break; + + case '*': + if (!Eval(operandStack, kZeroOrMore)) + return; + break; + + case '+': + if (!Eval(operandStack, kOneOrMore)) + return; + break; + + case '{': + { + unsigned n, m; + if (!ParseUnsigned(ds, &n)) + return; + + if (ds.Peek() == ',') { + ds.Take(); + if (ds.Peek() == '}') + m = kInfinityQuantifier; + else if (!ParseUnsigned(ds, &m) || m < n) + return; + } + else + m = n; + + if (!EvalQuantifier(operandStack, n, m) || ds.Peek() != '}') + return; + ds.Take(); + } + break; + + case '.': + PushOperand(operandStack, kAnyCharacterClass); + ImplicitConcatenation(atomCountStack, operatorStack); + break; + + case '[': + { + SizeType range; + if (!ParseRange(ds, &range)) + return; + SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, kRangeCharacterClass); + GetState(s).rangeStart = range; + *operandStack.template Push() = Frag(s, s, s); + } + ImplicitConcatenation(atomCountStack, operatorStack); + break; + + case '\\': // Escape character + if (!CharacterEscape(ds, &codepoint)) + return; // Unsupported escape character + // fall through to default + RAPIDJSON_DELIBERATE_FALLTHROUGH; + + default: // Pattern character + PushOperand(operandStack, codepoint); + ImplicitConcatenation(atomCountStack, operatorStack); + } + } + + while (!operatorStack.Empty()) + if (!Eval(operandStack, *operatorStack.template Pop(1))) + return; + + // Link the operand to matching state. + if (operandStack.GetSize() == sizeof(Frag)) { + Frag* e = operandStack.template Pop(1); + Patch(e->out, NewState(kRegexInvalidState, kRegexInvalidState, 0)); + root_ = e->start; + +#if RAPIDJSON_REGEX_VERBOSE + printf("root: %d\n", root_); + for (SizeType i = 0; i < stateCount_ ; i++) { + State& s = GetState(i); + printf("[%2d] out: %2d out1: %2d c: '%c'\n", i, s.out, s.out1, (char)s.codepoint); + } + printf("\n"); +#endif + } + } + + SizeType NewState(SizeType out, SizeType out1, unsigned codepoint) { + State* s = states_.template Push(); + s->out = out; + s->out1 = out1; + s->codepoint = codepoint; + s->rangeStart = kRegexInvalidRange; + return stateCount_++; + } + + void PushOperand(Stack& operandStack, unsigned codepoint) { + SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, codepoint); + *operandStack.template Push() = Frag(s, s, s); + } + + void ImplicitConcatenation(Stack& atomCountStack, Stack& operatorStack) { + if (*atomCountStack.template Top()) + *operatorStack.template Push() = kConcatenation; + (*atomCountStack.template Top())++; + } + + SizeType Append(SizeType l1, SizeType l2) { + SizeType old = l1; + while (GetState(l1).out != kRegexInvalidState) + l1 = GetState(l1).out; + GetState(l1).out = l2; + return old; + } + + void Patch(SizeType l, SizeType s) { + for (SizeType next; l != kRegexInvalidState; l = next) { + next = GetState(l).out; + GetState(l).out = s; + } + } + + bool Eval(Stack& operandStack, Operator op) { + switch (op) { + case kConcatenation: + RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag) * 2); + { + Frag e2 = *operandStack.template Pop(1); + Frag e1 = *operandStack.template Pop(1); + Patch(e1.out, e2.start); + *operandStack.template Push() = Frag(e1.start, e2.out, Min(e1.minIndex, e2.minIndex)); + } + return true; + + case kAlternation: + if (operandStack.GetSize() >= sizeof(Frag) * 2) { + Frag e2 = *operandStack.template Pop(1); + Frag e1 = *operandStack.template Pop(1); + SizeType s = NewState(e1.start, e2.start, 0); + *operandStack.template Push() = Frag(s, Append(e1.out, e2.out), Min(e1.minIndex, e2.minIndex)); + return true; + } + return false; + + case kZeroOrOne: + if (operandStack.GetSize() >= sizeof(Frag)) { + Frag e = *operandStack.template Pop(1); + SizeType s = NewState(kRegexInvalidState, e.start, 0); + *operandStack.template Push() = Frag(s, Append(e.out, s), e.minIndex); + return true; + } + return false; + + case kZeroOrMore: + if (operandStack.GetSize() >= sizeof(Frag)) { + Frag e = *operandStack.template Pop(1); + SizeType s = NewState(kRegexInvalidState, e.start, 0); + Patch(e.out, s); + *operandStack.template Push() = Frag(s, s, e.minIndex); + return true; + } + return false; + + case kOneOrMore: + if (operandStack.GetSize() >= sizeof(Frag)) { + Frag e = *operandStack.template Pop(1); + SizeType s = NewState(kRegexInvalidState, e.start, 0); + Patch(e.out, s); + *operandStack.template Push() = Frag(e.start, s, e.minIndex); + return true; + } + return false; + + default: + // syntax error (e.g. unclosed kLeftParenthesis) + return false; + } + } + + bool EvalQuantifier(Stack& operandStack, unsigned n, unsigned m) { + RAPIDJSON_ASSERT(n <= m); + RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag)); + + if (n == 0) { + if (m == 0) // a{0} not support + return false; + else if (m == kInfinityQuantifier) + Eval(operandStack, kZeroOrMore); // a{0,} -> a* + else { + Eval(operandStack, kZeroOrOne); // a{0,5} -> a? + for (unsigned i = 0; i < m - 1; i++) + CloneTopOperand(operandStack); // a{0,5} -> a? a? a? a? a? + for (unsigned i = 0; i < m - 1; i++) + Eval(operandStack, kConcatenation); // a{0,5} -> a?a?a?a?a? + } + return true; + } + + for (unsigned i = 0; i < n - 1; i++) // a{3} -> a a a + CloneTopOperand(operandStack); + + if (m == kInfinityQuantifier) + Eval(operandStack, kOneOrMore); // a{3,} -> a a a+ + else if (m > n) { + CloneTopOperand(operandStack); // a{3,5} -> a a a a + Eval(operandStack, kZeroOrOne); // a{3,5} -> a a a a? + for (unsigned i = n; i < m - 1; i++) + CloneTopOperand(operandStack); // a{3,5} -> a a a a? a? + for (unsigned i = n; i < m; i++) + Eval(operandStack, kConcatenation); // a{3,5} -> a a aa?a? + } + + for (unsigned i = 0; i < n - 1; i++) + Eval(operandStack, kConcatenation); // a{3} -> aaa, a{3,} -> aaa+, a{3.5} -> aaaa?a? + + return true; + } + + static SizeType Min(SizeType a, SizeType b) { return a < b ? a : b; } + + void CloneTopOperand(Stack& operandStack) { + const Frag src = *operandStack.template Top(); // Copy constructor to prevent invalidation + SizeType count = stateCount_ - src.minIndex; // Assumes top operand contains states in [src->minIndex, stateCount_) + State* s = states_.template Push(count); + memcpy(s, &GetState(src.minIndex), count * sizeof(State)); + for (SizeType j = 0; j < count; j++) { + if (s[j].out != kRegexInvalidState) + s[j].out += count; + if (s[j].out1 != kRegexInvalidState) + s[j].out1 += count; + } + *operandStack.template Push() = Frag(src.start + count, src.out + count, src.minIndex + count); + stateCount_ += count; + } + + template + bool ParseUnsigned(DecodedStream& ds, unsigned* u) { + unsigned r = 0; + if (ds.Peek() < '0' || ds.Peek() > '9') + return false; + while (ds.Peek() >= '0' && ds.Peek() <= '9') { + if (r >= 429496729 && ds.Peek() > '5') // 2^32 - 1 = 4294967295 + return false; // overflow + r = r * 10 + (ds.Take() - '0'); + } + *u = r; + return true; + } + + template + bool ParseRange(DecodedStream& ds, SizeType* range) { + bool isBegin = true; + bool negate = false; + int step = 0; + SizeType start = kRegexInvalidRange; + SizeType current = kRegexInvalidRange; + unsigned codepoint; + while ((codepoint = ds.Take()) != 0) { + if (isBegin) { + isBegin = false; + if (codepoint == '^') { + negate = true; + continue; + } + } + + switch (codepoint) { + case ']': + if (start == kRegexInvalidRange) + return false; // Error: nothing inside [] + if (step == 2) { // Add trailing '-' + SizeType r = NewRange('-'); + RAPIDJSON_ASSERT(current != kRegexInvalidRange); + GetRange(current).next = r; + } + if (negate) + GetRange(start).start |= kRangeNegationFlag; + *range = start; + return true; + + case '\\': + if (ds.Peek() == 'b') { + ds.Take(); + codepoint = 0x0008; // Escape backspace character + } + else if (!CharacterEscape(ds, &codepoint)) + return false; + // fall through to default + RAPIDJSON_DELIBERATE_FALLTHROUGH; + + default: + switch (step) { + case 1: + if (codepoint == '-') { + step++; + break; + } + // fall through to step 0 for other characters + RAPIDJSON_DELIBERATE_FALLTHROUGH; + + case 0: + { + SizeType r = NewRange(codepoint); + if (current != kRegexInvalidRange) + GetRange(current).next = r; + if (start == kRegexInvalidRange) + start = r; + current = r; + } + step = 1; + break; + + default: + RAPIDJSON_ASSERT(step == 2); + GetRange(current).end = codepoint; + step = 0; + } + } + } + return false; + } + + SizeType NewRange(unsigned codepoint) { + Range* r = ranges_.template Push(); + r->start = r->end = codepoint; + r->next = kRegexInvalidRange; + return rangeCount_++; + } + + template + bool CharacterEscape(DecodedStream& ds, unsigned* escapedCodepoint) { + unsigned codepoint; + switch (codepoint = ds.Take()) { + case '^': + case '$': + case '|': + case '(': + case ')': + case '?': + case '*': + case '+': + case '.': + case '[': + case ']': + case '{': + case '}': + case '\\': + *escapedCodepoint = codepoint; return true; + case 'f': *escapedCodepoint = 0x000C; return true; + case 'n': *escapedCodepoint = 0x000A; return true; + case 'r': *escapedCodepoint = 0x000D; return true; + case 't': *escapedCodepoint = 0x0009; return true; + case 'v': *escapedCodepoint = 0x000B; return true; + default: + return false; // Unsupported escape character + } + } + + Allocator* ownAllocator_; + Allocator* allocator_; + Stack states_; + Stack ranges_; + SizeType root_; + SizeType stateCount_; + SizeType rangeCount_; + + static const unsigned kInfinityQuantifier = ~0u; + + // For SearchWithAnchoring() + bool anchorBegin_; + bool anchorEnd_; +}; + +template +class GenericRegexSearch { +public: + typedef typename RegexType::EncodingType Encoding; + typedef typename Encoding::Ch Ch; + + GenericRegexSearch(const RegexType& regex, Allocator* allocator = 0) : + regex_(regex), allocator_(allocator), ownAllocator_(0), + state0_(allocator, 0), state1_(allocator, 0), stateSet_() + { + RAPIDJSON_ASSERT(regex_.IsValid()); + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + stateSet_ = static_cast(allocator_->Malloc(GetStateSetSize())); + state0_.template Reserve(regex_.stateCount_); + state1_.template Reserve(regex_.stateCount_); + } + + ~GenericRegexSearch() { + Allocator::Free(stateSet_); + RAPIDJSON_DELETE(ownAllocator_); + } + + template + bool Match(InputStream& is) { + return SearchWithAnchoring(is, true, true); + } + + bool Match(const Ch* s) { + GenericStringStream is(s); + return Match(is); + } + + template + bool Search(InputStream& is) { + return SearchWithAnchoring(is, regex_.anchorBegin_, regex_.anchorEnd_); + } + + bool Search(const Ch* s) { + GenericStringStream is(s); + return Search(is); + } + +private: + typedef typename RegexType::State State; + typedef typename RegexType::Range Range; + + template + bool SearchWithAnchoring(InputStream& is, bool anchorBegin, bool anchorEnd) { + DecodedStream ds(is); + + state0_.Clear(); + Stack *current = &state0_, *next = &state1_; + const size_t stateSetSize = GetStateSetSize(); + std::memset(stateSet_, 0, stateSetSize); + + bool matched = AddState(*current, regex_.root_); + unsigned codepoint; + while (!current->Empty() && (codepoint = ds.Take()) != 0) { + std::memset(stateSet_, 0, stateSetSize); + next->Clear(); + matched = false; + for (const SizeType* s = current->template Bottom(); s != current->template End(); ++s) { + const State& sr = regex_.GetState(*s); + if (sr.codepoint == codepoint || + sr.codepoint == RegexType::kAnyCharacterClass || + (sr.codepoint == RegexType::kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint))) + { + matched = AddState(*next, sr.out) || matched; + if (!anchorEnd && matched) + return true; + } + if (!anchorBegin) + AddState(*next, regex_.root_); + } + internal::Swap(current, next); + } + + return matched; + } + + size_t GetStateSetSize() const { + return (regex_.stateCount_ + 31) / 32 * 4; + } + + // Return whether the added states is a match state + bool AddState(Stack& l, SizeType index) { + RAPIDJSON_ASSERT(index != kRegexInvalidState); + + const State& s = regex_.GetState(index); + if (s.out1 != kRegexInvalidState) { // Split + bool matched = AddState(l, s.out); + return AddState(l, s.out1) || matched; + } + else if (!(stateSet_[index >> 5] & (1u << (index & 31)))) { + stateSet_[index >> 5] |= (1u << (index & 31)); + *l.template PushUnsafe() = index; + } + return s.out == kRegexInvalidState; // by using PushUnsafe() above, we can ensure s is not validated due to reallocation. + } + + bool MatchRange(SizeType rangeIndex, unsigned codepoint) const { + bool yes = (regex_.GetRange(rangeIndex).start & RegexType::kRangeNegationFlag) == 0; + while (rangeIndex != kRegexInvalidRange) { + const Range& r = regex_.GetRange(rangeIndex); + if (codepoint >= (r.start & ~RegexType::kRangeNegationFlag) && codepoint <= r.end) + return yes; + rangeIndex = r.next; + } + return !yes; + } + + const RegexType& regex_; + Allocator* allocator_; + Allocator* ownAllocator_; + Stack state0_; + Stack state1_; + uint32_t* stateSet_; +}; + +typedef GenericRegex > Regex; +typedef GenericRegexSearch RegexSearch; + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#if defined(__clang__) || defined(_MSC_VER) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_INTERNAL_REGEX_H_ diff --git a/libs/include/rapidjson/internal/stack.h b/libs/include/rapidjson/internal/stack.h new file mode 100644 index 0000000..73abd70 --- /dev/null +++ b/libs/include/rapidjson/internal/stack.h @@ -0,0 +1,232 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_INTERNAL_STACK_H_ +#define RAPIDJSON_INTERNAL_STACK_H_ + +#include "../allocators.h" +#include "swap.h" +#include + +#if defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(c++98-compat) +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +/////////////////////////////////////////////////////////////////////////////// +// Stack + +//! A type-unsafe stack for storing different types of data. +/*! \tparam Allocator Allocator for allocating stack memory. +*/ +template +class Stack { +public: + // Optimization note: Do not allocate memory for stack_ in constructor. + // Do it lazily when first Push() -> Expand() -> Resize(). + Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) { + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + Stack(Stack&& rhs) + : allocator_(rhs.allocator_), + ownAllocator_(rhs.ownAllocator_), + stack_(rhs.stack_), + stackTop_(rhs.stackTop_), + stackEnd_(rhs.stackEnd_), + initialCapacity_(rhs.initialCapacity_) + { + rhs.allocator_ = 0; + rhs.ownAllocator_ = 0; + rhs.stack_ = 0; + rhs.stackTop_ = 0; + rhs.stackEnd_ = 0; + rhs.initialCapacity_ = 0; + } +#endif + + ~Stack() { + Destroy(); + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + Stack& operator=(Stack&& rhs) { + if (&rhs != this) + { + Destroy(); + + allocator_ = rhs.allocator_; + ownAllocator_ = rhs.ownAllocator_; + stack_ = rhs.stack_; + stackTop_ = rhs.stackTop_; + stackEnd_ = rhs.stackEnd_; + initialCapacity_ = rhs.initialCapacity_; + + rhs.allocator_ = 0; + rhs.ownAllocator_ = 0; + rhs.stack_ = 0; + rhs.stackTop_ = 0; + rhs.stackEnd_ = 0; + rhs.initialCapacity_ = 0; + } + return *this; + } +#endif + + void Swap(Stack& rhs) RAPIDJSON_NOEXCEPT { + internal::Swap(allocator_, rhs.allocator_); + internal::Swap(ownAllocator_, rhs.ownAllocator_); + internal::Swap(stack_, rhs.stack_); + internal::Swap(stackTop_, rhs.stackTop_); + internal::Swap(stackEnd_, rhs.stackEnd_); + internal::Swap(initialCapacity_, rhs.initialCapacity_); + } + + void Clear() { stackTop_ = stack_; } + + void ShrinkToFit() { + if (Empty()) { + // If the stack is empty, completely deallocate the memory. + Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc) + stack_ = 0; + stackTop_ = 0; + stackEnd_ = 0; + } + else + Resize(GetSize()); + } + + // Optimization note: try to minimize the size of this function for force inline. + // Expansion is run very infrequently, so it is moved to another (probably non-inline) function. + template + RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) { + // Expand the stack if needed + if (RAPIDJSON_UNLIKELY(static_cast(sizeof(T) * count) > (stackEnd_ - stackTop_))) + Expand(count); + } + + template + RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) { + Reserve(count); + return PushUnsafe(count); + } + + template + RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) { + RAPIDJSON_ASSERT(stackTop_); + RAPIDJSON_ASSERT(static_cast(sizeof(T) * count) <= (stackEnd_ - stackTop_)); + T* ret = reinterpret_cast(stackTop_); + stackTop_ += sizeof(T) * count; + return ret; + } + + template + T* Pop(size_t count) { + RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T)); + stackTop_ -= count * sizeof(T); + return reinterpret_cast(stackTop_); + } + + template + T* Top() { + RAPIDJSON_ASSERT(GetSize() >= sizeof(T)); + return reinterpret_cast(stackTop_ - sizeof(T)); + } + + template + const T* Top() const { + RAPIDJSON_ASSERT(GetSize() >= sizeof(T)); + return reinterpret_cast(stackTop_ - sizeof(T)); + } + + template + T* End() { return reinterpret_cast(stackTop_); } + + template + const T* End() const { return reinterpret_cast(stackTop_); } + + template + T* Bottom() { return reinterpret_cast(stack_); } + + template + const T* Bottom() const { return reinterpret_cast(stack_); } + + bool HasAllocator() const { + return allocator_ != 0; + } + + Allocator& GetAllocator() { + RAPIDJSON_ASSERT(allocator_); + return *allocator_; + } + + bool Empty() const { return stackTop_ == stack_; } + size_t GetSize() const { return static_cast(stackTop_ - stack_); } + size_t GetCapacity() const { return static_cast(stackEnd_ - stack_); } + +private: + template + void Expand(size_t count) { + // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity. + size_t newCapacity; + if (stack_ == 0) { + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + newCapacity = initialCapacity_; + } else { + newCapacity = GetCapacity(); + newCapacity += (newCapacity + 1) / 2; + } + size_t newSize = GetSize() + sizeof(T) * count; + if (newCapacity < newSize) + newCapacity = newSize; + + Resize(newCapacity); + } + + void Resize(size_t newCapacity) { + const size_t size = GetSize(); // Backup the current size + stack_ = static_cast(allocator_->Realloc(stack_, GetCapacity(), newCapacity)); + stackTop_ = stack_ + size; + stackEnd_ = stack_ + newCapacity; + } + + void Destroy() { + Allocator::Free(stack_); + RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack + } + + // Prohibit copy constructor & assignment operator. + Stack(const Stack&); + Stack& operator=(const Stack&); + + Allocator* allocator_; + Allocator* ownAllocator_; + char *stack_; + char *stackTop_; + char *stackEnd_; + size_t initialCapacity_; +}; + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_STACK_H_ diff --git a/libs/include/rapidjson/internal/strfunc.h b/libs/include/rapidjson/internal/strfunc.h new file mode 100644 index 0000000..baecb6c --- /dev/null +++ b/libs/include/rapidjson/internal/strfunc.h @@ -0,0 +1,69 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_INTERNAL_STRFUNC_H_ +#define RAPIDJSON_INTERNAL_STRFUNC_H_ + +#include "../stream.h" +#include + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +//! Custom strlen() which works on different character types. +/*! \tparam Ch Character type (e.g. char, wchar_t, short) + \param s Null-terminated input string. + \return Number of characters in the string. + \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints. +*/ +template +inline SizeType StrLen(const Ch* s) { + RAPIDJSON_ASSERT(s != 0); + const Ch* p = s; + while (*p) ++p; + return SizeType(p - s); +} + +template <> +inline SizeType StrLen(const char* s) { + return SizeType(std::strlen(s)); +} + +template <> +inline SizeType StrLen(const wchar_t* s) { + return SizeType(std::wcslen(s)); +} + +//! Returns number of code points in a encoded string. +template +bool CountStringCodePoint(const typename Encoding::Ch* s, SizeType length, SizeType* outCount) { + RAPIDJSON_ASSERT(s != 0); + RAPIDJSON_ASSERT(outCount != 0); + GenericStringStream is(s); + const typename Encoding::Ch* end = s + length; + SizeType count = 0; + while (is.src_ < end) { + unsigned codepoint; + if (!Encoding::Decode(is, &codepoint)) + return false; + count++; + } + *outCount = count; + return true; +} + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_INTERNAL_STRFUNC_H_ diff --git a/libs/include/rapidjson/internal/strtod.h b/libs/include/rapidjson/internal/strtod.h new file mode 100644 index 0000000..d61a67a --- /dev/null +++ b/libs/include/rapidjson/internal/strtod.h @@ -0,0 +1,290 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_STRTOD_ +#define RAPIDJSON_STRTOD_ + +#include "ieee754.h" +#include "biginteger.h" +#include "diyfp.h" +#include "pow10.h" +#include +#include + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +inline double FastPath(double significand, int exp) { + if (exp < -308) + return 0.0; + else if (exp >= 0) + return significand * internal::Pow10(exp); + else + return significand / internal::Pow10(-exp); +} + +inline double StrtodNormalPrecision(double d, int p) { + if (p < -308) { + // Prevent expSum < -308, making Pow10(p) = 0 + d = FastPath(d, -308); + d = FastPath(d, p + 308); + } + else + d = FastPath(d, p); + return d; +} + +template +inline T Min3(T a, T b, T c) { + T m = a; + if (m > b) m = b; + if (m > c) m = c; + return m; +} + +inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) { + const Double db(b); + const uint64_t bInt = db.IntegerSignificand(); + const int bExp = db.IntegerExponent(); + const int hExp = bExp - 1; + + int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0; + + // Adjust for decimal exponent + if (dExp >= 0) { + dS_Exp2 += dExp; + dS_Exp5 += dExp; + } + else { + bS_Exp2 -= dExp; + bS_Exp5 -= dExp; + hS_Exp2 -= dExp; + hS_Exp5 -= dExp; + } + + // Adjust for binary exponent + if (bExp >= 0) + bS_Exp2 += bExp; + else { + dS_Exp2 -= bExp; + hS_Exp2 -= bExp; + } + + // Adjust for half ulp exponent + if (hExp >= 0) + hS_Exp2 += hExp; + else { + dS_Exp2 -= hExp; + bS_Exp2 -= hExp; + } + + // Remove common power of two factor from all three scaled values + int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2); + dS_Exp2 -= common_Exp2; + bS_Exp2 -= common_Exp2; + hS_Exp2 -= common_Exp2; + + BigInteger dS = d; + dS.MultiplyPow5(static_cast(dS_Exp5)) <<= static_cast(dS_Exp2); + + BigInteger bS(bInt); + bS.MultiplyPow5(static_cast(bS_Exp5)) <<= static_cast(bS_Exp2); + + BigInteger hS(1); + hS.MultiplyPow5(static_cast(hS_Exp5)) <<= static_cast(hS_Exp2); + + BigInteger delta(0); + dS.Difference(bS, &delta); + + return delta.Compare(hS); +} + +inline bool StrtodFast(double d, int p, double* result) { + // Use fast path for string-to-double conversion if possible + // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/ + if (p > 22 && p < 22 + 16) { + // Fast Path Cases In Disguise + d *= internal::Pow10(p - 22); + p = 22; + } + + if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1 + *result = FastPath(d, p); + return true; + } + else + return false; +} + +// Compute an approximation and see if it is within 1/2 ULP +inline bool StrtodDiyFp(const char* decimals, int dLen, int dExp, double* result) { + uint64_t significand = 0; + int i = 0; // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999 + for (; i < dLen; i++) { + if (significand > RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || + (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5')) + break; + significand = significand * 10u + static_cast(decimals[i] - '0'); + } + + if (i < dLen && decimals[i] >= '5') // Rounding + significand++; + + int remaining = dLen - i; + const int kUlpShift = 3; + const int kUlp = 1 << kUlpShift; + int64_t error = (remaining == 0) ? 0 : kUlp / 2; + + DiyFp v(significand, 0); + v = v.Normalize(); + error <<= -v.e; + + dExp += remaining; + + int actualExp; + DiyFp cachedPower = GetCachedPower10(dExp, &actualExp); + if (actualExp != dExp) { + static const DiyFp kPow10[] = { + DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60), // 10^1 + DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57), // 10^2 + DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54), // 10^3 + DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50), // 10^4 + DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47), // 10^5 + DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44), // 10^6 + DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40) // 10^7 + }; + int adjustment = dExp - actualExp; + RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8); + v = v * kPow10[adjustment - 1]; + if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit + error += kUlp / 2; + } + + v = v * cachedPower; + + error += kUlp + (error == 0 ? 0 : 1); + + const int oldExp = v.e; + v = v.Normalize(); + error <<= oldExp - v.e; + + const int effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e); + int precisionSize = 64 - effectiveSignificandSize; + if (precisionSize + kUlpShift >= 64) { + int scaleExp = (precisionSize + kUlpShift) - 63; + v.f >>= scaleExp; + v.e += scaleExp; + error = (error >> scaleExp) + 1 + kUlp; + precisionSize -= scaleExp; + } + + DiyFp rounded(v.f >> precisionSize, v.e + precisionSize); + const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp; + const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp; + if (precisionBits >= halfWay + static_cast(error)) { + rounded.f++; + if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340) + rounded.f >>= 1; + rounded.e++; + } + } + + *result = rounded.ToDouble(); + + return halfWay - static_cast(error) >= precisionBits || precisionBits >= halfWay + static_cast(error); +} + +inline double StrtodBigInteger(double approx, const char* decimals, int dLen, int dExp) { + RAPIDJSON_ASSERT(dLen >= 0); + const BigInteger dInt(decimals, static_cast(dLen)); + Double a(approx); + int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp); + if (cmp < 0) + return a.Value(); // within half ULP + else if (cmp == 0) { + // Round towards even + if (a.Significand() & 1) + return a.NextPositiveDouble(); + else + return a.Value(); + } + else // adjustment + return a.NextPositiveDouble(); +} + +inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t length, size_t decimalPosition, int exp) { + RAPIDJSON_ASSERT(d >= 0.0); + RAPIDJSON_ASSERT(length >= 1); + + double result = 0.0; + if (StrtodFast(d, p, &result)) + return result; + + RAPIDJSON_ASSERT(length <= INT_MAX); + int dLen = static_cast(length); + + RAPIDJSON_ASSERT(length >= decimalPosition); + RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX); + int dExpAdjust = static_cast(length - decimalPosition); + + RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust); + int dExp = exp - dExpAdjust; + + // Make sure length+dExp does not overflow + RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen); + + // Trim leading zeros + while (dLen > 0 && *decimals == '0') { + dLen--; + decimals++; + } + + // Trim trailing zeros + while (dLen > 0 && decimals[dLen - 1] == '0') { + dLen--; + dExp++; + } + + if (dLen == 0) { // Buffer only contains zeros. + return 0.0; + } + + // Trim right-most digits + const int kMaxDecimalDigit = 767 + 1; + if (dLen > kMaxDecimalDigit) { + dExp += dLen - kMaxDecimalDigit; + dLen = kMaxDecimalDigit; + } + + // If too small, underflow to zero. + // Any x <= 10^-324 is interpreted as zero. + if (dLen + dExp <= -324) + return 0.0; + + // If too large, overflow to infinity. + // Any x >= 10^309 is interpreted as +infinity. + if (dLen + dExp > 309) + return std::numeric_limits::infinity(); + + if (StrtodDiyFp(decimals, dLen, dExp, &result)) + return result; + + // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison + return StrtodBigInteger(result, decimals, dLen, dExp); +} + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_STRTOD_ diff --git a/libs/include/rapidjson/internal/swap.h b/libs/include/rapidjson/internal/swap.h new file mode 100644 index 0000000..2cf92f9 --- /dev/null +++ b/libs/include/rapidjson/internal/swap.h @@ -0,0 +1,46 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_INTERNAL_SWAP_H_ +#define RAPIDJSON_INTERNAL_SWAP_H_ + +#include "../rapidjson.h" + +#if defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(c++98-compat) +#endif + +RAPIDJSON_NAMESPACE_BEGIN +namespace internal { + +//! Custom swap() to avoid dependency on C++ header +/*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only. + \note This has the same semantics as std::swap(). +*/ +template +inline void Swap(T& a, T& b) RAPIDJSON_NOEXCEPT { + T tmp = a; + a = b; + b = tmp; +} + +} // namespace internal +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_INTERNAL_SWAP_H_ diff --git a/libs/include/rapidjson/istreamwrapper.h b/libs/include/rapidjson/istreamwrapper.h new file mode 100644 index 0000000..01437ec --- /dev/null +++ b/libs/include/rapidjson/istreamwrapper.h @@ -0,0 +1,128 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_ISTREAMWRAPPER_H_ +#define RAPIDJSON_ISTREAMWRAPPER_H_ + +#include "stream.h" +#include +#include + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Wrapper of \c std::basic_istream into RapidJSON's Stream concept. +/*! + The classes can be wrapped including but not limited to: + + - \c std::istringstream + - \c std::stringstream + - \c std::wistringstream + - \c std::wstringstream + - \c std::ifstream + - \c std::fstream + - \c std::wifstream + - \c std::wfstream + + \tparam StreamType Class derived from \c std::basic_istream. +*/ + +template +class BasicIStreamWrapper { +public: + typedef typename StreamType::char_type Ch; + + //! Constructor. + /*! + \param stream stream opened for read. + */ + BasicIStreamWrapper(StreamType &stream) : stream_(stream), buffer_(peekBuffer_), bufferSize_(4), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { + Read(); + } + + //! Constructor. + /*! + \param stream stream opened for read. + \param buffer user-supplied buffer. + \param bufferSize size of buffer in bytes. Must >=4 bytes. + */ + BasicIStreamWrapper(StreamType &stream, char* buffer, size_t bufferSize) : stream_(stream), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { + RAPIDJSON_ASSERT(bufferSize >= 4); + Read(); + } + + Ch Peek() const { return *current_; } + Ch Take() { Ch c = *current_; Read(); return c; } + size_t Tell() const { return count_ + static_cast(current_ - buffer_); } + + // Not implemented + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + + // For encoding detection only. + const Ch* Peek4() const { + return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0; + } + +private: + BasicIStreamWrapper(); + BasicIStreamWrapper(const BasicIStreamWrapper&); + BasicIStreamWrapper& operator=(const BasicIStreamWrapper&); + + void Read() { + if (current_ < bufferLast_) + ++current_; + else if (!eof_) { + count_ += readCount_; + readCount_ = bufferSize_; + bufferLast_ = buffer_ + readCount_ - 1; + current_ = buffer_; + + if (!stream_.read(buffer_, static_cast(bufferSize_))) { + readCount_ = static_cast(stream_.gcount()); + *(bufferLast_ = buffer_ + readCount_) = '\0'; + eof_ = true; + } + } + } + + StreamType &stream_; + Ch peekBuffer_[4], *buffer_; + size_t bufferSize_; + Ch *bufferLast_; + Ch *current_; + size_t readCount_; + size_t count_; //!< Number of characters read + bool eof_; +}; + +typedef BasicIStreamWrapper IStreamWrapper; +typedef BasicIStreamWrapper WIStreamWrapper; + +#if defined(__clang__) || defined(_MSC_VER) +RAPIDJSON_DIAG_POP +#endif + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_ISTREAMWRAPPER_H_ diff --git a/libs/include/rapidjson/memorybuffer.h b/libs/include/rapidjson/memorybuffer.h new file mode 100644 index 0000000..ffbc41e --- /dev/null +++ b/libs/include/rapidjson/memorybuffer.h @@ -0,0 +1,70 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_MEMORYBUFFER_H_ +#define RAPIDJSON_MEMORYBUFFER_H_ + +#include "stream.h" +#include "internal/stack.h" + +RAPIDJSON_NAMESPACE_BEGIN + +//! Represents an in-memory output byte stream. +/*! + This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream. + + It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file. + + Differences between MemoryBuffer and StringBuffer: + 1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer. + 2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator. + + \tparam Allocator type for allocating memory buffer. + \note implements Stream concept +*/ +template +struct GenericMemoryBuffer { + typedef char Ch; // byte + + GenericMemoryBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {} + + void Put(Ch c) { *stack_.template Push() = c; } + void Flush() {} + + void Clear() { stack_.Clear(); } + void ShrinkToFit() { stack_.ShrinkToFit(); } + Ch* Push(size_t count) { return stack_.template Push(count); } + void Pop(size_t count) { stack_.template Pop(count); } + + const Ch* GetBuffer() const { + return stack_.template Bottom(); + } + + size_t GetSize() const { return stack_.GetSize(); } + + static const size_t kDefaultCapacity = 256; + mutable internal::Stack stack_; +}; + +typedef GenericMemoryBuffer<> MemoryBuffer; + +//! Implement specialized version of PutN() with memset() for better performance. +template<> +inline void PutN(MemoryBuffer& memoryBuffer, char c, size_t n) { + std::memset(memoryBuffer.stack_.Push(n), c, n * sizeof(c)); +} + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_MEMORYBUFFER_H_ diff --git a/libs/include/rapidjson/memorystream.h b/libs/include/rapidjson/memorystream.h new file mode 100644 index 0000000..77af6c9 --- /dev/null +++ b/libs/include/rapidjson/memorystream.h @@ -0,0 +1,71 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_MEMORYSTREAM_H_ +#define RAPIDJSON_MEMORYSTREAM_H_ + +#include "stream.h" + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(unreachable-code) +RAPIDJSON_DIAG_OFF(missing-noreturn) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Represents an in-memory input byte stream. +/*! + This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream. + + It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file. + + Differences between MemoryStream and StringStream: + 1. StringStream has encoding but MemoryStream is a byte stream. + 2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source. + 3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4(). + \note implements Stream concept +*/ +struct MemoryStream { + typedef char Ch; // byte + + MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {} + + Ch Peek() const { return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_; } + Ch Take() { return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_++; } + size_t Tell() const { return static_cast(src_ - begin_); } + + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + + // For encoding detection only. + const Ch* Peek4() const { + return Tell() + 4 <= size_ ? src_ : 0; + } + + const Ch* src_; //!< Current read position. + const Ch* begin_; //!< Original head of the string. + const Ch* end_; //!< End of stream. + size_t size_; //!< Size of the stream. +}; + +RAPIDJSON_NAMESPACE_END + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_MEMORYBUFFER_H_ diff --git a/libs/include/rapidjson/msinttypes/inttypes.h b/libs/include/rapidjson/msinttypes/inttypes.h new file mode 100644 index 0000000..1811128 --- /dev/null +++ b/libs/include/rapidjson/msinttypes/inttypes.h @@ -0,0 +1,316 @@ +// ISO C9x compliant inttypes.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006-2013 Alexander Chemeris +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the product nor the names of its contributors may +// be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +/////////////////////////////////////////////////////////////////////////////// + +// The above software in this distribution may have been modified by +// THL A29 Limited ("Tencent Modifications"). +// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited. + +#ifndef _MSC_VER // [ +#error "Use this header only with Microsoft Visual C++ compilers!" +#endif // _MSC_VER ] + +#ifndef _MSC_INTTYPES_H_ // [ +#define _MSC_INTTYPES_H_ + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include "stdint.h" + +// miloyip: VC supports inttypes.h since VC2013 +#if _MSC_VER >= 1800 +#include +#else + +// 7.8 Format conversion of integer types + +typedef struct { + intmax_t quot; + intmax_t rem; +} imaxdiv_t; + +// 7.8.1 Macros for format specifiers + +#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [ See footnote 185 at page 198 + +// The fprintf macros for signed integers are: +#define PRId8 "d" +#define PRIi8 "i" +#define PRIdLEAST8 "d" +#define PRIiLEAST8 "i" +#define PRIdFAST8 "d" +#define PRIiFAST8 "i" + +#define PRId16 "hd" +#define PRIi16 "hi" +#define PRIdLEAST16 "hd" +#define PRIiLEAST16 "hi" +#define PRIdFAST16 "hd" +#define PRIiFAST16 "hi" + +#define PRId32 "I32d" +#define PRIi32 "I32i" +#define PRIdLEAST32 "I32d" +#define PRIiLEAST32 "I32i" +#define PRIdFAST32 "I32d" +#define PRIiFAST32 "I32i" + +#define PRId64 "I64d" +#define PRIi64 "I64i" +#define PRIdLEAST64 "I64d" +#define PRIiLEAST64 "I64i" +#define PRIdFAST64 "I64d" +#define PRIiFAST64 "I64i" + +#define PRIdMAX "I64d" +#define PRIiMAX "I64i" + +#define PRIdPTR "Id" +#define PRIiPTR "Ii" + +// The fprintf macros for unsigned integers are: +#define PRIo8 "o" +#define PRIu8 "u" +#define PRIx8 "x" +#define PRIX8 "X" +#define PRIoLEAST8 "o" +#define PRIuLEAST8 "u" +#define PRIxLEAST8 "x" +#define PRIXLEAST8 "X" +#define PRIoFAST8 "o" +#define PRIuFAST8 "u" +#define PRIxFAST8 "x" +#define PRIXFAST8 "X" + +#define PRIo16 "ho" +#define PRIu16 "hu" +#define PRIx16 "hx" +#define PRIX16 "hX" +#define PRIoLEAST16 "ho" +#define PRIuLEAST16 "hu" +#define PRIxLEAST16 "hx" +#define PRIXLEAST16 "hX" +#define PRIoFAST16 "ho" +#define PRIuFAST16 "hu" +#define PRIxFAST16 "hx" +#define PRIXFAST16 "hX" + +#define PRIo32 "I32o" +#define PRIu32 "I32u" +#define PRIx32 "I32x" +#define PRIX32 "I32X" +#define PRIoLEAST32 "I32o" +#define PRIuLEAST32 "I32u" +#define PRIxLEAST32 "I32x" +#define PRIXLEAST32 "I32X" +#define PRIoFAST32 "I32o" +#define PRIuFAST32 "I32u" +#define PRIxFAST32 "I32x" +#define PRIXFAST32 "I32X" + +#define PRIo64 "I64o" +#define PRIu64 "I64u" +#define PRIx64 "I64x" +#define PRIX64 "I64X" +#define PRIoLEAST64 "I64o" +#define PRIuLEAST64 "I64u" +#define PRIxLEAST64 "I64x" +#define PRIXLEAST64 "I64X" +#define PRIoFAST64 "I64o" +#define PRIuFAST64 "I64u" +#define PRIxFAST64 "I64x" +#define PRIXFAST64 "I64X" + +#define PRIoMAX "I64o" +#define PRIuMAX "I64u" +#define PRIxMAX "I64x" +#define PRIXMAX "I64X" + +#define PRIoPTR "Io" +#define PRIuPTR "Iu" +#define PRIxPTR "Ix" +#define PRIXPTR "IX" + +// The fscanf macros for signed integers are: +#define SCNd8 "d" +#define SCNi8 "i" +#define SCNdLEAST8 "d" +#define SCNiLEAST8 "i" +#define SCNdFAST8 "d" +#define SCNiFAST8 "i" + +#define SCNd16 "hd" +#define SCNi16 "hi" +#define SCNdLEAST16 "hd" +#define SCNiLEAST16 "hi" +#define SCNdFAST16 "hd" +#define SCNiFAST16 "hi" + +#define SCNd32 "ld" +#define SCNi32 "li" +#define SCNdLEAST32 "ld" +#define SCNiLEAST32 "li" +#define SCNdFAST32 "ld" +#define SCNiFAST32 "li" + +#define SCNd64 "I64d" +#define SCNi64 "I64i" +#define SCNdLEAST64 "I64d" +#define SCNiLEAST64 "I64i" +#define SCNdFAST64 "I64d" +#define SCNiFAST64 "I64i" + +#define SCNdMAX "I64d" +#define SCNiMAX "I64i" + +#ifdef _WIN64 // [ +# define SCNdPTR "I64d" +# define SCNiPTR "I64i" +#else // _WIN64 ][ +# define SCNdPTR "ld" +# define SCNiPTR "li" +#endif // _WIN64 ] + +// The fscanf macros for unsigned integers are: +#define SCNo8 "o" +#define SCNu8 "u" +#define SCNx8 "x" +#define SCNX8 "X" +#define SCNoLEAST8 "o" +#define SCNuLEAST8 "u" +#define SCNxLEAST8 "x" +#define SCNXLEAST8 "X" +#define SCNoFAST8 "o" +#define SCNuFAST8 "u" +#define SCNxFAST8 "x" +#define SCNXFAST8 "X" + +#define SCNo16 "ho" +#define SCNu16 "hu" +#define SCNx16 "hx" +#define SCNX16 "hX" +#define SCNoLEAST16 "ho" +#define SCNuLEAST16 "hu" +#define SCNxLEAST16 "hx" +#define SCNXLEAST16 "hX" +#define SCNoFAST16 "ho" +#define SCNuFAST16 "hu" +#define SCNxFAST16 "hx" +#define SCNXFAST16 "hX" + +#define SCNo32 "lo" +#define SCNu32 "lu" +#define SCNx32 "lx" +#define SCNX32 "lX" +#define SCNoLEAST32 "lo" +#define SCNuLEAST32 "lu" +#define SCNxLEAST32 "lx" +#define SCNXLEAST32 "lX" +#define SCNoFAST32 "lo" +#define SCNuFAST32 "lu" +#define SCNxFAST32 "lx" +#define SCNXFAST32 "lX" + +#define SCNo64 "I64o" +#define SCNu64 "I64u" +#define SCNx64 "I64x" +#define SCNX64 "I64X" +#define SCNoLEAST64 "I64o" +#define SCNuLEAST64 "I64u" +#define SCNxLEAST64 "I64x" +#define SCNXLEAST64 "I64X" +#define SCNoFAST64 "I64o" +#define SCNuFAST64 "I64u" +#define SCNxFAST64 "I64x" +#define SCNXFAST64 "I64X" + +#define SCNoMAX "I64o" +#define SCNuMAX "I64u" +#define SCNxMAX "I64x" +#define SCNXMAX "I64X" + +#ifdef _WIN64 // [ +# define SCNoPTR "I64o" +# define SCNuPTR "I64u" +# define SCNxPTR "I64x" +# define SCNXPTR "I64X" +#else // _WIN64 ][ +# define SCNoPTR "lo" +# define SCNuPTR "lu" +# define SCNxPTR "lx" +# define SCNXPTR "lX" +#endif // _WIN64 ] + +#endif // __STDC_FORMAT_MACROS ] + +// 7.8.2 Functions for greatest-width integer types + +// 7.8.2.1 The imaxabs function +#define imaxabs _abs64 + +// 7.8.2.2 The imaxdiv function + +// This is modified version of div() function from Microsoft's div.c found +// in %MSVC.NET%\crt\src\div.c +#ifdef STATIC_IMAXDIV // [ +static +#else // STATIC_IMAXDIV ][ +_inline +#endif // STATIC_IMAXDIV ] +imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom) +{ + imaxdiv_t result; + + result.quot = numer / denom; + result.rem = numer % denom; + + if (numer < 0 && result.rem > 0) { + // did division wrong; must fix up + ++result.quot; + result.rem -= denom; + } + + return result; +} + +// 7.8.2.3 The strtoimax and strtoumax functions +#define strtoimax _strtoi64 +#define strtoumax _strtoui64 + +// 7.8.2.4 The wcstoimax and wcstoumax functions +#define wcstoimax _wcstoi64 +#define wcstoumax _wcstoui64 + +#endif // _MSC_VER >= 1800 + +#endif // _MSC_INTTYPES_H_ ] diff --git a/libs/include/rapidjson/msinttypes/stdint.h b/libs/include/rapidjson/msinttypes/stdint.h new file mode 100644 index 0000000..3d4477b --- /dev/null +++ b/libs/include/rapidjson/msinttypes/stdint.h @@ -0,0 +1,300 @@ +// ISO C9x compliant stdint.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006-2013 Alexander Chemeris +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the product nor the names of its contributors may +// be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +/////////////////////////////////////////////////////////////////////////////// + +// The above software in this distribution may have been modified by +// THL A29 Limited ("Tencent Modifications"). +// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited. + +#ifndef _MSC_VER // [ +#error "Use this header only with Microsoft Visual C++ compilers!" +#endif // _MSC_VER ] + +#ifndef _MSC_STDINT_H_ // [ +#define _MSC_STDINT_H_ + +#if _MSC_VER > 1000 +#pragma once +#endif + +// miloyip: Originally Visual Studio 2010 uses its own stdint.h. However it generates warning with INT64_C(), so change to use this file for vs2010. +#if _MSC_VER >= 1600 // [ +#include + +#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 + +#undef INT8_C +#undef INT16_C +#undef INT32_C +#undef INT64_C +#undef UINT8_C +#undef UINT16_C +#undef UINT32_C +#undef UINT64_C + +// 7.18.4.1 Macros for minimum-width integer constants + +#define INT8_C(val) val##i8 +#define INT16_C(val) val##i16 +#define INT32_C(val) val##i32 +#define INT64_C(val) val##i64 + +#define UINT8_C(val) val##ui8 +#define UINT16_C(val) val##ui16 +#define UINT32_C(val) val##ui32 +#define UINT64_C(val) val##ui64 + +// 7.18.4.2 Macros for greatest-width integer constants +// These #ifndef's are needed to prevent collisions with . +// Check out Issue 9 for the details. +#ifndef INTMAX_C // [ +# define INTMAX_C INT64_C +#endif // INTMAX_C ] +#ifndef UINTMAX_C // [ +# define UINTMAX_C UINT64_C +#endif // UINTMAX_C ] + +#endif // __STDC_CONSTANT_MACROS ] + +#else // ] _MSC_VER >= 1700 [ + +#include + +// For Visual Studio 6 in C++ mode and for many Visual Studio versions when +// compiling for ARM we have to wrap include with 'extern "C++" {}' +// or compiler would give many errors like this: +// error C2733: second C linkage of overloaded function 'wmemchr' not allowed +#if defined(__cplusplus) && !defined(_M_ARM) +extern "C" { +#endif +# include +#if defined(__cplusplus) && !defined(_M_ARM) +} +#endif + +// Define _W64 macros to mark types changing their size, like intptr_t. +#ifndef _W64 +# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300 +# define _W64 __w64 +# else +# define _W64 +# endif +#endif + + +// 7.18.1 Integer types + +// 7.18.1.1 Exact-width integer types + +// Visual Studio 6 and Embedded Visual C++ 4 doesn't +// realize that, e.g. char has the same size as __int8 +// so we give up on __intX for them. +#if (_MSC_VER < 1300) + typedef signed char int8_t; + typedef signed short int16_t; + typedef signed int int32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; +#else + typedef signed __int8 int8_t; + typedef signed __int16 int16_t; + typedef signed __int32 int32_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; +#endif +typedef signed __int64 int64_t; +typedef unsigned __int64 uint64_t; + + +// 7.18.1.2 Minimum-width integer types +typedef int8_t int_least8_t; +typedef int16_t int_least16_t; +typedef int32_t int_least32_t; +typedef int64_t int_least64_t; +typedef uint8_t uint_least8_t; +typedef uint16_t uint_least16_t; +typedef uint32_t uint_least32_t; +typedef uint64_t uint_least64_t; + +// 7.18.1.3 Fastest minimum-width integer types +typedef int8_t int_fast8_t; +typedef int16_t int_fast16_t; +typedef int32_t int_fast32_t; +typedef int64_t int_fast64_t; +typedef uint8_t uint_fast8_t; +typedef uint16_t uint_fast16_t; +typedef uint32_t uint_fast32_t; +typedef uint64_t uint_fast64_t; + +// 7.18.1.4 Integer types capable of holding object pointers +#ifdef _WIN64 // [ + typedef signed __int64 intptr_t; + typedef unsigned __int64 uintptr_t; +#else // _WIN64 ][ + typedef _W64 signed int intptr_t; + typedef _W64 unsigned int uintptr_t; +#endif // _WIN64 ] + +// 7.18.1.5 Greatest-width integer types +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; + + +// 7.18.2 Limits of specified-width integer types + +#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259 + +// 7.18.2.1 Limits of exact-width integer types +#define INT8_MIN ((int8_t)_I8_MIN) +#define INT8_MAX _I8_MAX +#define INT16_MIN ((int16_t)_I16_MIN) +#define INT16_MAX _I16_MAX +#define INT32_MIN ((int32_t)_I32_MIN) +#define INT32_MAX _I32_MAX +#define INT64_MIN ((int64_t)_I64_MIN) +#define INT64_MAX _I64_MAX +#define UINT8_MAX _UI8_MAX +#define UINT16_MAX _UI16_MAX +#define UINT32_MAX _UI32_MAX +#define UINT64_MAX _UI64_MAX + +// 7.18.2.2 Limits of minimum-width integer types +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST8_MAX INT8_MAX +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST16_MAX INT16_MAX +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST32_MAX INT32_MAX +#define INT_LEAST64_MIN INT64_MIN +#define INT_LEAST64_MAX INT64_MAX +#define UINT_LEAST8_MAX UINT8_MAX +#define UINT_LEAST16_MAX UINT16_MAX +#define UINT_LEAST32_MAX UINT32_MAX +#define UINT_LEAST64_MAX UINT64_MAX + +// 7.18.2.3 Limits of fastest minimum-width integer types +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST8_MAX INT8_MAX +#define INT_FAST16_MIN INT16_MIN +#define INT_FAST16_MAX INT16_MAX +#define INT_FAST32_MIN INT32_MIN +#define INT_FAST32_MAX INT32_MAX +#define INT_FAST64_MIN INT64_MIN +#define INT_FAST64_MAX INT64_MAX +#define UINT_FAST8_MAX UINT8_MAX +#define UINT_FAST16_MAX UINT16_MAX +#define UINT_FAST32_MAX UINT32_MAX +#define UINT_FAST64_MAX UINT64_MAX + +// 7.18.2.4 Limits of integer types capable of holding object pointers +#ifdef _WIN64 // [ +# define INTPTR_MIN INT64_MIN +# define INTPTR_MAX INT64_MAX +# define UINTPTR_MAX UINT64_MAX +#else // _WIN64 ][ +# define INTPTR_MIN INT32_MIN +# define INTPTR_MAX INT32_MAX +# define UINTPTR_MAX UINT32_MAX +#endif // _WIN64 ] + +// 7.18.2.5 Limits of greatest-width integer types +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX +#define UINTMAX_MAX UINT64_MAX + +// 7.18.3 Limits of other integer types + +#ifdef _WIN64 // [ +# define PTRDIFF_MIN _I64_MIN +# define PTRDIFF_MAX _I64_MAX +#else // _WIN64 ][ +# define PTRDIFF_MIN _I32_MIN +# define PTRDIFF_MAX _I32_MAX +#endif // _WIN64 ] + +#define SIG_ATOMIC_MIN INT_MIN +#define SIG_ATOMIC_MAX INT_MAX + +#ifndef SIZE_MAX // [ +# ifdef _WIN64 // [ +# define SIZE_MAX _UI64_MAX +# else // _WIN64 ][ +# define SIZE_MAX _UI32_MAX +# endif // _WIN64 ] +#endif // SIZE_MAX ] + +// WCHAR_MIN and WCHAR_MAX are also defined in +#ifndef WCHAR_MIN // [ +# define WCHAR_MIN 0 +#endif // WCHAR_MIN ] +#ifndef WCHAR_MAX // [ +# define WCHAR_MAX _UI16_MAX +#endif // WCHAR_MAX ] + +#define WINT_MIN 0 +#define WINT_MAX _UI16_MAX + +#endif // __STDC_LIMIT_MACROS ] + + +// 7.18.4 Limits of other integer types + +#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 + +// 7.18.4.1 Macros for minimum-width integer constants + +#define INT8_C(val) val##i8 +#define INT16_C(val) val##i16 +#define INT32_C(val) val##i32 +#define INT64_C(val) val##i64 + +#define UINT8_C(val) val##ui8 +#define UINT16_C(val) val##ui16 +#define UINT32_C(val) val##ui32 +#define UINT64_C(val) val##ui64 + +// 7.18.4.2 Macros for greatest-width integer constants +// These #ifndef's are needed to prevent collisions with . +// Check out Issue 9 for the details. +#ifndef INTMAX_C // [ +# define INTMAX_C INT64_C +#endif // INTMAX_C ] +#ifndef UINTMAX_C // [ +# define UINTMAX_C UINT64_C +#endif // UINTMAX_C ] + +#endif // __STDC_CONSTANT_MACROS ] + +#endif // _MSC_VER >= 1600 ] + +#endif // _MSC_STDINT_H_ ] diff --git a/libs/include/rapidjson/ostreamwrapper.h b/libs/include/rapidjson/ostreamwrapper.h new file mode 100644 index 0000000..11ed4d3 --- /dev/null +++ b/libs/include/rapidjson/ostreamwrapper.h @@ -0,0 +1,81 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_OSTREAMWRAPPER_H_ +#define RAPIDJSON_OSTREAMWRAPPER_H_ + +#include "stream.h" +#include + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Wrapper of \c std::basic_ostream into RapidJSON's Stream concept. +/*! + The classes can be wrapped including but not limited to: + + - \c std::ostringstream + - \c std::stringstream + - \c std::wpstringstream + - \c std::wstringstream + - \c std::ifstream + - \c std::fstream + - \c std::wofstream + - \c std::wfstream + + \tparam StreamType Class derived from \c std::basic_ostream. +*/ + +template +class BasicOStreamWrapper { +public: + typedef typename StreamType::char_type Ch; + BasicOStreamWrapper(StreamType& stream) : stream_(stream) {} + + void Put(Ch c) { + stream_.put(c); + } + + void Flush() { + stream_.flush(); + } + + // Not implemented + char Peek() const { RAPIDJSON_ASSERT(false); return 0; } + char Take() { RAPIDJSON_ASSERT(false); return 0; } + size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; } + char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; } + +private: + BasicOStreamWrapper(const BasicOStreamWrapper&); + BasicOStreamWrapper& operator=(const BasicOStreamWrapper&); + + StreamType& stream_; +}; + +typedef BasicOStreamWrapper OStreamWrapper; +typedef BasicOStreamWrapper WOStreamWrapper; + +#ifdef __clang__ +RAPIDJSON_DIAG_POP +#endif + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_OSTREAMWRAPPER_H_ diff --git a/libs/include/rapidjson/pointer.h b/libs/include/rapidjson/pointer.h new file mode 100644 index 0000000..90e5903 --- /dev/null +++ b/libs/include/rapidjson/pointer.h @@ -0,0 +1,1415 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_POINTER_H_ +#define RAPIDJSON_POINTER_H_ + +#include "document.h" +#include "internal/itoa.h" + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(switch-enum) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +static const SizeType kPointerInvalidIndex = ~SizeType(0); //!< Represents an invalid index in GenericPointer::Token + +//! Error code of parsing. +/*! \ingroup RAPIDJSON_ERRORS + \see GenericPointer::GenericPointer, GenericPointer::GetParseErrorCode +*/ +enum PointerParseErrorCode { + kPointerParseErrorNone = 0, //!< The parse is successful + + kPointerParseErrorTokenMustBeginWithSolidus, //!< A token must begin with a '/' + kPointerParseErrorInvalidEscape, //!< Invalid escape + kPointerParseErrorInvalidPercentEncoding, //!< Invalid percent encoding in URI fragment + kPointerParseErrorCharacterMustPercentEncode //!< A character must percent encoded in URI fragment +}; + +/////////////////////////////////////////////////////////////////////////////// +// GenericPointer + +//! Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator. +/*! + This class implements RFC 6901 "JavaScript Object Notation (JSON) Pointer" + (https://tools.ietf.org/html/rfc6901). + + A JSON pointer is for identifying a specific value in a JSON document + (GenericDocument). It can simplify coding of DOM tree manipulation, because it + can access multiple-level depth of DOM tree with single API call. + + After it parses a string representation (e.g. "/foo/0" or URI fragment + representation (e.g. "#/foo/0") into its internal representation (tokens), + it can be used to resolve a specific value in multiple documents, or sub-tree + of documents. + + Contrary to GenericValue, Pointer can be copy constructed and copy assigned. + Apart from assignment, a Pointer cannot be modified after construction. + + Although Pointer is very convenient, please aware that constructing Pointer + involves parsing and dynamic memory allocation. A special constructor with user- + supplied tokens eliminates these. + + GenericPointer depends on GenericDocument and GenericValue. + + \tparam ValueType The value type of the DOM tree. E.g. GenericValue > + \tparam Allocator The allocator type for allocating memory for internal representation. + + \note GenericPointer uses same encoding of ValueType. + However, Allocator of GenericPointer is independent of Allocator of Value. +*/ +template +class GenericPointer { +public: + typedef typename ValueType::EncodingType EncodingType; //!< Encoding type from Value + typedef typename ValueType::Ch Ch; //!< Character type from Value + + //! A token is the basic units of internal representation. + /*! + A JSON pointer string representation "/foo/123" is parsed to two tokens: + "foo" and 123. 123 will be represented in both numeric form and string form. + They are resolved according to the actual value type (object or array). + + For token that are not numbers, or the numeric value is out of bound + (greater than limits of SizeType), they are only treated as string form + (i.e. the token's index will be equal to kPointerInvalidIndex). + + This struct is public so that user can create a Pointer without parsing and + allocation, using a special constructor. + */ + struct Token { + const Ch* name; //!< Name of the token. It has null character at the end but it can contain null character. + SizeType length; //!< Length of the name. + SizeType index; //!< A valid array index, if it is not equal to kPointerInvalidIndex. + }; + + //!@name Constructors and destructor. + //@{ + + //! Default constructor. + GenericPointer(Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {} + + //! Constructor that parses a string or URI fragment representation. + /*! + \param source A null-terminated, string or URI fragment representation of JSON pointer. + \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one. + */ + explicit GenericPointer(const Ch* source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) { + Parse(source, internal::StrLen(source)); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Constructor that parses a string or URI fragment representation. + /*! + \param source A string or URI fragment representation of JSON pointer. + \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one. + \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING. + */ + explicit GenericPointer(const std::basic_string& source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) { + Parse(source.c_str(), source.size()); + } +#endif + + //! Constructor that parses a string or URI fragment representation, with length of the source string. + /*! + \param source A string or URI fragment representation of JSON pointer. + \param length Length of source. + \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one. + \note Slightly faster than the overload without length. + */ + GenericPointer(const Ch* source, size_t length, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) { + Parse(source, length); + } + + //! Constructor with user-supplied tokens. + /*! + This constructor let user supplies const array of tokens. + This prevents the parsing process and eliminates allocation. + This is preferred for memory constrained environments. + + \param tokens An constant array of tokens representing the JSON pointer. + \param tokenCount Number of tokens. + + \b Example + \code + #define NAME(s) { s, sizeof(s) / sizeof(s[0]) - 1, kPointerInvalidIndex } + #define INDEX(i) { #i, sizeof(#i) - 1, i } + + static const Pointer::Token kTokens[] = { NAME("foo"), INDEX(123) }; + static const Pointer p(kTokens, sizeof(kTokens) / sizeof(kTokens[0])); + // Equivalent to static const Pointer p("/foo/123"); + + #undef NAME + #undef INDEX + \endcode + */ + GenericPointer(const Token* tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {} + + //! Copy constructor. + GenericPointer(const GenericPointer& rhs) : allocator_(rhs.allocator_), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) { + *this = rhs; + } + + //! Copy constructor. + GenericPointer(const GenericPointer& rhs, Allocator* allocator) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) { + *this = rhs; + } + + //! Destructor. + ~GenericPointer() { + if (nameBuffer_) // If user-supplied tokens constructor is used, nameBuffer_ is nullptr and tokens_ are not deallocated. + Allocator::Free(tokens_); + RAPIDJSON_DELETE(ownAllocator_); + } + + //! Assignment operator. + GenericPointer& operator=(const GenericPointer& rhs) { + if (this != &rhs) { + // Do not delete ownAllcator + if (nameBuffer_) + Allocator::Free(tokens_); + + tokenCount_ = rhs.tokenCount_; + parseErrorOffset_ = rhs.parseErrorOffset_; + parseErrorCode_ = rhs.parseErrorCode_; + + if (rhs.nameBuffer_) + CopyFromRaw(rhs); // Normally parsed tokens. + else { + tokens_ = rhs.tokens_; // User supplied const tokens. + nameBuffer_ = 0; + } + } + return *this; + } + + //! Swap the content of this pointer with an other. + /*! + \param other The pointer to swap with. + \note Constant complexity. + */ + GenericPointer& Swap(GenericPointer& other) RAPIDJSON_NOEXCEPT { + internal::Swap(allocator_, other.allocator_); + internal::Swap(ownAllocator_, other.ownAllocator_); + internal::Swap(nameBuffer_, other.nameBuffer_); + internal::Swap(tokens_, other.tokens_); + internal::Swap(tokenCount_, other.tokenCount_); + internal::Swap(parseErrorOffset_, other.parseErrorOffset_); + internal::Swap(parseErrorCode_, other.parseErrorCode_); + return *this; + } + + //! free-standing swap function helper + /*! + Helper function to enable support for common swap implementation pattern based on \c std::swap: + \code + void swap(MyClass& a, MyClass& b) { + using std::swap; + swap(a.pointer, b.pointer); + // ... + } + \endcode + \see Swap() + */ + friend inline void swap(GenericPointer& a, GenericPointer& b) RAPIDJSON_NOEXCEPT { a.Swap(b); } + + //@} + + //!@name Append token + //@{ + + //! Append a token and return a new Pointer + /*! + \param token Token to be appended. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + GenericPointer Append(const Token& token, Allocator* allocator = 0) const { + GenericPointer r; + r.allocator_ = allocator; + Ch *p = r.CopyFromRaw(*this, 1, token.length + 1); + std::memcpy(p, token.name, (token.length + 1) * sizeof(Ch)); + r.tokens_[tokenCount_].name = p; + r.tokens_[tokenCount_].length = token.length; + r.tokens_[tokenCount_].index = token.index; + return r; + } + + //! Append a name token with length, and return a new Pointer + /*! + \param name Name to be appended. + \param length Length of name. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + GenericPointer Append(const Ch* name, SizeType length, Allocator* allocator = 0) const { + Token token = { name, length, kPointerInvalidIndex }; + return Append(token, allocator); + } + + //! Append a name token without length, and return a new Pointer + /*! + \param name Name (const Ch*) to be appended. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr::Type, Ch> >), (GenericPointer)) + Append(T* name, Allocator* allocator = 0) const { + return Append(name, internal::StrLen(name), allocator); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Append a name token, and return a new Pointer + /*! + \param name Name to be appended. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + GenericPointer Append(const std::basic_string& name, Allocator* allocator = 0) const { + return Append(name.c_str(), static_cast(name.size()), allocator); + } +#endif + + //! Append a index token, and return a new Pointer + /*! + \param index Index to be appended. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + GenericPointer Append(SizeType index, Allocator* allocator = 0) const { + char buffer[21]; + char* end = sizeof(SizeType) == 4 ? internal::u32toa(index, buffer) : internal::u64toa(index, buffer); + SizeType length = static_cast(end - buffer); + buffer[length] = '\0'; + + if (sizeof(Ch) == 1) { + Token token = { reinterpret_cast(buffer), length, index }; + return Append(token, allocator); + } + else { + Ch name[21]; + for (size_t i = 0; i <= length; i++) + name[i] = static_cast(buffer[i]); + Token token = { name, length, index }; + return Append(token, allocator); + } + } + + //! Append a token by value, and return a new Pointer + /*! + \param token token to be appended. + \param allocator Allocator for the newly return Pointer. + \return A new Pointer with appended token. + */ + GenericPointer Append(const ValueType& token, Allocator* allocator = 0) const { + if (token.IsString()) + return Append(token.GetString(), token.GetStringLength(), allocator); + else { + RAPIDJSON_ASSERT(token.IsUint64()); + RAPIDJSON_ASSERT(token.GetUint64() <= SizeType(~0)); + return Append(static_cast(token.GetUint64()), allocator); + } + } + + //!@name Handling Parse Error + //@{ + + //! Check whether this is a valid pointer. + bool IsValid() const { return parseErrorCode_ == kPointerParseErrorNone; } + + //! Get the parsing error offset in code unit. + size_t GetParseErrorOffset() const { return parseErrorOffset_; } + + //! Get the parsing error code. + PointerParseErrorCode GetParseErrorCode() const { return parseErrorCode_; } + + //@} + + //! Get the allocator of this pointer. + Allocator& GetAllocator() { return *allocator_; } + + //!@name Tokens + //@{ + + //! Get the token array (const version only). + const Token* GetTokens() const { return tokens_; } + + //! Get the number of tokens. + size_t GetTokenCount() const { return tokenCount_; } + + //@} + + //!@name Equality/inequality operators + //@{ + + //! Equality operator. + /*! + \note When any pointers are invalid, always returns false. + */ + bool operator==(const GenericPointer& rhs) const { + if (!IsValid() || !rhs.IsValid() || tokenCount_ != rhs.tokenCount_) + return false; + + for (size_t i = 0; i < tokenCount_; i++) { + if (tokens_[i].index != rhs.tokens_[i].index || + tokens_[i].length != rhs.tokens_[i].length || + (tokens_[i].length != 0 && std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch)* tokens_[i].length) != 0)) + { + return false; + } + } + + return true; + } + + //! Inequality operator. + /*! + \note When any pointers are invalid, always returns true. + */ + bool operator!=(const GenericPointer& rhs) const { return !(*this == rhs); } + + //! Less than operator. + /*! + \note Invalid pointers are always greater than valid ones. + */ + bool operator<(const GenericPointer& rhs) const { + if (!IsValid()) + return false; + if (!rhs.IsValid()) + return true; + + if (tokenCount_ != rhs.tokenCount_) + return tokenCount_ < rhs.tokenCount_; + + for (size_t i = 0; i < tokenCount_; i++) { + if (tokens_[i].index != rhs.tokens_[i].index) + return tokens_[i].index < rhs.tokens_[i].index; + + if (tokens_[i].length != rhs.tokens_[i].length) + return tokens_[i].length < rhs.tokens_[i].length; + + if (int cmp = std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch) * tokens_[i].length)) + return cmp < 0; + } + + return false; + } + + //@} + + //!@name Stringify + //@{ + + //! Stringify the pointer into string representation. + /*! + \tparam OutputStream Type of output stream. + \param os The output stream. + */ + template + bool Stringify(OutputStream& os) const { + return Stringify(os); + } + + //! Stringify the pointer into URI fragment representation. + /*! + \tparam OutputStream Type of output stream. + \param os The output stream. + */ + template + bool StringifyUriFragment(OutputStream& os) const { + return Stringify(os); + } + + //@} + + //!@name Create value + //@{ + + //! Create a value in a subtree. + /*! + If the value is not exist, it creates all parent values and a JSON Null value. + So it always succeed and return the newly created or existing value. + + Remind that it may change types of parents according to tokens, so it + potentially removes previously stored values. For example, if a document + was an array, and "/foo" is used to create a value, then the document + will be changed to an object, and all existing array elements are lost. + + \param root Root value of a DOM subtree to be resolved. It can be any value other than document root. + \param allocator Allocator for creating the values if the specified value or its parents are not exist. + \param alreadyExist If non-null, it stores whether the resolved value is already exist. + \return The resolved newly created (a JSON Null value), or already exists value. + */ + ValueType& Create(ValueType& root, typename ValueType::AllocatorType& allocator, bool* alreadyExist = 0) const { + RAPIDJSON_ASSERT(IsValid()); + ValueType* v = &root; + bool exist = true; + for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) { + if (v->IsArray() && t->name[0] == '-' && t->length == 1) { + v->PushBack(ValueType().Move(), allocator); + v = &((*v)[v->Size() - 1]); + exist = false; + } + else { + if (t->index == kPointerInvalidIndex) { // must be object name + if (!v->IsObject()) + v->SetObject(); // Change to Object + } + else { // object name or array index + if (!v->IsArray() && !v->IsObject()) + v->SetArray(); // Change to Array + } + + if (v->IsArray()) { + if (t->index >= v->Size()) { + v->Reserve(t->index + 1, allocator); + while (t->index >= v->Size()) + v->PushBack(ValueType().Move(), allocator); + exist = false; + } + v = &((*v)[t->index]); + } + else { + typename ValueType::MemberIterator m = v->FindMember(GenericValue(GenericStringRef(t->name, t->length))); + if (m == v->MemberEnd()) { + v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator); + m = v->MemberEnd(); + v = &(--m)->value; // Assumes AddMember() appends at the end + exist = false; + } + else + v = &m->value; + } + } + } + + if (alreadyExist) + *alreadyExist = exist; + + return *v; + } + + //! Creates a value in a document. + /*! + \param document A document to be resolved. + \param alreadyExist If non-null, it stores whether the resolved value is already exist. + \return The resolved newly created, or already exists value. + */ + template + ValueType& Create(GenericDocument& document, bool* alreadyExist = 0) const { + return Create(document, document.GetAllocator(), alreadyExist); + } + + //@} + + //!@name Query value + //@{ + + //! Query a value in a subtree. + /*! + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \param unresolvedTokenIndex If the pointer cannot resolve a token in the pointer, this parameter can obtain the index of unresolved token. + \return Pointer to the value if it can be resolved. Otherwise null. + + \note + There are only 3 situations when a value cannot be resolved: + 1. A value in the path is not an array nor object. + 2. An object value does not contain the token. + 3. A token is out of range of an array value. + + Use unresolvedTokenIndex to retrieve the token index. + */ + ValueType* Get(ValueType& root, size_t* unresolvedTokenIndex = 0) const { + RAPIDJSON_ASSERT(IsValid()); + ValueType* v = &root; + for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) { + switch (v->GetType()) { + case kObjectType: + { + typename ValueType::MemberIterator m = v->FindMember(GenericValue(GenericStringRef(t->name, t->length))); + if (m == v->MemberEnd()) + break; + v = &m->value; + } + continue; + case kArrayType: + if (t->index == kPointerInvalidIndex || t->index >= v->Size()) + break; + v = &((*v)[t->index]); + continue; + default: + break; + } + + // Error: unresolved token + if (unresolvedTokenIndex) + *unresolvedTokenIndex = static_cast(t - tokens_); + return 0; + } + return v; + } + + //! Query a const value in a const subtree. + /*! + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \return Pointer to the value if it can be resolved. Otherwise null. + */ + const ValueType* Get(const ValueType& root, size_t* unresolvedTokenIndex = 0) const { + return Get(const_cast(root), unresolvedTokenIndex); + } + + //@} + + //!@name Query a value with default + //@{ + + //! Query a value in a subtree with default value. + /*! + Similar to Get(), but if the specified value do not exists, it creates all parents and clone the default value. + So that this function always succeed. + + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \param defaultValue Default value to be cloned if the value was not exists. + \param allocator Allocator for creating the values if the specified value or its parents are not exist. + \see Create() + */ + ValueType& GetWithDefault(ValueType& root, const ValueType& defaultValue, typename ValueType::AllocatorType& allocator) const { + bool alreadyExist; + ValueType& v = Create(root, allocator, &alreadyExist); + return alreadyExist ? v : v.CopyFrom(defaultValue, allocator); + } + + //! Query a value in a subtree with default null-terminated string. + ValueType& GetWithDefault(ValueType& root, const Ch* defaultValue, typename ValueType::AllocatorType& allocator) const { + bool alreadyExist; + ValueType& v = Create(root, allocator, &alreadyExist); + return alreadyExist ? v : v.SetString(defaultValue, allocator); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Query a value in a subtree with default std::basic_string. + ValueType& GetWithDefault(ValueType& root, const std::basic_string& defaultValue, typename ValueType::AllocatorType& allocator) const { + bool alreadyExist; + ValueType& v = Create(root, allocator, &alreadyExist); + return alreadyExist ? v : v.SetString(defaultValue, allocator); + } +#endif + + //! Query a value in a subtree with default primitive value. + /*! + \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (ValueType&)) + GetWithDefault(ValueType& root, T defaultValue, typename ValueType::AllocatorType& allocator) const { + return GetWithDefault(root, ValueType(defaultValue).Move(), allocator); + } + + //! Query a value in a document with default value. + template + ValueType& GetWithDefault(GenericDocument& document, const ValueType& defaultValue) const { + return GetWithDefault(document, defaultValue, document.GetAllocator()); + } + + //! Query a value in a document with default null-terminated string. + template + ValueType& GetWithDefault(GenericDocument& document, const Ch* defaultValue) const { + return GetWithDefault(document, defaultValue, document.GetAllocator()); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Query a value in a document with default std::basic_string. + template + ValueType& GetWithDefault(GenericDocument& document, const std::basic_string& defaultValue) const { + return GetWithDefault(document, defaultValue, document.GetAllocator()); + } +#endif + + //! Query a value in a document with default primitive value. + /*! + \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (ValueType&)) + GetWithDefault(GenericDocument& document, T defaultValue) const { + return GetWithDefault(document, defaultValue, document.GetAllocator()); + } + + //@} + + //!@name Set a value + //@{ + + //! Set a value in a subtree, with move semantics. + /*! + It creates all parents if they are not exist or types are different to the tokens. + So this function always succeeds but potentially remove existing values. + + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \param value Value to be set. + \param allocator Allocator for creating the values if the specified value or its parents are not exist. + \see Create() + */ + ValueType& Set(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator) = value; + } + + //! Set a value in a subtree, with copy semantics. + ValueType& Set(ValueType& root, const ValueType& value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator).CopyFrom(value, allocator); + } + + //! Set a null-terminated string in a subtree. + ValueType& Set(ValueType& root, const Ch* value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator) = ValueType(value, allocator).Move(); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Set a std::basic_string in a subtree. + ValueType& Set(ValueType& root, const std::basic_string& value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator) = ValueType(value, allocator).Move(); + } +#endif + + //! Set a primitive value in a subtree. + /*! + \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (ValueType&)) + Set(ValueType& root, T value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator) = ValueType(value).Move(); + } + + //! Set a value in a document, with move semantics. + template + ValueType& Set(GenericDocument& document, ValueType& value) const { + return Create(document) = value; + } + + //! Set a value in a document, with copy semantics. + template + ValueType& Set(GenericDocument& document, const ValueType& value) const { + return Create(document).CopyFrom(value, document.GetAllocator()); + } + + //! Set a null-terminated string in a document. + template + ValueType& Set(GenericDocument& document, const Ch* value) const { + return Create(document) = ValueType(value, document.GetAllocator()).Move(); + } + +#if RAPIDJSON_HAS_STDSTRING + //! Sets a std::basic_string in a document. + template + ValueType& Set(GenericDocument& document, const std::basic_string& value) const { + return Create(document) = ValueType(value, document.GetAllocator()).Move(); + } +#endif + + //! Set a primitive value in a document. + /*! + \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool + */ + template + RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (ValueType&)) + Set(GenericDocument& document, T value) const { + return Create(document) = value; + } + + //@} + + //!@name Swap a value + //@{ + + //! Swap a value with a value in a subtree. + /*! + It creates all parents if they are not exist or types are different to the tokens. + So this function always succeeds but potentially remove existing values. + + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \param value Value to be swapped. + \param allocator Allocator for creating the values if the specified value or its parents are not exist. + \see Create() + */ + ValueType& Swap(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const { + return Create(root, allocator).Swap(value); + } + + //! Swap a value with a value in a document. + template + ValueType& Swap(GenericDocument& document, ValueType& value) const { + return Create(document).Swap(value); + } + + //@} + + //! Erase a value in a subtree. + /*! + \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root. + \return Whether the resolved value is found and erased. + + \note Erasing with an empty pointer \c Pointer(""), i.e. the root, always fail and return false. + */ + bool Erase(ValueType& root) const { + RAPIDJSON_ASSERT(IsValid()); + if (tokenCount_ == 0) // Cannot erase the root + return false; + + ValueType* v = &root; + const Token* last = tokens_ + (tokenCount_ - 1); + for (const Token *t = tokens_; t != last; ++t) { + switch (v->GetType()) { + case kObjectType: + { + typename ValueType::MemberIterator m = v->FindMember(GenericValue(GenericStringRef(t->name, t->length))); + if (m == v->MemberEnd()) + return false; + v = &m->value; + } + break; + case kArrayType: + if (t->index == kPointerInvalidIndex || t->index >= v->Size()) + return false; + v = &((*v)[t->index]); + break; + default: + return false; + } + } + + switch (v->GetType()) { + case kObjectType: + return v->EraseMember(GenericStringRef(last->name, last->length)); + case kArrayType: + if (last->index == kPointerInvalidIndex || last->index >= v->Size()) + return false; + v->Erase(v->Begin() + last->index); + return true; + default: + return false; + } + } + +private: + //! Clone the content from rhs to this. + /*! + \param rhs Source pointer. + \param extraToken Extra tokens to be allocated. + \param extraNameBufferSize Extra name buffer size (in number of Ch) to be allocated. + \return Start of non-occupied name buffer, for storing extra names. + */ + Ch* CopyFromRaw(const GenericPointer& rhs, size_t extraToken = 0, size_t extraNameBufferSize = 0) { + if (!allocator_) // allocator is independently owned. + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + + size_t nameBufferSize = rhs.tokenCount_; // null terminators for tokens + for (Token *t = rhs.tokens_; t != rhs.tokens_ + rhs.tokenCount_; ++t) + nameBufferSize += t->length; + + tokenCount_ = rhs.tokenCount_ + extraToken; + tokens_ = static_cast(allocator_->Malloc(tokenCount_ * sizeof(Token) + (nameBufferSize + extraNameBufferSize) * sizeof(Ch))); + nameBuffer_ = reinterpret_cast(tokens_ + tokenCount_); + if (rhs.tokenCount_ > 0) { + std::memcpy(tokens_, rhs.tokens_, rhs.tokenCount_ * sizeof(Token)); + } + if (nameBufferSize > 0) { + std::memcpy(nameBuffer_, rhs.nameBuffer_, nameBufferSize * sizeof(Ch)); + } + + // Adjust pointers to name buffer + std::ptrdiff_t diff = nameBuffer_ - rhs.nameBuffer_; + for (Token *t = tokens_; t != tokens_ + rhs.tokenCount_; ++t) + t->name += diff; + + return nameBuffer_ + nameBufferSize; + } + + //! Check whether a character should be percent-encoded. + /*! + According to RFC 3986 2.3 Unreserved Characters. + \param c The character (code unit) to be tested. + */ + bool NeedPercentEncode(Ch c) const { + return !((c >= '0' && c <= '9') || (c >= 'A' && c <='Z') || (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || c =='~'); + } + + //! Parse a JSON String or its URI fragment representation into tokens. +#ifndef __clang__ // -Wdocumentation + /*! + \param source Either a JSON Pointer string, or its URI fragment representation. Not need to be null terminated. + \param length Length of the source string. + \note Source cannot be JSON String Representation of JSON Pointer, e.g. In "/\u0000", \u0000 will not be unescaped. + */ +#endif + void Parse(const Ch* source, size_t length) { + RAPIDJSON_ASSERT(source != NULL); + RAPIDJSON_ASSERT(nameBuffer_ == 0); + RAPIDJSON_ASSERT(tokens_ == 0); + + // Create own allocator if user did not supply. + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + + // Count number of '/' as tokenCount + tokenCount_ = 0; + for (const Ch* s = source; s != source + length; s++) + if (*s == '/') + tokenCount_++; + + Token* token = tokens_ = static_cast(allocator_->Malloc(tokenCount_ * sizeof(Token) + length * sizeof(Ch))); + Ch* name = nameBuffer_ = reinterpret_cast(tokens_ + tokenCount_); + size_t i = 0; + + // Detect if it is a URI fragment + bool uriFragment = false; + if (source[i] == '#') { + uriFragment = true; + i++; + } + + if (i != length && source[i] != '/') { + parseErrorCode_ = kPointerParseErrorTokenMustBeginWithSolidus; + goto error; + } + + while (i < length) { + RAPIDJSON_ASSERT(source[i] == '/'); + i++; // consumes '/' + + token->name = name; + bool isNumber = true; + + while (i < length && source[i] != '/') { + Ch c = source[i]; + if (uriFragment) { + // Decoding percent-encoding for URI fragment + if (c == '%') { + PercentDecodeStream is(&source[i], source + length); + GenericInsituStringStream os(name); + Ch* begin = os.PutBegin(); + if (!Transcoder, EncodingType>().Validate(is, os) || !is.IsValid()) { + parseErrorCode_ = kPointerParseErrorInvalidPercentEncoding; + goto error; + } + size_t len = os.PutEnd(begin); + i += is.Tell() - 1; + if (len == 1) + c = *name; + else { + name += len; + isNumber = false; + i++; + continue; + } + } + else if (NeedPercentEncode(c)) { + parseErrorCode_ = kPointerParseErrorCharacterMustPercentEncode; + goto error; + } + } + + i++; + + // Escaping "~0" -> '~', "~1" -> '/' + if (c == '~') { + if (i < length) { + c = source[i]; + if (c == '0') c = '~'; + else if (c == '1') c = '/'; + else { + parseErrorCode_ = kPointerParseErrorInvalidEscape; + goto error; + } + i++; + } + else { + parseErrorCode_ = kPointerParseErrorInvalidEscape; + goto error; + } + } + + // First check for index: all of characters are digit + if (c < '0' || c > '9') + isNumber = false; + + *name++ = c; + } + token->length = static_cast(name - token->name); + if (token->length == 0) + isNumber = false; + *name++ = '\0'; // Null terminator + + // Second check for index: more than one digit cannot have leading zero + if (isNumber && token->length > 1 && token->name[0] == '0') + isNumber = false; + + // String to SizeType conversion + SizeType n = 0; + if (isNumber) { + for (size_t j = 0; j < token->length; j++) { + SizeType m = n * 10 + static_cast(token->name[j] - '0'); + if (m < n) { // overflow detection + isNumber = false; + break; + } + n = m; + } + } + + token->index = isNumber ? n : kPointerInvalidIndex; + token++; + } + + RAPIDJSON_ASSERT(name <= nameBuffer_ + length); // Should not overflow buffer + parseErrorCode_ = kPointerParseErrorNone; + return; + + error: + Allocator::Free(tokens_); + nameBuffer_ = 0; + tokens_ = 0; + tokenCount_ = 0; + parseErrorOffset_ = i; + return; + } + + //! Stringify to string or URI fragment representation. + /*! + \tparam uriFragment True for stringifying to URI fragment representation. False for string representation. + \tparam OutputStream type of output stream. + \param os The output stream. + */ + template + bool Stringify(OutputStream& os) const { + RAPIDJSON_ASSERT(IsValid()); + + if (uriFragment) + os.Put('#'); + + for (Token *t = tokens_; t != tokens_ + tokenCount_; ++t) { + os.Put('/'); + for (size_t j = 0; j < t->length; j++) { + Ch c = t->name[j]; + if (c == '~') { + os.Put('~'); + os.Put('0'); + } + else if (c == '/') { + os.Put('~'); + os.Put('1'); + } + else if (uriFragment && NeedPercentEncode(c)) { + // Transcode to UTF8 sequence + GenericStringStream source(&t->name[j]); + PercentEncodeStream target(os); + if (!Transcoder >().Validate(source, target)) + return false; + j += source.Tell() - 1; + } + else + os.Put(c); + } + } + return true; + } + + //! A helper stream for decoding a percent-encoded sequence into code unit. + /*! + This stream decodes %XY triplet into code unit (0-255). + If it encounters invalid characters, it sets output code unit as 0 and + mark invalid, and to be checked by IsValid(). + */ + class PercentDecodeStream { + public: + typedef typename ValueType::Ch Ch; + + //! Constructor + /*! + \param source Start of the stream + \param end Past-the-end of the stream. + */ + PercentDecodeStream(const Ch* source, const Ch* end) : src_(source), head_(source), end_(end), valid_(true) {} + + Ch Take() { + if (*src_ != '%' || src_ + 3 > end_) { // %XY triplet + valid_ = false; + return 0; + } + src_++; + Ch c = 0; + for (int j = 0; j < 2; j++) { + c = static_cast(c << 4); + Ch h = *src_; + if (h >= '0' && h <= '9') c = static_cast(c + h - '0'); + else if (h >= 'A' && h <= 'F') c = static_cast(c + h - 'A' + 10); + else if (h >= 'a' && h <= 'f') c = static_cast(c + h - 'a' + 10); + else { + valid_ = false; + return 0; + } + src_++; + } + return c; + } + + size_t Tell() const { return static_cast(src_ - head_); } + bool IsValid() const { return valid_; } + + private: + const Ch* src_; //!< Current read position. + const Ch* head_; //!< Original head of the string. + const Ch* end_; //!< Past-the-end position. + bool valid_; //!< Whether the parsing is valid. + }; + + //! A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence. + template + class PercentEncodeStream { + public: + PercentEncodeStream(OutputStream& os) : os_(os) {} + void Put(char c) { // UTF-8 must be byte + unsigned char u = static_cast(c); + static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; + os_.Put('%'); + os_.Put(static_cast(hexDigits[u >> 4])); + os_.Put(static_cast(hexDigits[u & 15])); + } + private: + OutputStream& os_; + }; + + Allocator* allocator_; //!< The current allocator. It is either user-supplied or equal to ownAllocator_. + Allocator* ownAllocator_; //!< Allocator owned by this Pointer. + Ch* nameBuffer_; //!< A buffer containing all names in tokens. + Token* tokens_; //!< A list of tokens. + size_t tokenCount_; //!< Number of tokens in tokens_. + size_t parseErrorOffset_; //!< Offset in code unit when parsing fail. + PointerParseErrorCode parseErrorCode_; //!< Parsing error code. +}; + +//! GenericPointer for Value (UTF-8, default allocator). +typedef GenericPointer Pointer; + +//!@name Helper functions for GenericPointer +//@{ + +////////////////////////////////////////////////////////////////////////////// + +template +typename T::ValueType& CreateValueByPointer(T& root, const GenericPointer& pointer, typename T::AllocatorType& a) { + return pointer.Create(root, a); +} + +template +typename T::ValueType& CreateValueByPointer(T& root, const CharType(&source)[N], typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Create(root, a); +} + +// No allocator parameter + +template +typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const GenericPointer& pointer) { + return pointer.Create(document); +} + +template +typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const CharType(&source)[N]) { + return GenericPointer(source, N - 1).Create(document); +} + +////////////////////////////////////////////////////////////////////////////// + +template +typename T::ValueType* GetValueByPointer(T& root, const GenericPointer& pointer, size_t* unresolvedTokenIndex = 0) { + return pointer.Get(root, unresolvedTokenIndex); +} + +template +const typename T::ValueType* GetValueByPointer(const T& root, const GenericPointer& pointer, size_t* unresolvedTokenIndex = 0) { + return pointer.Get(root, unresolvedTokenIndex); +} + +template +typename T::ValueType* GetValueByPointer(T& root, const CharType (&source)[N], size_t* unresolvedTokenIndex = 0) { + return GenericPointer(source, N - 1).Get(root, unresolvedTokenIndex); +} + +template +const typename T::ValueType* GetValueByPointer(const T& root, const CharType(&source)[N], size_t* unresolvedTokenIndex = 0) { + return GenericPointer(source, N - 1).Get(root, unresolvedTokenIndex); +} + +////////////////////////////////////////////////////////////////////////////// + +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer& pointer, const typename T::ValueType& defaultValue, typename T::AllocatorType& a) { + return pointer.GetWithDefault(root, defaultValue, a); +} + +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer& pointer, const typename T::Ch* defaultValue, typename T::AllocatorType& a) { + return pointer.GetWithDefault(root, defaultValue, a); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer& pointer, const std::basic_string& defaultValue, typename T::AllocatorType& a) { + return pointer.GetWithDefault(root, defaultValue, a); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename T::ValueType&)) +GetValueByPointerWithDefault(T& root, const GenericPointer& pointer, T2 defaultValue, typename T::AllocatorType& a) { + return pointer.GetWithDefault(root, defaultValue, a); +} + +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::ValueType& defaultValue, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).GetWithDefault(root, defaultValue, a); +} + +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::Ch* defaultValue, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).GetWithDefault(root, defaultValue, a); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const std::basic_string& defaultValue, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).GetWithDefault(root, defaultValue, a); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename T::ValueType&)) +GetValueByPointerWithDefault(T& root, const CharType(&source)[N], T2 defaultValue, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).GetWithDefault(root, defaultValue, a); +} + +// No allocator parameter + +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer& pointer, const typename DocumentType::ValueType& defaultValue) { + return pointer.GetWithDefault(document, defaultValue); +} + +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer& pointer, const typename DocumentType::Ch* defaultValue) { + return pointer.GetWithDefault(document, defaultValue); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer& pointer, const std::basic_string& defaultValue) { + return pointer.GetWithDefault(document, defaultValue); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename DocumentType::ValueType&)) +GetValueByPointerWithDefault(DocumentType& document, const GenericPointer& pointer, T2 defaultValue) { + return pointer.GetWithDefault(document, defaultValue); +} + +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& defaultValue) { + return GenericPointer(source, N - 1).GetWithDefault(document, defaultValue); +} + +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* defaultValue) { + return GenericPointer(source, N - 1).GetWithDefault(document, defaultValue); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const std::basic_string& defaultValue) { + return GenericPointer(source, N - 1).GetWithDefault(document, defaultValue); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename DocumentType::ValueType&)) +GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], T2 defaultValue) { + return GenericPointer(source, N - 1).GetWithDefault(document, defaultValue); +} + +////////////////////////////////////////////////////////////////////////////// + +template +typename T::ValueType& SetValueByPointer(T& root, const GenericPointer& pointer, typename T::ValueType& value, typename T::AllocatorType& a) { + return pointer.Set(root, value, a); +} + +template +typename T::ValueType& SetValueByPointer(T& root, const GenericPointer& pointer, const typename T::ValueType& value, typename T::AllocatorType& a) { + return pointer.Set(root, value, a); +} + +template +typename T::ValueType& SetValueByPointer(T& root, const GenericPointer& pointer, const typename T::Ch* value, typename T::AllocatorType& a) { + return pointer.Set(root, value, a); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename T::ValueType& SetValueByPointer(T& root, const GenericPointer& pointer, const std::basic_string& value, typename T::AllocatorType& a) { + return pointer.Set(root, value, a); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename T::ValueType&)) +SetValueByPointer(T& root, const GenericPointer& pointer, T2 value, typename T::AllocatorType& a) { + return pointer.Set(root, value, a); +} + +template +typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Set(root, value, a); +} + +template +typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::ValueType& value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Set(root, value, a); +} + +template +typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::Ch* value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Set(root, value, a); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const std::basic_string& value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Set(root, value, a); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename T::ValueType&)) +SetValueByPointer(T& root, const CharType(&source)[N], T2 value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Set(root, value, a); +} + +// No allocator parameter + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer& pointer, typename DocumentType::ValueType& value) { + return pointer.Set(document, value); +} + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer& pointer, const typename DocumentType::ValueType& value) { + return pointer.Set(document, value); +} + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer& pointer, const typename DocumentType::Ch* value) { + return pointer.Set(document, value); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer& pointer, const std::basic_string& value) { + return pointer.Set(document, value); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename DocumentType::ValueType&)) +SetValueByPointer(DocumentType& document, const GenericPointer& pointer, T2 value) { + return pointer.Set(document, value); +} + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) { + return GenericPointer(source, N - 1).Set(document, value); +} + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& value) { + return GenericPointer(source, N - 1).Set(document, value); +} + +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* value) { + return GenericPointer(source, N - 1).Set(document, value); +} + +#if RAPIDJSON_HAS_STDSTRING +template +typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const std::basic_string& value) { + return GenericPointer(source, N - 1).Set(document, value); +} +#endif + +template +RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr, internal::IsGenericValue >), (typename DocumentType::ValueType&)) +SetValueByPointer(DocumentType& document, const CharType(&source)[N], T2 value) { + return GenericPointer(source, N - 1).Set(document, value); +} + +////////////////////////////////////////////////////////////////////////////// + +template +typename T::ValueType& SwapValueByPointer(T& root, const GenericPointer& pointer, typename T::ValueType& value, typename T::AllocatorType& a) { + return pointer.Swap(root, value, a); +} + +template +typename T::ValueType& SwapValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) { + return GenericPointer(source, N - 1).Swap(root, value, a); +} + +template +typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const GenericPointer& pointer, typename DocumentType::ValueType& value) { + return pointer.Swap(document, value); +} + +template +typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) { + return GenericPointer(source, N - 1).Swap(document, value); +} + +////////////////////////////////////////////////////////////////////////////// + +template +bool EraseValueByPointer(T& root, const GenericPointer& pointer) { + return pointer.Erase(root); +} + +template +bool EraseValueByPointer(T& root, const CharType(&source)[N]) { + return GenericPointer(source, N - 1).Erase(root); +} + +//@} + +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) || defined(_MSC_VER) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_POINTER_H_ diff --git a/libs/include/rapidjson/prettywriter.h b/libs/include/rapidjson/prettywriter.h new file mode 100644 index 0000000..fe45df1 --- /dev/null +++ b/libs/include/rapidjson/prettywriter.h @@ -0,0 +1,277 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_PRETTYWRITER_H_ +#define RAPIDJSON_PRETTYWRITER_H_ + +#include "writer.h" + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#if defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(c++98-compat) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Combination of PrettyWriter format flags. +/*! \see PrettyWriter::SetFormatOptions + */ +enum PrettyFormatOptions { + kFormatDefault = 0, //!< Default pretty formatting. + kFormatSingleLineArray = 1 //!< Format arrays on a single line. +}; + +//! Writer with indentation and spacing. +/*! + \tparam OutputStream Type of output os. + \tparam SourceEncoding Encoding of source string. + \tparam TargetEncoding Encoding of output stream. + \tparam StackAllocator Type of allocator for allocating memory of stack. +*/ +template, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags> +class PrettyWriter : public Writer { +public: + typedef Writer Base; + typedef typename Base::Ch Ch; + + //! Constructor + /*! \param os Output stream. + \param allocator User supplied allocator. If it is null, it will create a private one. + \param levelDepth Initial capacity of stack. + */ + explicit PrettyWriter(OutputStream& os, StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : + Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {} + + + explicit PrettyWriter(StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : + Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {} + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + PrettyWriter(PrettyWriter&& rhs) : + Base(std::forward(rhs)), indentChar_(rhs.indentChar_), indentCharCount_(rhs.indentCharCount_), formatOptions_(rhs.formatOptions_) {} +#endif + + //! Set custom indentation. + /*! \param indentChar Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r'). + \param indentCharCount Number of indent characters for each indentation level. + \note The default indentation is 4 spaces. + */ + PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) { + RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r'); + indentChar_ = indentChar; + indentCharCount_ = indentCharCount; + return *this; + } + + //! Set pretty writer formatting options. + /*! \param options Formatting options. + */ + PrettyWriter& SetFormatOptions(PrettyFormatOptions options) { + formatOptions_ = options; + return *this; + } + + /*! @name Implementation of Handler + \see Handler + */ + //@{ + + bool Null() { PrettyPrefix(kNullType); return Base::EndValue(Base::WriteNull()); } + bool Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); return Base::EndValue(Base::WriteBool(b)); } + bool Int(int i) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt(i)); } + bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); } + bool Int64(int64_t i64) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt64(i64)); } + bool Uint64(uint64_t u64) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint64(u64)); } + bool Double(double d) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteDouble(d)); } + + bool RawNumber(const Ch* str, SizeType length, bool copy = false) { + RAPIDJSON_ASSERT(str != 0); + (void)copy; + PrettyPrefix(kNumberType); + return Base::EndValue(Base::WriteString(str, length)); + } + + bool String(const Ch* str, SizeType length, bool copy = false) { + RAPIDJSON_ASSERT(str != 0); + (void)copy; + PrettyPrefix(kStringType); + return Base::EndValue(Base::WriteString(str, length)); + } + +#if RAPIDJSON_HAS_STDSTRING + bool String(const std::basic_string& str) { + return String(str.data(), SizeType(str.size())); + } +#endif + + bool StartObject() { + PrettyPrefix(kObjectType); + new (Base::level_stack_.template Push()) typename Base::Level(false); + return Base::WriteStartObject(); + } + + bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); } + +#if RAPIDJSON_HAS_STDSTRING + bool Key(const std::basic_string& str) { + return Key(str.data(), SizeType(str.size())); + } +#endif + + bool EndObject(SizeType memberCount = 0) { + (void)memberCount; + RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); // not inside an Object + RAPIDJSON_ASSERT(!Base::level_stack_.template Top()->inArray); // currently inside an Array, not Object + RAPIDJSON_ASSERT(0 == Base::level_stack_.template Top()->valueCount % 2); // Object has a Key without a Value + + bool empty = Base::level_stack_.template Pop(1)->valueCount == 0; + + if (!empty) { + Base::os_->Put('\n'); + WriteIndent(); + } + bool ret = Base::EndValue(Base::WriteEndObject()); + (void)ret; + RAPIDJSON_ASSERT(ret == true); + if (Base::level_stack_.Empty()) // end of json text + Base::Flush(); + return true; + } + + bool StartArray() { + PrettyPrefix(kArrayType); + new (Base::level_stack_.template Push()) typename Base::Level(true); + return Base::WriteStartArray(); + } + + bool EndArray(SizeType memberCount = 0) { + (void)memberCount; + RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); + RAPIDJSON_ASSERT(Base::level_stack_.template Top()->inArray); + bool empty = Base::level_stack_.template Pop(1)->valueCount == 0; + + if (!empty && !(formatOptions_ & kFormatSingleLineArray)) { + Base::os_->Put('\n'); + WriteIndent(); + } + bool ret = Base::EndValue(Base::WriteEndArray()); + (void)ret; + RAPIDJSON_ASSERT(ret == true); + if (Base::level_stack_.Empty()) // end of json text + Base::Flush(); + return true; + } + + //@} + + /*! @name Convenience extensions */ + //@{ + + //! Simpler but slower overload. + bool String(const Ch* str) { return String(str, internal::StrLen(str)); } + bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); } + + //@} + + //! Write a raw JSON value. + /*! + For user to write a stringified JSON as a value. + + \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range. + \param length Length of the json. + \param type Type of the root of json. + \note When using PrettyWriter::RawValue(), the result json may not be indented correctly. + */ + bool RawValue(const Ch* json, size_t length, Type type) { + RAPIDJSON_ASSERT(json != 0); + PrettyPrefix(type); + return Base::EndValue(Base::WriteRawValue(json, length)); + } + +protected: + void PrettyPrefix(Type type) { + (void)type; + if (Base::level_stack_.GetSize() != 0) { // this value is not at root + typename Base::Level* level = Base::level_stack_.template Top(); + + if (level->inArray) { + if (level->valueCount > 0) { + Base::os_->Put(','); // add comma if it is not the first element in array + if (formatOptions_ & kFormatSingleLineArray) + Base::os_->Put(' '); + } + + if (!(formatOptions_ & kFormatSingleLineArray)) { + Base::os_->Put('\n'); + WriteIndent(); + } + } + else { // in object + if (level->valueCount > 0) { + if (level->valueCount % 2 == 0) { + Base::os_->Put(','); + Base::os_->Put('\n'); + } + else { + Base::os_->Put(':'); + Base::os_->Put(' '); + } + } + else + Base::os_->Put('\n'); + + if (level->valueCount % 2 == 0) + WriteIndent(); + } + if (!level->inArray && level->valueCount % 2 == 0) + RAPIDJSON_ASSERT(type == kStringType); // if it's in object, then even number should be a name + level->valueCount++; + } + else { + RAPIDJSON_ASSERT(!Base::hasRoot_); // Should only has one and only one root. + Base::hasRoot_ = true; + } + } + + void WriteIndent() { + size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_; + PutN(*Base::os_, static_cast(indentChar_), count); + } + + Ch indentChar_; + unsigned indentCharCount_; + PrettyFormatOptions formatOptions_; + +private: + // Prohibit copy constructor & assignment operator. + PrettyWriter(const PrettyWriter&); + PrettyWriter& operator=(const PrettyWriter&); +}; + +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_RAPIDJSON_H_ diff --git a/libs/include/rapidjson/rapidjson.h b/libs/include/rapidjson/rapidjson.h new file mode 100644 index 0000000..a4e8953 --- /dev/null +++ b/libs/include/rapidjson/rapidjson.h @@ -0,0 +1,741 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_RAPIDJSON_H_ +#define RAPIDJSON_RAPIDJSON_H_ + +/*!\file rapidjson.h + \brief common definitions and configuration + + \see RAPIDJSON_CONFIG + */ + +/*! \defgroup RAPIDJSON_CONFIG RapidJSON configuration + \brief Configuration macros for library features + + Some RapidJSON features are configurable to adapt the library to a wide + variety of platforms, environments and usage scenarios. Most of the + features can be configured in terms of overridden or predefined + preprocessor macros at compile-time. + + Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs. + + \note These macros should be given on the compiler command-line + (where applicable) to avoid inconsistent values when compiling + different translation units of a single application. + */ + +#include // malloc(), realloc(), free(), size_t +#include // memset(), memcpy(), memmove(), memcmp() + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_VERSION_STRING +// +// ALWAYS synchronize the following 3 macros with corresponding variables in /CMakeLists.txt. +// + +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +// token stringification +#define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x) +#define RAPIDJSON_DO_STRINGIFY(x) #x + +// token concatenation +#define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y) +#define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y) +#define RAPIDJSON_DO_JOIN2(X, Y) X##Y +//!@endcond + +/*! \def RAPIDJSON_MAJOR_VERSION + \ingroup RAPIDJSON_CONFIG + \brief Major version of RapidJSON in integer. +*/ +/*! \def RAPIDJSON_MINOR_VERSION + \ingroup RAPIDJSON_CONFIG + \brief Minor version of RapidJSON in integer. +*/ +/*! \def RAPIDJSON_PATCH_VERSION + \ingroup RAPIDJSON_CONFIG + \brief Patch version of RapidJSON in integer. +*/ +/*! \def RAPIDJSON_VERSION_STRING + \ingroup RAPIDJSON_CONFIG + \brief Version of RapidJSON in ".." string format. +*/ +#define RAPIDJSON_MAJOR_VERSION 1 +#define RAPIDJSON_MINOR_VERSION 1 +#define RAPIDJSON_PATCH_VERSION 0 +#define RAPIDJSON_VERSION_STRING \ + RAPIDJSON_STRINGIFY(RAPIDJSON_MAJOR_VERSION.RAPIDJSON_MINOR_VERSION.RAPIDJSON_PATCH_VERSION) + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_NAMESPACE_(BEGIN|END) +/*! \def RAPIDJSON_NAMESPACE + \ingroup RAPIDJSON_CONFIG + \brief provide custom rapidjson namespace + + In order to avoid symbol clashes and/or "One Definition Rule" errors + between multiple inclusions of (different versions of) RapidJSON in + a single binary, users can customize the name of the main RapidJSON + namespace. + + In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE + to a custom name (e.g. \c MyRapidJSON) is sufficient. If multiple + levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref + RAPIDJSON_NAMESPACE_END need to be defined as well: + + \code + // in some .cpp file + #define RAPIDJSON_NAMESPACE my::rapidjson + #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson { + #define RAPIDJSON_NAMESPACE_END } } + #include "rapidjson/..." + \endcode + + \see rapidjson + */ +/*! \def RAPIDJSON_NAMESPACE_BEGIN + \ingroup RAPIDJSON_CONFIG + \brief provide custom rapidjson namespace (opening expression) + \see RAPIDJSON_NAMESPACE +*/ +/*! \def RAPIDJSON_NAMESPACE_END + \ingroup RAPIDJSON_CONFIG + \brief provide custom rapidjson namespace (closing expression) + \see RAPIDJSON_NAMESPACE +*/ +#ifndef RAPIDJSON_NAMESPACE +#define RAPIDJSON_NAMESPACE rapidjson +#endif +#ifndef RAPIDJSON_NAMESPACE_BEGIN +#define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE { +#endif +#ifndef RAPIDJSON_NAMESPACE_END +#define RAPIDJSON_NAMESPACE_END } +#endif + +/////////////////////////////////////////////////////////////////////////////// +// __cplusplus macro + +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN + +#if defined(_MSC_VER) +#define RAPIDJSON_CPLUSPLUS _MSVC_LANG +#else +#define RAPIDJSON_CPLUSPLUS __cplusplus +#endif + +//!@endcond + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_HAS_STDSTRING + +#ifndef RAPIDJSON_HAS_STDSTRING +#ifdef RAPIDJSON_DOXYGEN_RUNNING +#define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation +#else +#define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default +#endif +/*! \def RAPIDJSON_HAS_STDSTRING + \ingroup RAPIDJSON_CONFIG + \brief Enable RapidJSON support for \c std::string + + By defining this preprocessor symbol to \c 1, several convenience functions for using + \ref rapidjson::GenericValue with \c std::string are enabled, especially + for construction and comparison. + + \hideinitializer +*/ +#endif // !defined(RAPIDJSON_HAS_STDSTRING) + +#if RAPIDJSON_HAS_STDSTRING +#include +#endif // RAPIDJSON_HAS_STDSTRING + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_USE_MEMBERSMAP + +/*! \def RAPIDJSON_USE_MEMBERSMAP + \ingroup RAPIDJSON_CONFIG + \brief Enable RapidJSON support for object members handling in a \c std::multimap + + By defining this preprocessor symbol to \c 1, \ref rapidjson::GenericValue object + members are stored in a \c std::multimap for faster lookup and deletion times, a + trade off with a slightly slower insertion time and a small object allocat(or)ed + memory overhead. + + \hideinitializer +*/ +#ifndef RAPIDJSON_USE_MEMBERSMAP +#define RAPIDJSON_USE_MEMBERSMAP 0 // not by default +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_NO_INT64DEFINE + +/*! \def RAPIDJSON_NO_INT64DEFINE + \ingroup RAPIDJSON_CONFIG + \brief Use external 64-bit integer types. + + RapidJSON requires the 64-bit integer types \c int64_t and \c uint64_t types + to be available at global scope. + + If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to + prevent RapidJSON from defining its own types. +*/ +#ifndef RAPIDJSON_NO_INT64DEFINE +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#if defined(_MSC_VER) && (_MSC_VER < 1800) // Visual Studio 2013 +#include "msinttypes/stdint.h" +#include "msinttypes/inttypes.h" +#else +// Other compilers should have this. +#include +#include +#endif +//!@endcond +#ifdef RAPIDJSON_DOXYGEN_RUNNING +#define RAPIDJSON_NO_INT64DEFINE +#endif +#endif // RAPIDJSON_NO_INT64TYPEDEF + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_FORCEINLINE + +#ifndef RAPIDJSON_FORCEINLINE +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#if defined(_MSC_VER) && defined(NDEBUG) +#define RAPIDJSON_FORCEINLINE __forceinline +#elif defined(__GNUC__) && __GNUC__ >= 4 && defined(NDEBUG) +#define RAPIDJSON_FORCEINLINE __attribute__((always_inline)) +#else +#define RAPIDJSON_FORCEINLINE +#endif +//!@endcond +#endif // RAPIDJSON_FORCEINLINE + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_ENDIAN +#define RAPIDJSON_LITTLEENDIAN 0 //!< Little endian machine +#define RAPIDJSON_BIGENDIAN 1 //!< Big endian machine + +//! Endianness of the machine. +/*! + \def RAPIDJSON_ENDIAN + \ingroup RAPIDJSON_CONFIG + + GCC 4.6 provided macro for detecting endianness of the target machine. But other + compilers may not have this. User can define RAPIDJSON_ENDIAN to either + \ref RAPIDJSON_LITTLEENDIAN or \ref RAPIDJSON_BIGENDIAN. + + Default detection implemented with reference to + \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html + \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp +*/ +#ifndef RAPIDJSON_ENDIAN +// Detect with GCC 4.6's macro +# ifdef __BYTE_ORDER__ +# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +# define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN +# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ +# define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN +# else +# error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN. +# endif // __BYTE_ORDER__ +// Detect with GLIBC's endian.h +# elif defined(__GLIBC__) +# include +# if (__BYTE_ORDER == __LITTLE_ENDIAN) +# define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN +# elif (__BYTE_ORDER == __BIG_ENDIAN) +# define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN +# else +# error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN. +# endif // __GLIBC__ +// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro +# elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) +# define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN +# elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) +# define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN +// Detect with architecture macros +# elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__) +# define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN +# elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__) +# define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN +# elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64)) +# define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN +# elif defined(RAPIDJSON_DOXYGEN_RUNNING) +# define RAPIDJSON_ENDIAN +# else +# error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN. +# endif +#endif // RAPIDJSON_ENDIAN + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_64BIT + +//! Whether using 64-bit architecture +#ifndef RAPIDJSON_64BIT +#if defined(__LP64__) || (defined(__x86_64__) && defined(__ILP32__)) || defined(_WIN64) || defined(__EMSCRIPTEN__) +#define RAPIDJSON_64BIT 1 +#else +#define RAPIDJSON_64BIT 0 +#endif +#endif // RAPIDJSON_64BIT + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_ALIGN + +//! Data alignment of the machine. +/*! \ingroup RAPIDJSON_CONFIG + \param x pointer to align + + Some machines require strict data alignment. The default is 8 bytes. + User can customize by defining the RAPIDJSON_ALIGN function macro. +*/ +#ifndef RAPIDJSON_ALIGN +#define RAPIDJSON_ALIGN(x) (((x) + static_cast(7u)) & ~static_cast(7u)) +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_UINT64_C2 + +//! Construct a 64-bit literal by a pair of 32-bit integer. +/*! + 64-bit literal with or without ULL suffix is prone to compiler warnings. + UINT64_C() is C macro which cause compilation problems. + Use this macro to define 64-bit constants by a pair of 32-bit integer. +*/ +#ifndef RAPIDJSON_UINT64_C2 +#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast(high32) << 32) | static_cast(low32)) +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_48BITPOINTER_OPTIMIZATION + +//! Use only lower 48-bit address for some pointers. +/*! + \ingroup RAPIDJSON_CONFIG + + This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address. + The higher 16-bit can be used for storing other data. + \c GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture. +*/ +#ifndef RAPIDJSON_48BITPOINTER_OPTIMIZATION +#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64) +#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 1 +#else +#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 0 +#endif +#endif // RAPIDJSON_48BITPOINTER_OPTIMIZATION + +#if RAPIDJSON_48BITPOINTER_OPTIMIZATION == 1 +#if RAPIDJSON_64BIT != 1 +#error RAPIDJSON_48BITPOINTER_OPTIMIZATION can only be set to 1 when RAPIDJSON_64BIT=1 +#endif +#define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast((reinterpret_cast(p) & static_cast(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast(reinterpret_cast(x)))) +#define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast(reinterpret_cast(p) & static_cast(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF)))) +#else +#define RAPIDJSON_SETPOINTER(type, p, x) (p = (x)) +#define RAPIDJSON_GETPOINTER(type, p) (p) +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_NEON/RAPIDJSON_SIMD + +/*! \def RAPIDJSON_SIMD + \ingroup RAPIDJSON_CONFIG + \brief Enable SSE2/SSE4.2/Neon optimization. + + RapidJSON supports optimized implementations for some parsing operations + based on the SSE2, SSE4.2 or NEon SIMD extensions on modern Intel + or ARM compatible processors. + + To enable these optimizations, three different symbols can be defined; + \code + // Enable SSE2 optimization. + #define RAPIDJSON_SSE2 + + // Enable SSE4.2 optimization. + #define RAPIDJSON_SSE42 + \endcode + + // Enable ARM Neon optimization. + #define RAPIDJSON_NEON + \endcode + + \c RAPIDJSON_SSE42 takes precedence over SSE2, if both are defined. + + If any of these symbols is defined, RapidJSON defines the macro + \c RAPIDJSON_SIMD to indicate the availability of the optimized code. +*/ +#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \ + || defined(RAPIDJSON_NEON) || defined(RAPIDJSON_DOXYGEN_RUNNING) +#define RAPIDJSON_SIMD +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_NO_SIZETYPEDEFINE + +#ifndef RAPIDJSON_NO_SIZETYPEDEFINE +/*! \def RAPIDJSON_NO_SIZETYPEDEFINE + \ingroup RAPIDJSON_CONFIG + \brief User-provided \c SizeType definition. + + In order to avoid using 32-bit size types for indexing strings and arrays, + define this preprocessor symbol and provide the type rapidjson::SizeType + before including RapidJSON: + \code + #define RAPIDJSON_NO_SIZETYPEDEFINE + namespace rapidjson { typedef ::std::size_t SizeType; } + #include "rapidjson/..." + \endcode + + \see rapidjson::SizeType +*/ +#ifdef RAPIDJSON_DOXYGEN_RUNNING +#define RAPIDJSON_NO_SIZETYPEDEFINE +#endif +RAPIDJSON_NAMESPACE_BEGIN +//! Size type (for string lengths, array sizes, etc.) +/*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms, + instead of using \c size_t. Users may override the SizeType by defining + \ref RAPIDJSON_NO_SIZETYPEDEFINE. +*/ +typedef unsigned SizeType; +RAPIDJSON_NAMESPACE_END +#endif + +// always import std::size_t to rapidjson namespace +RAPIDJSON_NAMESPACE_BEGIN +using std::size_t; +RAPIDJSON_NAMESPACE_END + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_ASSERT + +//! Assertion. +/*! \ingroup RAPIDJSON_CONFIG + By default, rapidjson uses C \c assert() for internal assertions. + User can override it by defining RAPIDJSON_ASSERT(x) macro. + + \note Parsing errors are handled and can be customized by the + \ref RAPIDJSON_ERRORS APIs. +*/ +#ifndef RAPIDJSON_ASSERT +#include +#define RAPIDJSON_ASSERT(x) assert(x) +#endif // RAPIDJSON_ASSERT + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_STATIC_ASSERT + +// Prefer C++11 static_assert, if available +#ifndef RAPIDJSON_STATIC_ASSERT +#if RAPIDJSON_CPLUSPLUS >= 201103L || ( defined(_MSC_VER) && _MSC_VER >= 1800 ) +#define RAPIDJSON_STATIC_ASSERT(x) \ + static_assert(x, RAPIDJSON_STRINGIFY(x)) +#endif // C++11 +#endif // RAPIDJSON_STATIC_ASSERT + +// Adopt C++03 implementation from boost +#ifndef RAPIDJSON_STATIC_ASSERT +#ifndef __clang__ +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#endif +RAPIDJSON_NAMESPACE_BEGIN +template struct STATIC_ASSERTION_FAILURE; +template <> struct STATIC_ASSERTION_FAILURE { enum { value = 1 }; }; +template struct StaticAssertTest {}; +RAPIDJSON_NAMESPACE_END + +#if defined(__GNUC__) || defined(__clang__) +#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused)) +#else +#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE +#endif +#ifndef __clang__ +//!@endcond +#endif + +/*! \def RAPIDJSON_STATIC_ASSERT + \brief (Internal) macro to check for conditions at compile-time + \param x compile-time condition + \hideinitializer + */ +#define RAPIDJSON_STATIC_ASSERT(x) \ + typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \ + sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE)> \ + RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE +#endif // RAPIDJSON_STATIC_ASSERT + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_LIKELY, RAPIDJSON_UNLIKELY + +//! Compiler branching hint for expression with high probability to be true. +/*! + \ingroup RAPIDJSON_CONFIG + \param x Boolean expression likely to be true. +*/ +#ifndef RAPIDJSON_LIKELY +#if defined(__GNUC__) || defined(__clang__) +#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1) +#else +#define RAPIDJSON_LIKELY(x) (x) +#endif +#endif + +//! Compiler branching hint for expression with low probability to be true. +/*! + \ingroup RAPIDJSON_CONFIG + \param x Boolean expression unlikely to be true. +*/ +#ifndef RAPIDJSON_UNLIKELY +#if defined(__GNUC__) || defined(__clang__) +#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0) +#else +#define RAPIDJSON_UNLIKELY(x) (x) +#endif +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Helpers + +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN + +#define RAPIDJSON_MULTILINEMACRO_BEGIN do { +#define RAPIDJSON_MULTILINEMACRO_END \ +} while((void)0, 0) + +// adopted from Boost +#define RAPIDJSON_VERSION_CODE(x,y,z) \ + (((x)*100000) + ((y)*100) + (z)) + +#if defined(__has_builtin) +#define RAPIDJSON_HAS_BUILTIN(x) __has_builtin(x) +#else +#define RAPIDJSON_HAS_BUILTIN(x) 0 +#endif + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF + +#if defined(__GNUC__) +#define RAPIDJSON_GNUC \ + RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__) +#endif + +#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0)) + +#define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x)) +#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x) +#define RAPIDJSON_DIAG_OFF(x) \ + RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x))) + +// push/pop support in Clang and GCC>=4.6 +#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) +#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push) +#define RAPIDJSON_DIAG_POP RAPIDJSON_DIAG_PRAGMA(pop) +#else // GCC >= 4.2, < 4.6 +#define RAPIDJSON_DIAG_PUSH /* ignored */ +#define RAPIDJSON_DIAG_POP /* ignored */ +#endif + +#elif defined(_MSC_VER) + +// pragma (MSVC specific) +#define RAPIDJSON_PRAGMA(x) __pragma(x) +#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x)) + +#define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x) +#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push) +#define RAPIDJSON_DIAG_POP RAPIDJSON_DIAG_PRAGMA(pop) + +#else + +#define RAPIDJSON_DIAG_OFF(x) /* ignored */ +#define RAPIDJSON_DIAG_PUSH /* ignored */ +#define RAPIDJSON_DIAG_POP /* ignored */ + +#endif // RAPIDJSON_DIAG_* + +/////////////////////////////////////////////////////////////////////////////// +// C++11 features + +#ifndef RAPIDJSON_HAS_CXX11 +#define RAPIDJSON_HAS_CXX11 (RAPIDJSON_CPLUSPLUS >= 201103L) +#endif + +#ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS +#if RAPIDJSON_HAS_CXX11 +#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1 +#elif defined(__clang__) +#if __has_feature(cxx_rvalue_references) && \ + (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306) +#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1 +#else +#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0 +#endif +#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \ + (defined(_MSC_VER) && _MSC_VER >= 1600) || \ + (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__)) + +#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1 +#else +#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0 +#endif +#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS +#include // std::move +#endif + +#ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT +#if RAPIDJSON_HAS_CXX11 +#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1 +#elif defined(__clang__) +#define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept) +#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \ + (defined(_MSC_VER) && _MSC_VER >= 1900) || \ + (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__)) +#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1 +#else +#define RAPIDJSON_HAS_CXX11_NOEXCEPT 0 +#endif +#endif +#ifndef RAPIDJSON_NOEXCEPT +#if RAPIDJSON_HAS_CXX11_NOEXCEPT +#define RAPIDJSON_NOEXCEPT noexcept +#else +#define RAPIDJSON_NOEXCEPT throw() +#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT +#endif + +// no automatic detection, yet +#ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS +#if (defined(_MSC_VER) && _MSC_VER >= 1700) +#define RAPIDJSON_HAS_CXX11_TYPETRAITS 1 +#else +#define RAPIDJSON_HAS_CXX11_TYPETRAITS 0 +#endif +#endif + +#ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR +#if defined(__clang__) +#define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for) +#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \ + (defined(_MSC_VER) && _MSC_VER >= 1700) || \ + (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__)) +#define RAPIDJSON_HAS_CXX11_RANGE_FOR 1 +#else +#define RAPIDJSON_HAS_CXX11_RANGE_FOR 0 +#endif +#endif // RAPIDJSON_HAS_CXX11_RANGE_FOR + +/////////////////////////////////////////////////////////////////////////////// +// C++17 features + +#ifndef RAPIDJSON_HAS_CXX17 +#define RAPIDJSON_HAS_CXX17 (RAPIDJSON_CPLUSPLUS >= 201703L) +#endif + +#if RAPIDJSON_HAS_CXX17 +# define RAPIDJSON_DELIBERATE_FALLTHROUGH [[fallthrough]] +#elif defined(__has_cpp_attribute) +# if __has_cpp_attribute(clang::fallthrough) +# define RAPIDJSON_DELIBERATE_FALLTHROUGH [[clang::fallthrough]] +# elif __has_cpp_attribute(fallthrough) +# define RAPIDJSON_DELIBERATE_FALLTHROUGH __attribute__((fallthrough)) +# else +# define RAPIDJSON_DELIBERATE_FALLTHROUGH +# endif +#else +# define RAPIDJSON_DELIBERATE_FALLTHROUGH +#endif + +//!@endcond + +//! Assertion (in non-throwing contexts). + /*! \ingroup RAPIDJSON_CONFIG + Some functions provide a \c noexcept guarantee, if the compiler supports it. + In these cases, the \ref RAPIDJSON_ASSERT macro cannot be overridden to + throw an exception. This macro adds a separate customization point for + such cases. + + Defaults to C \c assert() (as \ref RAPIDJSON_ASSERT), if \c noexcept is + supported, and to \ref RAPIDJSON_ASSERT otherwise. + */ + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_NOEXCEPT_ASSERT + +#ifndef RAPIDJSON_NOEXCEPT_ASSERT +#ifdef RAPIDJSON_ASSERT_THROWS +#include +#define RAPIDJSON_NOEXCEPT_ASSERT(x) assert(x) +#else +#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x) +#endif // RAPIDJSON_ASSERT_THROWS +#endif // RAPIDJSON_NOEXCEPT_ASSERT + +/////////////////////////////////////////////////////////////////////////////// +// malloc/realloc/free + +#ifndef RAPIDJSON_MALLOC +///! customization point for global \c malloc +#define RAPIDJSON_MALLOC(size) std::malloc(size) +#endif +#ifndef RAPIDJSON_REALLOC +///! customization point for global \c realloc +#define RAPIDJSON_REALLOC(ptr, new_size) std::realloc(ptr, new_size) +#endif +#ifndef RAPIDJSON_FREE +///! customization point for global \c free +#define RAPIDJSON_FREE(ptr) std::free(ptr) +#endif + +/////////////////////////////////////////////////////////////////////////////// +// new/delete + +#ifndef RAPIDJSON_NEW +///! customization point for global \c new +#define RAPIDJSON_NEW(TypeName) new TypeName +#endif +#ifndef RAPIDJSON_DELETE +///! customization point for global \c delete +#define RAPIDJSON_DELETE(x) delete x +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Type + +/*! \namespace rapidjson + \brief main RapidJSON namespace + \see RAPIDJSON_NAMESPACE +*/ +RAPIDJSON_NAMESPACE_BEGIN + +//! Type of JSON value +enum Type { + kNullType = 0, //!< null + kFalseType = 1, //!< false + kTrueType = 2, //!< true + kObjectType = 3, //!< object + kArrayType = 4, //!< array + kStringType = 5, //!< string + kNumberType = 6 //!< number +}; + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_RAPIDJSON_H_ diff --git a/libs/include/rapidjson/reader.h b/libs/include/rapidjson/reader.h new file mode 100644 index 0000000..09ace4e --- /dev/null +++ b/libs/include/rapidjson/reader.h @@ -0,0 +1,2244 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_READER_H_ +#define RAPIDJSON_READER_H_ + +/*! \file reader.h */ + +#include "allocators.h" +#include "stream.h" +#include "encodedstream.h" +#include "internal/clzll.h" +#include "internal/meta.h" +#include "internal/stack.h" +#include "internal/strtod.h" +#include + +#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER) +#include +#pragma intrinsic(_BitScanForward) +#endif +#ifdef RAPIDJSON_SSE42 +#include +#elif defined(RAPIDJSON_SSE2) +#include +#elif defined(RAPIDJSON_NEON) +#include +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(old-style-cast) +RAPIDJSON_DIAG_OFF(padded) +RAPIDJSON_DIAG_OFF(switch-enum) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant +RAPIDJSON_DIAG_OFF(4702) // unreachable code +#endif + +#ifdef __GNUC__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(effc++) +#endif + +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#define RAPIDJSON_NOTHING /* deliberately empty */ +#ifndef RAPIDJSON_PARSE_ERROR_EARLY_RETURN +#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN(value) \ + RAPIDJSON_MULTILINEMACRO_BEGIN \ + if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \ + RAPIDJSON_MULTILINEMACRO_END +#endif +#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \ + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING) +//!@endcond + +/*! \def RAPIDJSON_PARSE_ERROR_NORETURN + \ingroup RAPIDJSON_ERRORS + \brief Macro to indicate a parse error. + \param parseErrorCode \ref rapidjson::ParseErrorCode of the error + \param offset position of the error in JSON input (\c size_t) + + This macros can be used as a customization point for the internal + error handling mechanism of RapidJSON. + + A common usage model is to throw an exception instead of requiring the + caller to explicitly check the \ref rapidjson::GenericReader::Parse's + return value: + + \code + #define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode,offset) \ + throw ParseException(parseErrorCode, #parseErrorCode, offset) + + #include // std::runtime_error + #include "rapidjson/error/error.h" // rapidjson::ParseResult + + struct ParseException : std::runtime_error, rapidjson::ParseResult { + ParseException(rapidjson::ParseErrorCode code, const char* msg, size_t offset) + : std::runtime_error(msg), ParseResult(code, offset) {} + }; + + #include "rapidjson/reader.h" + \endcode + + \see RAPIDJSON_PARSE_ERROR, rapidjson::GenericReader::Parse + */ +#ifndef RAPIDJSON_PARSE_ERROR_NORETURN +#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \ + RAPIDJSON_MULTILINEMACRO_BEGIN \ + RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \ + SetParseError(parseErrorCode, offset); \ + RAPIDJSON_MULTILINEMACRO_END +#endif + +/*! \def RAPIDJSON_PARSE_ERROR + \ingroup RAPIDJSON_ERRORS + \brief (Internal) macro to indicate and handle a parse error. + \param parseErrorCode \ref rapidjson::ParseErrorCode of the error + \param offset position of the error in JSON input (\c size_t) + + Invokes RAPIDJSON_PARSE_ERROR_NORETURN and stops the parsing. + + \see RAPIDJSON_PARSE_ERROR_NORETURN + \hideinitializer + */ +#ifndef RAPIDJSON_PARSE_ERROR +#define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset) \ + RAPIDJSON_MULTILINEMACRO_BEGIN \ + RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \ + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \ + RAPIDJSON_MULTILINEMACRO_END +#endif + +#include "error/error.h" // ParseErrorCode, ParseResult + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// ParseFlag + +/*! \def RAPIDJSON_PARSE_DEFAULT_FLAGS + \ingroup RAPIDJSON_CONFIG + \brief User-defined kParseDefaultFlags definition. + + User can define this as any \c ParseFlag combinations. +*/ +#ifndef RAPIDJSON_PARSE_DEFAULT_FLAGS +#define RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags +#endif + +//! Combination of parseFlags +/*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream + */ +enum ParseFlag { + kParseNoFlags = 0, //!< No flags are set. + kParseInsituFlag = 1, //!< In-situ(destructive) parsing. + kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings. + kParseIterativeFlag = 4, //!< Iterative(constant complexity in terms of function call stack size) parsing. + kParseStopWhenDoneFlag = 8, //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error. + kParseFullPrecisionFlag = 16, //!< Parse number in full precision (but slower). + kParseCommentsFlag = 32, //!< Allow one-line (//) and multi-line (/**/) comments. + kParseNumbersAsStringsFlag = 64, //!< Parse all numbers (ints/doubles) as strings. + kParseTrailingCommasFlag = 128, //!< Allow trailing commas at the end of objects and arrays. + kParseNanAndInfFlag = 256, //!< Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles. + kParseEscapedApostropheFlag = 512, //!< Allow escaped apostrophe in strings. + kParseDefaultFlags = RAPIDJSON_PARSE_DEFAULT_FLAGS //!< Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS +}; + +/////////////////////////////////////////////////////////////////////////////// +// Handler + +/*! \class rapidjson::Handler + \brief Concept for receiving events from GenericReader upon parsing. + The functions return true if no error occurs. If they return false, + the event publisher should terminate the process. +\code +concept Handler { + typename Ch; + + bool Null(); + bool Bool(bool b); + bool Int(int i); + bool Uint(unsigned i); + bool Int64(int64_t i); + bool Uint64(uint64_t i); + bool Double(double d); + /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length) + bool RawNumber(const Ch* str, SizeType length, bool copy); + bool String(const Ch* str, SizeType length, bool copy); + bool StartObject(); + bool Key(const Ch* str, SizeType length, bool copy); + bool EndObject(SizeType memberCount); + bool StartArray(); + bool EndArray(SizeType elementCount); +}; +\endcode +*/ +/////////////////////////////////////////////////////////////////////////////// +// BaseReaderHandler + +//! Default implementation of Handler. +/*! This can be used as base class of any reader handler. + \note implements Handler concept +*/ +template, typename Derived = void> +struct BaseReaderHandler { + typedef typename Encoding::Ch Ch; + + typedef typename internal::SelectIf, BaseReaderHandler, Derived>::Type Override; + + bool Default() { return true; } + bool Null() { return static_cast(*this).Default(); } + bool Bool(bool) { return static_cast(*this).Default(); } + bool Int(int) { return static_cast(*this).Default(); } + bool Uint(unsigned) { return static_cast(*this).Default(); } + bool Int64(int64_t) { return static_cast(*this).Default(); } + bool Uint64(uint64_t) { return static_cast(*this).Default(); } + bool Double(double) { return static_cast(*this).Default(); } + /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length) + bool RawNumber(const Ch* str, SizeType len, bool copy) { return static_cast(*this).String(str, len, copy); } + bool String(const Ch*, SizeType, bool) { return static_cast(*this).Default(); } + bool StartObject() { return static_cast(*this).Default(); } + bool Key(const Ch* str, SizeType len, bool copy) { return static_cast(*this).String(str, len, copy); } + bool EndObject(SizeType) { return static_cast(*this).Default(); } + bool StartArray() { return static_cast(*this).Default(); } + bool EndArray(SizeType) { return static_cast(*this).Default(); } +}; + +/////////////////////////////////////////////////////////////////////////////// +// StreamLocalCopy + +namespace internal { + +template::copyOptimization> +class StreamLocalCopy; + +//! Do copy optimization. +template +class StreamLocalCopy { +public: + StreamLocalCopy(Stream& original) : s(original), original_(original) {} + ~StreamLocalCopy() { original_ = s; } + + Stream s; + +private: + StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */; + + Stream& original_; +}; + +//! Keep reference. +template +class StreamLocalCopy { +public: + StreamLocalCopy(Stream& original) : s(original) {} + + Stream& s; + +private: + StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */; +}; + +} // namespace internal + +/////////////////////////////////////////////////////////////////////////////// +// SkipWhitespace + +//! Skip the JSON white spaces in a stream. +/*! \param is A input stream for skipping white spaces. + \note This function has SSE2/SSE4.2 specialization. +*/ +template +void SkipWhitespace(InputStream& is) { + internal::StreamLocalCopy copy(is); + InputStream& s(copy.s); + + typename InputStream::Ch c; + while ((c = s.Peek()) == ' ' || c == '\n' || c == '\r' || c == '\t') + s.Take(); +} + +inline const char* SkipWhitespace(const char* p, const char* end) { + while (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')) + ++p; + return p; +} + +#ifdef RAPIDJSON_SSE42 +//! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once. +inline const char *SkipWhitespace_SIMD(const char* p) { + // Fast return for single non-whitespace + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + // 16-byte align to the next boundary + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + // The rest of string using SIMD + static const char whitespace[16] = " \n\r\t"; + const __m128i w = _mm_loadu_si128(reinterpret_cast(&whitespace[0])); + + for (;; p += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY); + if (r != 16) // some of characters is non-whitespace + return p + r; + } +} + +inline const char *SkipWhitespace_SIMD(const char* p, const char* end) { + // Fast return for single non-whitespace + if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')) + ++p; + else + return p; + + // The middle of string using SIMD + static const char whitespace[16] = " \n\r\t"; + const __m128i w = _mm_loadu_si128(reinterpret_cast(&whitespace[0])); + + for (; p <= end - 16; p += 16) { + const __m128i s = _mm_loadu_si128(reinterpret_cast(p)); + const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY); + if (r != 16) // some of characters is non-whitespace + return p + r; + } + + return SkipWhitespace(p, end); +} + +#elif defined(RAPIDJSON_SSE2) + +//! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once. +inline const char *SkipWhitespace_SIMD(const char* p) { + // Fast return for single non-whitespace + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + // 16-byte align to the next boundary + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + // The rest of string + #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c } + static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') }; + #undef C16 + + const __m128i w0 = _mm_loadu_si128(reinterpret_cast(&whitespaces[0][0])); + const __m128i w1 = _mm_loadu_si128(reinterpret_cast(&whitespaces[1][0])); + const __m128i w2 = _mm_loadu_si128(reinterpret_cast(&whitespaces[2][0])); + const __m128i w3 = _mm_loadu_si128(reinterpret_cast(&whitespaces[3][0])); + + for (;; p += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + __m128i x = _mm_cmpeq_epi8(s, w0); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1)); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2)); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3)); + unsigned short r = static_cast(~_mm_movemask_epi8(x)); + if (r != 0) { // some of characters may be non-whitespace +#ifdef _MSC_VER // Find the index of first non-whitespace + unsigned long offset; + _BitScanForward(&offset, r); + return p + offset; +#else + return p + __builtin_ffs(r) - 1; +#endif + } + } +} + +inline const char *SkipWhitespace_SIMD(const char* p, const char* end) { + // Fast return for single non-whitespace + if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')) + ++p; + else + return p; + + // The rest of string + #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c } + static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') }; + #undef C16 + + const __m128i w0 = _mm_loadu_si128(reinterpret_cast(&whitespaces[0][0])); + const __m128i w1 = _mm_loadu_si128(reinterpret_cast(&whitespaces[1][0])); + const __m128i w2 = _mm_loadu_si128(reinterpret_cast(&whitespaces[2][0])); + const __m128i w3 = _mm_loadu_si128(reinterpret_cast(&whitespaces[3][0])); + + for (; p <= end - 16; p += 16) { + const __m128i s = _mm_loadu_si128(reinterpret_cast(p)); + __m128i x = _mm_cmpeq_epi8(s, w0); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1)); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2)); + x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3)); + unsigned short r = static_cast(~_mm_movemask_epi8(x)); + if (r != 0) { // some of characters may be non-whitespace +#ifdef _MSC_VER // Find the index of first non-whitespace + unsigned long offset; + _BitScanForward(&offset, r); + return p + offset; +#else + return p + __builtin_ffs(r) - 1; +#endif + } + } + + return SkipWhitespace(p, end); +} + +#elif defined(RAPIDJSON_NEON) + +//! Skip whitespace with ARM Neon instructions, testing 16 8-byte characters at once. +inline const char *SkipWhitespace_SIMD(const char* p) { + // Fast return for single non-whitespace + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + // 16-byte align to the next boundary + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') + ++p; + else + return p; + + const uint8x16_t w0 = vmovq_n_u8(' '); + const uint8x16_t w1 = vmovq_n_u8('\n'); + const uint8x16_t w2 = vmovq_n_u8('\r'); + const uint8x16_t w3 = vmovq_n_u8('\t'); + + for (;; p += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, w0); + x = vorrq_u8(x, vceqq_u8(s, w1)); + x = vorrq_u8(x, vceqq_u8(s, w2)); + x = vorrq_u8(x, vceqq_u8(s, w3)); + + x = vmvnq_u8(x); // Negate + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract + uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract + + if (low == 0) { + if (high != 0) { + uint32_t lz = internal::clzll(high); + return p + 8 + (lz >> 3); + } + } else { + uint32_t lz = internal::clzll(low); + return p + (lz >> 3); + } + } +} + +inline const char *SkipWhitespace_SIMD(const char* p, const char* end) { + // Fast return for single non-whitespace + if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')) + ++p; + else + return p; + + const uint8x16_t w0 = vmovq_n_u8(' '); + const uint8x16_t w1 = vmovq_n_u8('\n'); + const uint8x16_t w2 = vmovq_n_u8('\r'); + const uint8x16_t w3 = vmovq_n_u8('\t'); + + for (; p <= end - 16; p += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, w0); + x = vorrq_u8(x, vceqq_u8(s, w1)); + x = vorrq_u8(x, vceqq_u8(s, w2)); + x = vorrq_u8(x, vceqq_u8(s, w3)); + + x = vmvnq_u8(x); // Negate + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract + uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract + + if (low == 0) { + if (high != 0) { + uint32_t lz = internal::clzll(high); + return p + 8 + (lz >> 3); + } + } else { + uint32_t lz = internal::clzll(low); + return p + (lz >> 3); + } + } + + return SkipWhitespace(p, end); +} + +#endif // RAPIDJSON_NEON + +#ifdef RAPIDJSON_SIMD +//! Template function specialization for InsituStringStream +template<> inline void SkipWhitespace(InsituStringStream& is) { + is.src_ = const_cast(SkipWhitespace_SIMD(is.src_)); +} + +//! Template function specialization for StringStream +template<> inline void SkipWhitespace(StringStream& is) { + is.src_ = SkipWhitespace_SIMD(is.src_); +} + +template<> inline void SkipWhitespace(EncodedInputStream, MemoryStream>& is) { + is.is_.src_ = SkipWhitespace_SIMD(is.is_.src_, is.is_.end_); +} +#endif // RAPIDJSON_SIMD + +/////////////////////////////////////////////////////////////////////////////// +// GenericReader + +//! SAX-style JSON parser. Use \ref Reader for UTF8 encoding and default allocator. +/*! GenericReader parses JSON text from a stream, and send events synchronously to an + object implementing Handler concept. + + It needs to allocate a stack for storing a single decoded string during + non-destructive parsing. + + For in-situ parsing, the decoded string is directly written to the source + text string, no temporary buffer is required. + + A GenericReader object can be reused for parsing multiple JSON text. + + \tparam SourceEncoding Encoding of the input stream. + \tparam TargetEncoding Encoding of the parse output. + \tparam StackAllocator Allocator type for stack. +*/ +template +class GenericReader { +public: + typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type + + //! Constructor. + /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing) + \param stackCapacity stack capacity in bytes for storing a single decoded string. (Only use for non-destructive parsing) + */ + GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) : + stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {} + + //! Parse JSON text. + /*! \tparam parseFlags Combination of \ref ParseFlag. + \tparam InputStream Type of input stream, implementing Stream concept. + \tparam Handler Type of handler, implementing Handler concept. + \param is Input stream to be parsed. + \param handler The handler to receive events. + \return Whether the parsing is successful. + */ + template + ParseResult Parse(InputStream& is, Handler& handler) { + if (parseFlags & kParseIterativeFlag) + return IterativeParse(is, handler); + + parseResult_.Clear(); + + ClearStackOnExit scope(*this); + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + + if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell()); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + } + else { + ParseValue(is, handler); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + + if (!(parseFlags & kParseStopWhenDoneFlag)) { + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + + if (RAPIDJSON_UNLIKELY(is.Peek() != '\0')) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell()); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + } + } + } + + return parseResult_; + } + + //! Parse JSON text (with \ref kParseDefaultFlags) + /*! \tparam InputStream Type of input stream, implementing Stream concept + \tparam Handler Type of handler, implementing Handler concept. + \param is Input stream to be parsed. + \param handler The handler to receive events. + \return Whether the parsing is successful. + */ + template + ParseResult Parse(InputStream& is, Handler& handler) { + return Parse(is, handler); + } + + //! Initialize JSON text token-by-token parsing + /*! + */ + void IterativeParseInit() { + parseResult_.Clear(); + state_ = IterativeParsingStartState; + } + + //! Parse one token from JSON text + /*! \tparam InputStream Type of input stream, implementing Stream concept + \tparam Handler Type of handler, implementing Handler concept. + \param is Input stream to be parsed. + \param handler The handler to receive events. + \return Whether the parsing is successful. + */ + template + bool IterativeParseNext(InputStream& is, Handler& handler) { + while (RAPIDJSON_LIKELY(is.Peek() != '\0')) { + SkipWhitespaceAndComments(is); + + Token t = Tokenize(is.Peek()); + IterativeParsingState n = Predict(state_, t); + IterativeParsingState d = Transit(state_, t, n, is, handler); + + // If we've finished or hit an error... + if (RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d))) { + // Report errors. + if (d == IterativeParsingErrorState) { + HandleError(state_, is); + return false; + } + + // Transition to the finish state. + RAPIDJSON_ASSERT(d == IterativeParsingFinishState); + state_ = d; + + // If StopWhenDone is not set... + if (!(parseFlags & kParseStopWhenDoneFlag)) { + // ... and extra non-whitespace data is found... + SkipWhitespaceAndComments(is); + if (is.Peek() != '\0') { + // ... this is considered an error. + HandleError(state_, is); + return false; + } + } + + // Success! We are done! + return true; + } + + // Transition to the new state. + state_ = d; + + // If we parsed anything other than a delimiter, we invoked the handler, so we can return true now. + if (!IsIterativeParsingDelimiterState(n)) + return true; + } + + // We reached the end of file. + stack_.Clear(); + + if (state_ != IterativeParsingFinishState) { + HandleError(state_, is); + return false; + } + + return true; + } + + //! Check if token-by-token parsing JSON text is complete + /*! \return Whether the JSON has been fully decoded. + */ + RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const { + return IsIterativeParsingCompleteState(state_); + } + + //! Whether a parse error has occurred in the last parsing. + bool HasParseError() const { return parseResult_.IsError(); } + + //! Get the \ref ParseErrorCode of last parsing. + ParseErrorCode GetParseErrorCode() const { return parseResult_.Code(); } + + //! Get the position of last parsing error in input, 0 otherwise. + size_t GetErrorOffset() const { return parseResult_.Offset(); } + +protected: + void SetParseError(ParseErrorCode code, size_t offset) { parseResult_.Set(code, offset); } + +private: + // Prohibit copy constructor & assignment operator. + GenericReader(const GenericReader&); + GenericReader& operator=(const GenericReader&); + + void ClearStack() { stack_.Clear(); } + + // clear stack on any exit from ParseStream, e.g. due to exception + struct ClearStackOnExit { + explicit ClearStackOnExit(GenericReader& r) : r_(r) {} + ~ClearStackOnExit() { r_.ClearStack(); } + private: + GenericReader& r_; + ClearStackOnExit(const ClearStackOnExit&); + ClearStackOnExit& operator=(const ClearStackOnExit&); + }; + + template + void SkipWhitespaceAndComments(InputStream& is) { + SkipWhitespace(is); + + if (parseFlags & kParseCommentsFlag) { + while (RAPIDJSON_UNLIKELY(Consume(is, '/'))) { + if (Consume(is, '*')) { + while (true) { + if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) + RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell()); + else if (Consume(is, '*')) { + if (Consume(is, '/')) + break; + } + else + is.Take(); + } + } + else if (RAPIDJSON_LIKELY(Consume(is, '/'))) + while (is.Peek() != '\0' && is.Take() != '\n') {} + else + RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell()); + + SkipWhitespace(is); + } + } + } + + // Parse object: { string : value, ... } + template + void ParseObject(InputStream& is, Handler& handler) { + RAPIDJSON_ASSERT(is.Peek() == '{'); + is.Take(); // Skip '{' + + if (RAPIDJSON_UNLIKELY(!handler.StartObject())) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + if (Consume(is, '}')) { + if (RAPIDJSON_UNLIKELY(!handler.EndObject(0))) // empty object + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + return; + } + + for (SizeType memberCount = 0;;) { + if (RAPIDJSON_UNLIKELY(is.Peek() != '"')) + RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell()); + + ParseString(is, handler, true); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + if (RAPIDJSON_UNLIKELY(!Consume(is, ':'))) + RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell()); + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + ParseValue(is, handler); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + ++memberCount; + + switch (is.Peek()) { + case ',': + is.Take(); + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + break; + case '}': + is.Take(); + if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + return; + default: + RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); break; // This useless break is only for making warning and coverage happy + } + + if (parseFlags & kParseTrailingCommasFlag) { + if (is.Peek() == '}') { + if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + is.Take(); + return; + } + } + } + } + + // Parse array: [ value, ... ] + template + void ParseArray(InputStream& is, Handler& handler) { + RAPIDJSON_ASSERT(is.Peek() == '['); + is.Take(); // Skip '[' + + if (RAPIDJSON_UNLIKELY(!handler.StartArray())) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + if (Consume(is, ']')) { + if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + return; + } + + for (SizeType elementCount = 0;;) { + ParseValue(is, handler); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + ++elementCount; + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + + if (Consume(is, ',')) { + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + } + else if (Consume(is, ']')) { + if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + return; + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell()); + + if (parseFlags & kParseTrailingCommasFlag) { + if (is.Peek() == ']') { + if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + is.Take(); + return; + } + } + } + } + + template + void ParseNull(InputStream& is, Handler& handler) { + RAPIDJSON_ASSERT(is.Peek() == 'n'); + is.Take(); + + if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) { + if (RAPIDJSON_UNLIKELY(!handler.Null())) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); + } + + template + void ParseTrue(InputStream& is, Handler& handler) { + RAPIDJSON_ASSERT(is.Peek() == 't'); + is.Take(); + + if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e'))) { + if (RAPIDJSON_UNLIKELY(!handler.Bool(true))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); + } + + template + void ParseFalse(InputStream& is, Handler& handler) { + RAPIDJSON_ASSERT(is.Peek() == 'f'); + is.Take(); + + if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) { + if (RAPIDJSON_UNLIKELY(!handler.Bool(false))) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell()); + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); + } + + template + RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) { + if (RAPIDJSON_LIKELY(is.Peek() == expect)) { + is.Take(); + return true; + } + else + return false; + } + + // Helper function to parse four hexadecimal digits in \uXXXX in ParseString(). + template + unsigned ParseHex4(InputStream& is, size_t escapeOffset) { + unsigned codepoint = 0; + for (int i = 0; i < 4; i++) { + Ch c = is.Peek(); + codepoint <<= 4; + codepoint += static_cast(c); + if (c >= '0' && c <= '9') + codepoint -= '0'; + else if (c >= 'A' && c <= 'F') + codepoint -= 'A' - 10; + else if (c >= 'a' && c <= 'f') + codepoint -= 'a' - 10; + else { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0); + } + is.Take(); + } + return codepoint; + } + + template + class StackStream { + public: + typedef CharType Ch; + + StackStream(internal::Stack& stack) : stack_(stack), length_(0) {} + RAPIDJSON_FORCEINLINE void Put(Ch c) { + *stack_.template Push() = c; + ++length_; + } + + RAPIDJSON_FORCEINLINE void* Push(SizeType count) { + length_ += count; + return stack_.template Push(count); + } + + size_t Length() const { return length_; } + + Ch* Pop() { + return stack_.template Pop(length_); + } + + private: + StackStream(const StackStream&); + StackStream& operator=(const StackStream&); + + internal::Stack& stack_; + SizeType length_; + }; + + // Parse string and generate String event. Different code paths for kParseInsituFlag. + template + void ParseString(InputStream& is, Handler& handler, bool isKey = false) { + internal::StreamLocalCopy copy(is); + InputStream& s(copy.s); + + RAPIDJSON_ASSERT(s.Peek() == '\"'); + s.Take(); // Skip '\"' + + bool success = false; + if (parseFlags & kParseInsituFlag) { + typename InputStream::Ch *head = s.PutBegin(); + ParseStringToStream(s, s); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + size_t length = s.PutEnd(head) - 1; + RAPIDJSON_ASSERT(length <= 0xFFFFFFFF); + const typename TargetEncoding::Ch* const str = reinterpret_cast(head); + success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false)); + } + else { + StackStream stackStream(stack_); + ParseStringToStream(s, stackStream); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + SizeType length = static_cast(stackStream.Length()) - 1; + const typename TargetEncoding::Ch* const str = stackStream.Pop(); + success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true)); + } + if (RAPIDJSON_UNLIKELY(!success)) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell()); + } + + // Parse string to an output is + // This function handles the prefix/suffix double quotes, escaping, and optional encoding validation. + template + RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) { +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + static const char escape[256] = { + Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/', + Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0, + 0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0, + 0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16 + }; +#undef Z16 +//!@endcond + + for (;;) { + // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation. + if (!(parseFlags & kParseValidateEncodingFlag)) + ScanCopyUnescapedString(is, os); + + Ch c = is.Peek(); + if (RAPIDJSON_UNLIKELY(c == '\\')) { // Escape + size_t escapeOffset = is.Tell(); // For invalid escaping, report the initial '\\' as error offset + is.Take(); + Ch e = is.Peek(); + if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast(e)])) { + is.Take(); + os.Put(static_cast(escape[static_cast(e)])); + } + else if ((parseFlags & kParseEscapedApostropheFlag) && RAPIDJSON_LIKELY(e == '\'')) { // Allow escaped apostrophe + is.Take(); + os.Put('\''); + } + else if (RAPIDJSON_LIKELY(e == 'u')) { // Unicode + is.Take(); + unsigned codepoint = ParseHex4(is, escapeOffset); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDFFF)) { + // high surrogate, check if followed by valid low surrogate + if (RAPIDJSON_LIKELY(codepoint <= 0xDBFF)) { + // Handle UTF-16 surrogate pair + if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u'))) + RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset); + unsigned codepoint2 = ParseHex4(is, escapeOffset); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; + if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF)) + RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset); + codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000; + } + // single low surrogate + else + { + RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset); + } + } + TEncoding::Encode(os, codepoint); + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset); + } + else if (RAPIDJSON_UNLIKELY(c == '"')) { // Closing double quote + is.Take(); + os.Put('\0'); // null-terminate the string + return; + } + else if (RAPIDJSON_UNLIKELY(static_cast(c) < 0x20)) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF + if (c == '\0') + RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell()); + else + RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell()); + } + else { + size_t offset = is.Tell(); + if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ? + !Transcoder::Validate(is, os) : + !Transcoder::Transcode(is, os)))) + RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset); + } + } + } + + template + static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InputStream&, OutputStream&) { + // Do nothing for generic version + } + +#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) + // StringStream -> StackStream + static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream& os) { + const char* p = is.src_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = p; + return; + } + else + os.Put(*p++); + + // The rest of string using SIMD + static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' }; + static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' }; + static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }; + const __m128i dq = _mm_loadu_si128(reinterpret_cast(&dquote[0])); + const __m128i bs = _mm_loadu_si128(reinterpret_cast(&bslash[0])); + const __m128i sp = _mm_loadu_si128(reinterpret_cast(&space[0])); + + for (;; p += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + const __m128i t1 = _mm_cmpeq_epi8(s, dq); + const __m128i t2 = _mm_cmpeq_epi8(s, bs); + const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F + const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3); + unsigned short r = static_cast(_mm_movemask_epi8(x)); + if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped + SizeType length; + #ifdef _MSC_VER // Find the index of first escaped + unsigned long offset; + _BitScanForward(&offset, r); + length = offset; + #else + length = static_cast(__builtin_ffs(r) - 1); + #endif + if (length != 0) { + char* q = reinterpret_cast(os.Push(length)); + for (size_t i = 0; i < length; i++) + q[i] = p[i]; + + p += length; + } + break; + } + _mm_storeu_si128(reinterpret_cast<__m128i *>(os.Push(16)), s); + } + + is.src_ = p; + } + + // InsituStringStream -> InsituStringStream + static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) { + RAPIDJSON_ASSERT(&is == &os); + (void)os; + + if (is.src_ == is.dst_) { + SkipUnescapedString(is); + return; + } + + char* p = is.src_; + char *q = is.dst_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = p; + is.dst_ = q; + return; + } + else + *q++ = *p++; + + // The rest of string using SIMD + static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' }; + static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' }; + static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }; + const __m128i dq = _mm_loadu_si128(reinterpret_cast(&dquote[0])); + const __m128i bs = _mm_loadu_si128(reinterpret_cast(&bslash[0])); + const __m128i sp = _mm_loadu_si128(reinterpret_cast(&space[0])); + + for (;; p += 16, q += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + const __m128i t1 = _mm_cmpeq_epi8(s, dq); + const __m128i t2 = _mm_cmpeq_epi8(s, bs); + const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F + const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3); + unsigned short r = static_cast(_mm_movemask_epi8(x)); + if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped + size_t length; +#ifdef _MSC_VER // Find the index of first escaped + unsigned long offset; + _BitScanForward(&offset, r); + length = offset; +#else + length = static_cast(__builtin_ffs(r) - 1); +#endif + for (const char* pend = p + length; p != pend; ) + *q++ = *p++; + break; + } + _mm_storeu_si128(reinterpret_cast<__m128i *>(q), s); + } + + is.src_ = p; + is.dst_ = q; + } + + // When read/write pointers are the same for insitu stream, just skip unescaped characters + static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) { + RAPIDJSON_ASSERT(is.src_ == is.dst_); + char* p = is.src_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + for (; p != nextAligned; p++) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = is.dst_ = p; + return; + } + + // The rest of string using SIMD + static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' }; + static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' }; + static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }; + const __m128i dq = _mm_loadu_si128(reinterpret_cast(&dquote[0])); + const __m128i bs = _mm_loadu_si128(reinterpret_cast(&bslash[0])); + const __m128i sp = _mm_loadu_si128(reinterpret_cast(&space[0])); + + for (;; p += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + const __m128i t1 = _mm_cmpeq_epi8(s, dq); + const __m128i t2 = _mm_cmpeq_epi8(s, bs); + const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F + const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3); + unsigned short r = static_cast(_mm_movemask_epi8(x)); + if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped + size_t length; +#ifdef _MSC_VER // Find the index of first escaped + unsigned long offset; + _BitScanForward(&offset, r); + length = offset; +#else + length = static_cast(__builtin_ffs(r) - 1); +#endif + p += length; + break; + } + } + + is.src_ = is.dst_ = p; + } +#elif defined(RAPIDJSON_NEON) + // StringStream -> StackStream + static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream& os) { + const char* p = is.src_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = p; + return; + } + else + os.Put(*p++); + + // The rest of string using SIMD + const uint8x16_t s0 = vmovq_n_u8('"'); + const uint8x16_t s1 = vmovq_n_u8('\\'); + const uint8x16_t s2 = vmovq_n_u8('\b'); + const uint8x16_t s3 = vmovq_n_u8(32); + + for (;; p += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, s0); + x = vorrq_u8(x, vceqq_u8(s, s1)); + x = vorrq_u8(x, vceqq_u8(s, s2)); + x = vorrq_u8(x, vcltq_u8(s, s3)); + + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract + uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract + + SizeType length = 0; + bool escaped = false; + if (low == 0) { + if (high != 0) { + uint32_t lz = internal::clzll(high); + length = 8 + (lz >> 3); + escaped = true; + } + } else { + uint32_t lz = internal::clzll(low); + length = lz >> 3; + escaped = true; + } + if (RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped + if (length != 0) { + char* q = reinterpret_cast(os.Push(length)); + for (size_t i = 0; i < length; i++) + q[i] = p[i]; + + p += length; + } + break; + } + vst1q_u8(reinterpret_cast(os.Push(16)), s); + } + + is.src_ = p; + } + + // InsituStringStream -> InsituStringStream + static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) { + RAPIDJSON_ASSERT(&is == &os); + (void)os; + + if (is.src_ == is.dst_) { + SkipUnescapedString(is); + return; + } + + char* p = is.src_; + char *q = is.dst_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + while (p != nextAligned) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = p; + is.dst_ = q; + return; + } + else + *q++ = *p++; + + // The rest of string using SIMD + const uint8x16_t s0 = vmovq_n_u8('"'); + const uint8x16_t s1 = vmovq_n_u8('\\'); + const uint8x16_t s2 = vmovq_n_u8('\b'); + const uint8x16_t s3 = vmovq_n_u8(32); + + for (;; p += 16, q += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, s0); + x = vorrq_u8(x, vceqq_u8(s, s1)); + x = vorrq_u8(x, vceqq_u8(s, s2)); + x = vorrq_u8(x, vcltq_u8(s, s3)); + + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract + uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract + + SizeType length = 0; + bool escaped = false; + if (low == 0) { + if (high != 0) { + uint32_t lz = internal::clzll(high); + length = 8 + (lz >> 3); + escaped = true; + } + } else { + uint32_t lz = internal::clzll(low); + length = lz >> 3; + escaped = true; + } + if (RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped + for (const char* pend = p + length; p != pend; ) { + *q++ = *p++; + } + break; + } + vst1q_u8(reinterpret_cast(q), s); + } + + is.src_ = p; + is.dst_ = q; + } + + // When read/write pointers are the same for insitu stream, just skip unescaped characters + static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) { + RAPIDJSON_ASSERT(is.src_ == is.dst_); + char* p = is.src_; + + // Scan one by one until alignment (unaligned load may cross page boundary and cause crash) + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + for (; p != nextAligned; p++) + if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast(*p) < 0x20)) { + is.src_ = is.dst_ = p; + return; + } + + // The rest of string using SIMD + const uint8x16_t s0 = vmovq_n_u8('"'); + const uint8x16_t s1 = vmovq_n_u8('\\'); + const uint8x16_t s2 = vmovq_n_u8('\b'); + const uint8x16_t s3 = vmovq_n_u8(32); + + for (;; p += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, s0); + x = vorrq_u8(x, vceqq_u8(s, s1)); + x = vorrq_u8(x, vceqq_u8(s, s2)); + x = vorrq_u8(x, vcltq_u8(s, s3)); + + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract + uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract + + if (low == 0) { + if (high != 0) { + uint32_t lz = internal::clzll(high); + p += 8 + (lz >> 3); + break; + } + } else { + uint32_t lz = internal::clzll(low); + p += lz >> 3; + break; + } + } + + is.src_ = is.dst_ = p; + } +#endif // RAPIDJSON_NEON + + template + class NumberStream; + + template + class NumberStream { + public: + typedef typename InputStream::Ch Ch; + + NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader; } + + RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); } + RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); } + RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); } + RAPIDJSON_FORCEINLINE void Push(char) {} + + size_t Tell() { return is.Tell(); } + size_t Length() { return 0; } + const char* Pop() { return 0; } + + protected: + NumberStream& operator=(const NumberStream&); + + InputStream& is; + }; + + template + class NumberStream : public NumberStream { + typedef NumberStream Base; + public: + NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is), stackStream(reader.stack_) {} + + RAPIDJSON_FORCEINLINE Ch TakePush() { + stackStream.Put(static_cast(Base::is.Peek())); + return Base::is.Take(); + } + + RAPIDJSON_FORCEINLINE void Push(char c) { + stackStream.Put(c); + } + + size_t Length() { return stackStream.Length(); } + + const char* Pop() { + stackStream.Put('\0'); + return stackStream.Pop(); + } + + private: + StackStream stackStream; + }; + + template + class NumberStream : public NumberStream { + typedef NumberStream Base; + public: + NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is) {} + + RAPIDJSON_FORCEINLINE Ch Take() { return Base::TakePush(); } + }; + + template + void ParseNumber(InputStream& is, Handler& handler) { + internal::StreamLocalCopy copy(is); + NumberStream s(*this, copy.s); + + size_t startOffset = s.Tell(); + double d = 0.0; + bool useNanOrInf = false; + + // Parse minus + bool minus = Consume(s, '-'); + + // Parse int: zero / ( digit1-9 *DIGIT ) + unsigned i = 0; + uint64_t i64 = 0; + bool use64bit = false; + int significandDigit = 0; + if (RAPIDJSON_UNLIKELY(s.Peek() == '0')) { + i = 0; + s.TakePush(); + } + else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) { + i = static_cast(s.TakePush() - '0'); + + if (minus) + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648 + if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) { + i64 = i; + use64bit = true; + break; + } + } + i = i * 10 + static_cast(s.TakePush() - '0'); + significandDigit++; + } + else + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295 + if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) { + i64 = i; + use64bit = true; + break; + } + } + i = i * 10 + static_cast(s.TakePush() - '0'); + significandDigit++; + } + } + // Parse NaN or Infinity here + else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) { + if (Consume(s, 'N')) { + if (Consume(s, 'a') && Consume(s, 'N')) { + d = std::numeric_limits::quiet_NaN(); + useNanOrInf = true; + } + } + else if (RAPIDJSON_LIKELY(Consume(s, 'I'))) { + if (Consume(s, 'n') && Consume(s, 'f')) { + d = (minus ? -std::numeric_limits::infinity() : std::numeric_limits::infinity()); + useNanOrInf = true; + + if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n') + && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y')))) { + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell()); + } + } + } + + if (RAPIDJSON_UNLIKELY(!useNanOrInf)) { + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell()); + } + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell()); + + // Parse 64bit int + bool useDouble = false; + if (use64bit) { + if (minus) + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808 + if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) { + d = static_cast(i64); + useDouble = true; + break; + } + i64 = i64 * 10 + static_cast(s.TakePush() - '0'); + significandDigit++; + } + else + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615 + if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) { + d = static_cast(i64); + useDouble = true; + break; + } + i64 = i64 * 10 + static_cast(s.TakePush() - '0'); + significandDigit++; + } + } + + // Force double for big integer + if (useDouble) { + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + d = d * 10 + (s.TakePush() - '0'); + } + } + + // Parse frac = decimal-point 1*DIGIT + int expFrac = 0; + size_t decimalPosition; + if (Consume(s, '.')) { + decimalPosition = s.Length(); + + if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9'))) + RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell()); + + if (!useDouble) { +#if RAPIDJSON_64BIT + // Use i64 to store significand in 64-bit architecture + if (!use64bit) + i64 = i; + + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path + break; + else { + i64 = i64 * 10 + static_cast(s.TakePush() - '0'); + --expFrac; + if (i64 != 0) + significandDigit++; + } + } + + d = static_cast(i64); +#else + // Use double to store significand in 32-bit architecture + d = static_cast(use64bit ? i64 : i); +#endif + useDouble = true; + } + + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + if (significandDigit < 17) { + d = d * 10.0 + (s.TakePush() - '0'); + --expFrac; + if (RAPIDJSON_LIKELY(d > 0.0)) + significandDigit++; + } + else + s.TakePush(); + } + } + else + decimalPosition = s.Length(); // decimal position at the end of integer. + + // Parse exp = e [ minus / plus ] 1*DIGIT + int exp = 0; + if (Consume(s, 'e') || Consume(s, 'E')) { + if (!useDouble) { + d = static_cast(use64bit ? i64 : i); + useDouble = true; + } + + bool expMinus = false; + if (Consume(s, '+')) + ; + else if (Consume(s, '-')) + expMinus = true; + + if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + exp = static_cast(s.Take() - '0'); + if (expMinus) { + // (exp + expFrac) must not underflow int => we're detecting when -exp gets + // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into + // underflow territory): + // + // -(exp * 10 + 9) + expFrac >= INT_MIN + // <=> exp <= (expFrac - INT_MIN - 9) / 10 + RAPIDJSON_ASSERT(expFrac <= 0); + int maxExp = (expFrac + 2147483639) / 10; + + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + exp = exp * 10 + static_cast(s.Take() - '0'); + if (RAPIDJSON_UNLIKELY(exp > maxExp)) { + while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9')) // Consume the rest of exponent + s.Take(); + } + } + } + else { // positive exp + int maxExp = 308 - expFrac; + while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) { + exp = exp * 10 + static_cast(s.Take() - '0'); + if (RAPIDJSON_UNLIKELY(exp > maxExp)) + RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset); + } + } + } + else + RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell()); + + if (expMinus) + exp = -exp; + } + + // Finish parsing, call event according to the type of number. + bool cont = true; + + if (parseFlags & kParseNumbersAsStringsFlag) { + if (parseFlags & kParseInsituFlag) { + s.Pop(); // Pop stack no matter if it will be used or not. + typename InputStream::Ch* head = is.PutBegin(); + const size_t length = s.Tell() - startOffset; + RAPIDJSON_ASSERT(length <= 0xFFFFFFFF); + // unable to insert the \0 character here, it will erase the comma after this number + const typename TargetEncoding::Ch* const str = reinterpret_cast(head); + cont = handler.RawNumber(str, SizeType(length), false); + } + else { + SizeType numCharsToCopy = static_cast(s.Length()); + StringStream srcStream(s.Pop()); + StackStream dstStream(stack_); + while (numCharsToCopy--) { + Transcoder, TargetEncoding>::Transcode(srcStream, dstStream); + } + dstStream.Put('\0'); + const typename TargetEncoding::Ch* str = dstStream.Pop(); + const SizeType length = static_cast(dstStream.Length()) - 1; + cont = handler.RawNumber(str, SizeType(length), true); + } + } + else { + size_t length = s.Length(); + const char* decimal = s.Pop(); // Pop stack no matter if it will be used or not. + + if (useDouble) { + int p = exp + expFrac; + if (parseFlags & kParseFullPrecisionFlag) + d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp); + else + d = internal::StrtodNormalPrecision(d, p); + + // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal + if (d > (std::numeric_limits::max)()) { + // Overflow + // TODO: internal::StrtodX should report overflow (or underflow) + RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset); + } + + cont = handler.Double(minus ? -d : d); + } + else if (useNanOrInf) { + cont = handler.Double(d); + } + else { + if (use64bit) { + if (minus) + cont = handler.Int64(static_cast(~i64 + 1)); + else + cont = handler.Uint64(i64); + } + else { + if (minus) + cont = handler.Int(static_cast(~i + 1)); + else + cont = handler.Uint(i); + } + } + } + if (RAPIDJSON_UNLIKELY(!cont)) + RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset); + } + + // Parse any JSON value + template + void ParseValue(InputStream& is, Handler& handler) { + switch (is.Peek()) { + case 'n': ParseNull (is, handler); break; + case 't': ParseTrue (is, handler); break; + case 'f': ParseFalse (is, handler); break; + case '"': ParseString(is, handler); break; + case '{': ParseObject(is, handler); break; + case '[': ParseArray (is, handler); break; + default : + ParseNumber(is, handler); + break; + + } + } + + // Iterative Parsing + + // States + enum IterativeParsingState { + IterativeParsingFinishState = 0, // sink states at top + IterativeParsingErrorState, // sink states at top + IterativeParsingStartState, + + // Object states + IterativeParsingObjectInitialState, + IterativeParsingMemberKeyState, + IterativeParsingMemberValueState, + IterativeParsingObjectFinishState, + + // Array states + IterativeParsingArrayInitialState, + IterativeParsingElementState, + IterativeParsingArrayFinishState, + + // Single value state + IterativeParsingValueState, + + // Delimiter states (at bottom) + IterativeParsingElementDelimiterState, + IterativeParsingMemberDelimiterState, + IterativeParsingKeyValueDelimiterState, + + cIterativeParsingStateCount + }; + + // Tokens + enum Token { + LeftBracketToken = 0, + RightBracketToken, + + LeftCurlyBracketToken, + RightCurlyBracketToken, + + CommaToken, + ColonToken, + + StringToken, + FalseToken, + TrueToken, + NullToken, + NumberToken, + + kTokenCount + }; + + RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const { + +//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN +#define N NumberToken +#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N + // Maps from ASCII to Token + static const unsigned char tokenMap[256] = { + N16, // 00~0F + N16, // 10~1F + N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N, // 20~2F + N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N, // 30~3F + N16, // 40~4F + N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N, // 50~5F + N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N, // 60~6F + N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N, // 70~7F + N16, N16, N16, N16, N16, N16, N16, N16 // 80~FF + }; +#undef N +#undef N16 +//!@endcond + + if (sizeof(Ch) == 1 || static_cast(c) < 256) + return static_cast(tokenMap[static_cast(c)]); + else + return NumberToken; + } + + RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) const { + // current state x one lookahead token -> new state + static const char G[cIterativeParsingStateCount][kTokenCount] = { + // Finish(sink state) + { + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState + }, + // Error(sink state) + { + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState + }, + // Start + { + IterativeParsingArrayInitialState, // Left bracket + IterativeParsingErrorState, // Right bracket + IterativeParsingObjectInitialState, // Left curly bracket + IterativeParsingErrorState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingValueState, // String + IterativeParsingValueState, // False + IterativeParsingValueState, // True + IterativeParsingValueState, // Null + IterativeParsingValueState // Number + }, + // ObjectInitial + { + IterativeParsingErrorState, // Left bracket + IterativeParsingErrorState, // Right bracket + IterativeParsingErrorState, // Left curly bracket + IterativeParsingObjectFinishState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingMemberKeyState, // String + IterativeParsingErrorState, // False + IterativeParsingErrorState, // True + IterativeParsingErrorState, // Null + IterativeParsingErrorState // Number + }, + // MemberKey + { + IterativeParsingErrorState, // Left bracket + IterativeParsingErrorState, // Right bracket + IterativeParsingErrorState, // Left curly bracket + IterativeParsingErrorState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingKeyValueDelimiterState, // Colon + IterativeParsingErrorState, // String + IterativeParsingErrorState, // False + IterativeParsingErrorState, // True + IterativeParsingErrorState, // Null + IterativeParsingErrorState // Number + }, + // MemberValue + { + IterativeParsingErrorState, // Left bracket + IterativeParsingErrorState, // Right bracket + IterativeParsingErrorState, // Left curly bracket + IterativeParsingObjectFinishState, // Right curly bracket + IterativeParsingMemberDelimiterState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingErrorState, // String + IterativeParsingErrorState, // False + IterativeParsingErrorState, // True + IterativeParsingErrorState, // Null + IterativeParsingErrorState // Number + }, + // ObjectFinish(sink state) + { + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState + }, + // ArrayInitial + { + IterativeParsingArrayInitialState, // Left bracket(push Element state) + IterativeParsingArrayFinishState, // Right bracket + IterativeParsingObjectInitialState, // Left curly bracket(push Element state) + IterativeParsingErrorState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingElementState, // String + IterativeParsingElementState, // False + IterativeParsingElementState, // True + IterativeParsingElementState, // Null + IterativeParsingElementState // Number + }, + // Element + { + IterativeParsingErrorState, // Left bracket + IterativeParsingArrayFinishState, // Right bracket + IterativeParsingErrorState, // Left curly bracket + IterativeParsingErrorState, // Right curly bracket + IterativeParsingElementDelimiterState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingErrorState, // String + IterativeParsingErrorState, // False + IterativeParsingErrorState, // True + IterativeParsingErrorState, // Null + IterativeParsingErrorState // Number + }, + // ArrayFinish(sink state) + { + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState + }, + // Single Value (sink state) + { + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, + IterativeParsingErrorState + }, + // ElementDelimiter + { + IterativeParsingArrayInitialState, // Left bracket(push Element state) + IterativeParsingArrayFinishState, // Right bracket + IterativeParsingObjectInitialState, // Left curly bracket(push Element state) + IterativeParsingErrorState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingElementState, // String + IterativeParsingElementState, // False + IterativeParsingElementState, // True + IterativeParsingElementState, // Null + IterativeParsingElementState // Number + }, + // MemberDelimiter + { + IterativeParsingErrorState, // Left bracket + IterativeParsingErrorState, // Right bracket + IterativeParsingErrorState, // Left curly bracket + IterativeParsingObjectFinishState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingMemberKeyState, // String + IterativeParsingErrorState, // False + IterativeParsingErrorState, // True + IterativeParsingErrorState, // Null + IterativeParsingErrorState // Number + }, + // KeyValueDelimiter + { + IterativeParsingArrayInitialState, // Left bracket(push MemberValue state) + IterativeParsingErrorState, // Right bracket + IterativeParsingObjectInitialState, // Left curly bracket(push MemberValue state) + IterativeParsingErrorState, // Right curly bracket + IterativeParsingErrorState, // Comma + IterativeParsingErrorState, // Colon + IterativeParsingMemberValueState, // String + IterativeParsingMemberValueState, // False + IterativeParsingMemberValueState, // True + IterativeParsingMemberValueState, // Null + IterativeParsingMemberValueState // Number + }, + }; // End of G + + return static_cast(G[state][token]); + } + + // Make an advance in the token stream and state based on the candidate destination state which was returned by Transit(). + // May return a new state on state pop. + template + RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is, Handler& handler) { + (void)token; + + switch (dst) { + case IterativeParsingErrorState: + return dst; + + case IterativeParsingObjectInitialState: + case IterativeParsingArrayInitialState: + { + // Push the state(Element or MemeberValue) if we are nested in another array or value of member. + // In this way we can get the correct state on ObjectFinish or ArrayFinish by frame pop. + IterativeParsingState n = src; + if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState) + n = IterativeParsingElementState; + else if (src == IterativeParsingKeyValueDelimiterState) + n = IterativeParsingMemberValueState; + // Push current state. + *stack_.template Push(1) = n; + // Initialize and push the member/element count. + *stack_.template Push(1) = 0; + // Call handler + bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray(); + // On handler short circuits the parsing. + if (!hr) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell()); + return IterativeParsingErrorState; + } + else { + is.Take(); + return dst; + } + } + + case IterativeParsingMemberKeyState: + ParseString(is, handler, true); + if (HasParseError()) + return IterativeParsingErrorState; + else + return dst; + + case IterativeParsingKeyValueDelimiterState: + RAPIDJSON_ASSERT(token == ColonToken); + is.Take(); + return dst; + + case IterativeParsingMemberValueState: + // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state. + ParseValue(is, handler); + if (HasParseError()) { + return IterativeParsingErrorState; + } + return dst; + + case IterativeParsingElementState: + // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state. + ParseValue(is, handler); + if (HasParseError()) { + return IterativeParsingErrorState; + } + return dst; + + case IterativeParsingMemberDelimiterState: + case IterativeParsingElementDelimiterState: + is.Take(); + // Update member/element count. + *stack_.template Top() = *stack_.template Top() + 1; + return dst; + + case IterativeParsingObjectFinishState: + { + // Transit from delimiter is only allowed when trailing commas are enabled + if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingMemberDelimiterState) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorObjectMissName, is.Tell()); + return IterativeParsingErrorState; + } + // Get member count. + SizeType c = *stack_.template Pop(1); + // If the object is not empty, count the last member. + if (src == IterativeParsingMemberValueState) + ++c; + // Restore the state. + IterativeParsingState n = static_cast(*stack_.template Pop(1)); + // Transit to Finish state if this is the topmost scope. + if (n == IterativeParsingStartState) + n = IterativeParsingFinishState; + // Call handler + bool hr = handler.EndObject(c); + // On handler short circuits the parsing. + if (!hr) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell()); + return IterativeParsingErrorState; + } + else { + is.Take(); + return n; + } + } + + case IterativeParsingArrayFinishState: + { + // Transit from delimiter is only allowed when trailing commas are enabled + if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingElementDelimiterState) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorValueInvalid, is.Tell()); + return IterativeParsingErrorState; + } + // Get element count. + SizeType c = *stack_.template Pop(1); + // If the array is not empty, count the last element. + if (src == IterativeParsingElementState) + ++c; + // Restore the state. + IterativeParsingState n = static_cast(*stack_.template Pop(1)); + // Transit to Finish state if this is the topmost scope. + if (n == IterativeParsingStartState) + n = IterativeParsingFinishState; + // Call handler + bool hr = handler.EndArray(c); + // On handler short circuits the parsing. + if (!hr) { + RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell()); + return IterativeParsingErrorState; + } + else { + is.Take(); + return n; + } + } + + default: + // This branch is for IterativeParsingValueState actually. + // Use `default:` rather than + // `case IterativeParsingValueState:` is for code coverage. + + // The IterativeParsingStartState is not enumerated in this switch-case. + // It is impossible for that case. And it can be caught by following assertion. + + // The IterativeParsingFinishState is not enumerated in this switch-case either. + // It is a "derivative" state which cannot triggered from Predict() directly. + // Therefore it cannot happen here. And it can be caught by following assertion. + RAPIDJSON_ASSERT(dst == IterativeParsingValueState); + + // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state. + ParseValue(is, handler); + if (HasParseError()) { + return IterativeParsingErrorState; + } + return IterativeParsingFinishState; + } + } + + template + void HandleError(IterativeParsingState src, InputStream& is) { + if (HasParseError()) { + // Error flag has been set. + return; + } + + switch (src) { + case IterativeParsingStartState: RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell()); return; + case IterativeParsingFinishState: RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell()); return; + case IterativeParsingObjectInitialState: + case IterativeParsingMemberDelimiterState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell()); return; + case IterativeParsingMemberKeyState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell()); return; + case IterativeParsingMemberValueState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); return; + case IterativeParsingKeyValueDelimiterState: + case IterativeParsingArrayInitialState: + case IterativeParsingElementDelimiterState: RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); return; + default: RAPIDJSON_ASSERT(src == IterativeParsingElementState); RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell()); return; + } + } + + RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const { + return s >= IterativeParsingElementDelimiterState; + } + + RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const { + return s <= IterativeParsingErrorState; + } + + template + ParseResult IterativeParse(InputStream& is, Handler& handler) { + parseResult_.Clear(); + ClearStackOnExit scope(*this); + IterativeParsingState state = IterativeParsingStartState; + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + while (is.Peek() != '\0') { + Token t = Tokenize(is.Peek()); + IterativeParsingState n = Predict(state, t); + IterativeParsingState d = Transit(state, t, n, is, handler); + + if (d == IterativeParsingErrorState) { + HandleError(state, is); + break; + } + + state = d; + + // Do not further consume streams if a root JSON has been parsed. + if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState) + break; + + SkipWhitespaceAndComments(is); + RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_); + } + + // Handle the end of file. + if (state != IterativeParsingFinishState) + HandleError(state, is); + + return parseResult_; + } + + static const size_t kDefaultStackCapacity = 256; //!< Default stack capacity in bytes for storing a single decoded string. + internal::Stack stack_; //!< A stack for storing decoded string temporarily during non-destructive parsing. + ParseResult parseResult_; + IterativeParsingState state_; +}; // class GenericReader + +//! Reader with UTF8 encoding and default allocator. +typedef GenericReader, UTF8<> > Reader; + +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) || defined(_MSC_VER) +RAPIDJSON_DIAG_POP +#endif + + +#ifdef __GNUC__ +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_READER_H_ diff --git a/libs/include/rapidjson/schema.h b/libs/include/rapidjson/schema.h new file mode 100644 index 0000000..a034021 --- /dev/null +++ b/libs/include/rapidjson/schema.h @@ -0,0 +1,2648 @@ +// Tencent is pleased to support the open source community by making RapidJSON available-> +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip-> All rights reserved-> +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License-> You may obtain a copy of the License at +// +// http://opensource->org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied-> See the License for the +// specific language governing permissions and limitations under the License-> + +#ifndef RAPIDJSON_SCHEMA_H_ +#define RAPIDJSON_SCHEMA_H_ + +#include "document.h" +#include "pointer.h" +#include "stringbuffer.h" +#include "error/en.h" +#include // abs, floor + +#if !defined(RAPIDJSON_SCHEMA_USE_INTERNALREGEX) +#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 1 +#else +#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0 +#endif + +#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)) +#define RAPIDJSON_SCHEMA_USE_STDREGEX 1 +#else +#define RAPIDJSON_SCHEMA_USE_STDREGEX 0 +#endif + +#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX +#include "internal/regex.h" +#elif RAPIDJSON_SCHEMA_USE_STDREGEX +#include +#endif + +#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX || RAPIDJSON_SCHEMA_USE_STDREGEX +#define RAPIDJSON_SCHEMA_HAS_REGEX 1 +#else +#define RAPIDJSON_SCHEMA_HAS_REGEX 0 +#endif + +#ifndef RAPIDJSON_SCHEMA_VERBOSE +#define RAPIDJSON_SCHEMA_VERBOSE 0 +#endif + +#if RAPIDJSON_SCHEMA_VERBOSE +#include "stringbuffer.h" +#endif + +RAPIDJSON_DIAG_PUSH + +#if defined(__GNUC__) +RAPIDJSON_DIAG_OFF(effc++) +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_OFF(weak-vtables) +RAPIDJSON_DIAG_OFF(exit-time-destructors) +RAPIDJSON_DIAG_OFF(c++98-compat-pedantic) +RAPIDJSON_DIAG_OFF(variadic-macros) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// Verbose Utilities + +#if RAPIDJSON_SCHEMA_VERBOSE + +namespace internal { + +inline void PrintInvalidKeyword(const char* keyword) { + printf("Fail keyword: %s\n", keyword); +} + +inline void PrintInvalidKeyword(const wchar_t* keyword) { + wprintf(L"Fail keyword: %ls\n", keyword); +} + +inline void PrintInvalidDocument(const char* document) { + printf("Fail document: %s\n\n", document); +} + +inline void PrintInvalidDocument(const wchar_t* document) { + wprintf(L"Fail document: %ls\n\n", document); +} + +inline void PrintValidatorPointers(unsigned depth, const char* s, const char* d) { + printf("S: %*s%s\nD: %*s%s\n\n", depth * 4, " ", s, depth * 4, " ", d); +} + +inline void PrintValidatorPointers(unsigned depth, const wchar_t* s, const wchar_t* d) { + wprintf(L"S: %*ls%ls\nD: %*ls%ls\n\n", depth * 4, L" ", s, depth * 4, L" ", d); +} + +} // namespace internal + +#endif // RAPIDJSON_SCHEMA_VERBOSE + +/////////////////////////////////////////////////////////////////////////////// +// RAPIDJSON_INVALID_KEYWORD_RETURN + +#if RAPIDJSON_SCHEMA_VERBOSE +#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword) internal::PrintInvalidKeyword(keyword) +#else +#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword) +#endif + +#define RAPIDJSON_INVALID_KEYWORD_RETURN(code)\ +RAPIDJSON_MULTILINEMACRO_BEGIN\ + context.invalidCode = code;\ + context.invalidKeyword = SchemaType::GetValidateErrorKeyword(code).GetString();\ + RAPIDJSON_INVALID_KEYWORD_VERBOSE(context.invalidKeyword);\ + return false;\ +RAPIDJSON_MULTILINEMACRO_END + +/////////////////////////////////////////////////////////////////////////////// +// ValidateFlag + +/*! \def RAPIDJSON_VALIDATE_DEFAULT_FLAGS + \ingroup RAPIDJSON_CONFIG + \brief User-defined kValidateDefaultFlags definition. + + User can define this as any \c ValidateFlag combinations. +*/ +#ifndef RAPIDJSON_VALIDATE_DEFAULT_FLAGS +#define RAPIDJSON_VALIDATE_DEFAULT_FLAGS kValidateNoFlags +#endif + +//! Combination of validate flags +/*! \see + */ +enum ValidateFlag { + kValidateNoFlags = 0, //!< No flags are set. + kValidateContinueOnErrorFlag = 1, //!< Don't stop after first validation error. + kValidateDefaultFlags = RAPIDJSON_VALIDATE_DEFAULT_FLAGS //!< Default validate flags. Can be customized by defining RAPIDJSON_VALIDATE_DEFAULT_FLAGS +}; + +/////////////////////////////////////////////////////////////////////////////// +// Forward declarations + +template +class GenericSchemaDocument; + +namespace internal { + +template +class Schema; + +/////////////////////////////////////////////////////////////////////////////// +// ISchemaValidator + +class ISchemaValidator { +public: + virtual ~ISchemaValidator() {} + virtual bool IsValid() const = 0; + virtual void SetValidateFlags(unsigned flags) = 0; + virtual unsigned GetValidateFlags() const = 0; +}; + +/////////////////////////////////////////////////////////////////////////////// +// ISchemaStateFactory + +template +class ISchemaStateFactory { +public: + virtual ~ISchemaStateFactory() {} + virtual ISchemaValidator* CreateSchemaValidator(const SchemaType&, const bool inheritContinueOnErrors) = 0; + virtual void DestroySchemaValidator(ISchemaValidator* validator) = 0; + virtual void* CreateHasher() = 0; + virtual uint64_t GetHashCode(void* hasher) = 0; + virtual void DestroryHasher(void* hasher) = 0; + virtual void* MallocState(size_t size) = 0; + virtual void FreeState(void* p) = 0; +}; + +/////////////////////////////////////////////////////////////////////////////// +// IValidationErrorHandler + +template +class IValidationErrorHandler { +public: + typedef typename SchemaType::Ch Ch; + typedef typename SchemaType::SValue SValue; + + virtual ~IValidationErrorHandler() {} + + virtual void NotMultipleOf(int64_t actual, const SValue& expected) = 0; + virtual void NotMultipleOf(uint64_t actual, const SValue& expected) = 0; + virtual void NotMultipleOf(double actual, const SValue& expected) = 0; + virtual void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) = 0; + virtual void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) = 0; + virtual void AboveMaximum(double actual, const SValue& expected, bool exclusive) = 0; + virtual void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) = 0; + virtual void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) = 0; + virtual void BelowMinimum(double actual, const SValue& expected, bool exclusive) = 0; + + virtual void TooLong(const Ch* str, SizeType length, SizeType expected) = 0; + virtual void TooShort(const Ch* str, SizeType length, SizeType expected) = 0; + virtual void DoesNotMatch(const Ch* str, SizeType length) = 0; + + virtual void DisallowedItem(SizeType index) = 0; + virtual void TooFewItems(SizeType actualCount, SizeType expectedCount) = 0; + virtual void TooManyItems(SizeType actualCount, SizeType expectedCount) = 0; + virtual void DuplicateItems(SizeType index1, SizeType index2) = 0; + + virtual void TooManyProperties(SizeType actualCount, SizeType expectedCount) = 0; + virtual void TooFewProperties(SizeType actualCount, SizeType expectedCount) = 0; + virtual void StartMissingProperties() = 0; + virtual void AddMissingProperty(const SValue& name) = 0; + virtual bool EndMissingProperties() = 0; + virtual void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) = 0; + virtual void DisallowedProperty(const Ch* name, SizeType length) = 0; + + virtual void StartDependencyErrors() = 0; + virtual void StartMissingDependentProperties() = 0; + virtual void AddMissingDependentProperty(const SValue& targetName) = 0; + virtual void EndMissingDependentProperties(const SValue& sourceName) = 0; + virtual void AddDependencySchemaError(const SValue& souceName, ISchemaValidator* subvalidator) = 0; + virtual bool EndDependencyErrors() = 0; + + virtual void DisallowedValue(const ValidateErrorCode code) = 0; + virtual void StartDisallowedType() = 0; + virtual void AddExpectedType(const typename SchemaType::ValueType& expectedType) = 0; + virtual void EndDisallowedType(const typename SchemaType::ValueType& actualType) = 0; + virtual void NotAllOf(ISchemaValidator** subvalidators, SizeType count) = 0; + virtual void NoneOf(ISchemaValidator** subvalidators, SizeType count) = 0; + virtual void NotOneOf(ISchemaValidator** subvalidators, SizeType count, bool matched) = 0; + virtual void Disallowed() = 0; +}; + + +/////////////////////////////////////////////////////////////////////////////// +// Hasher + +// For comparison of compound value +template +class Hasher { +public: + typedef typename Encoding::Ch Ch; + + Hasher(Allocator* allocator = 0, size_t stackCapacity = kDefaultSize) : stack_(allocator, stackCapacity) {} + + bool Null() { return WriteType(kNullType); } + bool Bool(bool b) { return WriteType(b ? kTrueType : kFalseType); } + bool Int(int i) { Number n; n.u.i = i; n.d = static_cast(i); return WriteNumber(n); } + bool Uint(unsigned u) { Number n; n.u.u = u; n.d = static_cast(u); return WriteNumber(n); } + bool Int64(int64_t i) { Number n; n.u.i = i; n.d = static_cast(i); return WriteNumber(n); } + bool Uint64(uint64_t u) { Number n; n.u.u = u; n.d = static_cast(u); return WriteNumber(n); } + bool Double(double d) { + Number n; + if (d < 0) n.u.i = static_cast(d); + else n.u.u = static_cast(d); + n.d = d; + return WriteNumber(n); + } + + bool RawNumber(const Ch* str, SizeType len, bool) { + WriteBuffer(kNumberType, str, len * sizeof(Ch)); + return true; + } + + bool String(const Ch* str, SizeType len, bool) { + WriteBuffer(kStringType, str, len * sizeof(Ch)); + return true; + } + + bool StartObject() { return true; } + bool Key(const Ch* str, SizeType len, bool copy) { return String(str, len, copy); } + bool EndObject(SizeType memberCount) { + uint64_t h = Hash(0, kObjectType); + uint64_t* kv = stack_.template Pop(memberCount * 2); + for (SizeType i = 0; i < memberCount; i++) + h ^= Hash(kv[i * 2], kv[i * 2 + 1]); // Use xor to achieve member order insensitive + *stack_.template Push() = h; + return true; + } + + bool StartArray() { return true; } + bool EndArray(SizeType elementCount) { + uint64_t h = Hash(0, kArrayType); + uint64_t* e = stack_.template Pop(elementCount); + for (SizeType i = 0; i < elementCount; i++) + h = Hash(h, e[i]); // Use hash to achieve element order sensitive + *stack_.template Push() = h; + return true; + } + + bool IsValid() const { return stack_.GetSize() == sizeof(uint64_t); } + + uint64_t GetHashCode() const { + RAPIDJSON_ASSERT(IsValid()); + return *stack_.template Top(); + } + +private: + static const size_t kDefaultSize = 256; + struct Number { + union U { + uint64_t u; + int64_t i; + }u; + double d; + }; + + bool WriteType(Type type) { return WriteBuffer(type, 0, 0); } + + bool WriteNumber(const Number& n) { return WriteBuffer(kNumberType, &n, sizeof(n)); } + + bool WriteBuffer(Type type, const void* data, size_t len) { + // FNV-1a from http://isthe.com/chongo/tech/comp/fnv/ + uint64_t h = Hash(RAPIDJSON_UINT64_C2(0x84222325, 0xcbf29ce4), type); + const unsigned char* d = static_cast(data); + for (size_t i = 0; i < len; i++) + h = Hash(h, d[i]); + *stack_.template Push() = h; + return true; + } + + static uint64_t Hash(uint64_t h, uint64_t d) { + static const uint64_t kPrime = RAPIDJSON_UINT64_C2(0x00000100, 0x000001b3); + h ^= d; + h *= kPrime; + return h; + } + + Stack stack_; +}; + +/////////////////////////////////////////////////////////////////////////////// +// SchemaValidationContext + +template +struct SchemaValidationContext { + typedef Schema SchemaType; + typedef ISchemaStateFactory SchemaValidatorFactoryType; + typedef IValidationErrorHandler ErrorHandlerType; + typedef typename SchemaType::ValueType ValueType; + typedef typename ValueType::Ch Ch; + + enum PatternValidatorType { + kPatternValidatorOnly, + kPatternValidatorWithProperty, + kPatternValidatorWithAdditionalProperty + }; + + SchemaValidationContext(SchemaValidatorFactoryType& f, ErrorHandlerType& eh, const SchemaType* s) : + factory(f), + error_handler(eh), + schema(s), + valueSchema(), + invalidKeyword(), + invalidCode(), + hasher(), + arrayElementHashCodes(), + validators(), + validatorCount(), + patternPropertiesValidators(), + patternPropertiesValidatorCount(), + patternPropertiesSchemas(), + patternPropertiesSchemaCount(), + valuePatternValidatorType(kPatternValidatorOnly), + propertyExist(), + inArray(false), + valueUniqueness(false), + arrayUniqueness(false) + { + } + + ~SchemaValidationContext() { + if (hasher) + factory.DestroryHasher(hasher); + if (validators) { + for (SizeType i = 0; i < validatorCount; i++) + factory.DestroySchemaValidator(validators[i]); + factory.FreeState(validators); + } + if (patternPropertiesValidators) { + for (SizeType i = 0; i < patternPropertiesValidatorCount; i++) + factory.DestroySchemaValidator(patternPropertiesValidators[i]); + factory.FreeState(patternPropertiesValidators); + } + if (patternPropertiesSchemas) + factory.FreeState(patternPropertiesSchemas); + if (propertyExist) + factory.FreeState(propertyExist); + } + + SchemaValidatorFactoryType& factory; + ErrorHandlerType& error_handler; + const SchemaType* schema; + const SchemaType* valueSchema; + const Ch* invalidKeyword; + ValidateErrorCode invalidCode; + void* hasher; // Only validator access + void* arrayElementHashCodes; // Only validator access this + ISchemaValidator** validators; + SizeType validatorCount; + ISchemaValidator** patternPropertiesValidators; + SizeType patternPropertiesValidatorCount; + const SchemaType** patternPropertiesSchemas; + SizeType patternPropertiesSchemaCount; + PatternValidatorType valuePatternValidatorType; + PatternValidatorType objectPatternValidatorType; + SizeType arrayElementIndex; + bool* propertyExist; + bool inArray; + bool valueUniqueness; + bool arrayUniqueness; +}; + +/////////////////////////////////////////////////////////////////////////////// +// Schema + +template +class Schema { +public: + typedef typename SchemaDocumentType::ValueType ValueType; + typedef typename SchemaDocumentType::AllocatorType AllocatorType; + typedef typename SchemaDocumentType::PointerType PointerType; + typedef typename ValueType::EncodingType EncodingType; + typedef typename EncodingType::Ch Ch; + typedef SchemaValidationContext Context; + typedef Schema SchemaType; + typedef GenericValue SValue; + typedef IValidationErrorHandler ErrorHandler; + friend class GenericSchemaDocument; + + Schema(SchemaDocumentType* schemaDocument, const PointerType& p, const ValueType& value, const ValueType& document, AllocatorType* allocator) : + allocator_(allocator), + uri_(schemaDocument->GetURI(), *allocator), + pointer_(p, allocator), + typeless_(schemaDocument->GetTypeless()), + enum_(), + enumCount_(), + not_(), + type_((1 << kTotalSchemaType) - 1), // typeless + validatorCount_(), + notValidatorIndex_(), + properties_(), + additionalPropertiesSchema_(), + patternProperties_(), + patternPropertyCount_(), + propertyCount_(), + minProperties_(), + maxProperties_(SizeType(~0)), + additionalProperties_(true), + hasDependencies_(), + hasRequired_(), + hasSchemaDependencies_(), + additionalItemsSchema_(), + itemsList_(), + itemsTuple_(), + itemsTupleCount_(), + minItems_(), + maxItems_(SizeType(~0)), + additionalItems_(true), + uniqueItems_(false), + pattern_(), + minLength_(0), + maxLength_(~SizeType(0)), + exclusiveMinimum_(false), + exclusiveMaximum_(false), + defaultValueLength_(0) + { + typedef typename ValueType::ConstValueIterator ConstValueIterator; + typedef typename ValueType::ConstMemberIterator ConstMemberIterator; + + if (!value.IsObject()) + return; + + if (const ValueType* v = GetMember(value, GetTypeString())) { + type_ = 0; + if (v->IsString()) + AddType(*v); + else if (v->IsArray()) + for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) + AddType(*itr); + } + + if (const ValueType* v = GetMember(value, GetEnumString())) { + if (v->IsArray() && v->Size() > 0) { + enum_ = static_cast(allocator_->Malloc(sizeof(uint64_t) * v->Size())); + for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) { + typedef Hasher > EnumHasherType; + char buffer[256u + 24]; + MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer)); + EnumHasherType h(&hasherAllocator, 256); + itr->Accept(h); + enum_[enumCount_++] = h.GetHashCode(); + } + } + } + + if (schemaDocument) { + AssignIfExist(allOf_, *schemaDocument, p, value, GetAllOfString(), document); + AssignIfExist(anyOf_, *schemaDocument, p, value, GetAnyOfString(), document); + AssignIfExist(oneOf_, *schemaDocument, p, value, GetOneOfString(), document); + + if (const ValueType* v = GetMember(value, GetNotString())) { + schemaDocument->CreateSchema(¬_, p.Append(GetNotString(), allocator_), *v, document); + notValidatorIndex_ = validatorCount_; + validatorCount_++; + } + } + + // Object + + const ValueType* properties = GetMember(value, GetPropertiesString()); + const ValueType* required = GetMember(value, GetRequiredString()); + const ValueType* dependencies = GetMember(value, GetDependenciesString()); + { + // Gather properties from properties/required/dependencies + SValue allProperties(kArrayType); + + if (properties && properties->IsObject()) + for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr) + AddUniqueElement(allProperties, itr->name); + + if (required && required->IsArray()) + for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr) + if (itr->IsString()) + AddUniqueElement(allProperties, *itr); + + if (dependencies && dependencies->IsObject()) + for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) { + AddUniqueElement(allProperties, itr->name); + if (itr->value.IsArray()) + for (ConstValueIterator i = itr->value.Begin(); i != itr->value.End(); ++i) + if (i->IsString()) + AddUniqueElement(allProperties, *i); + } + + if (allProperties.Size() > 0) { + propertyCount_ = allProperties.Size(); + properties_ = static_cast(allocator_->Malloc(sizeof(Property) * propertyCount_)); + for (SizeType i = 0; i < propertyCount_; i++) { + new (&properties_[i]) Property(); + properties_[i].name = allProperties[i]; + properties_[i].schema = typeless_; + } + } + } + + if (properties && properties->IsObject()) { + PointerType q = p.Append(GetPropertiesString(), allocator_); + for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr) { + SizeType index; + if (FindPropertyIndex(itr->name, &index)) + schemaDocument->CreateSchema(&properties_[index].schema, q.Append(itr->name, allocator_), itr->value, document); + } + } + + if (const ValueType* v = GetMember(value, GetPatternPropertiesString())) { + PointerType q = p.Append(GetPatternPropertiesString(), allocator_); + patternProperties_ = static_cast(allocator_->Malloc(sizeof(PatternProperty) * v->MemberCount())); + patternPropertyCount_ = 0; + + for (ConstMemberIterator itr = v->MemberBegin(); itr != v->MemberEnd(); ++itr) { + new (&patternProperties_[patternPropertyCount_]) PatternProperty(); + patternProperties_[patternPropertyCount_].pattern = CreatePattern(itr->name); + schemaDocument->CreateSchema(&patternProperties_[patternPropertyCount_].schema, q.Append(itr->name, allocator_), itr->value, document); + patternPropertyCount_++; + } + } + + if (required && required->IsArray()) + for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr) + if (itr->IsString()) { + SizeType index; + if (FindPropertyIndex(*itr, &index)) { + properties_[index].required = true; + hasRequired_ = true; + } + } + + if (dependencies && dependencies->IsObject()) { + PointerType q = p.Append(GetDependenciesString(), allocator_); + hasDependencies_ = true; + for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) { + SizeType sourceIndex; + if (FindPropertyIndex(itr->name, &sourceIndex)) { + if (itr->value.IsArray()) { + properties_[sourceIndex].dependencies = static_cast(allocator_->Malloc(sizeof(bool) * propertyCount_)); + std::memset(properties_[sourceIndex].dependencies, 0, sizeof(bool)* propertyCount_); + for (ConstValueIterator targetItr = itr->value.Begin(); targetItr != itr->value.End(); ++targetItr) { + SizeType targetIndex; + if (FindPropertyIndex(*targetItr, &targetIndex)) + properties_[sourceIndex].dependencies[targetIndex] = true; + } + } + else if (itr->value.IsObject()) { + hasSchemaDependencies_ = true; + schemaDocument->CreateSchema(&properties_[sourceIndex].dependenciesSchema, q.Append(itr->name, allocator_), itr->value, document); + properties_[sourceIndex].dependenciesValidatorIndex = validatorCount_; + validatorCount_++; + } + } + } + } + + if (const ValueType* v = GetMember(value, GetAdditionalPropertiesString())) { + if (v->IsBool()) + additionalProperties_ = v->GetBool(); + else if (v->IsObject()) + schemaDocument->CreateSchema(&additionalPropertiesSchema_, p.Append(GetAdditionalPropertiesString(), allocator_), *v, document); + } + + AssignIfExist(minProperties_, value, GetMinPropertiesString()); + AssignIfExist(maxProperties_, value, GetMaxPropertiesString()); + + // Array + if (const ValueType* v = GetMember(value, GetItemsString())) { + PointerType q = p.Append(GetItemsString(), allocator_); + if (v->IsObject()) // List validation + schemaDocument->CreateSchema(&itemsList_, q, *v, document); + else if (v->IsArray()) { // Tuple validation + itemsTuple_ = static_cast(allocator_->Malloc(sizeof(const Schema*) * v->Size())); + SizeType index = 0; + for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr, index++) + schemaDocument->CreateSchema(&itemsTuple_[itemsTupleCount_++], q.Append(index, allocator_), *itr, document); + } + } + + AssignIfExist(minItems_, value, GetMinItemsString()); + AssignIfExist(maxItems_, value, GetMaxItemsString()); + + if (const ValueType* v = GetMember(value, GetAdditionalItemsString())) { + if (v->IsBool()) + additionalItems_ = v->GetBool(); + else if (v->IsObject()) + schemaDocument->CreateSchema(&additionalItemsSchema_, p.Append(GetAdditionalItemsString(), allocator_), *v, document); + } + + AssignIfExist(uniqueItems_, value, GetUniqueItemsString()); + + // String + AssignIfExist(minLength_, value, GetMinLengthString()); + AssignIfExist(maxLength_, value, GetMaxLengthString()); + + if (const ValueType* v = GetMember(value, GetPatternString())) + pattern_ = CreatePattern(*v); + + // Number + if (const ValueType* v = GetMember(value, GetMinimumString())) + if (v->IsNumber()) + minimum_.CopyFrom(*v, *allocator_); + + if (const ValueType* v = GetMember(value, GetMaximumString())) + if (v->IsNumber()) + maximum_.CopyFrom(*v, *allocator_); + + AssignIfExist(exclusiveMinimum_, value, GetExclusiveMinimumString()); + AssignIfExist(exclusiveMaximum_, value, GetExclusiveMaximumString()); + + if (const ValueType* v = GetMember(value, GetMultipleOfString())) + if (v->IsNumber() && v->GetDouble() > 0.0) + multipleOf_.CopyFrom(*v, *allocator_); + + // Default + if (const ValueType* v = GetMember(value, GetDefaultValueString())) + if (v->IsString()) + defaultValueLength_ = v->GetStringLength(); + + } + + ~Schema() { + AllocatorType::Free(enum_); + if (properties_) { + for (SizeType i = 0; i < propertyCount_; i++) + properties_[i].~Property(); + AllocatorType::Free(properties_); + } + if (patternProperties_) { + for (SizeType i = 0; i < patternPropertyCount_; i++) + patternProperties_[i].~PatternProperty(); + AllocatorType::Free(patternProperties_); + } + AllocatorType::Free(itemsTuple_); +#if RAPIDJSON_SCHEMA_HAS_REGEX + if (pattern_) { + pattern_->~RegexType(); + AllocatorType::Free(pattern_); + } +#endif + } + + const SValue& GetURI() const { + return uri_; + } + + const PointerType& GetPointer() const { + return pointer_; + } + + bool BeginValue(Context& context) const { + if (context.inArray) { + if (uniqueItems_) + context.valueUniqueness = true; + + if (itemsList_) + context.valueSchema = itemsList_; + else if (itemsTuple_) { + if (context.arrayElementIndex < itemsTupleCount_) + context.valueSchema = itemsTuple_[context.arrayElementIndex]; + else if (additionalItemsSchema_) + context.valueSchema = additionalItemsSchema_; + else if (additionalItems_) + context.valueSchema = typeless_; + else { + context.error_handler.DisallowedItem(context.arrayElementIndex); + // Must set valueSchema for when kValidateContinueOnErrorFlag is set, else reports spurious type error + context.valueSchema = typeless_; + // Must bump arrayElementIndex for when kValidateContinueOnErrorFlag is set + context.arrayElementIndex++; + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAdditionalItems); + } + } + else + context.valueSchema = typeless_; + + context.arrayElementIndex++; + } + return true; + } + + RAPIDJSON_FORCEINLINE bool EndValue(Context& context) const { + // Only check pattern properties if we have validators + if (context.patternPropertiesValidatorCount > 0) { + bool otherValid = false; + SizeType count = context.patternPropertiesValidatorCount; + if (context.objectPatternValidatorType != Context::kPatternValidatorOnly) + otherValid = context.patternPropertiesValidators[--count]->IsValid(); + + bool patternValid = true; + for (SizeType i = 0; i < count; i++) + if (!context.patternPropertiesValidators[i]->IsValid()) { + patternValid = false; + break; + } + + if (context.objectPatternValidatorType == Context::kPatternValidatorOnly) { + if (!patternValid) { + context.error_handler.PropertyViolations(context.patternPropertiesValidators, count); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPatternProperties); + } + } + else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty) { + if (!patternValid || !otherValid) { + context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPatternProperties); + } + } + else if (!patternValid && !otherValid) { // kPatternValidatorWithAdditionalProperty) + context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPatternProperties); + } + } + + // For enums only check if we have a hasher + if (enum_ && context.hasher) { + const uint64_t h = context.factory.GetHashCode(context.hasher); + for (SizeType i = 0; i < enumCount_; i++) + if (enum_[i] == h) + goto foundEnum; + context.error_handler.DisallowedValue(kValidateErrorEnum); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorEnum); + foundEnum:; + } + + // Only check allOf etc if we have validators + if (context.validatorCount > 0) { + if (allOf_.schemas) + for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++) + if (!context.validators[i]->IsValid()) { + context.error_handler.NotAllOf(&context.validators[allOf_.begin], allOf_.count); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAllOf); + } + + if (anyOf_.schemas) { + for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++) + if (context.validators[i]->IsValid()) + goto foundAny; + context.error_handler.NoneOf(&context.validators[anyOf_.begin], anyOf_.count); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAnyOf); + foundAny:; + } + + if (oneOf_.schemas) { + bool oneValid = false; + for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++) + if (context.validators[i]->IsValid()) { + if (oneValid) { + context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count, true); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorOneOfMatch); + } else + oneValid = true; + } + if (!oneValid) { + context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count, false); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorOneOf); + } + } + + if (not_ && context.validators[notValidatorIndex_]->IsValid()) { + context.error_handler.Disallowed(); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorNot); + } + } + + return true; + } + + bool Null(Context& context) const { + if (!(type_ & (1 << kNullSchemaType))) { + DisallowedType(context, GetNullString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType); + } + return CreateParallelValidator(context); + } + + bool Bool(Context& context, bool) const { + if (!(type_ & (1 << kBooleanSchemaType))) { + DisallowedType(context, GetBooleanString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType); + } + return CreateParallelValidator(context); + } + + bool Int(Context& context, int i) const { + if (!CheckInt(context, i)) + return false; + return CreateParallelValidator(context); + } + + bool Uint(Context& context, unsigned u) const { + if (!CheckUint(context, u)) + return false; + return CreateParallelValidator(context); + } + + bool Int64(Context& context, int64_t i) const { + if (!CheckInt(context, i)) + return false; + return CreateParallelValidator(context); + } + + bool Uint64(Context& context, uint64_t u) const { + if (!CheckUint(context, u)) + return false; + return CreateParallelValidator(context); + } + + bool Double(Context& context, double d) const { + if (!(type_ & (1 << kNumberSchemaType))) { + DisallowedType(context, GetNumberString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType); + } + + if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d)) + return false; + + if (!maximum_.IsNull() && !CheckDoubleMaximum(context, d)) + return false; + + if (!multipleOf_.IsNull() && !CheckDoubleMultipleOf(context, d)) + return false; + + return CreateParallelValidator(context); + } + + bool String(Context& context, const Ch* str, SizeType length, bool) const { + if (!(type_ & (1 << kStringSchemaType))) { + DisallowedType(context, GetStringString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType); + } + + if (minLength_ != 0 || maxLength_ != SizeType(~0)) { + SizeType count; + if (internal::CountStringCodePoint(str, length, &count)) { + if (count < minLength_) { + context.error_handler.TooShort(str, length, minLength_); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMinLength); + } + if (count > maxLength_) { + context.error_handler.TooLong(str, length, maxLength_); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMaxLength); + } + } + } + + if (pattern_ && !IsPatternMatch(pattern_, str, length)) { + context.error_handler.DoesNotMatch(str, length); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPattern); + } + + return CreateParallelValidator(context); + } + + bool StartObject(Context& context) const { + if (!(type_ & (1 << kObjectSchemaType))) { + DisallowedType(context, GetObjectString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType); + } + + if (hasDependencies_ || hasRequired_) { + context.propertyExist = static_cast(context.factory.MallocState(sizeof(bool) * propertyCount_)); + std::memset(context.propertyExist, 0, sizeof(bool) * propertyCount_); + } + + if (patternProperties_) { // pre-allocate schema array + SizeType count = patternPropertyCount_ + 1; // extra for valuePatternValidatorType + context.patternPropertiesSchemas = static_cast(context.factory.MallocState(sizeof(const SchemaType*) * count)); + context.patternPropertiesSchemaCount = 0; + std::memset(context.patternPropertiesSchemas, 0, sizeof(SchemaType*) * count); + } + + return CreateParallelValidator(context); + } + + bool Key(Context& context, const Ch* str, SizeType len, bool) const { + if (patternProperties_) { + context.patternPropertiesSchemaCount = 0; + for (SizeType i = 0; i < patternPropertyCount_; i++) + if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len)) { + context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = patternProperties_[i].schema; + context.valueSchema = typeless_; + } + } + + SizeType index = 0; + if (FindPropertyIndex(ValueType(str, len).Move(), &index)) { + if (context.patternPropertiesSchemaCount > 0) { + context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema; + context.valueSchema = typeless_; + context.valuePatternValidatorType = Context::kPatternValidatorWithProperty; + } + else + context.valueSchema = properties_[index].schema; + + if (context.propertyExist) + context.propertyExist[index] = true; + + return true; + } + + if (additionalPropertiesSchema_) { + if (context.patternPropertiesSchemaCount > 0) { + context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = additionalPropertiesSchema_; + context.valueSchema = typeless_; + context.valuePatternValidatorType = Context::kPatternValidatorWithAdditionalProperty; + } + else + context.valueSchema = additionalPropertiesSchema_; + return true; + } + else if (additionalProperties_) { + context.valueSchema = typeless_; + return true; + } + + if (context.patternPropertiesSchemaCount == 0) { // patternProperties are not additional properties + // Must set valueSchema for when kValidateContinueOnErrorFlag is set, else reports spurious type error + context.valueSchema = typeless_; + context.error_handler.DisallowedProperty(str, len); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAdditionalProperties); + } + + return true; + } + + bool EndObject(Context& context, SizeType memberCount) const { + if (hasRequired_) { + context.error_handler.StartMissingProperties(); + for (SizeType index = 0; index < propertyCount_; index++) + if (properties_[index].required && !context.propertyExist[index]) + if (properties_[index].schema->defaultValueLength_ == 0 ) + context.error_handler.AddMissingProperty(properties_[index].name); + if (context.error_handler.EndMissingProperties()) + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorRequired); + } + + if (memberCount < minProperties_) { + context.error_handler.TooFewProperties(memberCount, minProperties_); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMinProperties); + } + + if (memberCount > maxProperties_) { + context.error_handler.TooManyProperties(memberCount, maxProperties_); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMaxProperties); + } + + if (hasDependencies_) { + context.error_handler.StartDependencyErrors(); + for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++) { + const Property& source = properties_[sourceIndex]; + if (context.propertyExist[sourceIndex]) { + if (source.dependencies) { + context.error_handler.StartMissingDependentProperties(); + for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++) + if (source.dependencies[targetIndex] && !context.propertyExist[targetIndex]) + context.error_handler.AddMissingDependentProperty(properties_[targetIndex].name); + context.error_handler.EndMissingDependentProperties(source.name); + } + else if (source.dependenciesSchema) { + ISchemaValidator* dependenciesValidator = context.validators[source.dependenciesValidatorIndex]; + if (!dependenciesValidator->IsValid()) + context.error_handler.AddDependencySchemaError(source.name, dependenciesValidator); + } + } + } + if (context.error_handler.EndDependencyErrors()) + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorDependencies); + } + + return true; + } + + bool StartArray(Context& context) const { + context.arrayElementIndex = 0; + context.inArray = true; // Ensure we note that we are in an array + + if (!(type_ & (1 << kArraySchemaType))) { + DisallowedType(context, GetArrayString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType); + } + + return CreateParallelValidator(context); + } + + bool EndArray(Context& context, SizeType elementCount) const { + context.inArray = false; + + if (elementCount < minItems_) { + context.error_handler.TooFewItems(elementCount, minItems_); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMinItems); + } + + if (elementCount > maxItems_) { + context.error_handler.TooManyItems(elementCount, maxItems_); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMaxItems); + } + + return true; + } + + static const ValueType& GetValidateErrorKeyword(ValidateErrorCode validateErrorCode) { + switch (validateErrorCode) { + case kValidateErrorMultipleOf: return GetMultipleOfString(); + case kValidateErrorMaximum: return GetMaximumString(); + case kValidateErrorExclusiveMaximum: return GetMaximumString(); // Same + case kValidateErrorMinimum: return GetMinimumString(); + case kValidateErrorExclusiveMinimum: return GetMinimumString(); // Same + + case kValidateErrorMaxLength: return GetMaxLengthString(); + case kValidateErrorMinLength: return GetMinLengthString(); + case kValidateErrorPattern: return GetPatternString(); + + case kValidateErrorMaxItems: return GetMaxItemsString(); + case kValidateErrorMinItems: return GetMinItemsString(); + case kValidateErrorUniqueItems: return GetUniqueItemsString(); + case kValidateErrorAdditionalItems: return GetAdditionalItemsString(); + + case kValidateErrorMaxProperties: return GetMaxPropertiesString(); + case kValidateErrorMinProperties: return GetMinPropertiesString(); + case kValidateErrorRequired: return GetRequiredString(); + case kValidateErrorAdditionalProperties: return GetAdditionalPropertiesString(); + case kValidateErrorPatternProperties: return GetPatternPropertiesString(); + case kValidateErrorDependencies: return GetDependenciesString(); + + case kValidateErrorEnum: return GetEnumString(); + case kValidateErrorType: return GetTypeString(); + + case kValidateErrorOneOf: return GetOneOfString(); + case kValidateErrorOneOfMatch: return GetOneOfString(); // Same + case kValidateErrorAllOf: return GetAllOfString(); + case kValidateErrorAnyOf: return GetAnyOfString(); + case kValidateErrorNot: return GetNotString(); + + default: return GetNullString(); + } + } + + + // Generate functions for string literal according to Ch +#define RAPIDJSON_STRING_(name, ...) \ + static const ValueType& Get##name##String() {\ + static const Ch s[] = { __VA_ARGS__, '\0' };\ + static const ValueType v(s, static_cast(sizeof(s) / sizeof(Ch) - 1));\ + return v;\ + } + + RAPIDJSON_STRING_(Null, 'n', 'u', 'l', 'l') + RAPIDJSON_STRING_(Boolean, 'b', 'o', 'o', 'l', 'e', 'a', 'n') + RAPIDJSON_STRING_(Object, 'o', 'b', 'j', 'e', 'c', 't') + RAPIDJSON_STRING_(Array, 'a', 'r', 'r', 'a', 'y') + RAPIDJSON_STRING_(String, 's', 't', 'r', 'i', 'n', 'g') + RAPIDJSON_STRING_(Number, 'n', 'u', 'm', 'b', 'e', 'r') + RAPIDJSON_STRING_(Integer, 'i', 'n', 't', 'e', 'g', 'e', 'r') + RAPIDJSON_STRING_(Type, 't', 'y', 'p', 'e') + RAPIDJSON_STRING_(Enum, 'e', 'n', 'u', 'm') + RAPIDJSON_STRING_(AllOf, 'a', 'l', 'l', 'O', 'f') + RAPIDJSON_STRING_(AnyOf, 'a', 'n', 'y', 'O', 'f') + RAPIDJSON_STRING_(OneOf, 'o', 'n', 'e', 'O', 'f') + RAPIDJSON_STRING_(Not, 'n', 'o', 't') + RAPIDJSON_STRING_(Properties, 'p', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's') + RAPIDJSON_STRING_(Required, 'r', 'e', 'q', 'u', 'i', 'r', 'e', 'd') + RAPIDJSON_STRING_(Dependencies, 'd', 'e', 'p', 'e', 'n', 'd', 'e', 'n', 'c', 'i', 'e', 's') + RAPIDJSON_STRING_(PatternProperties, 'p', 'a', 't', 't', 'e', 'r', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's') + RAPIDJSON_STRING_(AdditionalProperties, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's') + RAPIDJSON_STRING_(MinProperties, 'm', 'i', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's') + RAPIDJSON_STRING_(MaxProperties, 'm', 'a', 'x', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's') + RAPIDJSON_STRING_(Items, 'i', 't', 'e', 'm', 's') + RAPIDJSON_STRING_(MinItems, 'm', 'i', 'n', 'I', 't', 'e', 'm', 's') + RAPIDJSON_STRING_(MaxItems, 'm', 'a', 'x', 'I', 't', 'e', 'm', 's') + RAPIDJSON_STRING_(AdditionalItems, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'I', 't', 'e', 'm', 's') + RAPIDJSON_STRING_(UniqueItems, 'u', 'n', 'i', 'q', 'u', 'e', 'I', 't', 'e', 'm', 's') + RAPIDJSON_STRING_(MinLength, 'm', 'i', 'n', 'L', 'e', 'n', 'g', 't', 'h') + RAPIDJSON_STRING_(MaxLength, 'm', 'a', 'x', 'L', 'e', 'n', 'g', 't', 'h') + RAPIDJSON_STRING_(Pattern, 'p', 'a', 't', 't', 'e', 'r', 'n') + RAPIDJSON_STRING_(Minimum, 'm', 'i', 'n', 'i', 'm', 'u', 'm') + RAPIDJSON_STRING_(Maximum, 'm', 'a', 'x', 'i', 'm', 'u', 'm') + RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm') + RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm') + RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f') + RAPIDJSON_STRING_(DefaultValue, 'd', 'e', 'f', 'a', 'u', 'l', 't') + +#undef RAPIDJSON_STRING_ + +private: + enum SchemaValueType { + kNullSchemaType, + kBooleanSchemaType, + kObjectSchemaType, + kArraySchemaType, + kStringSchemaType, + kNumberSchemaType, + kIntegerSchemaType, + kTotalSchemaType + }; + +#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX + typedef internal::GenericRegex RegexType; +#elif RAPIDJSON_SCHEMA_USE_STDREGEX + typedef std::basic_regex RegexType; +#else + typedef char RegexType; +#endif + + struct SchemaArray { + SchemaArray() : schemas(), count() {} + ~SchemaArray() { AllocatorType::Free(schemas); } + const SchemaType** schemas; + SizeType begin; // begin index of context.validators + SizeType count; + }; + + template + void AddUniqueElement(V1& a, const V2& v) { + for (typename V1::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr) + if (*itr == v) + return; + V1 c(v, *allocator_); + a.PushBack(c, *allocator_); + } + + static const ValueType* GetMember(const ValueType& value, const ValueType& name) { + typename ValueType::ConstMemberIterator itr = value.FindMember(name); + return itr != value.MemberEnd() ? &(itr->value) : 0; + } + + static void AssignIfExist(bool& out, const ValueType& value, const ValueType& name) { + if (const ValueType* v = GetMember(value, name)) + if (v->IsBool()) + out = v->GetBool(); + } + + static void AssignIfExist(SizeType& out, const ValueType& value, const ValueType& name) { + if (const ValueType* v = GetMember(value, name)) + if (v->IsUint64() && v->GetUint64() <= SizeType(~0)) + out = static_cast(v->GetUint64()); + } + + void AssignIfExist(SchemaArray& out, SchemaDocumentType& schemaDocument, const PointerType& p, const ValueType& value, const ValueType& name, const ValueType& document) { + if (const ValueType* v = GetMember(value, name)) { + if (v->IsArray() && v->Size() > 0) { + PointerType q = p.Append(name, allocator_); + out.count = v->Size(); + out.schemas = static_cast(allocator_->Malloc(out.count * sizeof(const Schema*))); + memset(out.schemas, 0, sizeof(Schema*)* out.count); + for (SizeType i = 0; i < out.count; i++) + schemaDocument.CreateSchema(&out.schemas[i], q.Append(i, allocator_), (*v)[i], document); + out.begin = validatorCount_; + validatorCount_ += out.count; + } + } + } + +#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX + template + RegexType* CreatePattern(const ValueType& value) { + if (value.IsString()) { + RegexType* r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), allocator_); + if (!r->IsValid()) { + r->~RegexType(); + AllocatorType::Free(r); + r = 0; + } + return r; + } + return 0; + } + + static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType) { + GenericRegexSearch rs(*pattern); + return rs.Search(str); + } +#elif RAPIDJSON_SCHEMA_USE_STDREGEX + template + RegexType* CreatePattern(const ValueType& value) { + if (value.IsString()) { + RegexType *r = static_cast(allocator_->Malloc(sizeof(RegexType))); + try { + return new (r) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript); + } + catch (const std::regex_error&) { + AllocatorType::Free(r); + } + } + return 0; + } + + static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType length) { + std::match_results r; + return std::regex_search(str, str + length, r, *pattern); + } +#else + template + RegexType* CreatePattern(const ValueType&) { return 0; } + + static bool IsPatternMatch(const RegexType*, const Ch *, SizeType) { return true; } +#endif // RAPIDJSON_SCHEMA_USE_STDREGEX + + void AddType(const ValueType& type) { + if (type == GetNullString() ) type_ |= 1 << kNullSchemaType; + else if (type == GetBooleanString()) type_ |= 1 << kBooleanSchemaType; + else if (type == GetObjectString() ) type_ |= 1 << kObjectSchemaType; + else if (type == GetArrayString() ) type_ |= 1 << kArraySchemaType; + else if (type == GetStringString() ) type_ |= 1 << kStringSchemaType; + else if (type == GetIntegerString()) type_ |= 1 << kIntegerSchemaType; + else if (type == GetNumberString() ) type_ |= (1 << kNumberSchemaType) | (1 << kIntegerSchemaType); + } + + bool CreateParallelValidator(Context& context) const { + if (enum_ || context.arrayUniqueness) + context.hasher = context.factory.CreateHasher(); + + if (validatorCount_) { + RAPIDJSON_ASSERT(context.validators == 0); + context.validators = static_cast(context.factory.MallocState(sizeof(ISchemaValidator*) * validatorCount_)); + context.validatorCount = validatorCount_; + + // Always return after first failure for these sub-validators + if (allOf_.schemas) + CreateSchemaValidators(context, allOf_, false); + + if (anyOf_.schemas) + CreateSchemaValidators(context, anyOf_, false); + + if (oneOf_.schemas) + CreateSchemaValidators(context, oneOf_, false); + + if (not_) + context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_, false); + + if (hasSchemaDependencies_) { + for (SizeType i = 0; i < propertyCount_; i++) + if (properties_[i].dependenciesSchema) + context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema, false); + } + } + + return true; + } + + void CreateSchemaValidators(Context& context, const SchemaArray& schemas, const bool inheritContinueOnErrors) const { + for (SizeType i = 0; i < schemas.count; i++) + context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i], inheritContinueOnErrors); + } + + // O(n) + bool FindPropertyIndex(const ValueType& name, SizeType* outIndex) const { + SizeType len = name.GetStringLength(); + const Ch* str = name.GetString(); + for (SizeType index = 0; index < propertyCount_; index++) + if (properties_[index].name.GetStringLength() == len && + (std::memcmp(properties_[index].name.GetString(), str, sizeof(Ch) * len) == 0)) + { + *outIndex = index; + return true; + } + return false; + } + + bool CheckInt(Context& context, int64_t i) const { + if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) { + DisallowedType(context, GetIntegerString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType); + } + + if (!minimum_.IsNull()) { + if (minimum_.IsInt64()) { + if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64()) { + context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum); + } + } + else if (minimum_.IsUint64()) { + context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum); // i <= max(int64_t) < minimum.GetUint64() + } + else if (!CheckDoubleMinimum(context, static_cast(i))) + return false; + } + + if (!maximum_.IsNull()) { + if (maximum_.IsInt64()) { + if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64()) { + context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum); + } + } + else if (maximum_.IsUint64()) { } + /* do nothing */ // i <= max(int64_t) < maximum_.GetUint64() + else if (!CheckDoubleMaximum(context, static_cast(i))) + return false; + } + + if (!multipleOf_.IsNull()) { + if (multipleOf_.IsUint64()) { + if (static_cast(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0) { + context.error_handler.NotMultipleOf(i, multipleOf_); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMultipleOf); + } + } + else if (!CheckDoubleMultipleOf(context, static_cast(i))) + return false; + } + + return true; + } + + bool CheckUint(Context& context, uint64_t i) const { + if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) { + DisallowedType(context, GetIntegerString()); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType); + } + + if (!minimum_.IsNull()) { + if (minimum_.IsUint64()) { + if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64()) { + context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum); + } + } + else if (minimum_.IsInt64()) + /* do nothing */; // i >= 0 > minimum.Getint64() + else if (!CheckDoubleMinimum(context, static_cast(i))) + return false; + } + + if (!maximum_.IsNull()) { + if (maximum_.IsUint64()) { + if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64()) { + context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum); + } + } + else if (maximum_.IsInt64()) { + context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum); // i >= 0 > maximum_ + } + else if (!CheckDoubleMaximum(context, static_cast(i))) + return false; + } + + if (!multipleOf_.IsNull()) { + if (multipleOf_.IsUint64()) { + if (i % multipleOf_.GetUint64() != 0) { + context.error_handler.NotMultipleOf(i, multipleOf_); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMultipleOf); + } + } + else if (!CheckDoubleMultipleOf(context, static_cast(i))) + return false; + } + + return true; + } + + bool CheckDoubleMinimum(Context& context, double d) const { + if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble()) { + context.error_handler.BelowMinimum(d, minimum_, exclusiveMinimum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum); + } + return true; + } + + bool CheckDoubleMaximum(Context& context, double d) const { + if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble()) { + context.error_handler.AboveMaximum(d, maximum_, exclusiveMaximum_); + RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum); + } + return true; + } + + bool CheckDoubleMultipleOf(Context& context, double d) const { + double a = std::abs(d), b = std::abs(multipleOf_.GetDouble()); + double q = std::floor(a / b); + double r = a - q * b; + if (r > 0.0) { + context.error_handler.NotMultipleOf(d, multipleOf_); + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMultipleOf); + } + return true; + } + + void DisallowedType(Context& context, const ValueType& actualType) const { + ErrorHandler& eh = context.error_handler; + eh.StartDisallowedType(); + + if (type_ & (1 << kNullSchemaType)) eh.AddExpectedType(GetNullString()); + if (type_ & (1 << kBooleanSchemaType)) eh.AddExpectedType(GetBooleanString()); + if (type_ & (1 << kObjectSchemaType)) eh.AddExpectedType(GetObjectString()); + if (type_ & (1 << kArraySchemaType)) eh.AddExpectedType(GetArrayString()); + if (type_ & (1 << kStringSchemaType)) eh.AddExpectedType(GetStringString()); + + if (type_ & (1 << kNumberSchemaType)) eh.AddExpectedType(GetNumberString()); + else if (type_ & (1 << kIntegerSchemaType)) eh.AddExpectedType(GetIntegerString()); + + eh.EndDisallowedType(actualType); + } + + struct Property { + Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {} + ~Property() { AllocatorType::Free(dependencies); } + SValue name; + const SchemaType* schema; + const SchemaType* dependenciesSchema; + SizeType dependenciesValidatorIndex; + bool* dependencies; + bool required; + }; + + struct PatternProperty { + PatternProperty() : schema(), pattern() {} + ~PatternProperty() { + if (pattern) { + pattern->~RegexType(); + AllocatorType::Free(pattern); + } + } + const SchemaType* schema; + RegexType* pattern; + }; + + AllocatorType* allocator_; + SValue uri_; + PointerType pointer_; + const SchemaType* typeless_; + uint64_t* enum_; + SizeType enumCount_; + SchemaArray allOf_; + SchemaArray anyOf_; + SchemaArray oneOf_; + const SchemaType* not_; + unsigned type_; // bitmask of kSchemaType + SizeType validatorCount_; + SizeType notValidatorIndex_; + + Property* properties_; + const SchemaType* additionalPropertiesSchema_; + PatternProperty* patternProperties_; + SizeType patternPropertyCount_; + SizeType propertyCount_; + SizeType minProperties_; + SizeType maxProperties_; + bool additionalProperties_; + bool hasDependencies_; + bool hasRequired_; + bool hasSchemaDependencies_; + + const SchemaType* additionalItemsSchema_; + const SchemaType* itemsList_; + const SchemaType** itemsTuple_; + SizeType itemsTupleCount_; + SizeType minItems_; + SizeType maxItems_; + bool additionalItems_; + bool uniqueItems_; + + RegexType* pattern_; + SizeType minLength_; + SizeType maxLength_; + + SValue minimum_; + SValue maximum_; + SValue multipleOf_; + bool exclusiveMinimum_; + bool exclusiveMaximum_; + + SizeType defaultValueLength_; +}; + +template +struct TokenHelper { + RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack& documentStack, SizeType index) { + *documentStack.template Push() = '/'; + char buffer[21]; + size_t length = static_cast((sizeof(SizeType) == 4 ? u32toa(index, buffer) : u64toa(index, buffer)) - buffer); + for (size_t i = 0; i < length; i++) + *documentStack.template Push() = static_cast(buffer[i]); + } +}; + +// Partial specialized version for char to prevent buffer copying. +template +struct TokenHelper { + RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack& documentStack, SizeType index) { + if (sizeof(SizeType) == 4) { + char *buffer = documentStack.template Push(1 + 10); // '/' + uint + *buffer++ = '/'; + const char* end = internal::u32toa(index, buffer); + documentStack.template Pop(static_cast(10 - (end - buffer))); + } + else { + char *buffer = documentStack.template Push(1 + 20); // '/' + uint64 + *buffer++ = '/'; + const char* end = internal::u64toa(index, buffer); + documentStack.template Pop(static_cast(20 - (end - buffer))); + } + } +}; + +} // namespace internal + +/////////////////////////////////////////////////////////////////////////////// +// IGenericRemoteSchemaDocumentProvider + +template +class IGenericRemoteSchemaDocumentProvider { +public: + typedef typename SchemaDocumentType::Ch Ch; + + virtual ~IGenericRemoteSchemaDocumentProvider() {} + virtual const SchemaDocumentType* GetRemoteDocument(const Ch* uri, SizeType length) = 0; +}; + +/////////////////////////////////////////////////////////////////////////////// +// GenericSchemaDocument + +//! JSON schema document. +/*! + A JSON schema document is a compiled version of a JSON schema. + It is basically a tree of internal::Schema. + + \note This is an immutable class (i.e. its instance cannot be modified after construction). + \tparam ValueT Type of JSON value (e.g. \c Value ), which also determine the encoding. + \tparam Allocator Allocator type for allocating memory of this document. +*/ +template +class GenericSchemaDocument { +public: + typedef ValueT ValueType; + typedef IGenericRemoteSchemaDocumentProvider IRemoteSchemaDocumentProviderType; + typedef Allocator AllocatorType; + typedef typename ValueType::EncodingType EncodingType; + typedef typename EncodingType::Ch Ch; + typedef internal::Schema SchemaType; + typedef GenericPointer PointerType; + typedef GenericValue URIType; + friend class internal::Schema; + template + friend class GenericSchemaValidator; + + //! Constructor. + /*! + Compile a JSON document into schema document. + + \param document A JSON document as source. + \param uri The base URI of this schema document for purposes of violation reporting. + \param uriLength Length of \c name, in code points. + \param remoteProvider An optional remote schema document provider for resolving remote reference. Can be null. + \param allocator An optional allocator instance for allocating memory. Can be null. + */ + explicit GenericSchemaDocument(const ValueType& document, const Ch* uri = 0, SizeType uriLength = 0, + IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) : + remoteProvider_(remoteProvider), + allocator_(allocator), + ownAllocator_(), + root_(), + typeless_(), + schemaMap_(allocator, kInitialSchemaMapSize), + schemaRef_(allocator, kInitialSchemaRefSize) + { + if (!allocator_) + ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); + + Ch noUri[1] = {0}; + uri_.SetString(uri ? uri : noUri, uriLength, *allocator_); + + typeless_ = static_cast(allocator_->Malloc(sizeof(SchemaType))); + new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), allocator_); + + // Generate root schema, it will call CreateSchema() to create sub-schemas, + // And call AddRefSchema() if there are $ref. + CreateSchemaRecursive(&root_, PointerType(), document, document); + + // Resolve $ref + while (!schemaRef_.Empty()) { + SchemaRefEntry* refEntry = schemaRef_.template Pop(1); + if (const SchemaType* s = GetSchema(refEntry->target)) { + if (refEntry->schema) + *refEntry->schema = s; + + // Create entry in map if not exist + if (!GetSchema(refEntry->source)) { + new (schemaMap_.template Push()) SchemaEntry(refEntry->source, const_cast(s), false, allocator_); + } + } + else if (refEntry->schema) + *refEntry->schema = typeless_; + + refEntry->~SchemaRefEntry(); + } + + RAPIDJSON_ASSERT(root_ != 0); + + schemaRef_.ShrinkToFit(); // Deallocate all memory for ref + } + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + //! Move constructor in C++11 + GenericSchemaDocument(GenericSchemaDocument&& rhs) RAPIDJSON_NOEXCEPT : + remoteProvider_(rhs.remoteProvider_), + allocator_(rhs.allocator_), + ownAllocator_(rhs.ownAllocator_), + root_(rhs.root_), + typeless_(rhs.typeless_), + schemaMap_(std::move(rhs.schemaMap_)), + schemaRef_(std::move(rhs.schemaRef_)), + uri_(std::move(rhs.uri_)) + { + rhs.remoteProvider_ = 0; + rhs.allocator_ = 0; + rhs.ownAllocator_ = 0; + rhs.typeless_ = 0; + } +#endif + + //! Destructor + ~GenericSchemaDocument() { + while (!schemaMap_.Empty()) + schemaMap_.template Pop(1)->~SchemaEntry(); + + if (typeless_) { + typeless_->~SchemaType(); + Allocator::Free(typeless_); + } + + RAPIDJSON_DELETE(ownAllocator_); + } + + const URIType& GetURI() const { return uri_; } + + //! Get the root schema. + const SchemaType& GetRoot() const { return *root_; } + +private: + //! Prohibit copying + GenericSchemaDocument(const GenericSchemaDocument&); + //! Prohibit assignment + GenericSchemaDocument& operator=(const GenericSchemaDocument&); + + struct SchemaRefEntry { + SchemaRefEntry(const PointerType& s, const PointerType& t, const SchemaType** outSchema, Allocator *allocator) : source(s, allocator), target(t, allocator), schema(outSchema) {} + PointerType source; + PointerType target; + const SchemaType** schema; + }; + + struct SchemaEntry { + SchemaEntry(const PointerType& p, SchemaType* s, bool o, Allocator* allocator) : pointer(p, allocator), schema(s), owned(o) {} + ~SchemaEntry() { + if (owned) { + schema->~SchemaType(); + Allocator::Free(schema); + } + } + PointerType pointer; + SchemaType* schema; + bool owned; + }; + + void CreateSchemaRecursive(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) { + if (schema) + *schema = typeless_; + + if (v.GetType() == kObjectType) { + const SchemaType* s = GetSchema(pointer); + if (!s) + CreateSchema(schema, pointer, v, document); + + for (typename ValueType::ConstMemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr) + CreateSchemaRecursive(0, pointer.Append(itr->name, allocator_), itr->value, document); + } + else if (v.GetType() == kArrayType) + for (SizeType i = 0; i < v.Size(); i++) + CreateSchemaRecursive(0, pointer.Append(i, allocator_), v[i], document); + } + + void CreateSchema(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) { + RAPIDJSON_ASSERT(pointer.IsValid()); + if (v.IsObject()) { + if (!HandleRefSchema(pointer, schema, v, document)) { + SchemaType* s = new (allocator_->Malloc(sizeof(SchemaType))) SchemaType(this, pointer, v, document, allocator_); + new (schemaMap_.template Push()) SchemaEntry(pointer, s, true, allocator_); + if (schema) + *schema = s; + } + } + } + + bool HandleRefSchema(const PointerType& source, const SchemaType** schema, const ValueType& v, const ValueType& document) { + static const Ch kRefString[] = { '$', 'r', 'e', 'f', '\0' }; + static const ValueType kRefValue(kRefString, 4); + + typename ValueType::ConstMemberIterator itr = v.FindMember(kRefValue); + if (itr == v.MemberEnd()) + return false; + + if (itr->value.IsString()) { + SizeType len = itr->value.GetStringLength(); + if (len > 0) { + const Ch* s = itr->value.GetString(); + SizeType i = 0; + while (i < len && s[i] != '#') // Find the first # + i++; + + if (i > 0) { // Remote reference, resolve immediately + if (remoteProvider_) { + if (const GenericSchemaDocument* remoteDocument = remoteProvider_->GetRemoteDocument(s, i)) { + PointerType pointer(&s[i], len - i, allocator_); + if (pointer.IsValid()) { + if (const SchemaType* sc = remoteDocument->GetSchema(pointer)) { + if (schema) + *schema = sc; + new (schemaMap_.template Push()) SchemaEntry(source, const_cast(sc), false, allocator_); + return true; + } + } + } + } + } + else if (s[i] == '#') { // Local reference, defer resolution + PointerType pointer(&s[i], len - i, allocator_); + if (pointer.IsValid()) { + if (const ValueType* nv = pointer.Get(document)) + if (HandleRefSchema(source, schema, *nv, document)) + return true; + + new (schemaRef_.template Push()) SchemaRefEntry(source, pointer, schema, allocator_); + return true; + } + } + } + } + return false; + } + + const SchemaType* GetSchema(const PointerType& pointer) const { + for (const SchemaEntry* target = schemaMap_.template Bottom(); target != schemaMap_.template End(); ++target) + if (pointer == target->pointer) + return target->schema; + return 0; + } + + PointerType GetPointer(const SchemaType* schema) const { + for (const SchemaEntry* target = schemaMap_.template Bottom(); target != schemaMap_.template End(); ++target) + if (schema == target->schema) + return target->pointer; + return PointerType(); + } + + const SchemaType* GetTypeless() const { return typeless_; } + + static const size_t kInitialSchemaMapSize = 64; + static const size_t kInitialSchemaRefSize = 64; + + IRemoteSchemaDocumentProviderType* remoteProvider_; + Allocator *allocator_; + Allocator *ownAllocator_; + const SchemaType* root_; //!< Root schema. + SchemaType* typeless_; + internal::Stack schemaMap_; // Stores created Pointer -> Schemas + internal::Stack schemaRef_; // Stores Pointer from $ref and schema which holds the $ref + URIType uri_; +}; + +//! GenericSchemaDocument using Value type. +typedef GenericSchemaDocument SchemaDocument; +//! IGenericRemoteSchemaDocumentProvider using SchemaDocument. +typedef IGenericRemoteSchemaDocumentProvider IRemoteSchemaDocumentProvider; + +/////////////////////////////////////////////////////////////////////////////// +// GenericSchemaValidator + +//! JSON Schema Validator. +/*! + A SAX style JSON schema validator. + It uses a \c GenericSchemaDocument to validate SAX events. + It delegates the incoming SAX events to an output handler. + The default output handler does nothing. + It can be reused multiple times by calling \c Reset(). + + \tparam SchemaDocumentType Type of schema document. + \tparam OutputHandler Type of output handler. Default handler does nothing. + \tparam StateAllocator Allocator for storing the internal validation states. +*/ +template < + typename SchemaDocumentType, + typename OutputHandler = BaseReaderHandler, + typename StateAllocator = CrtAllocator> +class GenericSchemaValidator : + public internal::ISchemaStateFactory, + public internal::ISchemaValidator, + public internal::IValidationErrorHandler { +public: + typedef typename SchemaDocumentType::SchemaType SchemaType; + typedef typename SchemaDocumentType::PointerType PointerType; + typedef typename SchemaType::EncodingType EncodingType; + typedef typename SchemaType::SValue SValue; + typedef typename EncodingType::Ch Ch; + typedef GenericStringRef StringRefType; + typedef GenericValue ValueType; + + //! Constructor without output handler. + /*! + \param schemaDocument The schema document to conform to. + \param allocator Optional allocator for storing internal validation states. + \param schemaStackCapacity Optional initial capacity of schema path stack. + \param documentStackCapacity Optional initial capacity of document path stack. + */ + GenericSchemaValidator( + const SchemaDocumentType& schemaDocument, + StateAllocator* allocator = 0, + size_t schemaStackCapacity = kDefaultSchemaStackCapacity, + size_t documentStackCapacity = kDefaultDocumentStackCapacity) + : + schemaDocument_(&schemaDocument), + root_(schemaDocument.GetRoot()), + stateAllocator_(allocator), + ownStateAllocator_(0), + schemaStack_(allocator, schemaStackCapacity), + documentStack_(allocator, documentStackCapacity), + outputHandler_(0), + error_(kObjectType), + currentError_(), + missingDependents_(), + valid_(true), + flags_(kValidateDefaultFlags) +#if RAPIDJSON_SCHEMA_VERBOSE + , depth_(0) +#endif + { + } + + //! Constructor with output handler. + /*! + \param schemaDocument The schema document to conform to. + \param allocator Optional allocator for storing internal validation states. + \param schemaStackCapacity Optional initial capacity of schema path stack. + \param documentStackCapacity Optional initial capacity of document path stack. + */ + GenericSchemaValidator( + const SchemaDocumentType& schemaDocument, + OutputHandler& outputHandler, + StateAllocator* allocator = 0, + size_t schemaStackCapacity = kDefaultSchemaStackCapacity, + size_t documentStackCapacity = kDefaultDocumentStackCapacity) + : + schemaDocument_(&schemaDocument), + root_(schemaDocument.GetRoot()), + stateAllocator_(allocator), + ownStateAllocator_(0), + schemaStack_(allocator, schemaStackCapacity), + documentStack_(allocator, documentStackCapacity), + outputHandler_(&outputHandler), + error_(kObjectType), + currentError_(), + missingDependents_(), + valid_(true), + flags_(kValidateDefaultFlags) +#if RAPIDJSON_SCHEMA_VERBOSE + , depth_(0) +#endif + { + } + + //! Destructor. + ~GenericSchemaValidator() { + Reset(); + RAPIDJSON_DELETE(ownStateAllocator_); + } + + //! Reset the internal states. + void Reset() { + while (!schemaStack_.Empty()) + PopSchema(); + documentStack_.Clear(); + ResetError(); + } + + //! Reset the error state. + void ResetError() { + error_.SetObject(); + currentError_.SetNull(); + missingDependents_.SetNull(); + valid_ = true; + } + + //! Implementation of ISchemaValidator + void SetValidateFlags(unsigned flags) { + flags_ = flags; + } + virtual unsigned GetValidateFlags() const { + return flags_; + } + + //! Checks whether the current state is valid. + // Implementation of ISchemaValidator + virtual bool IsValid() const { + if (!valid_) return false; + if (GetContinueOnErrors() && !error_.ObjectEmpty()) return false; + return true; + } + + //! Gets the error object. + ValueType& GetError() { return error_; } + const ValueType& GetError() const { return error_; } + + //! Gets the JSON pointer pointed to the invalid schema. + // If reporting all errors, the stack will be empty. + PointerType GetInvalidSchemaPointer() const { + return schemaStack_.Empty() ? PointerType() : CurrentSchema().GetPointer(); + } + + //! Gets the keyword of invalid schema. + // If reporting all errors, the stack will be empty, so return "errors". + const Ch* GetInvalidSchemaKeyword() const { + if (!schemaStack_.Empty()) return CurrentContext().invalidKeyword; + if (GetContinueOnErrors() && !error_.ObjectEmpty()) return (const Ch*)GetErrorsString(); + return 0; + } + + //! Gets the error code of invalid schema. + // If reporting all errors, the stack will be empty, so return kValidateErrors. + ValidateErrorCode GetInvalidSchemaCode() const { + if (!schemaStack_.Empty()) return CurrentContext().invalidCode; + if (GetContinueOnErrors() && !error_.ObjectEmpty()) return kValidateErrors; + return kValidateErrorNone; + } + + //! Gets the JSON pointer pointed to the invalid value. + // If reporting all errors, the stack will be empty. + PointerType GetInvalidDocumentPointer() const { + if (documentStack_.Empty()) { + return PointerType(); + } + else { + return PointerType(documentStack_.template Bottom(), documentStack_.GetSize() / sizeof(Ch)); + } + } + + void NotMultipleOf(int64_t actual, const SValue& expected) { + AddNumberError(kValidateErrorMultipleOf, ValueType(actual).Move(), expected); + } + void NotMultipleOf(uint64_t actual, const SValue& expected) { + AddNumberError(kValidateErrorMultipleOf, ValueType(actual).Move(), expected); + } + void NotMultipleOf(double actual, const SValue& expected) { + AddNumberError(kValidateErrorMultipleOf, ValueType(actual).Move(), expected); + } + void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) { + AddNumberError(exclusive ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum, ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMaximumString : 0); + } + void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) { + AddNumberError(exclusive ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum, ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMaximumString : 0); + } + void AboveMaximum(double actual, const SValue& expected, bool exclusive) { + AddNumberError(exclusive ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum, ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMaximumString : 0); + } + void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) { + AddNumberError(exclusive ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum, ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMinimumString : 0); + } + void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) { + AddNumberError(exclusive ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum, ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMinimumString : 0); + } + void BelowMinimum(double actual, const SValue& expected, bool exclusive) { + AddNumberError(exclusive ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum, ValueType(actual).Move(), expected, + exclusive ? &SchemaType::GetExclusiveMinimumString : 0); + } + + void TooLong(const Ch* str, SizeType length, SizeType expected) { + AddNumberError(kValidateErrorMaxLength, + ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move()); + } + void TooShort(const Ch* str, SizeType length, SizeType expected) { + AddNumberError(kValidateErrorMinLength, + ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move()); + } + void DoesNotMatch(const Ch* str, SizeType length) { + currentError_.SetObject(); + currentError_.AddMember(GetActualString(), ValueType(str, length, GetStateAllocator()).Move(), GetStateAllocator()); + AddCurrentError(kValidateErrorPattern); + } + + void DisallowedItem(SizeType index) { + currentError_.SetObject(); + currentError_.AddMember(GetDisallowedString(), ValueType(index).Move(), GetStateAllocator()); + AddCurrentError(kValidateErrorAdditionalItems, true); + } + void TooFewItems(SizeType actualCount, SizeType expectedCount) { + AddNumberError(kValidateErrorMinItems, + ValueType(actualCount).Move(), SValue(expectedCount).Move()); + } + void TooManyItems(SizeType actualCount, SizeType expectedCount) { + AddNumberError(kValidateErrorMaxItems, + ValueType(actualCount).Move(), SValue(expectedCount).Move()); + } + void DuplicateItems(SizeType index1, SizeType index2) { + ValueType duplicates(kArrayType); + duplicates.PushBack(index1, GetStateAllocator()); + duplicates.PushBack(index2, GetStateAllocator()); + currentError_.SetObject(); + currentError_.AddMember(GetDuplicatesString(), duplicates, GetStateAllocator()); + AddCurrentError(kValidateErrorUniqueItems, true); + } + + void TooManyProperties(SizeType actualCount, SizeType expectedCount) { + AddNumberError(kValidateErrorMaxProperties, + ValueType(actualCount).Move(), SValue(expectedCount).Move()); + } + void TooFewProperties(SizeType actualCount, SizeType expectedCount) { + AddNumberError(kValidateErrorMinProperties, + ValueType(actualCount).Move(), SValue(expectedCount).Move()); + } + void StartMissingProperties() { + currentError_.SetArray(); + } + void AddMissingProperty(const SValue& name) { + currentError_.PushBack(ValueType(name, GetStateAllocator()).Move(), GetStateAllocator()); + } + bool EndMissingProperties() { + if (currentError_.Empty()) + return false; + ValueType error(kObjectType); + error.AddMember(GetMissingString(), currentError_, GetStateAllocator()); + currentError_ = error; + AddCurrentError(kValidateErrorRequired); + return true; + } + void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) { + for (SizeType i = 0; i < count; ++i) + MergeError(static_cast(subvalidators[i])->GetError()); + } + void DisallowedProperty(const Ch* name, SizeType length) { + currentError_.SetObject(); + currentError_.AddMember(GetDisallowedString(), ValueType(name, length, GetStateAllocator()).Move(), GetStateAllocator()); + AddCurrentError(kValidateErrorAdditionalProperties, true); + } + + void StartDependencyErrors() { + currentError_.SetObject(); + } + void StartMissingDependentProperties() { + missingDependents_.SetArray(); + } + void AddMissingDependentProperty(const SValue& targetName) { + missingDependents_.PushBack(ValueType(targetName, GetStateAllocator()).Move(), GetStateAllocator()); + } + void EndMissingDependentProperties(const SValue& sourceName) { + if (!missingDependents_.Empty()) { + // Create equivalent 'required' error + ValueType error(kObjectType); + ValidateErrorCode code = kValidateErrorRequired; + error.AddMember(GetMissingString(), missingDependents_.Move(), GetStateAllocator()); + AddErrorCode(error, code); + AddErrorInstanceLocation(error, false); + // When appending to a pointer ensure its allocator is used + PointerType schemaRef = GetInvalidSchemaPointer().Append(SchemaType::GetValidateErrorKeyword(kValidateErrorDependencies), &GetInvalidSchemaPointer().GetAllocator()); + AddErrorSchemaLocation(error, schemaRef.Append(sourceName.GetString(), sourceName.GetStringLength(), &GetInvalidSchemaPointer().GetAllocator())); + ValueType wrapper(kObjectType); + wrapper.AddMember(ValueType(SchemaType::GetValidateErrorKeyword(code), GetStateAllocator()).Move(), error, GetStateAllocator()); + currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(), wrapper, GetStateAllocator()); + } + } + void AddDependencySchemaError(const SValue& sourceName, ISchemaValidator* subvalidator) { + currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(), + static_cast(subvalidator)->GetError(), GetStateAllocator()); + } + bool EndDependencyErrors() { + if (currentError_.ObjectEmpty()) + return false; + ValueType error(kObjectType); + error.AddMember(GetErrorsString(), currentError_, GetStateAllocator()); + currentError_ = error; + AddCurrentError(kValidateErrorDependencies); + return true; + } + + void DisallowedValue(const ValidateErrorCode code = kValidateErrorEnum) { + currentError_.SetObject(); + AddCurrentError(code); + } + void StartDisallowedType() { + currentError_.SetArray(); + } + void AddExpectedType(const typename SchemaType::ValueType& expectedType) { + currentError_.PushBack(ValueType(expectedType, GetStateAllocator()).Move(), GetStateAllocator()); + } + void EndDisallowedType(const typename SchemaType::ValueType& actualType) { + ValueType error(kObjectType); + error.AddMember(GetExpectedString(), currentError_, GetStateAllocator()); + error.AddMember(GetActualString(), ValueType(actualType, GetStateAllocator()).Move(), GetStateAllocator()); + currentError_ = error; + AddCurrentError(kValidateErrorType); + } + void NotAllOf(ISchemaValidator** subvalidators, SizeType count) { + // Treat allOf like oneOf and anyOf to match https://rapidjson.org/md_doc_schema.html#allOf-anyOf-oneOf + AddErrorArray(kValidateErrorAllOf, subvalidators, count); + //for (SizeType i = 0; i < count; ++i) { + // MergeError(static_cast(subvalidators[i])->GetError()); + //} + } + void NoneOf(ISchemaValidator** subvalidators, SizeType count) { + AddErrorArray(kValidateErrorAnyOf, subvalidators, count); + } + void NotOneOf(ISchemaValidator** subvalidators, SizeType count, bool matched = false) { + AddErrorArray(matched ? kValidateErrorOneOfMatch : kValidateErrorOneOf, subvalidators, count); + } + void Disallowed() { + currentError_.SetObject(); + AddCurrentError(kValidateErrorNot); + } + +#define RAPIDJSON_STRING_(name, ...) \ + static const StringRefType& Get##name##String() {\ + static const Ch s[] = { __VA_ARGS__, '\0' };\ + static const StringRefType v(s, static_cast(sizeof(s) / sizeof(Ch) - 1)); \ + return v;\ + } + + RAPIDJSON_STRING_(InstanceRef, 'i', 'n', 's', 't', 'a', 'n', 'c', 'e', 'R', 'e', 'f') + RAPIDJSON_STRING_(SchemaRef, 's', 'c', 'h', 'e', 'm', 'a', 'R', 'e', 'f') + RAPIDJSON_STRING_(Expected, 'e', 'x', 'p', 'e', 'c', 't', 'e', 'd') + RAPIDJSON_STRING_(Actual, 'a', 'c', 't', 'u', 'a', 'l') + RAPIDJSON_STRING_(Disallowed, 'd', 'i', 's', 'a', 'l', 'l', 'o', 'w', 'e', 'd') + RAPIDJSON_STRING_(Missing, 'm', 'i', 's', 's', 'i', 'n', 'g') + RAPIDJSON_STRING_(Errors, 'e', 'r', 'r', 'o', 'r', 's') + RAPIDJSON_STRING_(ErrorCode, 'e', 'r', 'r', 'o', 'r', 'C', 'o', 'd', 'e') + RAPIDJSON_STRING_(ErrorMessage, 'e', 'r', 'r', 'o', 'r', 'M', 'e', 's', 's', 'a', 'g', 'e') + RAPIDJSON_STRING_(Duplicates, 'd', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e', 's') + +#undef RAPIDJSON_STRING_ + +#if RAPIDJSON_SCHEMA_VERBOSE +#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \ +RAPIDJSON_MULTILINEMACRO_BEGIN\ + *documentStack_.template Push() = '\0';\ + documentStack_.template Pop(1);\ + internal::PrintInvalidDocument(documentStack_.template Bottom());\ +RAPIDJSON_MULTILINEMACRO_END +#else +#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() +#endif + +#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_(method, arg1)\ + if (!valid_) return false; \ + if ((!BeginValue() && !GetContinueOnErrors()) || (!CurrentSchema().method arg1 && !GetContinueOnErrors())) {\ + RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_();\ + return valid_ = false;\ + } + +#define RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2)\ + for (Context* context = schemaStack_.template Bottom(); context != schemaStack_.template End(); context++) {\ + if (context->hasher)\ + static_cast(context->hasher)->method arg2;\ + if (context->validators)\ + for (SizeType i_ = 0; i_ < context->validatorCount; i_++)\ + static_cast(context->validators[i_])->method arg2;\ + if (context->patternPropertiesValidators)\ + for (SizeType i_ = 0; i_ < context->patternPropertiesValidatorCount; i_++)\ + static_cast(context->patternPropertiesValidators[i_])->method arg2;\ + } + +#define RAPIDJSON_SCHEMA_HANDLE_END_(method, arg2)\ + valid_ = (EndValue() || GetContinueOnErrors()) && (!outputHandler_ || outputHandler_->method arg2);\ + return valid_; + +#define RAPIDJSON_SCHEMA_HANDLE_VALUE_(method, arg1, arg2) \ + RAPIDJSON_SCHEMA_HANDLE_BEGIN_ (method, arg1);\ + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\ + RAPIDJSON_SCHEMA_HANDLE_END_ (method, arg2) + + bool Null() { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null, (CurrentContext()), ( )); } + bool Bool(bool b) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool, (CurrentContext(), b), (b)); } + bool Int(int i) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int, (CurrentContext(), i), (i)); } + bool Uint(unsigned u) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint, (CurrentContext(), u), (u)); } + bool Int64(int64_t i) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int64, (CurrentContext(), i), (i)); } + bool Uint64(uint64_t u) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint64, (CurrentContext(), u), (u)); } + bool Double(double d) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Double, (CurrentContext(), d), (d)); } + bool RawNumber(const Ch* str, SizeType length, bool copy) + { RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); } + bool String(const Ch* str, SizeType length, bool copy) + { RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); } + + bool StartObject() { + RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartObject, (CurrentContext())); + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartObject, ()); + return valid_ = !outputHandler_ || outputHandler_->StartObject(); + } + + bool Key(const Ch* str, SizeType len, bool copy) { + if (!valid_) return false; + AppendToken(str, len); + if (!CurrentSchema().Key(CurrentContext(), str, len, copy) && !GetContinueOnErrors()) return valid_ = false; + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(Key, (str, len, copy)); + return valid_ = !outputHandler_ || outputHandler_->Key(str, len, copy); + } + + bool EndObject(SizeType memberCount) { + if (!valid_) return false; + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndObject, (memberCount)); + if (!CurrentSchema().EndObject(CurrentContext(), memberCount) && !GetContinueOnErrors()) return valid_ = false; + RAPIDJSON_SCHEMA_HANDLE_END_(EndObject, (memberCount)); + } + + bool StartArray() { + RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartArray, (CurrentContext())); + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartArray, ()); + return valid_ = !outputHandler_ || outputHandler_->StartArray(); + } + + bool EndArray(SizeType elementCount) { + if (!valid_) return false; + RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndArray, (elementCount)); + if (!CurrentSchema().EndArray(CurrentContext(), elementCount) && !GetContinueOnErrors()) return valid_ = false; + RAPIDJSON_SCHEMA_HANDLE_END_(EndArray, (elementCount)); + } + +#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_ +#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_ +#undef RAPIDJSON_SCHEMA_HANDLE_PARALLEL_ +#undef RAPIDJSON_SCHEMA_HANDLE_VALUE_ + + // Implementation of ISchemaStateFactory + virtual ISchemaValidator* CreateSchemaValidator(const SchemaType& root, const bool inheritContinueOnErrors) { + ISchemaValidator* sv = new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root, documentStack_.template Bottom(), documentStack_.GetSize(), +#if RAPIDJSON_SCHEMA_VERBOSE + depth_ + 1, +#endif + &GetStateAllocator()); + sv->SetValidateFlags(inheritContinueOnErrors ? GetValidateFlags() : GetValidateFlags() & ~(unsigned)kValidateContinueOnErrorFlag); + return sv; + } + + virtual void DestroySchemaValidator(ISchemaValidator* validator) { + GenericSchemaValidator* v = static_cast(validator); + v->~GenericSchemaValidator(); + StateAllocator::Free(v); + } + + virtual void* CreateHasher() { + return new (GetStateAllocator().Malloc(sizeof(HasherType))) HasherType(&GetStateAllocator()); + } + + virtual uint64_t GetHashCode(void* hasher) { + return static_cast(hasher)->GetHashCode(); + } + + virtual void DestroryHasher(void* hasher) { + HasherType* h = static_cast(hasher); + h->~HasherType(); + StateAllocator::Free(h); + } + + virtual void* MallocState(size_t size) { + return GetStateAllocator().Malloc(size); + } + + virtual void FreeState(void* p) { + StateAllocator::Free(p); + } + +private: + typedef typename SchemaType::Context Context; + typedef GenericValue, StateAllocator> HashCodeArray; + typedef internal::Hasher HasherType; + + GenericSchemaValidator( + const SchemaDocumentType& schemaDocument, + const SchemaType& root, + const char* basePath, size_t basePathSize, +#if RAPIDJSON_SCHEMA_VERBOSE + unsigned depth, +#endif + StateAllocator* allocator = 0, + size_t schemaStackCapacity = kDefaultSchemaStackCapacity, + size_t documentStackCapacity = kDefaultDocumentStackCapacity) + : + schemaDocument_(&schemaDocument), + root_(root), + stateAllocator_(allocator), + ownStateAllocator_(0), + schemaStack_(allocator, schemaStackCapacity), + documentStack_(allocator, documentStackCapacity), + outputHandler_(0), + error_(kObjectType), + currentError_(), + missingDependents_(), + valid_(true), + flags_(kValidateDefaultFlags) +#if RAPIDJSON_SCHEMA_VERBOSE + , depth_(depth) +#endif + { + if (basePath && basePathSize) + memcpy(documentStack_.template Push(basePathSize), basePath, basePathSize); + } + + StateAllocator& GetStateAllocator() { + if (!stateAllocator_) + stateAllocator_ = ownStateAllocator_ = RAPIDJSON_NEW(StateAllocator)(); + return *stateAllocator_; + } + + bool GetContinueOnErrors() const { + return flags_ & kValidateContinueOnErrorFlag; + } + + bool BeginValue() { + if (schemaStack_.Empty()) + PushSchema(root_); + else { + if (CurrentContext().inArray) + internal::TokenHelper, Ch>::AppendIndexToken(documentStack_, CurrentContext().arrayElementIndex); + + if (!CurrentSchema().BeginValue(CurrentContext()) && !GetContinueOnErrors()) + return false; + + SizeType count = CurrentContext().patternPropertiesSchemaCount; + const SchemaType** sa = CurrentContext().patternPropertiesSchemas; + typename Context::PatternValidatorType patternValidatorType = CurrentContext().valuePatternValidatorType; + bool valueUniqueness = CurrentContext().valueUniqueness; + RAPIDJSON_ASSERT(CurrentContext().valueSchema); + PushSchema(*CurrentContext().valueSchema); + + if (count > 0) { + CurrentContext().objectPatternValidatorType = patternValidatorType; + ISchemaValidator**& va = CurrentContext().patternPropertiesValidators; + SizeType& validatorCount = CurrentContext().patternPropertiesValidatorCount; + va = static_cast(MallocState(sizeof(ISchemaValidator*) * count)); + for (SizeType i = 0; i < count; i++) + va[validatorCount++] = CreateSchemaValidator(*sa[i], true); // Inherit continueOnError + } + + CurrentContext().arrayUniqueness = valueUniqueness; + } + return true; + } + + bool EndValue() { + if (!CurrentSchema().EndValue(CurrentContext()) && !GetContinueOnErrors()) + return false; + +#if RAPIDJSON_SCHEMA_VERBOSE + GenericStringBuffer sb; + schemaDocument_->GetPointer(&CurrentSchema()).Stringify(sb); + + *documentStack_.template Push() = '\0'; + documentStack_.template Pop(1); + internal::PrintValidatorPointers(depth_, sb.GetString(), documentStack_.template Bottom()); +#endif + void* hasher = CurrentContext().hasher; + uint64_t h = hasher && CurrentContext().arrayUniqueness ? static_cast(hasher)->GetHashCode() : 0; + + PopSchema(); + + if (!schemaStack_.Empty()) { + Context& context = CurrentContext(); + // Only check uniqueness if there is a hasher + if (hasher && context.valueUniqueness) { + HashCodeArray* a = static_cast(context.arrayElementHashCodes); + if (!a) + CurrentContext().arrayElementHashCodes = a = new (GetStateAllocator().Malloc(sizeof(HashCodeArray))) HashCodeArray(kArrayType); + for (typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr) + if (itr->GetUint64() == h) { + DuplicateItems(static_cast(itr - a->Begin()), a->Size()); + // Cleanup before returning if continuing + if (GetContinueOnErrors()) { + a->PushBack(h, GetStateAllocator()); + while (!documentStack_.Empty() && *documentStack_.template Pop(1) != '/'); + } + RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorUniqueItems); + } + a->PushBack(h, GetStateAllocator()); + } + } + + // Remove the last token of document pointer + while (!documentStack_.Empty() && *documentStack_.template Pop(1) != '/') + ; + + return true; + } + + void AppendToken(const Ch* str, SizeType len) { + documentStack_.template Reserve(1 + len * 2); // worst case all characters are escaped as two characters + *documentStack_.template PushUnsafe() = '/'; + for (SizeType i = 0; i < len; i++) { + if (str[i] == '~') { + *documentStack_.template PushUnsafe() = '~'; + *documentStack_.template PushUnsafe() = '0'; + } + else if (str[i] == '/') { + *documentStack_.template PushUnsafe() = '~'; + *documentStack_.template PushUnsafe() = '1'; + } + else + *documentStack_.template PushUnsafe() = str[i]; + } + } + + RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push()) Context(*this, *this, &schema); } + + RAPIDJSON_FORCEINLINE void PopSchema() { + Context* c = schemaStack_.template Pop(1); + if (HashCodeArray* a = static_cast(c->arrayElementHashCodes)) { + a->~HashCodeArray(); + StateAllocator::Free(a); + } + c->~Context(); + } + + void AddErrorInstanceLocation(ValueType& result, bool parent) { + GenericStringBuffer sb; + PointerType instancePointer = GetInvalidDocumentPointer(); + ((parent && instancePointer.GetTokenCount() > 0) + ? PointerType(instancePointer.GetTokens(), instancePointer.GetTokenCount() - 1) + : instancePointer).StringifyUriFragment(sb); + ValueType instanceRef(sb.GetString(), static_cast(sb.GetSize() / sizeof(Ch)), + GetStateAllocator()); + result.AddMember(GetInstanceRefString(), instanceRef, GetStateAllocator()); + } + + void AddErrorSchemaLocation(ValueType& result, PointerType schema = PointerType()) { + GenericStringBuffer sb; + SizeType len = CurrentSchema().GetURI().GetStringLength(); + if (len) memcpy(sb.Push(len), CurrentSchema().GetURI().GetString(), len * sizeof(Ch)); + if (schema.GetTokenCount()) schema.StringifyUriFragment(sb); + else GetInvalidSchemaPointer().StringifyUriFragment(sb); + ValueType schemaRef(sb.GetString(), static_cast(sb.GetSize() / sizeof(Ch)), + GetStateAllocator()); + result.AddMember(GetSchemaRefString(), schemaRef, GetStateAllocator()); + } + + void AddErrorCode(ValueType& result, const ValidateErrorCode code) { + result.AddMember(GetErrorCodeString(), code, GetStateAllocator()); + } + + void AddError(ValueType& keyword, ValueType& error) { + typename ValueType::MemberIterator member = error_.FindMember(keyword); + if (member == error_.MemberEnd()) + error_.AddMember(keyword, error, GetStateAllocator()); + else { + if (member->value.IsObject()) { + ValueType errors(kArrayType); + errors.PushBack(member->value, GetStateAllocator()); + member->value = errors; + } + member->value.PushBack(error, GetStateAllocator()); + } + } + + void AddCurrentError(const ValidateErrorCode code, bool parent = false) { + AddErrorCode(currentError_, code); + AddErrorInstanceLocation(currentError_, parent); + AddErrorSchemaLocation(currentError_); + AddError(ValueType(SchemaType::GetValidateErrorKeyword(code), GetStateAllocator(), false).Move(), currentError_); + } + + void MergeError(ValueType& other) { + for (typename ValueType::MemberIterator it = other.MemberBegin(), end = other.MemberEnd(); it != end; ++it) { + AddError(it->name, it->value); + } + } + + void AddNumberError(const ValidateErrorCode code, ValueType& actual, const SValue& expected, + const typename SchemaType::ValueType& (*exclusive)() = 0) { + currentError_.SetObject(); + currentError_.AddMember(GetActualString(), actual, GetStateAllocator()); + currentError_.AddMember(GetExpectedString(), ValueType(expected, GetStateAllocator()).Move(), GetStateAllocator()); + if (exclusive) + currentError_.AddMember(ValueType(exclusive(), GetStateAllocator()).Move(), true, GetStateAllocator()); + AddCurrentError(code); + } + + void AddErrorArray(const ValidateErrorCode code, + ISchemaValidator** subvalidators, SizeType count) { + ValueType errors(kArrayType); + for (SizeType i = 0; i < count; ++i) + errors.PushBack(static_cast(subvalidators[i])->GetError(), GetStateAllocator()); + currentError_.SetObject(); + currentError_.AddMember(GetErrorsString(), errors, GetStateAllocator()); + AddCurrentError(code); + } + + const SchemaType& CurrentSchema() const { return *schemaStack_.template Top()->schema; } + Context& CurrentContext() { return *schemaStack_.template Top(); } + const Context& CurrentContext() const { return *schemaStack_.template Top(); } + + static const size_t kDefaultSchemaStackCapacity = 1024; + static const size_t kDefaultDocumentStackCapacity = 256; + const SchemaDocumentType* schemaDocument_; + const SchemaType& root_; + StateAllocator* stateAllocator_; + StateAllocator* ownStateAllocator_; + internal::Stack schemaStack_; //!< stack to store the current path of schema (BaseSchemaType *) + internal::Stack documentStack_; //!< stack to store the current path of validating document (Ch) + OutputHandler* outputHandler_; + ValueType error_; + ValueType currentError_; + ValueType missingDependents_; + bool valid_; + unsigned flags_; +#if RAPIDJSON_SCHEMA_VERBOSE + unsigned depth_; +#endif +}; + +typedef GenericSchemaValidator SchemaValidator; + +/////////////////////////////////////////////////////////////////////////////// +// SchemaValidatingReader + +//! A helper class for parsing with validation. +/*! + This helper class is a functor, designed as a parameter of \ref GenericDocument::Populate(). + + \tparam parseFlags Combination of \ref ParseFlag. + \tparam InputStream Type of input stream, implementing Stream concept. + \tparam SourceEncoding Encoding of the input stream. + \tparam SchemaDocumentType Type of schema document. + \tparam StackAllocator Allocator type for stack. +*/ +template < + unsigned parseFlags, + typename InputStream, + typename SourceEncoding, + typename SchemaDocumentType = SchemaDocument, + typename StackAllocator = CrtAllocator> +class SchemaValidatingReader { +public: + typedef typename SchemaDocumentType::PointerType PointerType; + typedef typename InputStream::Ch Ch; + typedef GenericValue ValueType; + + //! Constructor + /*! + \param is Input stream. + \param sd Schema document. + */ + SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), invalidSchemaCode_(kValidateErrorNone), error_(kObjectType), isValid_(true) {} + + template + bool operator()(Handler& handler) { + GenericReader reader; + GenericSchemaValidator validator(sd_, handler); + parseResult_ = reader.template Parse(is_, validator); + + isValid_ = validator.IsValid(); + if (isValid_) { + invalidSchemaPointer_ = PointerType(); + invalidSchemaKeyword_ = 0; + invalidDocumentPointer_ = PointerType(); + error_.SetObject(); + } + else { + invalidSchemaPointer_ = validator.GetInvalidSchemaPointer(); + invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword(); + invalidSchemaCode_ = validator.GetInvalidSchemaCode(); + invalidDocumentPointer_ = validator.GetInvalidDocumentPointer(); + error_.CopyFrom(validator.GetError(), allocator_); + } + + return parseResult_; + } + + const ParseResult& GetParseResult() const { return parseResult_; } + bool IsValid() const { return isValid_; } + const PointerType& GetInvalidSchemaPointer() const { return invalidSchemaPointer_; } + const Ch* GetInvalidSchemaKeyword() const { return invalidSchemaKeyword_; } + const PointerType& GetInvalidDocumentPointer() const { return invalidDocumentPointer_; } + const ValueType& GetError() const { return error_; } + ValidateErrorCode GetInvalidSchemaCode() const { return invalidSchemaCode_; } + +private: + InputStream& is_; + const SchemaDocumentType& sd_; + + ParseResult parseResult_; + PointerType invalidSchemaPointer_; + const Ch* invalidSchemaKeyword_; + PointerType invalidDocumentPointer_; + ValidateErrorCode invalidSchemaCode_; + StackAllocator allocator_; + ValueType error_; + bool isValid_; +}; + +RAPIDJSON_NAMESPACE_END +RAPIDJSON_DIAG_POP + +#endif // RAPIDJSON_SCHEMA_H_ diff --git a/libs/include/rapidjson/stream.h b/libs/include/rapidjson/stream.h new file mode 100644 index 0000000..1fd7091 --- /dev/null +++ b/libs/include/rapidjson/stream.h @@ -0,0 +1,223 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#include "rapidjson.h" + +#ifndef RAPIDJSON_STREAM_H_ +#define RAPIDJSON_STREAM_H_ + +#include "encodings.h" + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// Stream + +/*! \class rapidjson::Stream + \brief Concept for reading and writing characters. + + For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd(). + + For write-only stream, only need to implement Put() and Flush(). + +\code +concept Stream { + typename Ch; //!< Character type of the stream. + + //! Read the current character from stream without moving the read cursor. + Ch Peek() const; + + //! Read the current character from stream and moving the read cursor to next character. + Ch Take(); + + //! Get the current read cursor. + //! \return Number of characters read from start. + size_t Tell(); + + //! Begin writing operation at the current read pointer. + //! \return The begin writer pointer. + Ch* PutBegin(); + + //! Write a character. + void Put(Ch c); + + //! Flush the buffer. + void Flush(); + + //! End the writing operation. + //! \param begin The begin write pointer returned by PutBegin(). + //! \return Number of characters written. + size_t PutEnd(Ch* begin); +} +\endcode +*/ + +//! Provides additional information for stream. +/*! + By using traits pattern, this type provides a default configuration for stream. + For custom stream, this type can be specialized for other configuration. + See TEST(Reader, CustomStringStream) in readertest.cpp for example. +*/ +template +struct StreamTraits { + //! Whether to make local copy of stream for optimization during parsing. + /*! + By default, for safety, streams do not use local copy optimization. + Stream that can be copied fast should specialize this, like StreamTraits. + */ + enum { copyOptimization = 0 }; +}; + +//! Reserve n characters for writing to a stream. +template +inline void PutReserve(Stream& stream, size_t count) { + (void)stream; + (void)count; +} + +//! Write character to a stream, presuming buffer is reserved. +template +inline void PutUnsafe(Stream& stream, typename Stream::Ch c) { + stream.Put(c); +} + +//! Put N copies of a character to a stream. +template +inline void PutN(Stream& stream, Ch c, size_t n) { + PutReserve(stream, n); + for (size_t i = 0; i < n; i++) + PutUnsafe(stream, c); +} + +/////////////////////////////////////////////////////////////////////////////// +// GenericStreamWrapper + +//! A Stream Wrapper +/*! \tThis string stream is a wrapper for any stream by just forwarding any + \treceived message to the origin stream. + \note implements Stream concept +*/ + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4702) // unreachable code +RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated +#endif + +template > +class GenericStreamWrapper { +public: + typedef typename Encoding::Ch Ch; + GenericStreamWrapper(InputStream& is): is_(is) {} + + Ch Peek() const { return is_.Peek(); } + Ch Take() { return is_.Take(); } + size_t Tell() { return is_.Tell(); } + Ch* PutBegin() { return is_.PutBegin(); } + void Put(Ch ch) { is_.Put(ch); } + void Flush() { is_.Flush(); } + size_t PutEnd(Ch* ch) { return is_.PutEnd(ch); } + + // wrapper for MemoryStream + const Ch* Peek4() const { return is_.Peek4(); } + + // wrapper for AutoUTFInputStream + UTFType GetType() const { return is_.GetType(); } + bool HasBOM() const { return is_.HasBOM(); } + +protected: + InputStream& is_; +}; + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +RAPIDJSON_DIAG_POP +#endif + +/////////////////////////////////////////////////////////////////////////////// +// StringStream + +//! Read-only string stream. +/*! \note implements Stream concept +*/ +template +struct GenericStringStream { + typedef typename Encoding::Ch Ch; + + GenericStringStream(const Ch *src) : src_(src), head_(src) {} + + Ch Peek() const { return *src_; } + Ch Take() { return *src_++; } + size_t Tell() const { return static_cast(src_ - head_); } + + Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } + void Put(Ch) { RAPIDJSON_ASSERT(false); } + void Flush() { RAPIDJSON_ASSERT(false); } + size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; } + + const Ch* src_; //!< Current read position. + const Ch* head_; //!< Original head of the string. +}; + +template +struct StreamTraits > { + enum { copyOptimization = 1 }; +}; + +//! String stream with UTF8 encoding. +typedef GenericStringStream > StringStream; + +/////////////////////////////////////////////////////////////////////////////// +// InsituStringStream + +//! A read-write string stream. +/*! This string stream is particularly designed for in-situ parsing. + \note implements Stream concept +*/ +template +struct GenericInsituStringStream { + typedef typename Encoding::Ch Ch; + + GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {} + + // Read + Ch Peek() { return *src_; } + Ch Take() { return *src_++; } + size_t Tell() { return static_cast(src_ - head_); } + + // Write + void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; } + + Ch* PutBegin() { return dst_ = src_; } + size_t PutEnd(Ch* begin) { return static_cast(dst_ - begin); } + void Flush() {} + + Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; } + void Pop(size_t count) { dst_ -= count; } + + Ch* src_; + Ch* dst_; + Ch* head_; +}; + +template +struct StreamTraits > { + enum { copyOptimization = 1 }; +}; + +//! Insitu string stream with UTF8 encoding. +typedef GenericInsituStringStream > InsituStringStream; + +RAPIDJSON_NAMESPACE_END + +#endif // RAPIDJSON_STREAM_H_ diff --git a/libs/include/rapidjson/stringbuffer.h b/libs/include/rapidjson/stringbuffer.h new file mode 100644 index 0000000..82ad3ca --- /dev/null +++ b/libs/include/rapidjson/stringbuffer.h @@ -0,0 +1,121 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_STRINGBUFFER_H_ +#define RAPIDJSON_STRINGBUFFER_H_ + +#include "stream.h" +#include "internal/stack.h" + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS +#include // std::move +#endif + +#include "internal/stack.h" + +#if defined(__clang__) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(c++98-compat) +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +//! Represents an in-memory output stream. +/*! + \tparam Encoding Encoding of the stream. + \tparam Allocator type for allocating memory buffer. + \note implements Stream concept +*/ +template +class GenericStringBuffer { +public: + typedef typename Encoding::Ch Ch; + + GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {} + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + GenericStringBuffer(GenericStringBuffer&& rhs) : stack_(std::move(rhs.stack_)) {} + GenericStringBuffer& operator=(GenericStringBuffer&& rhs) { + if (&rhs != this) + stack_ = std::move(rhs.stack_); + return *this; + } +#endif + + void Put(Ch c) { *stack_.template Push() = c; } + void PutUnsafe(Ch c) { *stack_.template PushUnsafe() = c; } + void Flush() {} + + void Clear() { stack_.Clear(); } + void ShrinkToFit() { + // Push and pop a null terminator. This is safe. + *stack_.template Push() = '\0'; + stack_.ShrinkToFit(); + stack_.template Pop(1); + } + + void Reserve(size_t count) { stack_.template Reserve(count); } + Ch* Push(size_t count) { return stack_.template Push(count); } + Ch* PushUnsafe(size_t count) { return stack_.template PushUnsafe(count); } + void Pop(size_t count) { stack_.template Pop(count); } + + const Ch* GetString() const { + // Push and pop a null terminator. This is safe. + *stack_.template Push() = '\0'; + stack_.template Pop(1); + + return stack_.template Bottom(); + } + + //! Get the size of string in bytes in the string buffer. + size_t GetSize() const { return stack_.GetSize(); } + + //! Get the length of string in Ch in the string buffer. + size_t GetLength() const { return stack_.GetSize() / sizeof(Ch); } + + static const size_t kDefaultCapacity = 256; + mutable internal::Stack stack_; + +private: + // Prohibit copy constructor & assignment operator. + GenericStringBuffer(const GenericStringBuffer&); + GenericStringBuffer& operator=(const GenericStringBuffer&); +}; + +//! String buffer with UTF8 encoding +typedef GenericStringBuffer > StringBuffer; + +template +inline void PutReserve(GenericStringBuffer& stream, size_t count) { + stream.Reserve(count); +} + +template +inline void PutUnsafe(GenericStringBuffer& stream, typename Encoding::Ch c) { + stream.PutUnsafe(c); +} + +//! Implement specialized version of PutN() with memset() for better performance. +template<> +inline void PutN(GenericStringBuffer >& stream, char c, size_t n) { + std::memset(stream.stack_.Push(n), c, n * sizeof(c)); +} + +RAPIDJSON_NAMESPACE_END + +#if defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_STRINGBUFFER_H_ diff --git a/libs/include/rapidjson/writer.h b/libs/include/rapidjson/writer.h new file mode 100644 index 0000000..8b38921 --- /dev/null +++ b/libs/include/rapidjson/writer.h @@ -0,0 +1,710 @@ +// Tencent is pleased to support the open source community by making RapidJSON available. +// +// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +// +// Licensed under the MIT License (the "License"); you may not use this file except +// in compliance with the License. You may obtain a copy of the License at +// +// http://opensource.org/licenses/MIT +// +// Unless required by applicable law or agreed to in writing, software distributed +// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +// CONDITIONS OF ANY KIND, either express or implied. See the License for the +// specific language governing permissions and limitations under the License. + +#ifndef RAPIDJSON_WRITER_H_ +#define RAPIDJSON_WRITER_H_ + +#include "stream.h" +#include "internal/clzll.h" +#include "internal/meta.h" +#include "internal/stack.h" +#include "internal/strfunc.h" +#include "internal/dtoa.h" +#include "internal/itoa.h" +#include "stringbuffer.h" +#include // placement new + +#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER) +#include +#pragma intrinsic(_BitScanForward) +#endif +#ifdef RAPIDJSON_SSE42 +#include +#elif defined(RAPIDJSON_SSE2) +#include +#elif defined(RAPIDJSON_NEON) +#include +#endif + +#ifdef __clang__ +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(padded) +RAPIDJSON_DIAG_OFF(unreachable-code) +RAPIDJSON_DIAG_OFF(c++98-compat) +#elif defined(_MSC_VER) +RAPIDJSON_DIAG_PUSH +RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant +#endif + +RAPIDJSON_NAMESPACE_BEGIN + +/////////////////////////////////////////////////////////////////////////////// +// WriteFlag + +/*! \def RAPIDJSON_WRITE_DEFAULT_FLAGS + \ingroup RAPIDJSON_CONFIG + \brief User-defined kWriteDefaultFlags definition. + + User can define this as any \c WriteFlag combinations. +*/ +#ifndef RAPIDJSON_WRITE_DEFAULT_FLAGS +#define RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNoFlags +#endif + +//! Combination of writeFlags +enum WriteFlag { + kWriteNoFlags = 0, //!< No flags are set. + kWriteValidateEncodingFlag = 1, //!< Validate encoding of JSON strings. + kWriteNanAndInfFlag = 2, //!< Allow writing of Infinity, -Infinity and NaN. + kWriteDefaultFlags = RAPIDJSON_WRITE_DEFAULT_FLAGS //!< Default write flags. Can be customized by defining RAPIDJSON_WRITE_DEFAULT_FLAGS +}; + +//! JSON writer +/*! Writer implements the concept Handler. + It generates JSON text by events to an output os. + + User may programmatically calls the functions of a writer to generate JSON text. + + On the other side, a writer can also be passed to objects that generates events, + + for example Reader::Parse() and Document::Accept(). + + \tparam OutputStream Type of output stream. + \tparam SourceEncoding Encoding of source string. + \tparam TargetEncoding Encoding of output stream. + \tparam StackAllocator Type of allocator for allocating memory of stack. + \note implements Handler concept +*/ +template, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags> +class Writer { +public: + typedef typename SourceEncoding::Ch Ch; + + static const int kDefaultMaxDecimalPlaces = 324; + + //! Constructor + /*! \param os Output stream. + \param stackAllocator User supplied allocator. If it is null, it will create a private one. + \param levelDepth Initial capacity of stack. + */ + explicit + Writer(OutputStream& os, StackAllocator* stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) : + os_(&os), level_stack_(stackAllocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {} + + explicit + Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) : + os_(0), level_stack_(allocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {} + +#if RAPIDJSON_HAS_CXX11_RVALUE_REFS + Writer(Writer&& rhs) : + os_(rhs.os_), level_stack_(std::move(rhs.level_stack_)), maxDecimalPlaces_(rhs.maxDecimalPlaces_), hasRoot_(rhs.hasRoot_) { + rhs.os_ = 0; + } +#endif + + //! Reset the writer with a new stream. + /*! + This function reset the writer with a new stream and default settings, + in order to make a Writer object reusable for output multiple JSONs. + + \param os New output stream. + \code + Writer writer(os1); + writer.StartObject(); + // ... + writer.EndObject(); + + writer.Reset(os2); + writer.StartObject(); + // ... + writer.EndObject(); + \endcode + */ + void Reset(OutputStream& os) { + os_ = &os; + hasRoot_ = false; + level_stack_.Clear(); + } + + //! Checks whether the output is a complete JSON. + /*! + A complete JSON has a complete root object or array. + */ + bool IsComplete() const { + return hasRoot_ && level_stack_.Empty(); + } + + int GetMaxDecimalPlaces() const { + return maxDecimalPlaces_; + } + + //! Sets the maximum number of decimal places for double output. + /*! + This setting truncates the output with specified number of decimal places. + + For example, + + \code + writer.SetMaxDecimalPlaces(3); + writer.StartArray(); + writer.Double(0.12345); // "0.123" + writer.Double(0.0001); // "0.0" + writer.Double(1.234567890123456e30); // "1.234567890123456e30" (do not truncate significand for positive exponent) + writer.Double(1.23e-4); // "0.0" (do truncate significand for negative exponent) + writer.EndArray(); + \endcode + + The default setting does not truncate any decimal places. You can restore to this setting by calling + \code + writer.SetMaxDecimalPlaces(Writer::kDefaultMaxDecimalPlaces); + \endcode + */ + void SetMaxDecimalPlaces(int maxDecimalPlaces) { + maxDecimalPlaces_ = maxDecimalPlaces; + } + + /*!@name Implementation of Handler + \see Handler + */ + //@{ + + bool Null() { Prefix(kNullType); return EndValue(WriteNull()); } + bool Bool(bool b) { Prefix(b ? kTrueType : kFalseType); return EndValue(WriteBool(b)); } + bool Int(int i) { Prefix(kNumberType); return EndValue(WriteInt(i)); } + bool Uint(unsigned u) { Prefix(kNumberType); return EndValue(WriteUint(u)); } + bool Int64(int64_t i64) { Prefix(kNumberType); return EndValue(WriteInt64(i64)); } + bool Uint64(uint64_t u64) { Prefix(kNumberType); return EndValue(WriteUint64(u64)); } + + //! Writes the given \c double value to the stream + /*! + \param d The value to be written. + \return Whether it is succeed. + */ + bool Double(double d) { Prefix(kNumberType); return EndValue(WriteDouble(d)); } + + bool RawNumber(const Ch* str, SizeType length, bool copy = false) { + RAPIDJSON_ASSERT(str != 0); + (void)copy; + Prefix(kNumberType); + return EndValue(WriteString(str, length)); + } + + bool String(const Ch* str, SizeType length, bool copy = false) { + RAPIDJSON_ASSERT(str != 0); + (void)copy; + Prefix(kStringType); + return EndValue(WriteString(str, length)); + } + +#if RAPIDJSON_HAS_STDSTRING + bool String(const std::basic_string& str) { + return String(str.data(), SizeType(str.size())); + } +#endif + + bool StartObject() { + Prefix(kObjectType); + new (level_stack_.template Push()) Level(false); + return WriteStartObject(); + } + + bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); } + +#if RAPIDJSON_HAS_STDSTRING + bool Key(const std::basic_string& str) + { + return Key(str.data(), SizeType(str.size())); + } +#endif + + bool EndObject(SizeType memberCount = 0) { + (void)memberCount; + RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object + RAPIDJSON_ASSERT(!level_stack_.template Top()->inArray); // currently inside an Array, not Object + RAPIDJSON_ASSERT(0 == level_stack_.template Top()->valueCount % 2); // Object has a Key without a Value + level_stack_.template Pop(1); + return EndValue(WriteEndObject()); + } + + bool StartArray() { + Prefix(kArrayType); + new (level_stack_.template Push()) Level(true); + return WriteStartArray(); + } + + bool EndArray(SizeType elementCount = 0) { + (void)elementCount; + RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); + RAPIDJSON_ASSERT(level_stack_.template Top()->inArray); + level_stack_.template Pop(1); + return EndValue(WriteEndArray()); + } + //@} + + /*! @name Convenience extensions */ + //@{ + + //! Simpler but slower overload. + bool String(const Ch* const& str) { return String(str, internal::StrLen(str)); } + bool Key(const Ch* const& str) { return Key(str, internal::StrLen(str)); } + + //@} + + //! Write a raw JSON value. + /*! + For user to write a stringified JSON as a value. + + \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range. + \param length Length of the json. + \param type Type of the root of json. + */ + bool RawValue(const Ch* json, size_t length, Type type) { + RAPIDJSON_ASSERT(json != 0); + Prefix(type); + return EndValue(WriteRawValue(json, length)); + } + + //! Flush the output stream. + /*! + Allows the user to flush the output stream immediately. + */ + void Flush() { + os_->Flush(); + } + + static const size_t kDefaultLevelDepth = 32; + +protected: + //! Information for each nested level + struct Level { + Level(bool inArray_) : valueCount(0), inArray(inArray_) {} + size_t valueCount; //!< number of values in this level + bool inArray; //!< true if in array, otherwise in object + }; + + bool WriteNull() { + PutReserve(*os_, 4); + PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l'); return true; + } + + bool WriteBool(bool b) { + if (b) { + PutReserve(*os_, 4); + PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'r'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'e'); + } + else { + PutReserve(*os_, 5); + PutUnsafe(*os_, 'f'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 's'); PutUnsafe(*os_, 'e'); + } + return true; + } + + bool WriteInt(int i) { + char buffer[11]; + const char* end = internal::i32toa(i, buffer); + PutReserve(*os_, static_cast(end - buffer)); + for (const char* p = buffer; p != end; ++p) + PutUnsafe(*os_, static_cast(*p)); + return true; + } + + bool WriteUint(unsigned u) { + char buffer[10]; + const char* end = internal::u32toa(u, buffer); + PutReserve(*os_, static_cast(end - buffer)); + for (const char* p = buffer; p != end; ++p) + PutUnsafe(*os_, static_cast(*p)); + return true; + } + + bool WriteInt64(int64_t i64) { + char buffer[21]; + const char* end = internal::i64toa(i64, buffer); + PutReserve(*os_, static_cast(end - buffer)); + for (const char* p = buffer; p != end; ++p) + PutUnsafe(*os_, static_cast(*p)); + return true; + } + + bool WriteUint64(uint64_t u64) { + char buffer[20]; + char* end = internal::u64toa(u64, buffer); + PutReserve(*os_, static_cast(end - buffer)); + for (char* p = buffer; p != end; ++p) + PutUnsafe(*os_, static_cast(*p)); + return true; + } + + bool WriteDouble(double d) { + if (internal::Double(d).IsNanOrInf()) { + if (!(writeFlags & kWriteNanAndInfFlag)) + return false; + if (internal::Double(d).IsNan()) { + PutReserve(*os_, 3); + PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N'); + return true; + } + if (internal::Double(d).Sign()) { + PutReserve(*os_, 9); + PutUnsafe(*os_, '-'); + } + else + PutReserve(*os_, 8); + PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f'); + PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y'); + return true; + } + + char buffer[25]; + char* end = internal::dtoa(d, buffer, maxDecimalPlaces_); + PutReserve(*os_, static_cast(end - buffer)); + for (char* p = buffer; p != end; ++p) + PutUnsafe(*os_, static_cast(*p)); + return true; + } + + bool WriteString(const Ch* str, SizeType length) { + static const typename OutputStream::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; + static const char escape[256] = { +#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + //0 1 2 3 4 5 6 7 8 9 A B C D E F + 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00 + 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10 + 0, 0, '"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20 + Z16, Z16, // 30~4F + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0, // 50 + Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16 // 60~FF +#undef Z16 + }; + + if (TargetEncoding::supportUnicode) + PutReserve(*os_, 2 + length * 6); // "\uxxxx..." + else + PutReserve(*os_, 2 + length * 12); // "\uxxxx\uyyyy..." + + PutUnsafe(*os_, '\"'); + GenericStringStream is(str); + while (ScanWriteUnescapedString(is, length)) { + const Ch c = is.Peek(); + if (!TargetEncoding::supportUnicode && static_cast(c) >= 0x80) { + // Unicode escaping + unsigned codepoint; + if (RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint))) + return false; + PutUnsafe(*os_, '\\'); + PutUnsafe(*os_, 'u'); + if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF)) { + PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]); + PutUnsafe(*os_, hexDigits[(codepoint >> 8) & 15]); + PutUnsafe(*os_, hexDigits[(codepoint >> 4) & 15]); + PutUnsafe(*os_, hexDigits[(codepoint ) & 15]); + } + else { + RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF); + // Surrogate pair + unsigned s = codepoint - 0x010000; + unsigned lead = (s >> 10) + 0xD800; + unsigned trail = (s & 0x3FF) + 0xDC00; + PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]); + PutUnsafe(*os_, hexDigits[(lead >> 8) & 15]); + PutUnsafe(*os_, hexDigits[(lead >> 4) & 15]); + PutUnsafe(*os_, hexDigits[(lead ) & 15]); + PutUnsafe(*os_, '\\'); + PutUnsafe(*os_, 'u'); + PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]); + PutUnsafe(*os_, hexDigits[(trail >> 8) & 15]); + PutUnsafe(*os_, hexDigits[(trail >> 4) & 15]); + PutUnsafe(*os_, hexDigits[(trail ) & 15]); + } + } + else if ((sizeof(Ch) == 1 || static_cast(c) < 256) && RAPIDJSON_UNLIKELY(escape[static_cast(c)])) { + is.Take(); + PutUnsafe(*os_, '\\'); + PutUnsafe(*os_, static_cast(escape[static_cast(c)])); + if (escape[static_cast(c)] == 'u') { + PutUnsafe(*os_, '0'); + PutUnsafe(*os_, '0'); + PutUnsafe(*os_, hexDigits[static_cast(c) >> 4]); + PutUnsafe(*os_, hexDigits[static_cast(c) & 0xF]); + } + } + else if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? + Transcoder::Validate(is, *os_) : + Transcoder::TranscodeUnsafe(is, *os_)))) + return false; + } + PutUnsafe(*os_, '\"'); + return true; + } + + bool ScanWriteUnescapedString(GenericStringStream& is, size_t length) { + return RAPIDJSON_LIKELY(is.Tell() < length); + } + + bool WriteStartObject() { os_->Put('{'); return true; } + bool WriteEndObject() { os_->Put('}'); return true; } + bool WriteStartArray() { os_->Put('['); return true; } + bool WriteEndArray() { os_->Put(']'); return true; } + + bool WriteRawValue(const Ch* json, size_t length) { + PutReserve(*os_, length); + GenericStringStream is(json); + while (RAPIDJSON_LIKELY(is.Tell() < length)) { + RAPIDJSON_ASSERT(is.Peek() != '\0'); + if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? + Transcoder::Validate(is, *os_) : + Transcoder::TranscodeUnsafe(is, *os_)))) + return false; + } + return true; + } + + void Prefix(Type type) { + (void)type; + if (RAPIDJSON_LIKELY(level_stack_.GetSize() != 0)) { // this value is not at root + Level* level = level_stack_.template Top(); + if (level->valueCount > 0) { + if (level->inArray) + os_->Put(','); // add comma if it is not the first element in array + else // in object + os_->Put((level->valueCount % 2 == 0) ? ',' : ':'); + } + if (!level->inArray && level->valueCount % 2 == 0) + RAPIDJSON_ASSERT(type == kStringType); // if it's in object, then even number should be a name + level->valueCount++; + } + else { + RAPIDJSON_ASSERT(!hasRoot_); // Should only has one and only one root. + hasRoot_ = true; + } + } + + // Flush the value if it is the top level one. + bool EndValue(bool ret) { + if (RAPIDJSON_UNLIKELY(level_stack_.Empty())) // end of json text + Flush(); + return ret; + } + + OutputStream* os_; + internal::Stack level_stack_; + int maxDecimalPlaces_; + bool hasRoot_; + +private: + // Prohibit copy constructor & assignment operator. + Writer(const Writer&); + Writer& operator=(const Writer&); +}; + +// Full specialization for StringStream to prevent memory copying + +template<> +inline bool Writer::WriteInt(int i) { + char *buffer = os_->Push(11); + const char* end = internal::i32toa(i, buffer); + os_->Pop(static_cast(11 - (end - buffer))); + return true; +} + +template<> +inline bool Writer::WriteUint(unsigned u) { + char *buffer = os_->Push(10); + const char* end = internal::u32toa(u, buffer); + os_->Pop(static_cast(10 - (end - buffer))); + return true; +} + +template<> +inline bool Writer::WriteInt64(int64_t i64) { + char *buffer = os_->Push(21); + const char* end = internal::i64toa(i64, buffer); + os_->Pop(static_cast(21 - (end - buffer))); + return true; +} + +template<> +inline bool Writer::WriteUint64(uint64_t u) { + char *buffer = os_->Push(20); + const char* end = internal::u64toa(u, buffer); + os_->Pop(static_cast(20 - (end - buffer))); + return true; +} + +template<> +inline bool Writer::WriteDouble(double d) { + if (internal::Double(d).IsNanOrInf()) { + // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag). + if (!(kWriteDefaultFlags & kWriteNanAndInfFlag)) + return false; + if (internal::Double(d).IsNan()) { + PutReserve(*os_, 3); + PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N'); + return true; + } + if (internal::Double(d).Sign()) { + PutReserve(*os_, 9); + PutUnsafe(*os_, '-'); + } + else + PutReserve(*os_, 8); + PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f'); + PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y'); + return true; + } + + char *buffer = os_->Push(25); + char* end = internal::dtoa(d, buffer, maxDecimalPlaces_); + os_->Pop(static_cast(25 - (end - buffer))); + return true; +} + +#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) +template<> +inline bool Writer::ScanWriteUnescapedString(StringStream& is, size_t length) { + if (length < 16) + return RAPIDJSON_LIKELY(is.Tell() < length); + + if (!RAPIDJSON_LIKELY(is.Tell() < length)) + return false; + + const char* p = is.src_; + const char* end = is.head_ + length; + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + const char* endAligned = reinterpret_cast(reinterpret_cast(end) & static_cast(~15)); + if (nextAligned > end) + return true; + + while (p != nextAligned) + if (*p < 0x20 || *p == '\"' || *p == '\\') { + is.src_ = p; + return RAPIDJSON_LIKELY(is.Tell() < length); + } + else + os_->PutUnsafe(*p++); + + // The rest of string using SIMD + static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' }; + static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' }; + static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }; + const __m128i dq = _mm_loadu_si128(reinterpret_cast(&dquote[0])); + const __m128i bs = _mm_loadu_si128(reinterpret_cast(&bslash[0])); + const __m128i sp = _mm_loadu_si128(reinterpret_cast(&space[0])); + + for (; p != endAligned; p += 16) { + const __m128i s = _mm_load_si128(reinterpret_cast(p)); + const __m128i t1 = _mm_cmpeq_epi8(s, dq); + const __m128i t2 = _mm_cmpeq_epi8(s, bs); + const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F + const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3); + unsigned short r = static_cast(_mm_movemask_epi8(x)); + if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped + SizeType len; +#ifdef _MSC_VER // Find the index of first escaped + unsigned long offset; + _BitScanForward(&offset, r); + len = offset; +#else + len = static_cast(__builtin_ffs(r) - 1); +#endif + char* q = reinterpret_cast(os_->PushUnsafe(len)); + for (size_t i = 0; i < len; i++) + q[i] = p[i]; + + p += len; + break; + } + _mm_storeu_si128(reinterpret_cast<__m128i *>(os_->PushUnsafe(16)), s); + } + + is.src_ = p; + return RAPIDJSON_LIKELY(is.Tell() < length); +} +#elif defined(RAPIDJSON_NEON) +template<> +inline bool Writer::ScanWriteUnescapedString(StringStream& is, size_t length) { + if (length < 16) + return RAPIDJSON_LIKELY(is.Tell() < length); + + if (!RAPIDJSON_LIKELY(is.Tell() < length)) + return false; + + const char* p = is.src_; + const char* end = is.head_ + length; + const char* nextAligned = reinterpret_cast((reinterpret_cast(p) + 15) & static_cast(~15)); + const char* endAligned = reinterpret_cast(reinterpret_cast(end) & static_cast(~15)); + if (nextAligned > end) + return true; + + while (p != nextAligned) + if (*p < 0x20 || *p == '\"' || *p == '\\') { + is.src_ = p; + return RAPIDJSON_LIKELY(is.Tell() < length); + } + else + os_->PutUnsafe(*p++); + + // The rest of string using SIMD + const uint8x16_t s0 = vmovq_n_u8('"'); + const uint8x16_t s1 = vmovq_n_u8('\\'); + const uint8x16_t s2 = vmovq_n_u8('\b'); + const uint8x16_t s3 = vmovq_n_u8(32); + + for (; p != endAligned; p += 16) { + const uint8x16_t s = vld1q_u8(reinterpret_cast(p)); + uint8x16_t x = vceqq_u8(s, s0); + x = vorrq_u8(x, vceqq_u8(s, s1)); + x = vorrq_u8(x, vceqq_u8(s, s2)); + x = vorrq_u8(x, vcltq_u8(s, s3)); + + x = vrev64q_u8(x); // Rev in 64 + uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract + uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract + + SizeType len = 0; + bool escaped = false; + if (low == 0) { + if (high != 0) { + uint32_t lz = internal::clzll(high); + len = 8 + (lz >> 3); + escaped = true; + } + } else { + uint32_t lz = internal::clzll(low); + len = lz >> 3; + escaped = true; + } + if (RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped + char* q = reinterpret_cast(os_->PushUnsafe(len)); + for (size_t i = 0; i < len; i++) + q[i] = p[i]; + + p += len; + break; + } + vst1q_u8(reinterpret_cast(os_->PushUnsafe(16)), s); + } + + is.src_ = p; + return RAPIDJSON_LIKELY(is.Tell() < length); +} +#endif // RAPIDJSON_NEON + +RAPIDJSON_NAMESPACE_END + +#if defined(_MSC_VER) || defined(__clang__) +RAPIDJSON_DIAG_POP +#endif + +#endif // RAPIDJSON_RAPIDJSON_H_ diff --git a/libs/include/stb_image.h b/libs/include/stb_image.h new file mode 100644 index 0000000..196dfd5 --- /dev/null +++ b/libs/include/stb_image.h @@ -0,0 +1,7559 @@ +/* stb_image - v2.23 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Phil Jordan + Dave Moore Roy Eltham Hayaki Saito Nathan Reed + Won Chun Luke Graham Johan Duparc Nick Verigakis + the Horde3D community Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Laurent Gomila Cort Stratton Sergio Gonzalez github:snagar + Aruelien Pocheville Thibault Reuille Cass Everitt github:Zelex + Ryamond Barbiero Paul Du Bois Engin Manap github:grim210 + Aldo Culquicondor Philipp Wiesemann Dale Weiler github:sammyhw + Oriol Ferrer Mesia Josh Tobin Matthew Gregan github:phprus + Julian Raschke Gregory Mullen Baldur Karlsson github:poppolopoppo + Christian Floisand Kevin Schmidt JR Smith github:darealshinji + Blazej Dariusz Roszkowski github:Michaelangel007 +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data) +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// By default we convert iphone-formatted PNGs back to RGB, even though +// they are internally encoded differently. You can disable this conversion +// by calling stbi_convert_iphone_png_to_rgb(0), in which case +// you will always just get the native iphone "format" through (which +// is BGR stored in RGB). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// + + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// NOT THREADSAFE +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + + +#ifdef _MSC_VER +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y)))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +// assume GCC or Clang on ARM targets +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + fseek((FILE*) user, n, SEEK_CUR); +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +// this is not threadsafe +static const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load = flag_true_if_should_flip; +} + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + if (ri.bits_per_channel != 8) { + STBI_ASSERT(ri.bits_per_channel == 16); + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + if (ri.bits_per_channel != 16) { + STBI_ASSERT(ri.bits_per_channel == 8); + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode))) + return 0; + +#if _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} + +static void stbi__skip(stbi__context *s, int n) +{ + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} + +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} + +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} + +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + return z + (stbi__get16le(s) << 16); +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + + +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} + +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} + +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} + +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) + for (j=0; j < count[i]; ++j) + h->size[k++] = (stbi_uc) (i+1); + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + + sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB + k = stbi_lrot(j->code_buffer, n); + STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask))); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & ~sgn); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + diff = t ? stbi__extend_receive(j, t) : 0; + + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc << j->succ_low); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) << shift); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) << shift); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + // handle 0s at the end of image data from IP Kamera 9060 + while (!stbi__at_eof(j->s)) { + int x = stbi__get8(j->s); + if (x == 255) { + j->marker = stbi__get8(j->s); + break; + } + } + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + } else { + if (!stbi__process_marker(j, m)) return 0; + } + m = stbi__get_marker(j); + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[288]; + stbi__uint16 value[288]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + if (z->zbuffer >= z->zbuffer_end) return 0; + return *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + STBI_ASSERT(z->code_buffer < (1U << z->num_bits)); + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s == 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + STBI_ASSERT(z->size[b] == s); + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) stbi__fill_bits(a); + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (int) (z->zout - z->zout_start); + limit = old_limit = (int) (z->zout_end - z->zout_start); + while (cur + n > limit) + limit *= 2; + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + return 1; + } + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (zout + len > a->zout_end) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) + c = stbi__zreceive(a,3)+3; + else { + STBI_ASSERT(c == 18); + c = stbi__zreceive(a,7)+11; + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + STBI_ASSERT(a->num_bits == 0); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[288] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , 288)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filters used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first, + STBI__F_paeth_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_paeth_first +}; + +static int stbi__paeth(int a, int b, int c) +{ + int p = a + b - c; + int pa = abs(p-a); + int pb = abs(p-b); + int pc = abs(p-c); + if (pa <= pb && pa <= pc) return a; + if (pb <= pc) return b; + return c; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *prior; + int filter = *raw++; + + if (filter > 4) + return stbi__err("invalid filter","Corrupt PNG"); + + if (depth < 8) { + STBI_ASSERT(img_width_bytes <= x); + cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place + filter_bytes = 1; + width = img_width_bytes; + } + prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // handle first byte explicitly + for (k=0; k < filter_bytes; ++k) { + switch (filter) { + case STBI__F_none : cur[k] = raw[k]; break; + case STBI__F_sub : cur[k] = raw[k]; break; + case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; + case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break; + case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break; + case STBI__F_avg_first : cur[k] = raw[k]; break; + case STBI__F_paeth_first: cur[k] = raw[k]; break; + } + } + + if (depth == 8) { + if (img_n != out_n) + cur[img_n] = 255; // first pixel + raw += img_n; + cur += out_n; + prior += out_n; + } else if (depth == 16) { + if (img_n != out_n) { + cur[filter_bytes] = 255; // first pixel top byte + cur[filter_bytes+1] = 255; // first pixel bottom byte + } + raw += filter_bytes; + cur += output_bytes; + prior += output_bytes; + } else { + raw += 1; + cur += 1; + prior += 1; + } + + // this is a little gross, so that we don't switch per-pixel or per-component + if (depth < 8 || img_n == out_n) { + int nk = (width - 1)*filter_bytes; + #define STBI__CASE(f) \ + case f: \ + for (k=0; k < nk; ++k) + switch (filter) { + // "none" filter turns into a memcpy here; make that explicit. + case STBI__F_none: memcpy(cur, raw, nk); break; + STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break; + STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; + STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break; + STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break; + STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break; + STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break; + } + #undef STBI__CASE + raw += nk; + } else { + STBI_ASSERT(img_n+1 == out_n); + #define STBI__CASE(f) \ + case f: \ + for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \ + for (k=0; k < filter_bytes; ++k) + switch (filter) { + STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break; + STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break; + STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; + STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break; + STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break; + STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break; + STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break; + } + #undef STBI__CASE + + // the loop above sets the high byte of the pixels' alpha, but for + // 16 bit png files we also need the low byte set. we'll do that here. + if (depth == 16) { + cur = a->out + stride*j; // start at the beginning of the row again + for (i=0; i < x; ++i,cur+=output_bytes) { + cur[filter_bytes+1] = 255; + } + } + } + } + + // we make a separate pass to expand bits to pixels; for performance, + // this could run two scanlines behind the above code, so it won't + // intefere with filtering but will still be in the cache. + if (depth < 8) { + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes; + // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit + // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + + // note that the final byte might overshoot and write more data than desired. + // we can allocate enough data that this never writes out of memory, but it + // could also overwrite the next scanline. can it overwrite non-empty data + // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel. + // so we need to explicitly clamp the final ones + + if (depth == 4) { + for (k=x*img_n; k >= 2; k-=2, ++in) { + *cur++ = scale * ((*in >> 4) ); + *cur++ = scale * ((*in ) & 0x0f); + } + if (k > 0) *cur++ = scale * ((*in >> 4) ); + } else if (depth == 2) { + for (k=x*img_n; k >= 4; k-=4, ++in) { + *cur++ = scale * ((*in >> 6) ); + *cur++ = scale * ((*in >> 4) & 0x03); + *cur++ = scale * ((*in >> 2) & 0x03); + *cur++ = scale * ((*in ) & 0x03); + } + if (k > 0) *cur++ = scale * ((*in >> 6) ); + if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03); + if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03); + } else if (depth == 1) { + for (k=x*img_n; k >= 8; k-=8, ++in) { + *cur++ = scale * ((*in >> 7) ); + *cur++ = scale * ((*in >> 6) & 0x01); + *cur++ = scale * ((*in >> 5) & 0x01); + *cur++ = scale * ((*in >> 4) & 0x01); + *cur++ = scale * ((*in >> 3) & 0x01); + *cur++ = scale * ((*in >> 2) & 0x01); + *cur++ = scale * ((*in >> 1) & 0x01); + *cur++ = scale * ((*in ) & 0x01); + } + if (k > 0) *cur++ = scale * ((*in >> 7) ); + if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01); + if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01); + if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01); + if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01); + if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01); + if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01); + } + if (img_n != out_n) { + int q; + // insert alpha = 255 + cur = a->out + stride*j; + if (img_n == 1) { + for (q=x-1; q >= 0; --q) { + cur[q*2+1] = 255; + cur[q*2+0] = cur[q]; + } + } else { + STBI_ASSERT(img_n == 3); + for (q=x-1; q >= 0; --q) { + cur[q*4+3] = 255; + cur[q*4+2] = cur[q*3+2]; + cur[q*4+1] = cur[q*3+1]; + cur[q*4+0] = cur[q*3+0]; + } + } + } + } + } else if (depth == 16) { + // force the image data from big-endian to platform-native. + // this is done in a separate pass due to the decoding relying + // on the data being untouched, but could probably be done + // per-line during decode if care is taken. + stbi_uc *cur = a->out; + stbi__uint16 *cur16 = (stbi__uint16*)cur; + + for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) { + *cur16 = (cur[0] << 8) | cur[1]; + } + } + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load = 0; +static int stbi__de_iphone_flag = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag = flag_true_if_should_convert; +} + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); + s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + if (scan == STBI__SCAN_header) return 1; + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + // if SCAN_header, have to scan to see if we have a tRNS + } + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + if (z->depth == 16) { + for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; } + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth < 8) + ri->bits_per_channel = 8; + else + ri->bits_per_channel = p->depth; + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v >= 0 && v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; +} stbi__bmp_data; + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - 14 - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - 14 - info.hsz) >> 2; + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - 14 - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispoase of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + out = (stbi_uc*) STBI_REALLOC( out, layers * stride ); + if (delays) { + *delays = (int*) STBI_REALLOC( *delays, sizeof(int) * layers ); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + stbi__rewind( s ); + if (p == NULL) + return 0; + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + (void) stbi__get32be(s); + (void) stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) +// Does not support 16-bit-per-channel + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n)) + return 0; + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + stbi__getn(s, out, s->img_n * s->img_x * s->img_y); + + if (req_comp && req_comp != s->img_n) { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + + if (maxv > 255) + return stbi__err("max value > 255", "PPM image not 8-bit"); + else + return 1; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/libs/include/systemctrl.h b/libs/include/systemctrl.h new file mode 100644 index 0000000..831d087 --- /dev/null +++ b/libs/include/systemctrl.h @@ -0,0 +1,401 @@ +#ifndef __SCTRLLIBRARY_H__ +#define __SCTRLLIBRARY_H__ + +#if defined (__cplusplus) +extern "C" { +#endif + +#include +#include +#include +#include + +enum BootLoadFlags +{ + BOOTLOAD_VSH = 1, + BOOTLOAD_GAME = 2, + BOOTLOAD_UPDATER = 4, + BOOTLOAD_POPS = 8, + BOOTLOAD_UMDEMU = 64, /* for original NP9660 */ +}; + +/** + * Restart the vsh. + * + * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL + * + * @returns < 0 on some errors. + * +*/ +int sctrlKernelExitVSH(struct SceKernelLoadExecVSHParam *param); + +/** + * Executes a new executable from a disc. + * It is the function used by the firmware to execute the EBOOT.BIN from a disc. + * + * @param file - The file to execute. + * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL. + * + * @returns < 0 on some errors. +*/ +int sctrlKernelLoadExecVSHDisc(const char *file, struct SceKernelLoadExecVSHParam *param); + +/** + * Executes a new executable from a disc. + * It is the function used by the firmware to execute an updater from a disc. + * + * @param file - The file to execute. + * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL. + * + * @returns < 0 on some errors. +*/ +int sctrlKernelLoadExecVSHDiscUpdater(const char *file, struct SceKernelLoadExecVSHParam *param); + +/** + * Executes a new executable from a memory stick. + * It is the function used by the firmware to execute an updater from a memory stick. + * + * @param file - The file to execute. + * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL. + * + * @returns < 0 on some errors. +*/ +int sctrlKernelLoadExecVSHMs1(const char *file, struct SceKernelLoadExecVSHParam *param); + +/** + * Executes a new executable from a memory stick. + * It is the function used by the firmware to execute games (and homebrew :P) from a memory stick. + * + * @param file - The file to execute. + * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL. + * + * @returns < 0 on some errors. +*/ +int sctrlKernelLoadExecVSHMs2(const char *file, struct SceKernelLoadExecVSHParam *param); +int sctrlKernelLoadExecVSHEf2(const char *file, struct SceKernelLoadExecVSHParam *param); + +/** + * Executes a new executable from a memory stick. + * It is the function used by the firmware to execute ... ? + * + * @param file - The file to execute. + * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL. + * + * @returns < 0 on some errors. +*/ +int sctrlKernelLoadExecVSHMs3(const char *file, struct SceKernelLoadExecVSHParam *param); + +/** + * Executes a new executable from a memory stick. + * It is the function used by the firmware to execute psx games + * + * @param file - The file to execute. + * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL. + * + * @returns < 0 on some errors. +*/ +int sctrlKernelLoadExecVSHMs4(const char *file, struct SceKernelLoadExecVSHParam *param); + + +/** + * Executes a new executable with the specified apitype + * + * @param apitype - The apitype + * @param file - The file to execute. + * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL. + * + * @returns < 0 on some errors. +*/ +int sctrlKernelLoadExecVSHWithApitype(int apitype, const char *file, struct SceKernelLoadExecVSHParam *param); + +/** + * Sets the api type + * + * @param apitype - The apitype to set + * @returns the previous apitype + * + * @Note - this will modify also the value of sceKernelBootFrom, since the value of + * bootfrom is calculated from the apitype +*/ +int sctrlKernelSetInitApitype(int apitype); + +/** + * Sets the filename of the launched executable. + * + * @param filename - The filename to set + * @returns 0 on success +*/ +int sctrlKernelSetInitFileName(char *filename); + +/** + * Sets the init key config + * + * @param key - The key code + * @returns the previous key config +*/ +int sctrlKernelSetInitKeyConfig(int key); + +/** + * Sets the user level of the current thread + * + * @param level - The user level + * @return the previous user level on success + */ +int sctrlKernelSetUserLevel(int level); + +/** + * Sets the devkit version + * + * @param version - The devkit version to set + * @return the previous devkit version + * +*/ +int sctrlKernelSetDevkitVersion(int version); + +/** + * Checks if we are in SE. + * + * @returns 1 if we are in SE-C or later, 0 if we are in HEN-D or later, + * and < 0 (a kernel error code) in any other case +*/ +int sctrlHENIsSE(); + +/** + * Checks if we are in Devhook. + * + * @returns 1 if we are in SE-C/HEN-D for devhook or later, 0 if we are in normal SE-C/HEN-D or later, + * and < 0 (a kernel error code) in any other case +*/ +int sctrlHENIsDevhook(); + +/** + * Gets the HEN version + * + * @returns - The HEN version + * + * HEN D / SE-C : 0x00000400 + */ +int sctrlHENGetVersion(); + +/** + * Gets the HEN minor version + * + * @returns - The HEN minor version + */ +int sctrlHENGetMinorVersion(); + +/** + * Finds a driver + * + * @param drvname - The name of the driver (without ":" or numbers) + * + * @returns the driver if found, NULL otherwise + * + */ +PspIoDrv *sctrlHENFindDriver(char *drvname); + +/** + * Finds a function. + * + * @param modname - The module where to search the function + * @param libname - The library name + * @nid - The nid of the function + * + * @returns - The function address or 0 if not found + * +*/ +u32 sctrlHENFindFunction(char *modname, char *libname, u32 nid); + +typedef struct SceModule2 { + struct SceModule2 *next; + unsigned short attribute; + unsigned char version[2]; + char modname[27]; + char terminal; + unsigned int unknown1; + unsigned int unknown2; + SceUID modid; + unsigned int unknown3[2]; + u32 mpid_text; // 0x38 + u32 mpid_data; // 0x3C + void * ent_top; + unsigned int ent_size; + void * stub_top; + unsigned int stub_size; + unsigned int unknown4[5]; + unsigned int entry_addr; + unsigned int gp_value; + unsigned int text_addr; + unsigned int text_size; + unsigned int data_size; + unsigned int bss_size; + unsigned int nsegment; + unsigned int segmentaddr[4]; + unsigned int segmentsize[4]; +} SceModule2; + +typedef int (* STMOD_HANDLER)(SceModule2 *); + +/** + * Sets a function to be called just before module_start of a module is gonna be called (useful for patching purposes) + * + * @param handler - The function, that will receive the module structure before the module is started. + * + * @returns - The previous set function (NULL if none); + * @Note: because only one handler function is handled by HEN, you should + * call the previous function in your code. + * + * @Example: + * + * STMOD_HANDLER previous = NULL; + * + * int OnModuleStart(SceModule2 *mod); + * + * void somepointofmycode() + * { + * previous = sctrlHENSetStartModuleHandler(OnModuleStart); + * } + * + * int OnModuleStart(SceModule2 *mod) + * { + * if (strcmp(mod->modname, "vsh_module") == 0) + * { + * // Do something with vsh module here + * } + * + * if (!previous) + * return 0; + * + * // Call previous handler + * + * return previous(mod); + * } + * + * @Note2: The above example should be compiled with the flag -fno-pic + * in order to avoid problems with gp register that may lead to a crash. + * +*/ +STMOD_HANDLER sctrlHENSetStartModuleHandler(STMOD_HANDLER handler); + +typedef int (* KDEC_HANDLER)(u32 *buf, int size, int *retSize, int m); +typedef int (* MDEC_HANDLER)(u32 *tag, u8 *keys, u32 code, u32 *buf, int size, int *retSize, int m, void *unk0, int unk1, int unk2, int unk3, int unk4); + +/** + * Sets the speed (only for kernel usage) + * + * @param cpu - The cpu speed + * @param bus - The bus speed +*/ +void sctrlHENSetSpeed(int cpu, int bus); + +/** + * Sets the partition 2 and 8 memory for next loadexec. + * + * @param p2 - The size in MB for the user partition. Must be > 0 + * @param p8 - The size in MB for partition 8. Can be 0. + * + * @returns 0 on success, < 0 on error. + * This function is only available in the slim. The function will fail + * if p2+p8 > 52 or p2 == 0 +*/ +int sctrlHENSetMemory(u32 p2, u32 p8); + +void sctrlHENPatchSyscall(void *addr, void *newaddr); + +int sctrlKernelQuerySystemCall(void *func_addr); + +int sctrlKernelBootFrom(void); + +/** + * Patch module by offset + * + * @param modname - module name + * @param inst - instruction + * @param offset - module patch offset + * + * @return < 0 on error + */ +int sctrlPatchModule(char *modname, u32 inst, u32 offset); + +/** + * Get module text address + * + * @param modname - module name + * + * @return text address, or 0 if not found + */ +u32 sctrlModuleTextAddr(char *modname); + +/** + * Get sceInit module text address + * + * @note Only useful before sceInit exits + * + * @return text address, or 0 if not found + */ +u32 sctrlGetInitTextAddr(void); + +/** + * Set custom start module handler + * It can be used to replace a system module + * + * @note: func returns -1 to ignore the module and load the original module. Or new modid if replace is done. + */ +void sctrlSetCustomStartModule(int (*func)(int modid, SceSize argsize, void *argp, int *modstatus, SceKernelSMOption *opt)); + +/** + * Loads a module on next reboot. Only kernel mode. + * + * @param module_after - The path of the module which is loaded after the module to be loaded. + The module passed to this function will be loaded just before that module. + * @param buf - The buffer containing the module - Don't deallocate this one. It has to reside in kernel memory. + * @param size - The size of the module + * @param flags - The modes in which the module should be loaded, one of BootLoadFlags + * + * @Example: + * sctrlHENLoadModuleOnReboot("/kd/usersystemlib.prx", module_buffer, module_size, BOOTLOAD_GAME | BOOTLOAD_POPS | BOOTLOAD_UMDEMU); + * + * This will load the module contained in module_buffer just before /kd/usersystemlib.prx in the next reboot, if the mode of next reboot is game, pops or umdemu + * + * @Remarks: Don't use too early modules in first param like "/kd/init.prx" or "/kd/systemctrl.prx", or your module may not load properly + * Only one module will be loaded on reboot with this function. + * If this function is called many times, only the last one will be considered. + * By making a module to load itself using this function, and calling + * sctrlHENLoadModuleOnReboot on module_start, a prx can cause itself to be resident in the modes choosen by flags. + * If all flags are selected, the module will stay resident until a psp shutdown, or until sctrlHENLoadModuleOnReboot is not called. +*/ + +void sctrlHENLoadModuleOnReboot(char *module_after, void *buf, int size, int flags); + +/** + * Enable/disable NID Resolver on particular library + * + * @param libname the name of the library to be enabled/disabled + * @param enabled 0 - disabled, != 0 - enabled + * + * @Example: + * sctrlKernelSetNidResolver("sceImpose_driver", 0); // disable sceImpose_driver resolving + * + * @return previous value if set, < 0 on error + */ +int sctrlKernelSetNidResolver(char *libname, u32 enabled); + +/** + * Get a random u32 key from PSP Kirk PRNG + */ +u32 sctrlKernelRand(void); + +/** + * Get the real unspoofed Ethernet (MAC) Address of the systems WLAN chip + * + * @param mac Out-Buffer (6B) for real MAC Address + * + * @return 0 on success, < 0 on error + */ +int sctrlGetRealEthernetAddress(uint8_t * mac); + +#if defined (__cplusplus) +} +#endif + +#endif diff --git a/libs/include/systemctrl_se.h b/libs/include/systemctrl_se.h new file mode 100644 index 0000000..ce0501a --- /dev/null +++ b/libs/include/systemctrl_se.h @@ -0,0 +1,233 @@ +#ifndef __SCTRLLIBRARY_SE_H__ +#define __SCTRLLIBRARY_SE_H__ + +/** + * These functions are only available in SE-C and later, + * and they are not in HEN +*/ + +enum +{ + FAKE_REGION_DISABLED = 0, + FAKE_REGION_JAPAN = 1, + FAKE_REGION_AMERICA = 2, + FAKE_REGION_EUROPE = 3, + FAKE_REGION_KOREA = 4, + FAKE_REGION_UNK = 5, + FAKE_REGION_UNK2 = 6, + FAKE_REGION_AUSTRALIA = 7, + FAKE_REGION_HONGKONG = 8, + FAKE_REGION_TAIWAN = 9, + FAKE_REGION_RUSSIA = 10, + FAKE_REGION_CHINA = 11, + FAKE_REGION_DEBUG_TYPE_I = 12, + FAKE_REGION_DEBUG_TYPE_II = 13, +}; + +// No MODE_OE_LEGACY any more +enum SEUmdModes +{ + MODE_UMD = 0, + MODE_MARCH33 = 1, + MODE_NP9660 = 2, + MODE_INFERNO = 3, + MODE_VSHUMD = 4, + MODE_UPDATERUMD = 5, +}; + +enum MsSpeedFlag +{ + MSSPEED_NONE = 0, + MSSPEED_POP = 1, + MSSPEED_GAME = 2, + MSSPEED_VSH = 3, + MSSPEED_POP_GAME = 4, + MSSPEED_GAME_VSH = 5, + MSSPEED_VSH_POP = 6, + MSSPEED_ALWAYS = 7, +}; + +enum InfernoCachePolicy +{ + CACHE_POLICY_LRU = 0, + CACHE_POLICY_RR = 1, +}; + +typedef struct _SEConfig +{ + int magic; + s16 umdmode; + s16 vshcpuspeed; + s16 vshbusspeed; + s16 umdisocpuspeed; + s16 umdisobusspeed; + s16 fakeregion; + s16 usbdevice; + s16 usbcharge; + s16 machidden; + s16 skipgameboot; + s16 hidepic; + s16 plugvsh; + s16 pluggame; + s16 plugpop; + s16 flashprot; + s16 skiplogo; + s16 useversion; + s16 useownupdate; + s16 usenodrm; + s16 hibblock; + s16 noanalog; + s16 oldplugin; + s16 htmlviewer_custom_save_location; + s16 hide_cfw_dirs; + s16 chn_iso; + s16 msspeed; + s16 slimcolor; + s16 iso_cache; + s16 iso_cache_total_size; // in MB + s16 iso_cache_num; + s16 iso_cache_policy; + s16 usbversion; + s16 language; /* -1 as autodetect */ + s16 retail_high_memory; + s16 macspoofer; +} SEConfig; + +/** + * Gets the SE/OE version + * + * @returns the SE version + * + * 3.03 OE-A: 0x00000500 +*/ +int sctrlSEGetVersion(); + +/** + * Gets the SE configuration. + * Avoid using this function, it may corrupt your program. + * Use sctrlSEGetCongiEx function instead. + * + * @param config - pointer to a SEConfig structure that receives the SE configuration + * @returns 0 on success +*/ +int sctrlSEGetConfig(SEConfig *config); + +/** + * Gets the SE configuration + * + * @param config - pointer to a SEConfig structure that receives the SE configuration + * @param size - The size of the structure + * @returns 0 on success +*/ +int sctrlSEGetConfigEx(SEConfig *config, int size); + +/** + * Sets the SE configuration + * This function can corrupt the configuration in flash, use + * sctrlSESetConfigEx instead. + * + * @param config - pointer to a SEConfig structure that has the SE configuration to set + * @returns 0 on success +*/ +int sctrlSESetConfig(SEConfig *config); + +/** + * Sets the SE configuration + * + * @param config - pointer to a SEConfig structure that has the SE configuration to set + * @param size - the size of the structure + * @returns 0 on success +*/ +int sctrlSESetConfigEx(SEConfig *config, int size); + +/** + * Initiates the emulation of a disc from an ISO9660/CSO file. + * + * @param file - The path of the + * @param noumd - Wether use noumd or not + * @param isofs - Wether use the custom SE isofs driver or not + * + * @returns 0 on success + * + * @Note - When setting noumd to 1, isofs should also be set to 1, + * otherwise the umd would be still required. + * + * @Note 2 - The function doesn't check if the file is valid or even if it exists + * and it may return success on those cases + * + * @Note 3 - This function is not available in SE for devhook + * @Example: + * + * SEConfig config; + * + * sctrlSEGetConfig(&config); + * + * if (config.usenoumd) + * { + * sctrlSEMountUmdFromFile("ms0:/ISO/mydisc.iso", 1, 1); + * } + * else + * { + * sctrlSEMountUmdFromFile("ms0:/ISO/mydisc.iso", 0, config.useisofsonumdinserted); + * } +*/ +int sctrlSEMountUmdFromFile(char *file, int noumd, int isofs); + +/** + * Umounts an iso. + * + * @returns 0 on success +*/ +int sctrlSEUmountUmd(void); + +/** + * Forces the umd disc out state + * + * @param out - non-zero for disc out, 0 otherwise + * +*/ +void sctrlSESetDiscOut(int out); + +/** + * Sets the disctype. + * + * @param type - the disctype (0x10=game, 0x20=video, 0x40=audio) + * @note: Currently only inferno available, needs reset to take effect +*/ +void sctrlSESetDiscType(int type); + +/** + * Get the disctype. +*/ +int sctrlSEGetDiscType(void); + +/** + * Sets the current umd file (kernel only) +*/ +char *sctrlSEGetUmdFile(); + +/** + * Gets the current umd file (kernel only) +*/ +char *sctrlSEGetUmdFile(); + +/** + * Sets the current umd file (kernel only) + * + * @param file - The umd file +*/ +void sctrlSESetUmdFile(char *file); + +/** + * Sets the boot config file for next reboot + * + * @param index - The index identifying the file (0 -> normal bootconf, 1 -> march33 driver bootconf, 2 -> np9660 bootcnf, 3 -> inferno bootconf), 4 -> inferno vsh mount +*/ +void sctrlSESetBootConfFileIndex(int index); + +/** + * Get the boot config index + */ +u32 sctrlSEGetBootConfFileIndex(void); + +#endif diff --git a/libs/include/vorbis/codec.h b/libs/include/vorbis/codec.h new file mode 100644 index 0000000..9e6f1a4 --- /dev/null +++ b/libs/include/vorbis/codec.h @@ -0,0 +1,240 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001 * + * by the XIPHOPHORUS Company http://www.xiph.org/ * + + ******************************************************************** + + function: libvorbis codec headers + last mod: $Id: codec.h 1367 2005-11-05 18:14:13Z mrbrown $ + + ********************************************************************/ + +#ifndef _vorbis_codec_h_ +#define _vorbis_codec_h_ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#include + +typedef struct vorbis_info{ + int version; + int channels; + long rate; + + /* The below bitrate declarations are *hints*. + Combinations of the three values carry the following implications: + + all three set to the same value: + implies a fixed rate bitstream + only nominal set: + implies a VBR stream that averages the nominal bitrate. No hard + upper/lower limit + upper and or lower set: + implies a VBR bitstream that obeys the bitrate limits. nominal + may also be set to give a nominal rate. + none set: + the coder does not care to speculate. + */ + + long bitrate_upper; + long bitrate_nominal; + long bitrate_lower; + long bitrate_window; + + void *codec_setup; +} vorbis_info; + +/* vorbis_dsp_state buffers the current vorbis audio + analysis/synthesis state. The DSP state belongs to a specific + logical bitstream ****************************************************/ +typedef struct vorbis_dsp_state{ + int analysisp; + vorbis_info *vi; + + float **pcm; + float **pcmret; + int pcm_storage; + int pcm_current; + int pcm_returned; + + int preextrapolate; + int eofflag; + + long lW; + long W; + long nW; + long centerW; + + ogg_int64_t granulepos; + ogg_int64_t sequence; + + ogg_int64_t glue_bits; + ogg_int64_t time_bits; + ogg_int64_t floor_bits; + ogg_int64_t res_bits; + + void *backend_state; +} vorbis_dsp_state; + +typedef struct vorbis_block{ + /* necessary stream state for linking to the framing abstraction */ + float **pcm; /* this is a pointer into local storage */ + oggpack_buffer opb; + + long lW; + long W; + long nW; + int pcmend; + int mode; + + int eofflag; + ogg_int64_t granulepos; + ogg_int64_t sequence; + vorbis_dsp_state *vd; /* For read-only access of configuration */ + + /* local storage to avoid remallocing; it's up to the mapping to + structure it */ + void *localstore; + long localtop; + long localalloc; + long totaluse; + struct alloc_chain *reap; + + /* bitmetrics for the frame */ + long glue_bits; + long time_bits; + long floor_bits; + long res_bits; + + void *internal; + +} vorbis_block; + +/* vorbis_block is a single block of data to be processed as part of +the analysis/synthesis stream; it belongs to a specific logical +bitstream, but is independant from other vorbis_blocks belonging to +that logical bitstream. *************************************************/ + +struct alloc_chain{ + void *ptr; + struct alloc_chain *next; +}; + +/* vorbis_info contains all the setup information specific to the + specific compression/decompression mode in progress (eg, + psychoacoustic settings, channel setup, options, codebook + etc). vorbis_info and substructures are in backends.h. +*********************************************************************/ + +/* the comments are not part of vorbis_info so that vorbis_info can be + static storage */ +typedef struct vorbis_comment{ + /* unlimited user comment fields. libvorbis writes 'libvorbis' + whatever vendor is set to in encode */ + char **user_comments; + int *comment_lengths; + int comments; + char *vendor; + +} vorbis_comment; + + +/* libvorbis encodes in two abstraction layers; first we perform DSP + and produce a packet (see docs/analysis.txt). The packet is then + coded into a framed OggSquish bitstream by the second layer (see + docs/framing.txt). Decode is the reverse process; we sync/frame + the bitstream and extract individual packets, then decode the + packet back into PCM audio. + + The extra framing/packetizing is used in streaming formats, such as + files. Over the net (such as with UDP), the framing and + packetization aren't necessary as they're provided by the transport + and the streaming layer is not used */ + +/* Vorbis PRIMITIVES: general ***************************************/ + +extern void vorbis_info_init(vorbis_info *vi); +extern void vorbis_info_clear(vorbis_info *vi); +extern int vorbis_info_blocksize(vorbis_info *vi,int zo); +extern void vorbis_comment_init(vorbis_comment *vc); +extern void vorbis_comment_add(vorbis_comment *vc, char *comment); +extern void vorbis_comment_add_tag(vorbis_comment *vc, + char *tag, char *contents); +extern char *vorbis_comment_query(vorbis_comment *vc, char *tag, int count); +extern int vorbis_comment_query_count(vorbis_comment *vc, char *tag); +extern void vorbis_comment_clear(vorbis_comment *vc); + +extern int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb); +extern int vorbis_block_clear(vorbis_block *vb); +extern void vorbis_dsp_clear(vorbis_dsp_state *v); +extern double vorbis_granule_time(vorbis_dsp_state *v, + ogg_int64_t granulepos); + +/* Vorbis PRIMITIVES: analysis/DSP layer ****************************/ + +extern int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi); +extern int vorbis_commentheader_out(vorbis_comment *vc, ogg_packet *op); +extern int vorbis_analysis_headerout(vorbis_dsp_state *v, + vorbis_comment *vc, + ogg_packet *op, + ogg_packet *op_comm, + ogg_packet *op_code); +extern float **vorbis_analysis_buffer(vorbis_dsp_state *v,int vals); +extern int vorbis_analysis_wrote(vorbis_dsp_state *v,int vals); +extern int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb); +extern int vorbis_analysis(vorbis_block *vb,ogg_packet *op); + +extern int vorbis_bitrate_addblock(vorbis_block *vb); +extern int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd, + ogg_packet *op); + +/* Vorbis PRIMITIVES: synthesis layer *******************************/ +extern int vorbis_synthesis_headerin(vorbis_info *vi,vorbis_comment *vc, + ogg_packet *op); + +extern int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi); +extern int vorbis_synthesis_restart(vorbis_dsp_state *v); +extern int vorbis_synthesis(vorbis_block *vb,ogg_packet *op); +extern int vorbis_synthesis_trackonly(vorbis_block *vb,ogg_packet *op); +extern int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb); +extern int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm); +extern int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm); +extern int vorbis_synthesis_read(vorbis_dsp_state *v,int samples); +extern long vorbis_packet_blocksize(vorbis_info *vi,ogg_packet *op); + +extern int vorbis_synthesis_halfrate(vorbis_info *v,int flag); +extern int vorbis_synthesis_halfrate_p(vorbis_info *v); + +/* Vorbis ERRORS and return codes ***********************************/ + +#define OV_FALSE -1 +#define OV_EOF -2 +#define OV_HOLE -3 + +#define OV_EREAD -128 +#define OV_EFAULT -129 +#define OV_EIMPL -130 +#define OV_EINVAL -131 +#define OV_ENOTVORBIS -132 +#define OV_EBADHEADER -133 +#define OV_EVERSION -134 +#define OV_ENOTAUDIO -135 +#define OV_EBADPACKET -136 +#define OV_EBADLINK -137 +#define OV_ENOSEEK -138 + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif + diff --git a/libs/include/vorbis/vorbisenc.h b/libs/include/vorbis/vorbisenc.h new file mode 100644 index 0000000..b715c83 --- /dev/null +++ b/libs/include/vorbis/vorbisenc.h @@ -0,0 +1,112 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001 * + * by the XIPHOPHORUS Company http://www.xiph.org/ * + * * + ******************************************************************** + + function: vorbis encode-engine setup + last mod: $Id: vorbisenc.h 1367 2005-11-05 18:14:13Z mrbrown $ + + ********************************************************************/ + +#ifndef _OV_ENC_H_ +#define _OV_ENC_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#include "codec.h" + +extern int vorbis_encode_init(vorbis_info *vi, + long channels, + long rate, + + long max_bitrate, + long nominal_bitrate, + long min_bitrate); + +extern int vorbis_encode_setup_managed(vorbis_info *vi, + long channels, + long rate, + + long max_bitrate, + long nominal_bitrate, + long min_bitrate); + +extern int vorbis_encode_setup_vbr(vorbis_info *vi, + long channels, + long rate, + + float quality /* quality level from 0. (lo) to 1. (hi) */ + ); + +extern int vorbis_encode_init_vbr(vorbis_info *vi, + long channels, + long rate, + + float base_quality /* quality level from 0. (lo) to 1. (hi) */ + ); + +extern int vorbis_encode_setup_init(vorbis_info *vi); + +extern int vorbis_encode_ctl(vorbis_info *vi,int number,void *arg); + + /* deprecated rate management supported only for compatability */ +#define OV_ECTL_RATEMANAGE_GET 0x10 +#define OV_ECTL_RATEMANAGE_SET 0x11 +#define OV_ECTL_RATEMANAGE_AVG 0x12 +#define OV_ECTL_RATEMANAGE_HARD 0x13 + +struct ovectl_ratemanage_arg { + int management_active; + + long bitrate_hard_min; + long bitrate_hard_max; + double bitrate_hard_window; + + long bitrate_av_lo; + long bitrate_av_hi; + double bitrate_av_window; + double bitrate_av_window_center; +}; + + + /* new rate setup */ +#define OV_ECTL_RATEMANAGE2_GET 0x14 +#define OV_ECTL_RATEMANAGE2_SET 0x15 + +struct ovectl_ratemanage2_arg { + int management_active; + + long bitrate_limit_min_kbps; + long bitrate_limit_max_kbps; + long bitrate_limit_reservoir_bits; + double bitrate_limit_reservoir_bias; + + long bitrate_average_kbps; + double bitrate_average_damping; +}; + + + +#define OV_ECTL_LOWPASS_GET 0x20 +#define OV_ECTL_LOWPASS_SET 0x21 + +#define OV_ECTL_IBLOCK_GET 0x30 +#define OV_ECTL_IBLOCK_SET 0x31 + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif + + diff --git a/libs/include/vorbis/vorbisfile.h b/libs/include/vorbis/vorbisfile.h new file mode 100644 index 0000000..b74b6ee --- /dev/null +++ b/libs/include/vorbis/vorbisfile.h @@ -0,0 +1,143 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001 * + * by the XIPHOPHORUS Company http://www.xiph.org/ * + * * + ******************************************************************** + + function: stdio-based convenience library for opening/seeking/decoding + last mod: $Id: vorbisfile.h 1367 2005-11-05 18:14:13Z mrbrown $ + + ********************************************************************/ + +#ifndef _OV_FILE_H_ +#define _OV_FILE_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#include +#include "codec.h" + +/* The function prototypes for the callbacks are basically the same as for + * the stdio functions fread, fseek, fclose, ftell. + * The one difference is that the FILE * arguments have been replaced with + * a void * - this is to be used as a pointer to whatever internal data these + * functions might need. In the stdio case, it's just a FILE * cast to a void * + * + * If you use other functions, check the docs for these functions and return + * the right values. For seek_func(), you *MUST* return -1 if the stream is + * unseekable + */ +typedef struct { + size_t (*read_func) (void *ptr, size_t size, size_t nmemb, void *datasource); + int (*seek_func) (void *datasource, ogg_int64_t offset, int whence); + int (*close_func) (void *datasource); + long (*tell_func) (void *datasource); +} ov_callbacks; + +#define NOTOPEN 0 +#define PARTOPEN 1 +#define OPENED 2 +#define STREAMSET 3 +#define INITSET 4 + +typedef struct OggVorbis_File { + void *datasource; /* Pointer to a FILE *, etc. */ + int seekable; + ogg_int64_t offset; + ogg_int64_t end; + ogg_sync_state oy; + + /* If the FILE handle isn't seekable (eg, a pipe), only the current + stream appears */ + int links; + ogg_int64_t *offsets; + ogg_int64_t *dataoffsets; + long *serialnos; + ogg_int64_t *pcmlengths; /* overloaded to maintain binary + compatability; x2 size, stores both + beginning and end values */ + vorbis_info *vi; + vorbis_comment *vc; + + /* Decoding working state local storage */ + ogg_int64_t pcm_offset; + int ready_state; + long current_serialno; + int current_link; + + double bittrack; + double samptrack; + + ogg_stream_state os; /* take physical pages, weld into a logical + stream of packets */ + vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */ + vorbis_block vb; /* local working space for packet->PCM decode */ + + ov_callbacks callbacks; + +} OggVorbis_File; + +extern int ov_clear(OggVorbis_File *vf); +extern int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes); +extern int ov_open_callbacks(void *datasource, OggVorbis_File *vf, + char *initial, long ibytes, ov_callbacks callbacks); + +extern int ov_test(FILE *f,OggVorbis_File *vf,char *initial,long ibytes); +extern int ov_test_callbacks(void *datasource, OggVorbis_File *vf, + char *initial, long ibytes, ov_callbacks callbacks); +extern int ov_test_open(OggVorbis_File *vf); + +extern long ov_bitrate(OggVorbis_File *vf,int i); +extern long ov_bitrate_instant(OggVorbis_File *vf); +extern long ov_streams(OggVorbis_File *vf); +extern long ov_seekable(OggVorbis_File *vf); +extern long ov_serialnumber(OggVorbis_File *vf,int i); + +extern ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i); +extern ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i); +extern double ov_time_total(OggVorbis_File *vf,int i); + +extern int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos); +extern int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos); +extern int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos); +extern int ov_time_seek(OggVorbis_File *vf,double pos); +extern int ov_time_seek_page(OggVorbis_File *vf,double pos); + +extern int ov_raw_seek_lap(OggVorbis_File *vf,ogg_int64_t pos); +extern int ov_pcm_seek_lap(OggVorbis_File *vf,ogg_int64_t pos); +extern int ov_pcm_seek_page_lap(OggVorbis_File *vf,ogg_int64_t pos); +extern int ov_time_seek_lap(OggVorbis_File *vf,double pos); +extern int ov_time_seek_page_lap(OggVorbis_File *vf,double pos); + +extern ogg_int64_t ov_raw_tell(OggVorbis_File *vf); +extern ogg_int64_t ov_pcm_tell(OggVorbis_File *vf); +extern double ov_time_tell(OggVorbis_File *vf); + +extern vorbis_info *ov_info(OggVorbis_File *vf,int link); +extern vorbis_comment *ov_comment(OggVorbis_File *vf,int link); + +extern long ov_read_float(OggVorbis_File *vf,float ***pcm_channels,int samples, + int *bitstream); +extern long ov_read(OggVorbis_File *vf,char *buffer,int length, + int bigendianp,int word,int sgned,int *bitstream); +extern int ov_crosslap(OggVorbis_File *vf1,OggVorbis_File *vf2); + +extern int ov_halfrate(OggVorbis_File *vf,int flag); +extern int ov_halfrate_p(OggVorbis_File *vf); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif + + diff --git a/libs/include/xmp.h b/libs/include/xmp.h new file mode 100644 index 0000000..e3d223e --- /dev/null +++ b/libs/include/xmp.h @@ -0,0 +1,358 @@ +#ifndef XMP_H +#define XMP_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define XMP_VERSION "4.4.1" +#define XMP_VERCODE 0x040401 +#define XMP_VER_MAJOR 4 +#define XMP_VER_MINOR 4 +#define XMP_VER_RELEASE 1 + +#if defined(_WIN32) && !defined(__CYGWIN__) +# if defined(BUILDING_STATIC) +# define EXPORT +# elif defined(BUILDING_DLL) +# define EXPORT __declspec(dllexport) +# else +# define EXPORT __declspec(dllimport) +# endif +#elif __GNUC__ >= 4 || defined(__HP_cc) +# define EXPORT __attribute__((visibility ("default"))) +#elif defined(__SUNPRO_C) +# define EXPORT __global +#elif defined(EMSCRIPTEN) +# define EXPORT EMSCRIPTEN_KEEPALIVE +#else +# define EXPORT +#endif + +#define XMP_NAME_SIZE 64 /* Size of module name and type */ + +#define XMP_KEY_OFF 0x81 /* Note number for key off event */ +#define XMP_KEY_CUT 0x82 /* Note number for key cut event */ +#define XMP_KEY_FADE 0x83 /* Note number for fade event */ + +/* mixer parameter macros */ + +/* sample format flags */ +#define XMP_FORMAT_8BIT (1 << 0) /* Mix to 8-bit instead of 16 */ +#define XMP_FORMAT_UNSIGNED (1 << 1) /* Mix to unsigned samples */ +#define XMP_FORMAT_MONO (1 << 2) /* Mix to mono instead of stereo */ + +/* player parameters */ +#define XMP_PLAYER_AMP 0 /* Amplification factor */ +#define XMP_PLAYER_MIX 1 /* Stereo mixing */ +#define XMP_PLAYER_INTERP 2 /* Interpolation type */ +#define XMP_PLAYER_DSP 3 /* DSP effect flags */ +#define XMP_PLAYER_FLAGS 4 /* Player flags */ +#define XMP_PLAYER_CFLAGS 5 /* Player flags for current module */ +#define XMP_PLAYER_SMPCTL 6 /* Sample control flags */ +#define XMP_PLAYER_VOLUME 7 /* Player module volume */ +#define XMP_PLAYER_STATE 8 /* Internal player state (read only) */ +#define XMP_PLAYER_SMIX_VOLUME 9 /* SMIX volume */ +#define XMP_PLAYER_DEFPAN 10 /* Default pan setting */ +#define XMP_PLAYER_MODE 11 /* Player personality */ +#define XMP_PLAYER_MIXER_TYPE 12 /* Current mixer (read only) */ +#define XMP_PLAYER_VOICES 13 /* Maximum number of mixer voices */ + +/* interpolation types */ +#define XMP_INTERP_NEAREST 0 /* Nearest neighbor */ +#define XMP_INTERP_LINEAR 1 /* Linear (default) */ +#define XMP_INTERP_SPLINE 2 /* Cubic spline */ + +/* dsp effect types */ +#define XMP_DSP_LOWPASS (1 << 0) /* Lowpass filter effect */ +#define XMP_DSP_ALL (XMP_DSP_LOWPASS) + +/* player state */ +#define XMP_STATE_UNLOADED 0 /* Context created */ +#define XMP_STATE_LOADED 1 /* Module loaded */ +#define XMP_STATE_PLAYING 2 /* Module playing */ + +/* player flags */ +#define XMP_FLAGS_VBLANK (1 << 0) /* Use vblank timing */ +#define XMP_FLAGS_FX9BUG (1 << 1) /* Emulate FX9 bug */ +#define XMP_FLAGS_FIXLOOP (1 << 2) /* Emulate sample loop bug */ +#define XMP_FLAGS_A500 (1 << 3) /* Use Paula mixer in Amiga modules */ + +/* player modes */ +#define XMP_MODE_AUTO 0 /* Autodetect mode (default) */ +#define XMP_MODE_MOD 1 /* Play as a generic MOD player */ +#define XMP_MODE_NOISETRACKER 2 /* Play using Noisetracker quirks */ +#define XMP_MODE_PROTRACKER 3 /* Play using Protracker quirks */ +#define XMP_MODE_S3M 4 /* Play as a generic S3M player */ +#define XMP_MODE_ST3 5 /* Play using ST3 bug emulation */ +#define XMP_MODE_ST3GUS 6 /* Play using ST3+GUS quirks */ +#define XMP_MODE_XM 7 /* Play as a generic XM player */ +#define XMP_MODE_FT2 8 /* Play using FT2 bug emulation */ +#define XMP_MODE_IT 9 /* Play using IT quirks */ +#define XMP_MODE_ITSMP 10 /* Play using IT sample mode quirks */ + +/* mixer types */ +#define XMP_MIXER_STANDARD 0 /* Standard mixer */ +#define XMP_MIXER_A500 1 /* Amiga 500 */ +#define XMP_MIXER_A500F 2 /* Amiga 500 with led filter */ + +/* sample flags */ +#define XMP_SMPCTL_SKIP (1 << 0) /* Don't load samples */ + +/* limits */ +#define XMP_MAX_KEYS 121 /* Number of valid keys */ +#define XMP_MAX_ENV_POINTS 32 /* Max number of envelope points */ +#define XMP_MAX_MOD_LENGTH 256 /* Max number of patterns in module */ +#define XMP_MAX_CHANNELS 64 /* Max number of channels in module */ +#define XMP_MAX_SRATE 49170 /* max sampling rate (Hz) */ +#define XMP_MIN_SRATE 4000 /* min sampling rate (Hz) */ +#define XMP_MIN_BPM 20 /* min BPM */ +/* frame rate = (50 * bpm / 125) Hz */ +/* frame size = (sampling rate * channels * size) / frame rate */ +#define XMP_MAX_FRAMESIZE (5 * XMP_MAX_SRATE * 2 / XMP_MIN_BPM) + +/* error codes */ +#define XMP_END 1 +#define XMP_ERROR_INTERNAL 2 /* Internal error */ +#define XMP_ERROR_FORMAT 3 /* Unsupported module format */ +#define XMP_ERROR_LOAD 4 /* Error loading file */ +#define XMP_ERROR_DEPACK 5 /* Error depacking file */ +#define XMP_ERROR_SYSTEM 6 /* System error */ +#define XMP_ERROR_INVALID 7 /* Invalid parameter */ +#define XMP_ERROR_STATE 8 /* Invalid player state */ + +struct xmp_channel { + int pan; /* Channel pan (0x80 is center) */ + int vol; /* Channel volume */ +#define XMP_CHANNEL_SYNTH (1 << 0) /* Channel is synthesized */ +#define XMP_CHANNEL_MUTE (1 << 1) /* Channel is muted */ +#define XMP_CHANNEL_SPLIT (1 << 2) /* Split Amiga channel in bits 5-4 */ +#define XMP_CHANNEL_SURROUND (1 << 4) /* Surround channel */ + int flg; /* Channel flags */ +}; + +struct xmp_pattern { + int rows; /* Number of rows */ + int index[1]; /* Track index */ +}; + +struct xmp_event { + unsigned char note; /* Note number (0 means no note) */ + unsigned char ins; /* Patch number */ + unsigned char vol; /* Volume (0 to basevol) */ + unsigned char fxt; /* Effect type */ + unsigned char fxp; /* Effect parameter */ + unsigned char f2t; /* Secondary effect type */ + unsigned char f2p; /* Secondary effect parameter */ + unsigned char _flag; /* Internal (reserved) flags */ +}; + +struct xmp_track { + int rows; /* Number of rows */ + struct xmp_event event[1]; /* Event data */ +}; + +struct xmp_envelope { +#define XMP_ENVELOPE_ON (1 << 0) /* Envelope is enabled */ +#define XMP_ENVELOPE_SUS (1 << 1) /* Envelope has sustain point */ +#define XMP_ENVELOPE_LOOP (1 << 2) /* Envelope has loop */ +#define XMP_ENVELOPE_FLT (1 << 3) /* Envelope is used for filter */ +#define XMP_ENVELOPE_SLOOP (1 << 4) /* Envelope has sustain loop */ +#define XMP_ENVELOPE_CARRY (1 << 5) /* Don't reset envelope position */ + int flg; /* Flags */ + int npt; /* Number of envelope points */ + int scl; /* Envelope scaling */ + int sus; /* Sustain start point */ + int sue; /* Sustain end point */ + int lps; /* Loop start point */ + int lpe; /* Loop end point */ + short data[XMP_MAX_ENV_POINTS * 2]; +}; + +struct xmp_instrument { + char name[32]; /* Instrument name */ + int vol; /* Instrument volume */ + int nsm; /* Number of samples */ + int rls; /* Release (fadeout) */ + struct xmp_envelope aei; /* Amplitude envelope info */ + struct xmp_envelope pei; /* Pan envelope info */ + struct xmp_envelope fei; /* Frequency envelope info */ + + struct { + unsigned char ins; /* Instrument number for each key */ + signed char xpo; /* Instrument transpose for each key */ + } map[XMP_MAX_KEYS]; + + struct xmp_subinstrument { + int vol; /* Default volume */ + int gvl; /* Global volume */ + int pan; /* Pan */ + int xpo; /* Transpose */ + int fin; /* Finetune */ + int vwf; /* Vibrato waveform */ + int vde; /* Vibrato depth */ + int vra; /* Vibrato rate */ + int vsw; /* Vibrato sweep */ + int rvv; /* Random volume/pan variation (IT) */ + int sid; /* Sample number */ +#define XMP_INST_NNA_CUT 0x00 +#define XMP_INST_NNA_CONT 0x01 +#define XMP_INST_NNA_OFF 0x02 +#define XMP_INST_NNA_FADE 0x03 + int nna; /* New note action */ +#define XMP_INST_DCT_OFF 0x00 +#define XMP_INST_DCT_NOTE 0x01 +#define XMP_INST_DCT_SMP 0x02 +#define XMP_INST_DCT_INST 0x03 + int dct; /* Duplicate check type */ +#define XMP_INST_DCA_CUT XMP_INST_NNA_CUT +#define XMP_INST_DCA_OFF XMP_INST_NNA_OFF +#define XMP_INST_DCA_FADE XMP_INST_NNA_FADE + int dca; /* Duplicate check action */ + int ifc; /* Initial filter cutoff */ + int ifr; /* Initial filter resonance */ + } *sub; + + void *extra; /* Extra fields */ +}; + +struct xmp_sample { + char name[32]; /* Sample name */ + int len; /* Sample length */ + int lps; /* Loop start */ + int lpe; /* Loop end */ +#define XMP_SAMPLE_16BIT (1 << 0) /* 16bit sample */ +#define XMP_SAMPLE_LOOP (1 << 1) /* Sample is looped */ +#define XMP_SAMPLE_LOOP_BIDIR (1 << 2) /* Bidirectional sample loop */ +#define XMP_SAMPLE_LOOP_REVERSE (1 << 3) /* Backwards sample loop */ +#define XMP_SAMPLE_LOOP_FULL (1 << 4) /* Play full sample before looping */ +#define XMP_SAMPLE_SLOOP (1 << 5) /* Sample has sustain loop */ +#define XMP_SAMPLE_SLOOP_BIDIR (1 << 6) /* Bidirectional sustain loop */ +#define XMP_SAMPLE_SYNTH (1 << 15) /* Data contains synth patch */ + int flg; /* Flags */ + unsigned char *data; /* Sample data */ +}; + +struct xmp_sequence { + int entry_point; + int duration; +}; + +struct xmp_module { + char name[XMP_NAME_SIZE]; /* Module title */ + char type[XMP_NAME_SIZE]; /* Module format */ + int pat; /* Number of patterns */ + int trk; /* Number of tracks */ + int chn; /* Tracks per pattern */ + int ins; /* Number of instruments */ + int smp; /* Number of samples */ + int spd; /* Initial speed */ + int bpm; /* Initial BPM */ + int len; /* Module length in patterns */ + int rst; /* Restart position */ + int gvl; /* Global volume */ + + struct xmp_pattern **xxp; /* Patterns */ + struct xmp_track **xxt; /* Tracks */ + struct xmp_instrument *xxi; /* Instruments */ + struct xmp_sample *xxs; /* Samples */ + struct xmp_channel xxc[XMP_MAX_CHANNELS]; /* Channel info */ + unsigned char xxo[XMP_MAX_MOD_LENGTH]; /* Orders */ +}; + +struct xmp_test_info { + char name[XMP_NAME_SIZE]; /* Module title */ + char type[XMP_NAME_SIZE]; /* Module format */ +}; + +struct xmp_module_info { + unsigned char md5[16]; /* MD5 message digest */ + int vol_base; /* Volume scale */ + struct xmp_module *mod; /* Pointer to module data */ + char *comment; /* Comment text, if any */ + int num_sequences; /* Number of valid sequences */ + struct xmp_sequence *seq_data; /* Pointer to sequence data */ +}; + +struct xmp_frame_info { /* Current frame information */ + int pos; /* Current position */ + int pattern; /* Current pattern */ + int row; /* Current row in pattern */ + int num_rows; /* Number of rows in current pattern */ + int frame; /* Current frame */ + int speed; /* Current replay speed */ + int bpm; /* Current bpm */ + int time; /* Current module time in ms */ + int total_time; /* Estimated replay time in ms*/ + int frame_time; /* Frame replay time in us */ + void *buffer; /* Pointer to sound buffer */ + int buffer_size; /* Used buffer size */ + int total_size; /* Total buffer size */ + int volume; /* Current master volume */ + int loop_count; /* Loop counter */ + int virt_channels; /* Number of virtual channels */ + int virt_used; /* Used virtual channels */ + int sequence; /* Current sequence */ + + struct xmp_channel_info { /* Current channel information */ + unsigned int period; /* Sample period (* 4096) */ + unsigned int position; /* Sample position */ + short pitchbend; /* Linear bend from base note*/ + unsigned char note; /* Current base note number */ + unsigned char instrument; /* Current instrument number */ + unsigned char sample; /* Current sample number */ + unsigned char volume; /* Current volume */ + unsigned char pan; /* Current stereo pan */ + unsigned char reserved; /* Reserved */ + struct xmp_event event; /* Current track event */ + } channel_info[XMP_MAX_CHANNELS]; +}; + + +typedef char *xmp_context; + +EXPORT extern const char *xmp_version; +EXPORT extern const unsigned int xmp_vercode; + +EXPORT xmp_context xmp_create_context (void); +EXPORT void xmp_free_context (xmp_context); +EXPORT int xmp_test_module (char *, struct xmp_test_info *); +EXPORT int xmp_load_module (xmp_context, char *); +EXPORT void xmp_scan_module (xmp_context); +EXPORT void xmp_release_module (xmp_context); +EXPORT int xmp_start_player (xmp_context, int, int); +EXPORT int xmp_play_frame (xmp_context); +EXPORT int xmp_play_buffer (xmp_context, void *, int, int); +EXPORT void xmp_get_frame_info (xmp_context, struct xmp_frame_info *); +EXPORT void xmp_end_player (xmp_context); +EXPORT void xmp_inject_event (xmp_context, int, struct xmp_event *); +EXPORT void xmp_get_module_info (xmp_context, struct xmp_module_info *); +EXPORT char **xmp_get_format_list (void); +EXPORT int xmp_next_position (xmp_context); +EXPORT int xmp_prev_position (xmp_context); +EXPORT int xmp_set_position (xmp_context, int); +EXPORT void xmp_stop_module (xmp_context); +EXPORT void xmp_restart_module (xmp_context); +EXPORT int xmp_seek_time (xmp_context, int); +EXPORT int xmp_channel_mute (xmp_context, int, int); +EXPORT int xmp_channel_vol (xmp_context, int, int); +EXPORT int xmp_set_player (xmp_context, int, int); +EXPORT int xmp_get_player (xmp_context, int); +EXPORT int xmp_set_instrument_path (xmp_context, char *); +EXPORT int xmp_load_module_from_memory (xmp_context, void *, long); +EXPORT int xmp_load_module_from_file (xmp_context, void *, long); + +/* External sample mixer API */ +EXPORT int xmp_start_smix (xmp_context, int, int); +EXPORT void xmp_end_smix (xmp_context); +EXPORT int xmp_smix_play_instrument(xmp_context, int, int, int, int); +EXPORT int xmp_smix_play_sample (xmp_context, int, int, int, int); +EXPORT int xmp_smix_channel_pan (xmp_context, int, int); +EXPORT int xmp_smix_load_sample (xmp_context, int, char *); +EXPORT int xmp_smix_release_sample (xmp_context, int); + +#ifdef __cplusplus +} +#endif + +#endif /* XMP_H */ diff --git a/libs/lib/libFLAC.a b/libs/lib/libFLAC.a new file mode 100644 index 0000000000000000000000000000000000000000..4192c3641e7ee91c0a7a0723e85964878ae6163e GIT binary patch literal 445416 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 z
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

>^5kmHy7JvD@a?xB@AN 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 cCQln+a literal 0 HcmV?d00001 diff --git a/libs/lib/libintrafont.a b/libs/lib/libintrafont.a new file mode 100644 index 0000000000000000000000000000000000000000..80dc933e1ea5e06c6ee626ffcac717fab8388019 GIT binary patch literal 38914 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 AVgLXD literal 0 HcmV?d00001 diff --git a/libs/lib/libmpg123.a b/libs/lib/libmpg123.a new file mode 100644 index 0000000000000000000000000000000000000000..169a3c9503ab282bc23fb8bf64dde13fc25197ed GIT binary patch literal 335788 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≫&qEY_;5A#`!fR-)YE( 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 ln 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

y1o8ps%AaAaOaxt}g02q1UwtU(>g@~- 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 EKQABgRR910 literal 0 HcmV?d00001 diff --git a/libs/lib/libopus.a b/libs/lib/libopus.a new file mode 100644 index 0000000000000000000000000000000000000000..d7f34a4c8d093f0b7499a7fe8886eb96f2ab55e2 GIT binary patch literal 2942040 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

  • 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%0DLZ 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∓<@a$w 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%0D%(aYXqIr4BK>>15NQ#L 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

    R3U8>K+8Q3|BaGx={-f>gt9Y^E6^b_~ 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

    QvvyyKu+*HZmz?&ff|=X_U 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 A&j0`b literal 0 HcmV?d00001 diff --git a/libs/lib/libopusfile.a b/libs/lib/libopusfile.a new file mode 100644 index 0000000000000000000000000000000000000000..0d694deb923413152052ddf8ee0757d0bcfc2e81 GIT binary patch literal 244268 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æZUJ# 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

    !s0yLEoy>)Zis6tLE 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

    ;inzxIVy9;=Mk)<;b-hQqOGGfJnT zv?J#IYAlR!RZByqd6Ob+k_$0xo$6g`;b?udxjNcVxx%q8uVadkagz*?FaJyoz$QDf zXr;~X3R41@7m&M#h%*}_HGzt#tBv8+jcAuHJew;d6gXwFD$7O&Ko{^ zblz~(-U*cx3i5_mEv=2!R@Bzj##fwBQ;Rvnyhx8>vuxNb88M>w8bW!eX>5+0(Zh5RW)f*-Qf);k)!`WW8;2V7W$zt_Tnr&HlMYkr z6)3#A#tIBg$(@ynSrKJBFw3X5KG)LF5{pJ07ABkXG6cOejz)yUl`m&U4A+e*W=isrTZb_oxOcd(z?K^veX%EYgJrr~}5^D_OC65s%AMet{f5hBw zI5iEoisg(k5w8ptAAL~%s^Wz=!{2xEu*5!f4nW5rMKD>!= zPn%nA#OTj+%gtIxw}r6hXC>^mfyJ3wrJH;k{OjG4)<9FIOlQ~2uk1o?C6% z+j!*POUDk_^R!QCW>#@)U_LXj$>)zC45T0C&WPBG`gnN-i1ub!;~h0e>%RLo?dB+^ z-l|4t#DDc#ZG>Q7h;9AoUD*{C&C#Xa+pp1^9lZP6b6DQ~)!CkEbMT#)Y5&mcvXcU} zZ`fvb|C`TIaD-~d2Ht+y7LvD$*sqvRZ~W)QD(^FFEVkV6h_kuIKi%>4&p>HZh54-U z0+420{2YTX-Tx~N2J zB3`;%n?)b?%3ca!oQ2Y-o==k79?B-dM?B3yKW8Pmsc!AsxGI8F|)JP-8?GwuIx zB{dy{=Q_BcocOqiEx8O`^t65nTgIR2pqnQ?E?V;Bgra>XXHGkv?wr|9XE^7y)0w!# ztL@{WC9G+a2(PPiO*@_KY;324=4Kkt$VKY!^#thRmnKgp>45X`VYUZ;IA{7%9&hNF zZJ+vYpf`U~C)XM4;ZuCQIh6K1UFLmg&)ccJIhFQVNfkhQ-s9xWtF-Ue!F~wzFf@oV zxTXE54)(k$z?(O_!M>=2{j?7H6liZArTf!5*z>-8Zyu$6Z3p{vp?9F+wIV&VzpR73 z^W9nUznL8WtBFxFrZ){**^S&7TUtOmWsr?+{rn*oMl&l%YN)-z4*?j&iuqO%O}=j~v)QM2nvZ?~c) zChBNB>L-A?geT$y7?dI;=8U~0CT*U&4IGJ^ut-ey+d#fAlebHyfZL^aNbi(>QTjFN zJY06A2195Yf&Q3-L59-@WH|ZK_}Q1y1=5Am6RF|9h#HK8xGlq3MRWLHLvwJQbgT4D z()=|D?YB_F|6SDJJ}@u{r?P1d`!8t@IsvN#Ahr3S0+=P8EBijuoO1jaEX}xpe;kYX z`*akoA&S)T!+$?A9dokGG0YqL1IGRVrX7M7C?Tq#}i!X_9 ziEK}_=iPf`rr28?A|5N&iChcO{T1Sk;vM3H;#1-uME>4}{{AU`C8px?0L^i)kKq6j z_ly{gTPqAt5ziFOuc6>?x%B1Y4dNZ*6XF@@0F0+v$B(NAa-O z8GVWFdy7Yl3gKjdqLs;Md>$X|GxC+BGblnrjqz}m(GAU6rKIzA$Uld;^5&j3VKPa7rg*MaQgM?W>=|R$?rN>E6 zkzPn5yp=M)T>3WI-!J}3_D@N_D*bm7{>^(s5iicf7@bcdJx7x;FO;4jT`awjg#SjF zpC^5V^mQb{xmo&`vVTI_yiXMV-;jQXg!}iU&3i?mzmVp;GHIVmB3->m_#Z7jMVu|3 zDOQVXNVva|L^zwpUx?dfzk@_Od0FOfiF;(ePx@o=a}we9!6KgN$`gl(!^A>yym*p0 zMVu+l78i+&#fVrVHi>a@rMODO@M@k%4{6f39%*Dcxfk`L?zxYo&X*n{&GS06A1^&e odcJg-bVPck^eX9xq#u#qExlLzkTkXow%ka>mnS_@x=8x}1EEKljQ{`u literal 0 HcmV?d00001 diff --git a/libs/lib/libpspkubridge.a b/libs/lib/libpspkubridge.a new file mode 100644 index 0000000000000000000000000000000000000000..89d64d09107abaa4b118b757cbcada677902158d GIT binary patch literal 17186 zcmeI4O>7%Q6o6miq$Po(B&yU(m0*LQAOwz`*p8#})1+-s6eqPvt5hY_UfYvo@y|x< zO^K0E5l0TF;(!oRL{%=8Dgg(C5J$wJCsdU)H%=T7Ck~u=Z+B-syRl=ZTGMWJr+qu~ z-i&8wrt{70&dzlFHCZcezA-!@IbA%Nn2yJiGx3-t;a_y(Rgw}(QOqw6A^%5Jy|$XMprIfHQvqy!lBk zSJ$@-xvE;)uCUzVM(YiiYzYLPY0skL=w!?wP~^viXoW!QCAv5hNCKVQ<8SXI>;Sxwbh zQCHNO9gV-iLJR2^igIz2E!3{d6{RHWY_`(OE6Z5(rt5$c^ zfM{LUOn;Mybhe{I6kAk=XrW$*sKz#w+PaDXm8{Wvk-g38N{Q7loyIEBic-LQwhQ77 z_79)JXsRD}VZ)jAvJ~{pG6Rfbn9@b8D0e#EMlWJKwMeIQuV5Oy=a!WnP<|)5fE$?p4>&Sw#T@F zegyyE&}F*_48mz!qxd5bbLaywgF0^;9Pwa9h#$rD?+Lom?$N!yvPEaKJEGlZ9YZ1Z z@aAafh!M?fhZVPx2^>1>x~%EEDE(OAr%>s~Mx`>5&p9LJ<6SVHPBlmTPR!rIdmMy$ z?avo7B*=7Iwp&t-1S8Tb2(Z=4P0p8<60d$o{|uEEr4!SfecmtIF+GlXb;C6EHN58* zdWLJq^c2R5`-S1>M1 z2`oo>kQ4JFJ&zgRM86Z$e`C4={lIcOKdy6Mv_A~f63+hy74;>3F3uYwl)rsvAaoICrj|z4|Fh$f&oB`eE)Y3NQwYQSrUr zXazTyiAT(3?)=;dl90>baVfre1dvO6ZH>TmbD0#mObaVZ<|>o1zLZYlB9q}duP+_+ znf9CSf6tSITzbo8)(6kDd1Iz9F9GAyUf!nKyO~UN!(=MaGbWcm{_#7KkV$Wuyy62U zS#X)8XV~T!CaWFXY)*H@X7AQ!fBWI?ZIX~pZ`t(2`(=QiV;$dlTg{p2Zn*5>+U(u2 zZ+{^Px%8IHaBY^pkqm+)%*&6_HGB@A1VbZbh=MgY@V|B4i5;7S)Ch@q8?L_u$BL+nKA!5=x0%O+HJx@CJ{Ip}T zhu<+bMkg0ZLMFXs(huJ;HwE}a_5|}`Wpd9sG^(?kO~<~Uc5EKtT-ibQ{p|jezey6Z z=`EWXAFTV(**5M1#-?!;lJ9gjVnD}Q>uvPKf}=q-9N6>|UP7eCO)@`y?To-m>Y3JwE|Hk170*2<8AqT>c095e5YS literal 0 HcmV?d00001 diff --git a/libs/lib/libpspsystemctrl_kernel.a b/libs/lib/libpspsystemctrl_kernel.a new file mode 100644 index 0000000000000000000000000000000000000000..dc18b956195416620da1e1542da16fe25458544f GIT binary patch literal 57410 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 literal 0 HcmV?d00001 diff --git a/libs/lib/libpspsystemctrl_user.a b/libs/lib/libpspsystemctrl_user.a new file mode 100644 index 0000000000000000000000000000000000000000..0d8323d3473724f4433f0892850557a12ed0b170 GIT binary patch literal 46494 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 ZX_-sUyjvmK6W^nL+=)VsjSmu={{wOgc!2-_ literal 0 HcmV?d00001 diff --git a/libs/lib/libpspumd_kernel.a b/libs/lib/libpspumd_kernel.a new file mode 100644 index 0000000000000000000000000000000000000000..1cfd7951ca9413c77cb074a0a7fb0c1d79059c4d GIT binary patch literal 35244 zcmeI5U5wmT6@brXHz7@mnv{rE5Wxhslt^VVvpYYwS_=DCOQq@vuMTr2xIkxZE z$75%=$YybK?&{3-z4l(;d*^=l=iFn@p4*LHYvGP<`wHBZ%X+C)(e=`Jp-^&9g+B|0 za;fA+6i#jffSUluZUxv{0@!{D;JU{EJ~jhz1D^WC1%OYr0Y0-E;O18W_C5~q`8xs1 zc&>uyw37h0UkmWX=K-d_3vl2|0C&9yaQF#;qelRaZw0vTIe-UN0gMtr`x3yy_W?Q@ z!16l)_KyG_!t}n5|MSf!0nXz8JPM75?ev?C?sB`|F&lQvJl1W4=gpbUq-|UCOJ;kv zW6b-p2TW(CXPq|Z9K-3`e&kVe-m)FDckIy2w9)BI8Lh?0naP%8oi-eE==4g*XqiWP z%L`W1a)Nstv(4WA)8>*xw>}uk(p=wOF_+p$O}pPU4=uM%|9_4xsZ3xFF&_t)PAw1J z%*$os1t$zEDBSc^qzFe%H?NUIF|qx<-f}NeA6~J{UUyKaMyXz%E$=Tylbtb*___&7 zlz0h!8Kz^lsK6>;gUXujm_~2-yK2m86V>sF`h;IRR_NdhSi7DRzS3!9sbzNJQe|-` zEN9_ft84cBTViV)uE$1YYI3|fTbcAPQn&PjK@Ek<@1JYbs(Mwc&({5LP=|iR^n%%1 zJY=@5e%Ft|EW}h-wNle(rYBT7Smg;+SaypV9g^l!)Ijn}#bxX;{60df>TZ89Q7BZ) z_(6R`tx_oz^qS^(Dkrx+vj6Vck&zKlZUnYM5CTBJVWjlq9ToS2&%t&)eHdvw)mHMWeWa>@=R_I3SBo!0d&#pRQ=q7=cqQ;x(+*Fy5|ad zuA}sB^pDA-`%;=!-`|8jxw}!Y10Fb)ze5;9*Q@KkipRSKS9$4C@F2=Hq4*1!QMxb1 zQ5{fvl>eP5stkAt9h4Jv;5${`@IC3&8O*>1^l6~^2nwaQ1BKELr*|s`&SIQ$Dm@ie zemH&j|;(Rg`CSH#FVXC|9sV0ZHzEU$>18c>!M`UzT zOSj&HHx76mXS~*M_KxH9(3qViuRq)N^mQb{Yy7zUVdizwXMwyhm!W7D|6%8qRyd*M zrdti1*9p#RIf>Wx&#|APy8i%k?3aIE+Cd_`rpxO}4#wBPlI>3s;Z-8Slshj+vMI^x`F>*5wIMl$2}Hs_yTCJ}Da<@QVtxP4f-^|o>R-JHNY zght(nNl+}mI_I~VH11}nmpcCQ@7zNo{HDuq9`sTV3BQbArI$*gmyNw;ZfjLTL}Ta7 z8S15e^;_pFB*JdG?22A0e|jlq>xrhcRrJOA(>W=9aqy@ww`Anw zEVqlQCpX z`OSm=*p_)RnK{eld^Dz?PHCE1-^Ighv!Lz+jO~=y`TKei39y{{97#e9GTlhX^GDYWcN(`xBhVUrzFB|y6omb z2PN-};$v>y8>4Be%$enOQS`csSUbiH=gEuLp1(*U%%;n19_Goi-@}<@>)PO5?(Pbg zbIWa{v_yNx?B0KT%}p;{BoS`YFOI&cJgRr%wojy9iq$)1IL6NJefxD1 z;Wk}vWj>t4`S9Rp{k#s1jjTi$;t5+YZ^D@RV+v4C!o;X&y-IJbZ zrea{Ug0RY14gVT0RSh3kxvi6)wD+3fJD+~BdjGp5!fLv#${tSs z=D?BPsdjrZ&MUWX(i8Vwvm0CAf1&y}65%ynUS-XiKVBPypOE(^9h_BW*W|u#B3{3g zoqa@Sao77K!fLv#=3#7=--qV*5orHEY1`KPlG&c^7~YDW^UCa*^itA3PKNs6i_iSz eGKuh-F0XkQTV>rk#OsV@w+=3y@_uQISp5%E9LQJz literal 0 HcmV?d00001 diff --git a/libs/lib/libpspusbdevice.a b/libs/lib/libpspusbdevice.a new file mode 100644 index 0000000000000000000000000000000000000000..1a3dacf72b76d35e3520054405dec39423d9c48b GIT binary patch literal 3250 zcmeHK-D(q25T2N(wo#!iUWndoZ~Ot-?51gGP((qiLKU%!-sN{|7uqIdHxf}0!AI}` z#49faU&0H)8*h9JeF6Qx-JRrYnzm7TBRcKbIWuQ=&dg-KX}Wm1-feDP$rr3Nx$a82 z>=c)Zj%DE&WIipc5{uB+@*ie&Fcxuj>cym?jC0om=sE~Pt8S)?*w7-Sgx)QY$j%W@rO z$+DJRJh(5HaBrnjOfIkGU*1?-&15ntOiUS>k)b5=8S0GlZmtv^pO<4e-;c~(Xg3uZ z&tA=$FWJGf?XcbuI|#cm-_%{`^+T~+^{_5>BM8LqdQbeFjW#xIYVDxu-S+~&uuRvegl4b4fBHi_h)d-9H$erIJea{7DhJtJgbnWOM9%P_ zzf&rJ^IrN~PWTaU(i+yuXcs>;zB>?UuXZ);$JyP6eilpV69VPE)UgKi$N1;5GzV-Y z#CpU{LYl96Cy!nufDhn=*HJ9`o5P}i(_aa~8|akOpUTQjeHIzgr&1Q#o=^cii=Ty* zoRhODd0L#5JS7!Fo|5lBZ$Z|YVlv2vaXyaFANy_nJLG2U9Bu>s@|Q=mR8ioE#qn<0LN>-303~)7ijjIc_$rRLY6{!L#8# z?)aVAVCBAja#Q#|21Lc7IIzXOOemD#6`Yl8;8C`-Idy73!D#dK@)E?0JpuIb4 zr~SEzHz&b8`w@3`^dkBjhx;Yy&G?9W`d8BU3Q(AM?jumzQO7w;JIdFv=uhXv1MJlY zwuAjB?jPgq9t{$r50dGNat)5(f**u?4uL*jNJ#yutlZT93GOX*1fIpzV4ak*$aX~q zaN_=^Armi+L}u+4SjpWu->(fPf_WOq=0F&J$zT{q5JaJ*f2SwIZpG0r0*8;?3)wFp jx&CAKaIyR1FTn2e1Q%o`Mh$gJ|Lrqq)+so>eO zc+#8TAEE~@-u(ys3-mX;JIUKLAFcEvI_2%W`Pg|gvu}Q+D>v(YvwbUXn`v_0a;fAv zWw&UWPGr)brdcVAe=Sc$22rL&lJT(4Gxu-~Zec3b@&RqX}6Cqd(m+Vh&K+VZ_U z<&&=4QekXNY1h4u7qk-t*`w*n;S+dyO$@cXepYgR)d5*udy>taVk@xCj+-HenB1*m zrBW!NTdw1*nr6|(gZHI1kYDk(2sdrcA?r2$!gWZI$4b%Aj?qkgQvkH!At*TVihmXOqO4~hj*g8x9G9FKL}1NP(m zm$0M;Y-u0sDQ^;zdi68ebbtgtf%EvC!s2*~SR7xESBCHrIw6TCvT$8*phAu*WT4t} zB7htCTTaP2x|EXV$w|p`RMF%)`uXbtWa$-!?$$I8`-3vFDDEuM&f)`c{><&d05&7+n1ve^w-EW6 z=4{;ffHRJR8)okNH(tPliMTKp5itFLgDnhy@n-1yGT!UMq#xzjwq zI?26Vf$}JL!1okq_9Ol3kgX)k%jB}Kfwc20)ZPq6Yi6c zfojVlfHNL!YBJA@d?4=KGI#Ru{7<`v#~J^zldZ$X@Ha}FWEM%;#ZoexF`GTh;(zk9 oeAW2!nb-eWKG|7*^B2tWYi(}ynbp)0R*3ws&vN=di{U)~2C%T4=l}o! literal 0 HcmV?d00001 diff --git a/libs/lib/libvorbis.a b/libs/lib/libvorbis.a new file mode 100644 index 0000000000000000000000000000000000000000..a0cc0bff7742fadf30a6059825b72477c1ef0dac GIT binary patch literal 235816 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

    ANP(%oP0+O>c6LjJ>HY;g!i=P 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 z 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 Om41o$Th{j#A^bNo89>Vb literal 0 HcmV?d00001 diff --git a/libs/lib/libvorbisfile.a b/libs/lib/libvorbisfile.a new file mode 100644 index 0000000000000000000000000000000000000000..a604e8cec9e9299b7b0371007f8a4defb46a3d19 GIT binary patch literal 33716 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 W$tR$P(t(3vy5jLAH$Wey1OFR1(g2hI literal 0 HcmV?d00001 diff --git a/libs/lib/libxmp-lite.a b/libs/lib/libxmp-lite.a new file mode 100644 index 0000000000000000000000000000000000000000..858656229f348b1ad0087f2ecb5dab39df81fed1 GIT binary patch literal 187010 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 d71R&wV_e?zL9xwlrg>; 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 z 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

    $@tVo0W{!v__1}{S&qYqqE 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%0AW8U;a&qVlrdJyG?d;#?EnFiRKFEp?> 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ΞIz8)Vohl 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 )aI)8OUCEi} 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