From ef5a0e678c1c4f9c38ff590dc4c06f8827d99b5f Mon Sep 17 00:00:00 2001 From: David Madl Date: Mon, 2 Mar 2026 09:42:44 +0100 Subject: [PATCH] jni: add libmpg123 --- app/build.gradle | 7 + app/src/main/cpp/CMakeLists.txt | 14 + app/src/main/cpp/jni_bridge.cpp | 16 + app/src/main/cpp/mp3file.cpp | 93 + app/src/main/cpp/mp3file.h | 30 + .../java/at/lockstep/pb/PlaybackEngine.java | 6 + app/src/main/lib/mpg123/build.sh | 20 + app/src/main/lib/mpg123/build_64.sh | 24 + app/src/main/lib/mpg123/build_win.sh | 23 + .../lib/mpg123/lib/arm64-v8a/include/fmt123.h | 135 + .../lib/mpg123/lib/arm64-v8a/include/mpg123.h | 1441 ++++++++++ .../lib/mpg123/lib/arm64-v8a/libmpg123.so | Bin 0 -> 212800 bytes .../mpg123/lib/armeabi-v7a/include/fmt123.h | 135 + .../mpg123/lib/armeabi-v7a/include/mpg123.h | 1441 ++++++++++ .../lib/mpg123/lib/armeabi-v7a/libmpg123.so | Bin 0 -> 277884 bytes .../lib/mpg123/lib/x86_64/include/fmt123.h | 159 ++ .../lib/mpg123/lib/x86_64/include/mpg123.h | 2356 +++++++++++++++++ .../lib/mpg123/lib/x86_64/include/out123.h | 751 ++++++ .../lib/mpg123/lib/x86_64/include/syn123.h | 1211 +++++++++ .../main/lib/mpg123/lib/x86_64/libmpg123.so | Bin 0 -> 337496 bytes 20 files changed, 7862 insertions(+) create mode 100644 app/src/main/cpp/jni_bridge.cpp create mode 100644 app/src/main/cpp/mp3file.cpp create mode 100644 app/src/main/cpp/mp3file.h create mode 100644 app/src/main/lib/mpg123/build.sh create mode 100644 app/src/main/lib/mpg123/build_64.sh create mode 100644 app/src/main/lib/mpg123/build_win.sh create mode 100644 app/src/main/lib/mpg123/lib/arm64-v8a/include/fmt123.h create mode 100644 app/src/main/lib/mpg123/lib/arm64-v8a/include/mpg123.h create mode 100644 app/src/main/lib/mpg123/lib/arm64-v8a/libmpg123.so create mode 100644 app/src/main/lib/mpg123/lib/armeabi-v7a/include/fmt123.h create mode 100644 app/src/main/lib/mpg123/lib/armeabi-v7a/include/mpg123.h create mode 100644 app/src/main/lib/mpg123/lib/armeabi-v7a/libmpg123.so create mode 100644 app/src/main/lib/mpg123/lib/x86_64/include/fmt123.h create mode 100644 app/src/main/lib/mpg123/lib/x86_64/include/mpg123.h create mode 100644 app/src/main/lib/mpg123/lib/x86_64/include/out123.h create mode 100644 app/src/main/lib/mpg123/lib/x86_64/include/syn123.h create mode 100644 app/src/main/lib/mpg123/lib/x86_64/libmpg123.so diff --git a/app/build.gradle b/app/build.gradle index f1e8103..745bbb2 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -23,6 +23,13 @@ android { //path 'src/main/cpp/CMakeLists.txt' cppFlags '' arguments "-DANDROID_STL=c++_shared" + + //cppFlags "-std=c++14" + //arguments '-DANDROID_STL=c++_static' + + // armeabi and mips are deprecated in NDK r16 so we don't want to build for them + // TODO: android manifest filters to include only these hardware archs + abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86_64' //, 'x86', 'x86_64' } } } diff --git a/app/src/main/cpp/CMakeLists.txt b/app/src/main/cpp/CMakeLists.txt index e11ba6a..75c2999 100644 --- a/app/src/main/cpp/CMakeLists.txt +++ b/app/src/main/cpp/CMakeLists.txt @@ -29,6 +29,8 @@ add_library(${CMAKE_PROJECT_NAME} SHARED # List C/C++ source files with relative paths to this CMakeLists.txt. lockstep.cpp PlaybackEngine.cpp + mp3file.cpp + jni_bridge.cpp ) find_package (oboe REQUIRED CONFIG) @@ -36,13 +38,25 @@ find_package (oboe REQUIRED CONFIG) add_library(ndk-logger SHARED logging.cpp logging_jni.cpp) target_link_libraries(ndk-logger log) +# Add pre-built libmpg123 library +add_library(mpg123 SHARED IMPORTED) +set(mpg123_DIR ${CMAKE_SOURCE_DIR}/../lib/mpg123) +set_target_properties(mpg123 PROPERTIES IMPORTED_LOCATION + ${mpg123_DIR}/lib/${ANDROID_ABI}/libmpg123.so) +include_directories(${mpg123_DIR}/lib/${ANDROID_ABI}/include) + # Specifies libraries CMake should link to your target library. You # can link libraries from various origins, such as libraries defined in this # build script, prebuilt third-party libraries, or Android system libraries. target_link_libraries(${CMAKE_PROJECT_NAME} # List libraries link to the target library oboe::oboe + mpg123 android log ndk-logger ) + +# Enable optimization flags: if having problems with source level debugging, +# disable -Ofast ( and debug ), re-enable after done debugging. +target_compile_options(${CMAKE_PROJECT_NAME} PRIVATE -Wall -Werror "$<$:-Ofast>") diff --git a/app/src/main/cpp/jni_bridge.cpp b/app/src/main/cpp/jni_bridge.cpp new file mode 100644 index 0000000..8462477 --- /dev/null +++ b/app/src/main/cpp/jni_bridge.cpp @@ -0,0 +1,16 @@ +// +// Created by david on 02.03.2026. +// + +#include +#include "mpg123.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_at_lockstep_pb_PlaybackEngine_native_1mpg123_1init + (JNIEnv *env, jclass) { + return mpg123_init(); +} + +} \ No newline at end of file diff --git a/app/src/main/cpp/mp3file.cpp b/app/src/main/cpp/mp3file.cpp new file mode 100644 index 0000000..c7273b0 --- /dev/null +++ b/app/src/main/cpp/mp3file.cpp @@ -0,0 +1,93 @@ +// +// Created by david on 17.05.20. +// + +#define LOG_TAG "mp3file" + +#include "mp3file.h" +#include +#include +#include "logging.h" + +MP3File* mp3file_init(mpg123_handle *handle) { + MP3File* mp3file = (MP3File *) malloc(sizeof(MP3File)); + if(mp3file == NULL) return NULL; + memset(mp3file, 0, sizeof(MP3File)); + mp3file->handle = handle; + return mp3file; +} + +void mp3file_delete(MP3File *mp3file) { + if(mp3file == NULL) return; + mpg123_close(mp3file->handle); + mpg123_delete(mp3file->handle); + if(mp3file->buffer) { + free(mp3file->buffer); + mp3file->buffer = 0; + } + free(mp3file); +} + +MP3File* mp3file_open(const char *filename, int forceEncoding) { + const char *errorText = ""; +#define handleError(text) \ + do { \ + errorText = text; \ + goto on_error; \ + } while(0) + + int err = MPG123_OK; + mpg123_handle *mh = mpg123_new(NULL, &err); + if(err != MPG123_OK || mh == NULL) { + LOGE("mpg123_new() failed: %s", mpg123_plain_strerror(err)); + return NULL; + } + + MP3File* mp3 = mp3file_init(mh); + if(mp3 == NULL) handleError("malloc() failed"); + err = mpg123_open(mh, filename); + if(err != MPG123_OK) handleError("mpg123_open()"); + + int encoding; + err = mpg123_getformat(mh, &mp3->rate, &mp3->channels, &encoding); + if(err != MPG123_OK) handleError("mpg123_getformat()"); + if(encoding != MPG123_ENC_SIGNED_16) handleError("unknown file encoding"); + + if(forceEncoding != 0) { + encoding = forceEncoding; + } + + // Ensure that this output format will not change + // (it could, when we allow it). + mpg123_format_none(mh); + err = mpg123_format(mh, mp3->rate, mp3->channels, encoding); + if(err != MPG123_OK) handleError("could not set mpg123_format()"); + + mp3->buffer_size = mpg123_outblock(mh); + mp3->buffer = (unsigned char*) malloc(mp3->buffer_size); + if(mp3->buffer == NULL) handleError("malloc() failed"); + + mp3->num_samples = mpg123_length(mh); + mp3->samples_per_frame = mpg123_spf(mh); + mp3->secs_per_frame = mpg123_tpf(mh); + + if (mp3->num_samples == MPG123_ERR || mp3->samples_per_frame < 0) + mp3->num_frames = 0; + else + mp3->num_frames = mp3->num_samples / mp3->samples_per_frame; + + if (mp3->num_samples == MPG123_ERR || mp3->samples_per_frame < 0 || mp3->secs_per_frame < 0) + mp3->duration = 0; + else + mp3->duration = mp3->num_samples / mp3->samples_per_frame * mp3->secs_per_frame; + + LOGV("channels: %d rate: %ld num_samples: %ld", mp3->channels, mp3->rate, mp3->num_samples); + return mp3; + +on_error: + LOGE("%s, err = %s", errorText, mpg123_plain_strerror(err)); + mp3file_delete(mp3); + return NULL; + +#undef handleError +} diff --git a/app/src/main/cpp/mp3file.h b/app/src/main/cpp/mp3file.h new file mode 100644 index 0000000..b33c50b --- /dev/null +++ b/app/src/main/cpp/mp3file.h @@ -0,0 +1,30 @@ +// +// Created by david on 17.05.20. +// + +#ifndef SAMPLES_MP3FILE_H +#define SAMPLES_MP3FILE_H + +#include "mpg123.h" + +struct MP3File +{ + mpg123_handle* handle; + int channels; + long rate; + long num_samples; + int samples_per_frame; + double secs_per_frame; + long num_frames; + double duration; + size_t buffer_size; + unsigned char* buffer; + size_t leftSamples; + size_t offset; +}; + +MP3File* mp3file_init(mpg123_handle *handle); +void mp3file_delete(MP3File *mp3file); +MP3File* mp3file_open(const char *filename, int forceEncoding = 0); + +#endif //SAMPLES_MP3FILE_H diff --git a/app/src/main/java/at/lockstep/pb/PlaybackEngine.java b/app/src/main/java/at/lockstep/pb/PlaybackEngine.java index 4484940..1f5dcc2 100644 --- a/app/src/main/java/at/lockstep/pb/PlaybackEngine.java +++ b/app/src/main/java/at/lockstep/pb/PlaybackEngine.java @@ -5,9 +5,13 @@ import android.util.Log; public class PlaybackEngine { static long mEngineHandle = 0; + static final int MPG123_OK = 0; static { System.loadLibrary("lockstep-native"); + int ok = native_mpg123_init(); + if(ok != MPG123_OK) + throw new IllegalStateException("mpg123_init() failed"); } public static boolean create(Context context) { @@ -28,4 +32,6 @@ public class PlaybackEngine { private static native long native_createEngine(); private static native void native_deleteEngine(long engineHandle); + + private static native int native_mpg123_init(); } diff --git a/app/src/main/lib/mpg123/build.sh b/app/src/main/lib/mpg123/build.sh new file mode 100644 index 0000000..ea9280a --- /dev/null +++ b/app/src/main/lib/mpg123/build.sh @@ -0,0 +1,20 @@ +export TOOLCHAIN=/opt/android-sdk/ndk-bundle/toolchains/llvm/prebuilt/linux-x86_64 +export TARGET=armv7a-linux-androideabi +export TARGET2=arm-linux-androideabi +export API=21 +export AR=$TOOLCHAIN/bin/$TARGET2-ar +export AS=$TOOLCHAIN/bin/$TARGET2-as +export CC=$TOOLCHAIN/bin/$TARGET$API-clang +export CXX=$TOOLCHAIN/bin/$TARGET$API-clang++ +export LD=$TOOLCHAIN/bin/$TARGET2-ld +export RANLIB=$TOOLCHAIN/bin/$TARGET2-ranlib +export STRIP=$TOOLCHAIN/bin/$TARGET2-strip + +export CFLAGS=-DNOXFERMEM +./configure --host $TARGET --with-audio=dummy --with-cpu=arm_fpu --prefix=$(pwd)/install +make +make install + +# add NOXFERMEM ifdefs to buffer.c and xfermem.c +# see https://android.googlesource.com/platform/external/mpg123/+/refs/heads/master/src/buffer.c + diff --git a/app/src/main/lib/mpg123/build_64.sh b/app/src/main/lib/mpg123/build_64.sh new file mode 100644 index 0000000..8dfcd9d --- /dev/null +++ b/app/src/main/lib/mpg123/build_64.sh @@ -0,0 +1,24 @@ +export TOOLCHAIN2=/opt/android-sdk/ndk-bundle/toolchains/llvm/prebuilt/linux-x86_64/aarch64-linux-android +export TOOLCHAIN=/opt/android-sdk/ndk-bundle/toolchains/llvm/prebuilt/linux-x86_64 +export TARGET=aarch64-linux-android +export TARGET2=arm-linux-androideabi +#export API=28 +export API=21 +export AR=$TOOLCHAIN2/bin/ar +export AS=$TOOLCHAIN2/bin/as +export CC=$TOOLCHAIN/bin/${TARGET}$API-clang +export CXX=$TOOLCHAIN/bin/${TARGET}$API-clang++ +#export CC=$TOOLCHAIN/bin/${TARGET}26-clang +#export CXX=$TOOLCHAIN/bin/${TARGET}28-clang++ +export LD=$TOOLCHAIN2/bin/ld +export RANLIB=$TOOLCHAIN2/bin/ranlib +export STRIP=$TOOLCHAIN2/bin/strip + +export CFLAGS="-DNOXFERMEM -fno-integrated-as" +./configure --host $TARGET --with-audio=dummy --with-cpu=neon64 --prefix=$(pwd)/install_64 +make +make install + +# add NOXFERMEM ifdefs to buffer.c and xfermem.c +# see https://android.googlesource.com/platform/external/mpg123/+/refs/heads/master/src/buffer.c + diff --git a/app/src/main/lib/mpg123/build_win.sh b/app/src/main/lib/mpg123/build_win.sh new file mode 100644 index 0000000..6d40602 --- /dev/null +++ b/app/src/main/lib/mpg123/build_win.sh @@ -0,0 +1,23 @@ +export TOOLCHAIN=/c/Users/david/AppData/Local/Android/Sdk/ndk/26.1.10909125/toolchains/llvm/prebuilt/windows-x86_64 +export TARGET=x86_64-linux-android +export API=21 +# run configure,make,make install -- all from MSYS2 + +export AR=$TOOLCHAIN/bin/llvm-ar +export AS=$TOOLCHAIN/bin/llvm-as +export CC=$TOOLCHAIN/bin/$TARGET$API-clang +export CXX=$TOOLCHAIN/bin/$TARGET$API-clang++ +export LD=$TOOLCHAIN/bin/ld +export RANLIB=$TOOLCHAIN/bin/llvm-ranlib +export STRIP=$TOOLCHAIN/bin/llvm-strip + + + +export CFLAGS=-DNOXFERMEM +./configure --host $TARGET --with-audio=dummy --prefix=$(pwd)/install +make +make install + +# add NOXFERMEM ifdefs to buffer.c and xfermem.c +# see https://android.googlesource.com/platform/external/mpg123/+/refs/heads/master/src/buffer.c + diff --git a/app/src/main/lib/mpg123/lib/arm64-v8a/include/fmt123.h b/app/src/main/lib/mpg123/lib/arm64-v8a/include/fmt123.h new file mode 100644 index 0000000..cc30a06 --- /dev/null +++ b/app/src/main/lib/mpg123/lib/arm64-v8a/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/app/src/main/lib/mpg123/lib/arm64-v8a/include/mpg123.h b/app/src/main/lib/mpg123/lib/arm64-v8a/include/mpg123.h new file mode 100644 index 0000000..99df615 --- /dev/null +++ b/app/src/main/lib/mpg123/lib/arm64-v8a/include/mpg123.h @@ -0,0 +1,1441 @@ +/* + libmpg123: MPEG Audio Decoder library (version 1.25.13) + + 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/app/src/main/lib/mpg123/lib/arm64-v8a/libmpg123.so b/app/src/main/lib/mpg123/lib/arm64-v8a/libmpg123.so new file mode 100644 index 0000000000000000000000000000000000000000..6eab311882b2f64fdc6a66c2b6b2c6eaf85d606d GIT binary patch literal 212800 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 abP=T8=zp|$o5jEP45P2KTX_EU + +/** \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/app/src/main/lib/mpg123/lib/armeabi-v7a/libmpg123.so b/app/src/main/lib/mpg123/lib/armeabi-v7a/libmpg123.so new file mode 100644 index 0000000000000000000000000000000000000000..e7d400a8fdb2878f9dc7b8fd55b1ad75152809f6 GIT binary patch literal 277884 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

G-`5^mHyV?mmk}udMT;?B|r!cOA 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�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 NDe*Ffh{(qKe*xa{p`!o* literal 0 HcmV?d00001 diff --git a/app/src/main/lib/mpg123/lib/x86_64/include/fmt123.h b/app/src/main/lib/mpg123/lib/x86_64/include/fmt123.h new file mode 100644 index 0000000..d7772e1 --- /dev/null +++ b/app/src/main/lib/mpg123/lib/x86_64/include/fmt123.h @@ -0,0 +1,159 @@ +/* + libmpg123: MPEG Audio Decoder library + + separate header just for audio format definitions not tied to + library code + + copyright 1995-2020 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) < 1 \ + ? 0 \ + : ( (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 \ +) ) ) ) ) ) + +/** Representation of zero in differing encodings. + * This exists to define proper silence in various encodings without + * having to link to libsyn123 to do actual conversions at runtime. + * You have to handle big/little endian order yourself, though. + * This takes the shortcut that any signed encoding has a zero with + * all-zero bits. Unsigned linear encodings just have the highest bit set + * (2^(n-1) for n bits), while the nonlinear 8-bit ones are special. + * \param enc the encoding (mpg123_enc_enum value) + * \param siz bytes per sample (return value of MPG123_SAMPLESIZE(enc)) + * \param off byte (octet) offset counted from LSB + * \return unsigned byte value for the designated octet + */ +#define MPG123_ZEROSAMPLE(enc, siz, off) ( \ + (enc) == MPG123_ENC_ULAW_8 \ + ? (off == 0 ? 0xff : 0x00) \ + : ( (enc) == MPG123_ENC_ALAW_8 \ + ? (off == 0 ? 0xd5 : 0x00) \ + : ( (((enc) & (MPG123_ENC_SIGNED|MPG123_ENC_FLOAT)) || (siz) != ((off)+1)) \ + ? 0x00 \ + : 0x80 \ + ) ) ) + +/** 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/app/src/main/lib/mpg123/lib/x86_64/include/mpg123.h b/app/src/main/lib/mpg123/lib/x86_64/include/mpg123.h new file mode 100644 index 0000000..3b390b7 --- /dev/null +++ b/app/src/main/lib/mpg123/lib/x86_64/include/mpg123.h @@ -0,0 +1,2356 @@ +/* + libmpg123: MPEG Audio Decoder library + + copyright 1995-2023 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 "fmt123.h" + +/** \file mpg123.h The header file for the libmpg123 MPEG Audio decoder */ + +/** \defgroup mpg123_h mpg123 header general settings and notes + * @{ + */ + +/** A macro to check at compile time which set of API functions to expect. + * This must be incremented at least each time a new symbol is added + * to the header. + */ +#define MPG123_API_VERSION 49 +/** library patch level at client build time */ +#define MPG123_PATCHLEVEL 4 + +#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 + +/** \page enumapi About enum API + * + * Earlier versions of libmpg123 put enums into public API calls, + * which is not exactly safe. There are ABI rules, but you can use + * compiler switches to change the sizes of enums. It is safer not + * to have them in API calls. Thus, the default is to remap calls and + * structs to variants that use plain ints. Define MPG123_ENUM_API to + * prevent that remapping. + * + * You might want to define this to increase the chance of your binary + * working with an older version of the library. But if that is your goal, + * you should better build with an older version to begin with. + * + * You can avoid renamed symbols by using the non-enum names directly: + * + * - mpg123_param2() + * - mpg123_getparam2() + * - mpg123_feature2() + * - mpg123_eq2() + * - mpg123_geteq2() + * - mpg123_frameinfo2() + * - mpg123_info2() + * - mpg123_getstate2() + * - mpg123_enc_from_id3_2() + * - mpg123_store_utf8_2() + * - mpg123_par2() + * - mpg123_getpar2() + */ +#ifndef MPG123_ENUM_API + +#define mpg123_param mpg123_param2 +#define mpg123_getparam mpg123_getparam2 +#define mpg123_feature mpg123_feature2 +#define mpg123_eq mpg123_eq2 +#define mpg123_geteq mpg123_geteq2 +#define mpg123_frameinfo mpg123_frameinfo2 +#define mpg123_info mpg123_info2 +#define mpg123_getstate mpg123_getstate2 +#define mpg123_enc_from_id3 mpg123_enc_from_id3_2 +#define mpg123_store_utf8 mpg123_store_utf8_2 +#define mpg123_par mpg123_par2 +#define mpg123_getpar mpg123_getpar2 + +#endif + +#include +#include + +#ifndef MPG123_PORTABLE_API +#include +/** A little hack to help MSVC not having ssize_t. */ +#ifdef _MSC_VER +typedef ptrdiff_t mpg123_ssize_t; +#else +typedef ssize_t mpg123_ssize_t; +#endif +#endif + + +/** \page lfs Handling of large file offsets + * + * When client code defines _FILE_OFFSET_BITS, it wants non-default large file + * support, and thus functions with added suffix (mpg123_open_64). The default + * library build provides wrapper and alias functions to accomodate client code + * variations (dual-mode library like glibc). + * + * Client code can definie MPG123_NO_LARGENAME and MPG123_LARGESUFFIX, + * respectively, for disabling or enforcing the suffixes. You should *not* do + * this, though, unless you *really* want to deal with symbol ABI yourself. + * If explicit usage of 64 bit offsets is desired, the int64_t API + * consisting of functions with 64 suffix without underscore, notably + * mpg123_reader64(), can be used since API version 48 (mpg123 1.32). A matching + * mpg123_open64(), stripped-down mpg123_open_handle_64() is present since API + * version 49 (mpg123 1.33). + * + * When in doubt, use the explicit 64 bit functions and avoid off_t in the API. + * You can define MPG123_PORTABLE_API to ensure that. That being said, if you + * and your compiler do not have problems with the concept of off_t, just use + * the normal AP like the I/O API of the standard C library. Both 32 and 64 bit + * versions of functions will be present where appropriate. + * + * If your toolchain enforces _FILE_OFFSET_BITS also during build of libmpg123, + * only that setting will be supported for client code. + */ + +#ifndef MPG123_PORTABLE_API +/** \page lfs_names Renaming of functions for largefile support + * + * 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. These are the affected API functions: + * + * - mpg123_open_fixed() + * - mpg123_open() + * - mpg123_open_fd() + * - mpg123_open_handle() + * - mpg123_framebyframe_decode() + * - mpg123_decode_frame() + * - mpg123_tell() + * - mpg123_tellframe() + * - mpg123_tell_stream() + * - mpg123_seek() + * - mpg123_feedseek() + * - mpg123_seek_frame() + * - mpg123_timeframe() + * - mpg123_index() + * - mpg123_set_index() + * - mpg123_position() + * - mpg123_length() + * - mpg123_framelength() + * - mpg123_set_filesize() + * - mpg123_replace_reader() + * - mpg123_replace_reader_handle() + * - mpg123_framepos() +*/ +#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_fixed MPG123_LARGENAME(mpg123_open_fixed) +#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 + +/** @} */ + +#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; + +/** Get version of the mpg123 distribution this library build came with. + * (optional means non-NULL) + * \param major optional address to store major version number + * \param minor optional address to store minor version number + * \param patch optional address to store patchlevel version number + * \return full version string (like "1.2.3-beta4 (experimental)") + */ +const char *mpg123_distversion(unsigned int *major, unsigned int *minor, unsigned int *patch); + +/** Get API version of library build. + * \param patch optional address to store patchlevel + * \return API version of library + */ +unsigned int mpg123_libversion(unsigned int *patch); + +/** Useless no-op that used to do initialization work. + * + * For API version before 46 (mpg123 1.27.0), you had to ensure to have + * this called once before creating a handle. To be pure, this had to + * happen in a single-threaded context, too (while in practice, there was no + * harm done possibly racing to compute the same numbers again). + * + * Now this function really does nothing anymore. The only reason to call + * it is to be compatible with old versions of the library that still require + * it. + * + * \return MPG123_OK if successful, otherwise an error number. + */ +MPG123_EXPORT int mpg123_init(void); + +/** Superfluous Function to close down the mpg123 library. + * This was created with the thought that there sometime will be cleanup code + * to be run after library use. This never materialized. You can forget about + * this function and it is only here for old programs that do call it. + */ +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); + +/** Free plain memory allocated within libmpg123. + * This is for library users that are not sure to use the same underlying + * memory allocator as libmpg123. It is just a wrapper over free() in + * the underlying C library. + */ +MPG123_EXPORT void mpg123_free(void *ptr); + +/** 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). + Make sure to set this _before_ opening a stream.*/ + 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) */ + ,MPG123_FREEFORMAT_SIZE /**< Tell the parser a free-format frame size to + * avoid read-ahead to get it. A value of -1 (default) means that the parser + * will determine it. The parameter value is applied during decoder setup + * for a freshly opened stream only. + */ +}; + +/** 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. */ + ,MPG123_STORE_RAW_ID3 = 0x80000 /**< Store raw ID3 data (even if skipping). + * Before mpg123 1.33.2 (libmpg123 API 49, patchlevel 4), this has to be combined with + * MPG123_SKIP_ID3 to avoid getting corrupted data due to the ID3 parser inserting + * encoding bytes for its own convenience. + */ + ,MPG123_FORCE_ENDIAN = 0x100000 /**< Enforce endianess of output samples. + * This is not reflected in the format codes. If this flag is set along with + * MPG123_BIG_ENDIAN, MPG123_ENC_SIGNED16 means s16be, without + * MPG123_BIG_ENDIAN, it means s16le. Normal operation without + * MPG123_FORCE_ENDIAN produces output in native byte order. + */ + ,MPG123_BIG_ENDIAN = 0x200000 /**< Choose big endian instead of little. */ + ,MPG123_NO_READAHEAD = 0x400000 /**< Disable read-ahead in parser. If + * you know you provide full frames to the feeder API, this enables + * decoder output from the first one on, instead of having to wait for + * the next frame to confirm that the stream is healthy. It also disables + * free format support unless you provide a frame size using + * MPG123_FREEFORMAT_SIZE. + */ + ,MPG123_FLOAT_FALLBACK = 0x800000 /**< Consider floating point output encoding only after + * trying other (possibly downsampled) rates and encodings first. This is to + * support efficient playback where floating point output is only configured for + * an external resampler, bypassing that resampler when the desired rate can + * be produced directly. This is enabled by default to be closer to older versions + * of libmpg123 which did not enable float automatically at all. If disabled, + * float is considered after the 16 bit default and higher-bit integer encodings + * for any rate. */ + ,MPG123_NO_FRANKENSTEIN = 0x1000000 /**< Disable support for Frankenstein streams + * (different MPEG streams stiched together). Do not accept serious change of MPEG + * header inside a single stream. With this flag, the audio output format cannot + * change during decoding unless you open a new stream. This also stops decoding + * after an announced end of stream (Info header contained a number of frames + * and this number has been reached). This makes your MP3 files behave more like + * ordinary media files with defined structure, rather than stream dumps with + * some sugar. */ +}; + +/** 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. */ +}; + +#ifdef MPG123_ENUM_API +/** Set a specific parameter on a handle. + * + * Note that this name is mapped to mpg123_param2() instead unless + * MPG123_ENUM_API is defined. + * + * \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 ); +#endif + +/** Set a specific parameter on a handle. No enums. + * + * This is actually called instead of mpg123_param() + * unless MPG123_ENUM_API is defined. + * + * \param mh handle + * \param type parameter choice (from enum #mpg123_parms) + * \param value integer value + * \param fvalue floating point value + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_param2( mpg123_handle *mh +, int type, long value, double fvalue ); + +#ifdef MPG123_ENUM_API +/** Get a specific parameter from a handle. + * + * Note that this name is mapped to mpg123_getparam2() instead unless + * MPG123_ENUM_API is defined. + * + * \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 ); +#endif + +/** Get a specific parameter from a handle. No enums. + * + * This is actually called instead of mpg123_getparam() unless MPG123_ENUM_API + * is defined. + * + * \param mh handle + * \param type parameter choice (from enum #mpg123_parms) + * \param value integer value return address + * \param fvalue floating point value return address + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_getparam2( mpg123_handle *mh +, int 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 */ + ,MPG123_FEATURE_MOREINFO /**< more info extraction (for frame analyzer) */ + ,MPG123_FEATURE_OUTPUT_FLOAT32 /**< 32 bit float output */ + ,MPG123_FEATURE_OUTPUT_FLOAT64 /**< 64 bit float output (as of now: never!) */ +}; + +#ifdef MPG123_ENUM_API +/** Query libmpg123 features. + * + * Note that this name is mapped to mpg123_feature2() instead unless + * MPG123_ENUM_API is defined. + * + * \param key feature selection + * \return 1 for success, 0 for unimplemented functions + */ +MPG123_EXPORT int mpg123_feature(const enum mpg123_feature_set key); +#endif + +/** Query libmpg123 features. No enums. + * + * This is actually called instead of mpg123_feature() unless MPG123_ENUM_API + * is defined. + * + * \param key feature selection (from enum #mpg123_feature_set) + * \return 1 for success, 0 for unimplemented functions + */ +MPG123_EXPORT int mpg123_feature2(int 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 or no reader callback setup. */ + 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. */ + ,MPG123_BAD_FLOAT /**< Floating-point computations work not as expected. */ +}; + +/** 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. + * + * This possibly writes to static storage in the library, so avoid + * calling concurrently, please. + * + * \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. + * If you do feel confused and just want to decode your normal MPEG audio files that + * don't alter properties in the middle, just use mpg123_open_fixed() with a fixed encoding + * and channel count and forget about a matrix of audio formats. If you want to get funky, + * read ahead ... + * + * 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. + * This list is in ascending order. + * \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 ); + +/** Set the audio format support of a mpg123_handle in detail: + * \param mh handle + * \param rate The sample rate value (in Hertz). Special value 0 means + * all rates (the reason for this variant of mpg123_format()). + * \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_format2( 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!). + * @{ + */ + +#ifndef MPG123_PORTABLE_API +/** Open a simple MPEG file with fixed properties. + * + * This function shall simplify the common use case of a plain MPEG + * file on disk that you want to decode, with one fixed sample + * rate and channel count, and usually a length defined by a Lame/Info/Xing + * tag. It will: + * + * - set the MPG123_NO_FRANKENSTEIN flag + * - set up format support according to given parameters, + * - open the file, + * - query audio format, + * - fix the audio format support table to ensure the format stays the same, + * - call mpg123_scan() if there is no header frame to tell the track length. + * + * From that on, you can call mpg123_getformat() for querying the sample + * rate (and channel count in case you allowed both) and mpg123_length() + * to get a pretty safe number for the duration. + * Only the sample rate is left open as that indeed is a fixed property of + * MPEG files. You could set MPG123_FORCE_RATE beforehand, but that may trigger + * low-quality resampling in the decoder, only do so if in dire need. + * The library will convert mono files to stereo for you, and vice versa. + * If any constraint cannot be satisified (most likely because of a non-default + * build of libmpg123), you get MPG123_ERR returned and can query the detailed + * cause from the handle. Only on MPG123_OK there will an open file that you + * then close using mpg123_close(), or implicitly on mpg123_delete() or the next + * call to open another file. + * + * So, for your usual CD rip collection, you could use + * + * mpg123_open_fixed(mh, path, MPG123_STEREO, MPG123_ENC_SIGNED_16) + * + * and be happy calling mpg123_getformat() to verify 44100 Hz rate, then just + * playing away with mpg123_read(). The occasional mono file, or MP2 file, + * will also be decoded without you really noticing. Just the speed could be + * wrong if you do not care about sample rate at all. + * \param mh handle + * \param path filesystem path (see mpg123_open()) + * \param channels allowed channel count, either 1 (MPG123_MONO) or + * 2 (MPG123_STEREO), or bitwise or of them, but then you're halfway back to + * calling mpg123_format() again;-) + * \param encoding a definite encoding from enum mpg123_enc_enum + * or a bitmask like for mpg123_format(), defeating the purpose somewhat + */ +MPG123_EXPORT int mpg123_open_fixed(mpg123_handle *mh, const char *path +, int channels, int encoding); + +/** 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(). + * + * The path parameter usually is just a string that is handed to the underlying + * OS routine for opening, treated as a blob of binary data. On platforms + * where encoding needs to be involved, something like _wopen() is called + * underneath and the path argument to libmpg123 is assumed to be encoded in UTF-8. + * So, if you have to ask yourself which encoding is needed, the answer is + * UTF-8, which also fits any sane modern install of Unix-like systems. + * + * \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() or mpg123_reader64()! + * mpg123_close() will call the cleanup callback for your non-NULL + * handle (if you gave one). + * Note that this used to be usable with MPG123_PORTABLE_API defined in + * mpg123 1.32.x and was in fact the only entry point for handle I/O. + * Since mpg123 1.33.0 and API version 49, there is + * mpg123_open_handle64() for the portable case and has to be used + * instead of this function here, even if it _would_ work just fine, + * the inclusion of a largefile-renamed symbol in the portable set was wrong. + * + * \param mh handle + * \param iohandle your handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_open_handle(mpg123_handle *mh, void *iohandle); +#endif + +/** Open and prepare to decode the specified file by filesystem path. + * This works exactly like mpg123_open() in modern libmpg123, see there + * for more description. This name is not subject to largefile symbol renaming. + * You can also use it with MPG123_PORTABLE_API. + * + * \param mh handle + * \param path filesystem path of your resource + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_open64(mpg123_handle *mh, const char *path); + +/** Open a simple MPEG file with fixed properties. + * This is the same as mpg123_open_fixed(), just with a stable + * symbol name for int64_t portable API. + * + * \param mh handle + * \param path filesystem path (see mpg123_open()) + * \param channels allowed channel count, either 1 (MPG123_MONO) or + * 2 (MPG123_STEREO), or bitwise or of them, but then you're halfway back to + * calling mpg123_format() again;-) + * \param encoding a definite encoding from enum mpg123_enc_enum + * or a bitmask like for mpg123_format(), defeating the purpose somewhat + */ +MPG123_EXPORT int mpg123_open_fixed64(mpg123_handle *mh, const char *path +, int channels, int encoding); + +/** Use an opaque handle as bitstream input. This works only with the + * replaced I/O from mpg123_reader64()! + * mpg123_close() will call the cleanup callback for your non-NULL + * handle (if you gave one). + * This is a simplified variant of mpg123_open_handle() that only + * supports the int64_t API, available with MPG123_PORTABLE_API. + * + * \param mh handle + * \param iohandle your handle + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_open_handle64(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. + * Also, you are expected to handle ICY metadata extraction yourself. This + * input method does not handle MPG123_ICY_INTERVAL. It does parse ID3 frames, though. + * \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. + * + * Note: The type of outmemory changed to a void pointer in mpg123 1.26.0 + * (API version 45). + * + * \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 +, void *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. + * + * Note: The type of outmemory changed to a void pointer in mpg123 1.26.0 + * (API version 45). + * + * \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 +, void *outmemory, size_t outmemsize, size_t *done ); + +#ifndef MPG123_PORTABLE_API +/** 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 ); +#endif /* un-portable API */ + +/** 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_frame64( mpg123_handle *mh +, int64_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_decode64( mpg123_handle *mh +, int64_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 ); + +#ifndef MPG123_PORTABLE_API +/** 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); +#endif + +/** Get the 64 bit 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 int64_t mpg123_framepos64(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. The term sample refers to a group of samples for + * multiple channels, normally dubbed PCM frames. The latter term is + * avoided here because frame means something different in the context of MPEG + * audio. Since all samples of a PCM frame occur at the same time, there is only + * very limited ambiguity when talking about playback offset, as counting each + * channel sample individually does not make sense. + * + * 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 + * + * Since API version 48 (mpg123 1.32), the offset given with SEEK_END is always + * taken to be negative in the terms of standard lseek(). You can only seek from + * the end towards the beginning. All earlier versions had the sign wrong, positive + * was towards the beginning, negative past the end (which results in error, + * anyway). + * + * 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;-) + * + * Streams may be openend in ways that do not support seeking. Also, consider + * the effect of #MPG123_FUZZY. + * + * @{ + */ + +#ifndef MPG123_PORTABLE_API +/** Returns the current position in samples. + * On the next successful read, you'd get audio data with that offset. + * \param mh handle + * \return sample (PCM frame) offset or MPG123_ERR (null handle) + */ +MPG123_EXPORT off_t mpg123_tell(mpg123_handle *mh); +#endif + +/** Returns the current 64 bit position in samples. + * On the next successful read, you'd get audio data with that offset. + * \param mh handle + * \return sample (PCM frame) offset or MPG123_ERR (null handle) + */ +MPG123_EXPORT int64_t mpg123_tell64(mpg123_handle *mh); + +#ifndef MPG123_PORTABLE_API +/** 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); +#endif + +/** Returns the 64 bit frame number that the next read will give you data from. + * \param mh handle + * \return frame offset or MPG123_ERR (null handle) + */ +MPG123_EXPORT int64_t mpg123_tellframe64(mpg123_handle *mh); + +#ifndef MPG123_PORTABLE_API +/** 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); +#endif + +/** Returns the current 64 bit byte offset in the input stream. + * \param mh handle + * \return byte offset or MPG123_ERR (null handle) + */ +MPG123_EXPORT int64_t mpg123_tell_stream64(mpg123_handle *mh); + + +#ifndef MPG123_PORTABLE_API +/** Seek to a desired sample offset. + * Usage is modelled afer the standard lseek(). + * \param mh handle + * \param sampleoff offset in samples (PCM frames) + * \param whence one of SEEK_SET, SEEK_CUR or SEEK_END + * (Offset for SEEK_END is always effectively negative since API + * version 48, was inverted from lseek() usage since ever before.) + * \return The resulting offset >= 0 or error/message code + */ +MPG123_EXPORT off_t mpg123_seek( mpg123_handle *mh +, off_t sampleoff, int whence ); +#endif + +/** Seek to a desired 64 bit sample offset. + * Usage is modelled afer the standard lseek(). + * \param mh handle + * \param sampleoff offset in samples (PCM frames) + * \param whence one of SEEK_SET, SEEK_CUR or SEEK_END + * (Offset for SEEK_END is always effectively negative.) + * \return The resulting offset >= 0 or error/message code + */ +MPG123_EXPORT int64_t mpg123_seek64( mpg123_handle *mh +, int64_t sampleoff, int whence ); + +#ifndef MPG123_PORTABLE_API +/** 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 samples (PCM frames) + * \param whence one of SEEK_SET, SEEK_CUR or SEEK_END + * (Offset for SEEK_END is always effectively negative since API + * version 48, was inverted from lseek() usage since ever before.) + * \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 ); +#endif + +/** Seek to a desired 64 bit 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 samples (PCM frames) + * \param whence one of SEEK_SET, SEEK_CUR or SEEK_END + * (Offset for SEEK_END is always effectively negative.) + * \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 int64_t mpg123_feedseek64( mpg123_handle *mh +, int64_t sampleoff, int whence, int64_t *input_offset ); + +#ifndef MPG123_PORTABLE_API +/** 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 + * (Offset for SEEK_END is always effectively negative since API + * version 48, was inverted from lseek() usage since ever before.) + * \return The resulting offset >= 0 or error/message code */ +MPG123_EXPORT off_t mpg123_seek_frame( mpg123_handle *mh +, off_t frameoff, int whence ); +#endif + +/** Seek to a desired 64 bit 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 + * (Offset for SEEK_END is always effectively negative.) + * \return The resulting offset >= 0 or error/message code */ +MPG123_EXPORT int64_t mpg123_seek_frame64( mpg123_handle *mh +, int64_t frameoff, int whence ); + +#ifndef MPG123_PORTABLE_API +/** 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. + * Note: This can be just a copy of the data in case a conversion is done + * from the internal 64 bit values. + * \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 ); +#endif + +/** Return a 64 bit 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 int64_t mpg123_timeframe64(mpg123_handle *mh, double sec); + +/** Give access to the 64 bit 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_index64( mpg123_handle *mh +, int64_t **offsets, int64_t *step, size_t *fill ); + +#ifndef MPG123_PORTABLE_API +/** 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. + * Note that this function might involve conversion/copying of data because of + * the varying nature of off_t. Better use mpg123_set_index64(). + * \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 ); +#endif + +/** Set the 64 bit 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_index64( mpg123_handle *mh +, int64_t *offsets, int64_t step, size_t fill ); + + +#ifndef MPG123_PORTABLE_API +/** 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.32.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 INT123_frame_offset, off_t buffered_bytes, off_t *current_frame, off_t *frames_left, double *current_seconds, double *seconds_left); +#endif + +/** @} */ + + +/** \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 */ +}; + +#ifdef MPG123_ENUM_API +/** Set the 32 Band Audio Equalizer settings. + * + * Note that this name is mapped to mpg123_eq2() instead unless + * MPG123_ENUM_API is defined. + * + * \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 ); +#endif + +/** Set the 32 Band Audio Equalizer settings. No enums. + * + * This is actually called instead of mpg123_eq() unless MPG123_ENUM_API + * is defined. + * + * \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_eq2( mpg123_handle *mh +, int channel, int band, double val ); + +/** Set a range of equalizer bands + * \param channel Can be #MPG123_LEFT, #MPG123_RIGHT or + * #MPG123_LEFT|#MPG123_RIGHT for both. + * \param mh handle + * \param a The first equalizer band to set (from 0 to 31) + * \param b The last equalizer band to set (from 0 to 31) + * \param factor The (linear) adjustment factor, 1 being neutral. + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_eq_bands( mpg123_handle *mh +, int channel, int a, int b, double factor ); + +/** Change a range of equalizer bands + * \param mh handle + * \param channel Can be #MPG123_LEFT, #MPG123_RIGHT or + * #MPG123_LEFT|#MPG123_RIGHT for both. + * \param a The first equalizer band to change (from 0 to 31) + * \param b The last equalizer band to change (from 0 to 31) + * \param db The adjustment in dB (limited to +/- 60 dB). + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_eq_change( mpg123_handle *mh +, int channel, int a, int b, double db ); + +#ifdef MPG123_ENUM_API +/** Get the 32 Band Audio Equalizer settings. + * + * Note that this name is mapped to mpg123_geteq2() instead unless + * MPG123_ENUM_API is defined. + * + * \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); +#endif + +/** Get the 32 Band Audio Equalizer settings. + * + * This is actually called instead of mpg123_geteq() unless MPG123_ENUM_API + * is defined. + * + * \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_geteq2(mpg123_handle *mh, int 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); + +/** Adjust output volume including the RVA setting by chosen amount + * \param mh handle + * \param db volume adjustment in decibels (limited to +/- 60 dB) + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_volume_change_db(mpg123_handle *mh, double db); + +/** 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. */ +}; + +#ifdef MPG123_ENUM_API +/** 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. */ +}; +#endif + +/** Data structure for storing information about a frame of MPEG Audio without enums */ +struct mpg123_frameinfo2 +{ + int version; /**< The MPEG version (1.0/2.0/2.5), enum mpg123_version. */ + int layer; /**< The MPEG Audio Layer (MP1/MP2/MP3). */ + long rate; /**< The sampling rate in Hz. */ + int mode; /**< The audio mode (enum mpg123_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). */ + int flags; /**< MPEG Audio flag bits. Bitwise combination of enum mpg123_flags values. */ + int emphasis; /**< The emphasis type. */ + int bitrate; /**< Bitrate of the frame (kbps). */ + int abr_rate; /**< The target average bitrate. */ + int vbr; /**< The VBR mode, enum mpg123_vbr. */ +}; + +/** Data structure for even more detailed information out of the decoder, + * for MPEG layer III only. + * This was added to support the frame analyzer by the Lame project and + * just follows what was used there before. You know what the fields mean + * if you want use this structure. */ +struct mpg123_moreinfo +{ + double xr[2][2][576]; /**< internal data */ + double sfb[2][2][22]; /**< [2][2][SBMAX_l] */ + double sfb_s[2][2][3*13]; /**< [2][2][3*SBMAX_s] */ + int qss[2][2]; /**< internal data */ + int big_values[2][2]; /**< internal data */ + int sub_gain[2][2][3]; /**< internal data */ + int scalefac_scale[2][2]; /**< internal data */ + int preflag[2][2]; /**< internal data */ + int blocktype[2][2]; /**< internal data */ + int mixed[2][2]; /**< internal data */ + int mainbits[2][2]; /**< internal data */ + int sfbits[2][2]; /**< internal data */ + int scfsi[2]; /**< internal data */ + int maindata; /**< internal data */ + int padding; /**< internal data */ +}; + +#ifdef MPG123_ENUM_API +/** Get frame information about the MPEG audio bitstream and store + * it in a mpg123_frameinfo structure. + * + * Note that this name is mapped to mpg123_info2() instead unless + * MPG123_ENUM_API is defined. + * + * \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); +#endif + +/** Get frame information about the MPEG audio bitstream and store + * it in a mpg123_frameinfo2 structure. + * + * This is actually called instead of mpg123_info() + * unless MPG123_ENUM_API is defined. + * + * \param mh handle + * \param mi address of existing frameinfo structure to write to + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_info2(mpg123_handle *mh, struct mpg123_frameinfo2 *mi); + +/** Trigger collection of additional decoder information while decoding. + * \param mh handle + * \param mi pointer to data storage (NULL to disable collection) + * \return MPG123_OK if the collection was enabled/disabled as desired, MPG123_ERR + * otherwise (e.g. if the feature is disabled) + */ +MPG123_EXPORT int mpg123_set_moreinfo( mpg123_handle *mh +, struct mpg123_moreinfo *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); + +#ifndef MPG123_PORTABLE_API +/** Return, if possible, the full (expected) length of current track in + * MPEG 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 (PCM frames). + * + * This relies either on an Info frame at the beginning or a previous + * call to mpg123_scan() to get the real number of MPEG frames in a + * file. It will guess based on file size if neither Info frame nor + * scan data are present. In any case, there is no guarantee that the + * decoder will not give you more data, for example in case the open + * file gets appended to during decoding. + * \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); +#endif + +/** Return, if possible, the full (expected) length of current track in + * MPEG frames as 64 bit number. + * \param mh handle + * \return length >= 0 or MPG123_ERR if there is no length guess possible. + */ +MPG123_EXPORT int64_t mpg123_framelength64(mpg123_handle *mh); + +/** Return, if possible, the full (expected) length of current + * track in samples (PCM frames) as 64 bit value. + * + * This relies either on an Info frame at the beginning or a previous + * call to mpg123_scan() to get the real number of MPEG frames in a + * file. It will guess based on file size if neither Info frame nor + * scan data are present. In any case, there is no guarantee that the + * decoder will not give you more data, for example in case the open + * file gets appended to during decoding. + * \param mh handle + * \return length >= 0 or MPG123_ERR if there is no length guess possible. + */ +MPG123_EXPORT int64_t mpg123_length64(mpg123_handle *mh); + +/** Override the 64 bit 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_filesize64(mpg123_handle *mh, int64_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. */ + ,MPG123_ENC_DELAY /** Encoder delay read from Info tag (layer III, -1 if unknown). */ + ,MPG123_ENC_PADDING /** Encoder padding read from Info tag (layer III, -1 if unknown). */ + ,MPG123_DEC_DELAY /** Decoder delay (for layer III only, -1 otherwise). */ +}; + +#ifdef MPG123_ENUM_API +/** Get various current decoder/stream state information. + * + * Note that this name is mapped to mpg123_getstate2() instead unless + * MPG123_ENUM_API is defined. + * + * \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 ); +#endif + +/** Get various current decoder/stream state information. No enums. + * + * This is actually called instead of mpg123_getstate() + * unless MPG123_ENUM_API is defined. + * + * \param mh handle + * \param key the key to identify the information to give (enum mpg123_state) + * \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_getstate2( mpg123_handle *mh +, int 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; + +/** Allocate and intialize a new string. + * \param val optional initial string value (can be NULL) + */ +MPG123_EXPORT mpg123_string* mpg123_new_string(const char* val); + +/** Free memory of contents and the string structure itself. + * \param sb string handle + */ +MPG123_EXPORT void mpg123_delete_string(mpg123_string* sb); + +/** Initialize an existing mpg123_string structure to {NULL, 0, 0}. + * If you hand in a NULL pointer here, your program should crash. The other + * string functions are more forgiving, but this one here is too basic. + * \param sb string handle (address of existing structure on your side) + */ +MPG123_EXPORT void mpg123_init_string(mpg123_string* sb); + +/** Free-up memory of the contents of an mpg123_string (not the struct itself). + * This also calls mpg123_init_string() and hence is safe to be called + * repeatedly. + * \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); + +/** Move the contents of one mpg123_string string to another. + * This frees any memory associated with the target and moves over the + * pointers from the source, leaving the source without content after + * that. The only possible error is that you hand in NULL pointers. + * If you handed in a valid source, its contents will be gone, even if + * there was no target to move to. If you hand in a valid target, its + * original contents will also always be gone, to be replaced with the + * source's contents if there was some. + * \param from source string handle + * \param to target string handle + * \return 0 on error, 1 on success + */ +MPG123_EXPORT int mpg123_move_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 Unicode points). + * This function is of limited use, as it does just count code points + * encoded in an UTF-8 string, only loosely related to the count of visible + * characters. Get your full Unicode handling support elsewhere. + * \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); + +/** Determine if two strings contain the same data. + * This only returns 1 if both given handles are non-NULL and + * if they are filled with the same bytes. + * \param a first string handle + * \param b second string handle + * \return 0 for different strings, 1 for identical + */ +MPG123_EXPORT int mpg123_same_string(mpg123_string *a, mpg123_string *b); + +/** 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. */ +}; + +#ifdef MPG123_ENUM_API +/** Convert ID3 encoding byte to mpg123 encoding index. + * + * Note that this name is mapped to mpg123_enc_from_id3_2() instead unless + * MPG123_ENUM_API is defined. + * + * \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); +#endif + +/** Convert ID3 encoding byte to mpg123 encoding index. No enums. + * + * This is actually called instead of mpg123_enc_from_id3() + * unless MPG123_ENUM_API is defined. + * + * \param id3_enc_byte the ID3 encoding code + * \return the mpg123 encoding index + */ +MPG123_EXPORT int mpg123_enc_from_id3_2(unsigned char id3_enc_byte); + +#ifdef MPG123_ENUM_API +/** Store text data in string, after converting to UTF-8 from indicated encoding. + * + * Note that this name is mapped to mpg123_store_utf8_2() instead unless + * MPG123_ENUM_API is defined. + * + * 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); +#endif + +/** Store text data in string, after converting to UTF-8 from indicated encoding. No enums. + * + * This is actually called instead of mpg123_store_utf8() + * unless MPG123_ENUM_API is defined. + * + * 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 (enum mpg123_text_encoding) + * \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_2(mpg123_string *sb +, int 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, TXXX and USLT may 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). + Only populated if MPG123_PICTURE flag is set! */ + 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 ); + +/** Return pointers to and size of stored raw ID3 data if storage has + * been configured with MPG123_STORE_RAW_ID3 and stream parsing passed the + * metadata already. Null value with zero size is a possibility! + * The storage can change at any next API call. + * + * \param mh mpg123 handle + * \param v1 address to store pointer to v1 tag + * \param v1_size size of v1 data in bytes + * \param v2 address to store pointer to v2 tag + * \param v2_size size of v2 data in bytes + * \return MPG123_OK or MPG123_ERR. Only on MPG123_OK the output + * values are set. + */ +MPG123_EXPORT int mpg123_id3_raw( mpg123_handle *mh +, unsigned char **v1, size_t *v1_size +, unsigned char **v2, size_t *v2_size ); + +/** 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); + +/** Set the audio format support of a mpg123_pars in detail: + * \param mp parameter handle + * \param rate The sample rate value (in Hertz). Special value 0 means + * all rates (reason for this variant of mpg123_fmt). + * \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_fmt2(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); + +#ifdef MPG123_ENUM_API +/** Set a specific parameter in a par handle. + * + * Note that this name is mapped to mpg123_par2() instead unless + * MPG123_ENUM_API is defined. + * + * \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 ); +#endif + +/** Set a specific parameter in a par handle. No enums. + * + * This is actually called instead of mpg123_par() + * unless MPG123_ENUM_API is defined. + * + * \param mp parameter handle + * \param type parameter choice (enum mpg123_parms) + * \param value integer value + * \param fvalue floating point value + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_par2( mpg123_pars *mp +, int type, long value, double fvalue ); + +#ifdef MPG123_ENUM_API +/** Get a specific parameter from a par handle. + * + * Note that this name is mapped to mpg123_getpar2() instead unless + * MPG123_ENUM_API is defined. + * + * \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 ); +#endif + +/** Get a specific parameter from a par handle. No enums. + * + * This is actually called instead of mpg123_getpar() + * unless MPG123_ENUM_API is defined. + * + * \param mp parameter handle + * \param type parameter choice (enum mpg123_parms) + * \param value integer value return address + * \param fvalue floating point value return address + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_getpar2( mpg123_pars *mp +, int 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). + * + * Note: The type of data changed to a void pointer in mpg123 1.26.0 + * (API version 45). + * + * \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 +, void *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); + +#ifndef MPG123_PORTABLE_API +/** 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 just a call to POSIX read/lseek is + * done (without handling signals). + * 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 +, mpg123_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 a non-NULL 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 +, mpg123_ssize_t (*r_read) (void *, void *, size_t) +, off_t (*r_lseek)(void *, off_t, int) +, void (*cleanup)(void*) ); +#endif + +/** Set up portable read functions on an opaque handle. + * The handle is a void pointer, so you can pass any data you want... + * mpg123_open64() (since API 49) or 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 + * The parameters are the handle, the buffer to read into, a byte count to read, + * address to store the returned byte count. Return value is zero for + * no issue, non-zero for some error. Recoverable signal handling has to happen + * inside the callback. + * \param r_lseek callback for seeking (like POSIX lseek), maybe NULL for + * non-seekable streams + * \param cleanup A callback to clean up a non-NULL I/O handle on mpg123_close, + * maybe NULL for none + * \return MPG123_OK on success + */ +MPG123_EXPORT int mpg123_reader64( mpg123_handle *mh, int (*r_read) (void *, void *, size_t, size_t *), int64_t (*r_lseek)(void *, int64_t, int), void (*cleanup)(void*) ); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/app/src/main/lib/mpg123/lib/x86_64/include/out123.h b/app/src/main/lib/mpg123/lib/x86_64/include/out123.h new file mode 100644 index 0000000..8ac2aae --- /dev/null +++ b/app/src/main/lib/mpg123/lib/x86_64/include/out123.h @@ -0,0 +1,751 @@ +/* + out123: audio output interface + + copyright 1995-2016 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 + initially written as audio.h by Michael Hipp, reworked into out123 API + by Thomas Orgis +*/ + +#ifndef _OUT123_H_ +#define _OUT123_H_ + +/** \file out123.h The header file for the libout123 audio output facility. */ + +/** A macro to check at compile time which set of API functions to expect. + * This must be incremented at least each time a new symbol is added + * to the header. + */ +#define OUT123_API_VERSION 5 +/** library patch level at client build time */ +#define OUT123_PATCHLEVEL 2 + +/* We only need size_t definition. */ +#include + +/* Common audio encoding specification, including a macro for getting + * size of encoded samples in bytes. Said macro is still hardcoded + * into out123_encsize(). Relying on this one may help an old program + * know sizes of encodings added to fmt123.h later on. + * If you don't care, just use the macro. + */ +#include "fmt123.h" + +#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 + +/* Earlier versions of libout123 put enums into public API calls, + * thich is not exactly safe. There are ABI rules, but you can use + * compiler switches to change the sizes of enums. It is safer not + * to have them in API calls. Thus, the default is to remap calls and + * structs to variants that use plain ints. Define MPG123_ENUM_API to + * prevent that remapping. + * + * You might want to define this to increase the chance of your binary + * working with an older version of the library. But if that is your goal, + * you should better build with an older version to begin with. + */ +#ifndef MPG123_ENUM_API + +#define out123_param out123_param2 +#define out123_getparam out123_getparam2 + +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/** \defgroup out123_api out123 library API + * This is out123, a library focused on continuous playback of audio streams + * via various platform-specific output methods. It glosses over details of + * the native APIs to give an interface close to simply writing data to a + * file. There might be the option to tune details like buffer (period) sizes + * and the number of them on the device side in future, but the focus of the + * library is to ease the use case of just getting that raw audio data out + * there, without interruptions. + * + * The basic idea is to create a handle with out123_new() and open a certain + * output device (using a certain driver module, possibly build-time defaults) + * with out123_open(). Now, you can query the output device for supported + * encodings for given rate and channel count with out123_get_encodings() and + * decide what to use for actually starting playback with out123_start(). + * + * Then, you just need to provide (interleaved pcm) data for playback with + * out123_play(), which will block when the device's buffers are full. You get + * your timing from that (instead of callbacks). If your program does the + * production of the audio data just a little bit faster than the playback, + * causing out123_play() to block ever so briefly, you're fine. + * + * You stop playback with out123_stop(), or just close the device and driver + * via out123_close(), or even just decide to drop it all and do out123_del() + * right away when you're done. + * + * There are other functions for specific needs, but the basic idea should be + * covered by the above. + * + * Note that the driver modules that bind to the operating system API for + * output might impose restrictions on what you can safely do regarding your + * out123_handle and multiple threads or processes. You should be on the safe + * side ensuring that you confine usage of a handle to a single thread instead + * of passing it around. + @{ + */ + +/** Opaque structure for the libout123 handle. */ +struct out123_struct; +/** Typedef shortcut as preferrend name for the handle type. */ +typedef struct out123_struct out123_handle; + +/** Get version of the mpg123 distribution this library build came with. + * (optional means non-NULL) + * \param major optional address to store major version number + * \param minor optional address to store minor version number + * \param patch optional address to store patchlevel version number + * \return full version string (like "1.2.3-beta4 (experimental)") + */ +MPG123_EXPORT +const char *out123_distversion(unsigned int *major, unsigned int *minor, unsigned int *patch); + +/** Get API version of library build. + * \param patch optional address to store patchlevel + * \return API version of library + */ +MPG123_EXPORT +unsigned int out123_libversion(unsigned int *patch); + +/** Enumeration of codes for the parameters that it is possible to set/get. */ +enum out123_parms +{ + OUT123_FLAGS = 1 /**< integer, various flags, see enum #out123_flags */ +, OUT123_PRELOAD /**< float, fraction of buffer to fill before playback */ +, OUT123_GAIN /**< integer, output device gain (module-specific) */ +, OUT123_VERBOSE /**< integer, verbosity to stderr, >= 0 */ +, OUT123_DEVICEBUFFER /**< + * float, length of device buffer in seconds; + * This might be ignored, might have only a loose relation to actual + * buffer sizes and latency, depending on output driver. Try to tune + * this before opening a device if you want to influcence latency or reduce + * dropouts. Value <= 0 uses some default, usually favouring stable playback + * over low latency. Values above 0.5 are probably too much. + */ +, OUT123_PROPFLAGS /**< integer, query driver/device property flags (r/o) */ +, OUT123_NAME /**< string, name of this instance (NULL restores default); + * The value returned by out123_getparam() might be different if the audio + * backend changed it (to be unique among clients, p.ex.). + * TODO: The name provided here is used as prefix in diagnostic messages. */ +, OUT123_BINDIR /**< string, path to a program binary directory to use + * as starting point in the search for the output module directory + * (e.g. ../lib/mpg123 or ./plugins). The environment variable MPG123_MODDIR + * is always tried first and the in-built installation path last. + */ +, OUT123_ADD_FLAGS /**< enable given flags */ +, OUT123_REMOVE_FLAGS /**< disable diven flags */ +}; + +/** Flags to tune out123 behaviour */ +enum out123_flags +{ + OUT123_HEADPHONES = 0x01 /**< output to headphones (if supported) */ +, OUT123_INTERNAL_SPEAKER = 0x02 /**< output to speaker (if supported) */ +, OUT123_LINE_OUT = 0x04 /**< output to line out (if supported) */ +, OUT123_QUIET = 0x08 /**< no printouts to standard error */ +, OUT123_KEEP_PLAYING = 0x10 /**< + * When this is set (default), playback continues in a loop when the device + * does not consume all given data at once. This happens when encountering + * signals (like SIGSTOP, SIGCONT) that cause interruption of the underlying + * functions. + * Note that this flag is meaningless when the optional buffer is employed, + * There, your program will always block until the buffer completely took + * over the data given to it via out123_play(), unless a communication error + * arises. + */ +, OUT123_MUTE = 0x20 /**< software mute (play silent audio) */ +}; + +/** Read-only output driver/device property flags (OUT123_PROPFLAGS). */ +enum out123_propflags +{ + OUT123_PROP_LIVE = 0x01 /**< This is a live output, meaning that + * special care might be needed for pauses in playback (p.ex. stream + * of silence instead of interruption), as opposed to files on disk. + */ +, OUT123_PROP_PERSISTENT = 0x02 /**< This (live) output does not need + * special care for pauses (continues with silence itself), + * out123_pause() does nothing to the device. + */ +}; + +/** Create a new output handle. + * This only allocates and initializes memory, so the only possible + * error condition is running out of memory. + * \return pointer to new handle or NULL on error + */ +MPG123_EXPORT +out123_handle *out123_new(void); + +/** Delete output handle. + * This implies out123_close(). + */ +MPG123_EXPORT +void out123_del(out123_handle *ao); + +/** Free plain memory allocated within libout123. + * This is for library users that are not sure to use the same underlying + * memory allocator as libout123. It is just a wrapper over free() in + * the underlying C library. + */ +MPG123_EXPORT void out123_free(void *ptr); + +/** Error code enumeration + * API calls return a useful (positve) value or zero (OUT123_OK) on simple + * success. A negative value (-1 == OUT123_ERR) usually indicates that some + * error occured. Which one, that can be queried using out123_errcode() + * and friends. + */ +enum out123_error +{ + OUT123_ERR = -1 /**< generic alias for verbosity, always == -1 */ +, OUT123_OK = 0 /**< just a name for zero, not going to change */ +, OUT123_DOOM /**< dazzled, out of memory */ +, OUT123_BAD_DRIVER_NAME /**< bad driver name given */ +, OUT123_BAD_DRIVER /**< unspecified issue loading a driver */ +, OUT123_NO_DRIVER /**< no driver loaded */ +, OUT123_NOT_LIVE /**< no active audio device */ +, OUT123_DEV_PLAY /**< some device playback error */ +, OUT123_DEV_OPEN /**< error opening device */ +, OUT123_BUFFER_ERROR /**< + * Some (really unexpected) error in buffer infrastructure. + */ +, OUT123_MODULE_ERROR /**< basic failure in module loading */ +, OUT123_ARG_ERROR /**< some bad function arguments supplied */ +, OUT123_BAD_PARAM /**< unknown parameter code */ +, OUT123_SET_RO_PARAM /**< attempt to set read-only parameter */ +, OUT123_BAD_HANDLE /**< bad handle pointer (NULL, usually) */ +, OUT123_NOT_SUPPORTED /**< some requested operation is not supported (right now) */ +, OUT123_DEV_ENUMERATE /**< device enumeration itself failed */ +, OUT123_ERRCOUNT /**< placeholder for shaping arrays */ +}; + +/** Get string representation of last encountered error in the + * context of given handle. + * \param ao handle + * \return error string + */ +MPG123_EXPORT +const char* out123_strerror(out123_handle *ao); + +/** Get the plain errcode intead of a string. + * Note that this used to return OUT123_ERR instead of + * OUT123_BAD_HANDLE in case of ao==NULL before mpg123-1.23.5 . + * \param ao handle + * \return error code recorded in handle or OUT123_BAD_HANDLE + */ +MPG123_EXPORT +int out123_errcode(out123_handle *ao); + +/** Return the error string for a given error code. + * \param errcode the integer error code + * \return error string + */ +MPG123_EXPORT +const char* out123_plain_strerror(int errcode); + +/** Set a desired output buffer size. + * This starts a separate process that handles the audio output, decoupling + * the latter from the main process with a memory buffer and saving you the + * burden to ensure sparing CPU cycles for actual playback. + * This is for applicatons that prefer continuous playback over small latency. + * In other words: The kind of applications that out123 is designed for. + * This routine always kills off any currently active audio output module / + * device, even if you just disable the buffer when there is no buffer. + * + * Keep this in mind for memory-constrainted systems: Activating the + * buffer causes a fork of the calling process, doubling the virtual memory + * use. Depending on your operating system kernel's behaviour regarding + * memory overcommit, it might be wise to call out123_set_buffer() very + * early in your program before allocating lots of memory. + * + * There _might_ be a change to threads in future, but for now this is + * classic fork with shared memory, working without any threading library. + * If your platform or build does not support that, you will always get an + * error on trying to set up a non-zero buffer (but the API call will be + * present). + * + * Also, if you do intend to use this from a multithreaded program, think + * twice and make sure that your setup is happy with forking full-blown + * processes off threaded programs. Probably you are better off spawning a + * buffer thread yourself. + * + * \param ao handle + * \param buffer_bytes size (bytes) of a memory buffer for decoded audio, + * a value of zero disables the buffer. + * \return 0 on success, OUT123_ERR on error + */ +MPG123_EXPORT +int out123_set_buffer(out123_handle *ao, size_t buffer_bytes); + +#ifdef MPG123_ENUM_API +/** Set a parameter on a out123_handle. + * + * Note that this name is mapped to out123_param2() instead unless + * MPG123_ENUM_API is defined. + * + * The parameters usually only change what happens on next out123_open, not + * incfluencing running operation. There are macros To ease the API a bit: + * You can call out123_param_int(ao, code, value) for integer (long) values, + * same with out123_param_float() and out123_param_string(). + * + * \param ao handle + * \param code parameter code + * \param value input value for integer parameters + * \param fvalue input value for floating point parameters + * \param svalue input value for string parameters (contens are copied) + * \return 0 on success, OUT123_ERR on error. + */ +MPG123_EXPORT +int out123_param( out123_handle *ao, enum out123_parms code +, long value, double fvalue, const char *svalue ); +#endif + +/** Set a parameter on a out123_handle. No enum. + * + * This is actually called instead of out123_param() + * unless MPG123_ENUM_API is defined. + * + * The parameters usually only change what happens on next out123_open, not + * incfluencing running operation. There are macros To ease the API a bit: + * You can call out123_param_int(ao, code, value) for integer (long) values, + * same with out123_param_float() and out123_param_string(). + * + * \param ao handle + * \param code parameter code (from enum #out123_parms) + * \param value input value for integer parameters + * \param fvalue input value for floating point parameters + * \param svalue input value for string parameters (contens are copied) + * \return 0 on success, OUT123_ERR on error. + */ +MPG123_EXPORT +int out123_param2( out123_handle *ao, int code +, long value, double fvalue, const char *svalue ); + + +/** Shortcut for out123_param() to set an integer parameter. */ +#define out123_param_int(ao, code, value) \ + out123_param((ao), (code), (value), 0., NULL) +/** Shortcut for out123_param() to set a float parameter. */ +#define out123_param_float(ao, code, value) \ + out123_param((ao), (code), 0, (value), NULL) +/** Shortcut for out123_param() to set an string parameter. */ +#define out123_param_string(ao, code, value) \ + out123_param((ao), (code), 0, 0., (value)) + +#ifdef MPG123_ENUM_API +/** Get a parameter from an out123_handle. + * + * Note that this name is mapped to out123_param2() instead unless + * MPG123_ENUM_API is defined. + * + * \param ao handle + * \param code parameter code + * \param ret_value output address for integer parameters + * \param ret_fvalue output address for floating point parameters + * \param ret_svalue output address for string parameters (pointer to + * internal memory, so no messing around, please) + * \return 0 on success, OUT123_ERR on error (bad parameter name or bad handle). + */ +MPG123_EXPORT +int out123_getparam( out123_handle *ao, enum out123_parms code +, long *ret_value, double *ret_fvalue, char* *ret_svalue ); +#endif + +/** Get a parameter from an out123_handle. No enum. + * + * This is actually called instead of out123_getparam() + * unless MPG123_ENUM_API is defined. + * + * \param ao handle + * \param code parameter code (from enum #out123_parms) + * \param ret_value output address for integer parameters + * \param ret_fvalue output address for floating point parameters + * \param ret_svalue output address for string parameters (pointer to + * internal memory, so no messing around, please) + * \return 0 on success, OUT123_ERR on error (bad parameter name or bad handle). + */ +MPG123_EXPORT +int out123_getparam2( out123_handle *ao, int code +, long *ret_value, double *ret_fvalue, char* *ret_svalue ); + +/** Shortcut for out123_getparam() to get an integer parameter. */ +#define out123_getparam_int(ao, code, value) \ + out123_getparam((ao), (code), (value), NULL, NULL) +/** Shortcut for out123_getparam() to get a float parameter. */ +#define out123_getparam_float(ao, code, value) \ + out123_getparam((ao), (code), NULL, (value), NULL) +/** Shortcut for out123_getparam() to get a string parameter. */ +#define out123_getparam_string(ao, code, value) \ + out123_getparam((ao), (code), NULL, NULL, (value)) + +/** Copy parameters from another out123_handle. + * \param ao handle + * \param from_ao the handle to copy parameters from + * \return 0 in success, -1 on error + */ +MPG123_EXPORT +int out123_param_from(out123_handle *ao, out123_handle* from_ao); + +/** Get list of driver modules reachable in system in C argv-style format. + * + * The client is responsible for freeing the memory of both the individual + * strings and the lists themselves. There is out123_stringlists_free() + * to assist. + * + * A module that is not loadable because of missing libraries is simply + * skipped. You will get stderr messages about that unless OUT123_QUIET was + * was set, though. Failure to open the module directory is a serious error, + * resulting in negative return value. + * + * \param ao handle + * \param names address for storing list of names + * \param descr address for storing list of descriptions + * \return number of drivers found, -1 on error + */ +MPG123_EXPORT +int out123_drivers(out123_handle *ao, char ***names, char ***descr); + +/** Get a list of available output devices for a given driver. + * + * If the driver supports enumeration, you can get a listing of possible + * output devices. If this list is exhaustive, depends on the driver. + * Note that this implies out123_close(). When you have a device already + * open, you don't need to look for one anymore. If you really do, just + * create another handle. + * + * Your provided pointers are only used for non-negative return values. + * In this case, you are responsible for freeing the associated memory of + * the strings and the lists themselves. The format of the lists is an + * array of char pointers, with the returned count just like the usual + * C argv and argc. There is out123_stringlists_free() to assist. + * + * Note: Calling this on a handle with a configured buffer process will + * yield #OUT123_NOT_SUPPORTED. + * + * \param ao handle + * \param driver driver name or comma-separated list of names + * to try, just like for out123_open(), possibly NULL for some default + * \param names address for storing list of names + * \param descr address for storing list of descriptions + * \param active_driver address for storing a copy of the actually active + * driver name (in case you gave a list or NULL as driver), can be NULL + * if not interesting + * \return count of devices or #OUT123_ERR if some error was encountered, + * possibly just #OUT123_NOT_SUPPORTED if the driver lacks enumeration support + */ +MPG123_EXPORT +int out123_devices( out123_handle *ao, const char *driver +, char ***names, char ***descr, char **active_driver ); + +/** Helper to free string list memory. + * + * This aids in freeing the memory allocated by out123_devices() and + * out123_drivers(). + * + * Any of the given lists can be NULL and nothing will happen to it. + * + * \param name first string list + * \param descr second string list + * \param count count of strings + */ +MPG123_EXPORT +void out123_stringlists_free(char **name, char **descr, int count); + + +/** Open an output device with a certain driver + * Note: Opening means that the driver code is loaded and the desired + * device name recorded, possibly tested for availability or tentatively + * opened. After out123_open(), you can ask for supported encodings + * and then really open the device for playback with out123_start(). + * \param ao handle + * \param driver (comma-separated list of) output driver name(s to try), + * NULL for default + * \param device device name to open, NULL for default + * (stdout for file-based drivers) + * \return 0 on success, -1 on error. + */ +MPG123_EXPORT +int out123_open(out123_handle *ao, const char* driver, const char* device); + +/** Give info about currently loaded driver and device + * Any of the return addresses can be NULL if you are not interested in + * everything. You get pointers to internal storage. They are valid + * as long as the driver/device combination is opened. + * The device may be NULL indicating some unnamed default. + * TODO: Make the driver modules return names for such defaults. + * \param ao handle + * \param driver return address for driver name + * \param device return address for device name + * \return 0 on success, -1 on error (i.e. no driver loaded) + */ +MPG123_EXPORT +int out123_driver_info(out123_handle *ao, char **driver, char **device); + +/** Close the current output device and driver. + * This implies out123_drain() to ensure no data is lost. + * With a buffer, that might cause considerable delay during + * which your main application is blocked waiting. + * Call out123_drop() beforehand if you want to end things + * quickly. + * \param ao handle + */ +MPG123_EXPORT +void out123_close(out123_handle *ao); + +/** Get supported audio encodings for given rate and channel count, + * for the currently openend audio device. + * Usually, a wider range of rates is supported, but the number + * of sample encodings is limited, as is the number of channels. + * So you can call this with some standard rate and hope that the + * returned encodings work also for others, with the tested channel + * count. + * The return value of -1 on some encountered error conveniently also + * does not match any defined format (only 15 bits used for encodings, + * so this would even work with 16 bit integers). + * This implies out123_stop() to enter query mode. + * \param ao handle + * \param rate sampling rate + * \param channels number of channels + * \return supported encodings combined with bitwise or, to be checked + * against your favourite bitmask, -1 on error + */ +MPG123_EXPORT +int out123_encodings(out123_handle *ao, long rate, int channels); + +/** 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 out123_encsize(int encoding); + +/** Get list of supported formats for currently opened audio device. + * Given a list of sampling rates and minimal/maximal channel count, + * this quickly checks what formats are supported with these + * constraints. The first entry is always reserved for a default + * format for the output device. If there is no such default, + * all values of the format are -1. + * For each requested combination of rate and channels, a format entry is + * created, possible with encoding value 0 to indicate that this combination + * has been tested and rejected. So, when there is no basic error, the + * number of returned format entries should be + * (ratecount*(maxchannels-minchannels+1)+1) + * . But instead of forcing you to guess, this will be allocated by + * successful run. + * For the first entry, the encoding member is supposed to be a definite + * encoding, for the others it is a bitwise combination of all possible + * encodings. + * This function is more efficient than many calls to out123_encodings(). + * \param ao handle + * \param rates pointer to an array of sampling rates, may be NULL for none + * \param ratecount number of provided sampling rates + * \param minchannels minimal channel count + * \param maxchannels maximal channel count + * \param fmtlist return address for array of supported formats + * the encoding field of each entry is a combination of all + * supported encodings at this rate and channel count; + * Memory shall be freed by user. + * \return number of returned format enries, -1 on error + */ +MPG123_EXPORT +int out123_formats( out123_handle *ao, const long *rates, int ratecount + , int minchannels, int maxchannels + , struct mpg123_fmt **fmtlist ); + +/** Get list of encodings known to the library. + * You are responsible for freeing the allocated array. + * \param enclist return address for allocated array of encoding codes + * \return number of encodings, -1 on error + */ +MPG123_EXPORT +int out123_enc_list(int **enclist); + +/** Find encoding code by name. + * \param name short or long name to find encoding code for + * \return encoding if found (enum #mpg123_enc_enum), else 0 + */ +MPG123_EXPORT +int out123_enc_byname(const char *name); + +/** Get name of encoding. + * \param encoding code (enum #mpg123_enc_enum) + * \return short name for valid encodings, NULL otherwise + */ +MPG123_EXPORT +const char* out123_enc_name(int encoding); + +/** Get long name of encoding. + * \param encoding code (enum #mpg123_enc_enum) + * \return long name for valid encodings, NULL otherwise + */ +MPG123_EXPORT +const char* out123_enc_longname(int encoding); + +/** Start playback with a certain output format + * It might be a good idea to have audio data handy to feed after this + * returns with success. + * Rationale for not taking a pointer to struct mpg123_fmt: This would + * always force you to deal with that type and needlessly enlarge the + * shortest possible program. + * \param ao handle + * \param encoding sample encoding (values matching libmpg123 API) + * \param channels number of channels (1 or 2, usually) + * \param rate sampling rate + * \return 0 on success, negative on error (bad format, usually) + */ +MPG123_EXPORT +int out123_start( out123_handle *ao +, long rate, int channels, int encoding ); + +/** Pause playback + * Interrupt playback, holding any data in the optional buffer. + * + * This closes the audio device if it is a live sink, ready to be re-opened + * by out123_continue() or out123_play() with the existing parameters. + * \param ao handle + */ +MPG123_EXPORT +void out123_pause(out123_handle *ao); + +/** Continue playback + * The counterpart to out123_pause(). Announce to the driver that playback + * shall continue. + * + * Playback might not resume immediately if the optional buffer is configured + * to wait for a minimum fill and close to being empty. You can force playback + * of the last scrap with out123_drain(), or just by feeding more data with + * out123_play(), which will trigger out123_continue() for you, too. + * \param ao handle + */ +MPG123_EXPORT +void out123_continue(out123_handle *ao); + +/** Stop playback. + * This waits for pending audio data to drain to the speakers. + * You might want to call out123_drop() before stopping if you want + * to end things right away. + * \param ao handle + */ +MPG123_EXPORT +void out123_stop(out123_handle *ao); + +/** Hand over data for playback and wait in case audio device is busy. + * This survives non-fatal signals like SIGSTOP/SIGCONT and keeps on + * playing until the buffer is done with if the flag + * OUT123_KEEP_PLAYING ist set (default). So, per default, if + * you provided a byte count divisible by the PCM frame size, it is an + * error when less bytes than given are played. + * To be sure if an error occured, check out123_errcode(). + * Also note that it is no accident that the buffer parameter is not marked + * as constant. Some output drivers might need to do things like swap + * byte order. This is done in-place instead of wasting memory on yet + * another copy. Software muting also overwrites the data. + * \param ao handle + * \param buffer pointer to raw audio data to be played + * \param bytes number of bytes to read from the buffer + * \return number of bytes played (might be less than given, even zero) + */ +MPG123_EXPORT +size_t out123_play( out123_handle *ao + , void *buffer, size_t bytes ); + +/** Drop any buffered data, making next provided data play right away. + * This does not imply an actual pause in playback. + * You are expected to play something, unless you called out123_pause(). + * Feel free to call out123_stop() afterwards instead for a quicker + * exit than the implied out123_drain(). + * For live sinks, this may include dropping data from their buffers. + * For others (files), this only concerns data in the optional buffer. + * \param ao handle + */ +MPG123_EXPORT +void out123_drop(out123_handle *ao); + +/** Drain the output, waiting until all data went to the hardware. + * This does imply out123_continue() before and out123_pause() + * after draining. + * This might involve only the optional buffer process, or the + * buffers on the audio driver side, too. + * \param ao handle + */ +MPG123_EXPORT +void out123_drain(out123_handle *ao); + +/** Drain the output, but only partially up to the given number of + * bytes. This gives you the opportunity to do something while + * the optional buffer is writing remaining data instead of having + * one atomic API call for it all. + * + * It is wholly expected that the return value of out123_buffered() + * before and after calling this has a bigger difference than the + * provided limit, as the buffer is writing all the time in the + * background. + * + * This is just a plain out123_drain() if the optional buffer is not + * in use. Also triggers out123_continue(), but only out123_pause() + * if there is no buffered data anymore. + * \param ao handle + * \param bytes limit of buffered bytes to drain + * \return number of bytes drained from buffer + */ +MPG123_EXPORT +void out123_ndrain(out123_handle *ao, size_t bytes); + +/** Get an indication of how many bytes reside in the optional buffer. + * This might get extended to tell the number of bytes queued up in the + * audio backend, too. + * \param ao handle + * \return number of bytes in out123 library buffer + */ +MPG123_EXPORT +size_t out123_buffered(out123_handle *ao); + +/** Extract currently used audio format from handle. + * matching mpg123_getformat(). + * Given return addresses may be NULL to indicate no interest. + * \param ao handle + * \param rate address for sample rate + * \param channels address for channel count + * \param encoding address for encoding + * \param framesize size of a full PCM frame (for convenience) + * \return 0 on success, -1 on error + */ +MPG123_EXPORT +int out123_getformat( out123_handle *ao +, long *rate, int *channels, int *encoding, int *framesize ); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/app/src/main/lib/mpg123/lib/x86_64/include/syn123.h b/app/src/main/lib/mpg123/lib/x86_64/include/syn123.h new file mode 100644 index 0000000..600f23c --- /dev/null +++ b/app/src/main/lib/mpg123/lib/x86_64/include/syn123.h @@ -0,0 +1,1211 @@ +/* + syn123: some audio signal synthesis and format conversion + + copyright 2017-2023 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 + + initially written by Thomas Orgis + + Consider defining SYN123_PORTABLE_API to limit the definitions to + a safer subset without some problematic features (mainly off_t usage). +*/ + +#ifndef SYN123_H +#define SYN123_H + +/** \file syn123.h The header file for the libsyn123 library. */ + +/* Common audio encoding specification. */ +#include "fmt123.h" + +/** A macro to check at compile time which set of API functions to expect. + * This must be incremented at least each time a new symbol is added + * to the header. + */ +#define SYN123_API_VERSION 2 +/** library patch level at client build time */ +#define SYN123_PATCHLEVEL 3 + +#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 + +/** Support the restrict keyword for handed-in pointers. Defined to + 'restrict' if available. + */ +#ifndef MPG123_RESTRICT +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#define MPG123_RESTRICT restrict +#else +#define MPG123_RESTRICT +#endif +#endif + +// for off_t and ssize_t +#ifndef SYN123_PORTABLE_API +#include +#endif + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** \defgroup syn123_api syn123 library API + * I wanted to create some test signals in different encodings for testing + * libout123. Also, they shall serve to verify the decoding of libmpg123 + * in automated testing. Then, the awful drop-sample resampling inside the + * latter needed replacement. As digital filtering is part of the resampler + * dance, a chain of those can also be configured and applied. I hope I can + * avoid adding yet more functionality. It's a little utility library to + * accompany libmpg123 and libout123, OK? + * + * This is what libsyn123 offers: + * + * - signal generation (mix of differing wave shapes, noise, a simulated + * Geiger counter for fun) + * - format conversion and channel mixing and amplification, with hard and + * soft clipping, also optional dithering + * - near-zero-latency good-enough quite-fast resampling + * - applying digital filters with user-provided coefficients + * + * The usage model for signal generation is this: + * + * 1. Create handle with desired output format. + * 2. Set up synthesis mode with parameters. + * 3. Repeatedly extract buffers with PCM samples. + * + * If your hardware is slow on floating point operations, you may benefit + * from the period buffer in the handle that only needs actual computation + * once in the setup function. The frequencies of a wave mix may be fudged + * a bit to make for a configured period size. + * + * The usage model for resampling is this: + * + * 1. Create handle with any format or re-use a signal generation handle. + * 2. Set up resampling (rate ratio, channels, dirty mode). + * 3. Use predictor functions to work out matching sizes of input and + * output buffers. + * 4. Call the resampler on chunks of input, immediately producing matching + * chunks of output. + * + * The resampler works on 32 bit float, exclusively. This is what is required + * and appropriate for the provided quality. + * + * The usage model for filtering is this: + * + * 1. Create or re-use a handle. + * 2. Set up the filter chain for single or double precision floating point. + * 3. Apply the filter to chunks of input in succession. + * + * Computations are generally done in floating point, either 32 bit or 64 + * bit (single or double precision). The functions for encoding conversion, + * (de-)interleaving, and interleaved mixing can work without a handle and + * only use the buffers you hand in. Some support using a syn123 handle to + * provide the temporary buffers for encoding conversion on the fly to apply + * flotating-point processing to integer encodings. + * + * Only the functions that are able to return a success code do check + * arguments for obvious trouble like NULL pointers. You are supposed to + * act responsibly when calling. + * + * The size of buffers is either counted in bytes or samples, which, + * depending on the context, refer to individual PCM samples or to what is + * more strictly called a frame (one sample for each channel counted + * together). + @{ + */ + +/** Opaque structure for the libsyn123 handle. + * + * Simple context-free API functions do not need a handle, while + * others require it. Those that require it want it as first argument. + * Functions taking a handle as last argument after others make optional + * use of it (if non-NULL) to enable advanced functionality like + * on-the-fly encoding conversion that needs temporary storage. + */ +struct syn123_struct; +/** Typedef shortcut as preferrend name for the handle type. */ +typedef struct syn123_struct syn123_handle; + +/** Get version of the mpg123 distribution this library build came with. + * (optional means non-NULL) + * \param major optional address to store major version number + * \param minor optional address to store minor version number + * \param patch optional address to store patchlevel version number + * \return full version string (like "1.2.3-beta4 (experimental)") + */ +MPG123_EXPORT +const char *syn123_distversion(unsigned int *major, unsigned int *minor, unsigned int *patch); + +/** Get API version of library build. + * \param patch optional address to store patchlevel + * \return API version of library + */ +MPG123_EXPORT +unsigned int syn123_libversion(unsigned int *patch); + +/** Functions that return an integer success code either return + * SYN123_OK if everything went fine, or one of the other detailed + * error codes. + */ +enum syn123_error +{ + SYN123_OK = 0 /**< no error */ +, SYN123_BAD_HANDLE /**< bad handle given (NULL) */ +, SYN123_BAD_FMT /**< bad format (rate/channels) */ +, SYN123_BAD_ENC /**< bad encoding given */ +, SYN123_BAD_CONV /**< unsupported conversion */ +, SYN123_BAD_SIZE /**< buffer size bad (too small) */ +, SYN123_BAD_BUF /**< bad buffer pointer (NULL) */ +, SYN123_BAD_CHOP /**< byte buffer not cut at sample boundaries */ +, SYN123_DOOM /**< Disaster, Out Of Memory. */ +, SYN123_WEIRD /**< An internal error that should never occur. */ +, SYN123_BAD_FREQ /**< Invalid wave frequency given. */ +, SYN123_BAD_SWEEP /**< Invalid sweep curve given. */ +, SYN123_OVERFLOW /**< Some fatal (integer) overflow that prevents proper operation. */ +, SYN123_NO_DATA /**< Not enough data to do something. */ +, SYN123_BAD_DATA /**< Data present, but not usable. */ +}; + +/** Give a short phrase explaining an error code. + * \param errcode the code returned by an API function + * \return error phrase + */ +const char* syn123_strerror(int errcode); + +/** Create new handle with specified output format. + * \param rate sampling rate + * \param channels channel count (duplicated mono channels) + * \param encoding sample encoding (see enum mpg123_enc_enum) + * \param maxbuf maximum buffer size in bytes to allow for caching periodic + * signals. When this is given, it is attempted to fit any configured signal + * into this buffer in the hope it will work being played periodically. Maybe + * there will be tricks with non-periodic signals. + * A buffer size of zero turns off buffering and signals are always generated + * during extraction. + * \param err address to store error code, non-NULL if you care + * \return Pointer to allocated handle structure or NULL on error. + */ +MPG123_EXPORT +syn123_handle* syn123_new( long rate, int channels, int encoding +, size_t maxbuf, int *err ); + +/** Delete a handle. + * \param sh the handle to delete + */ +MPG123_EXPORT +void syn123_del(syn123_handle *sh); + +/** Enable/disable dithering for conversions. + * + * The default is no dither for conversions to integer encodings. You can + * enable dithering after handle creation, or disable it, as you wish. + * Enabling the dither resets the random number generator seed to the provided + * value or an internal default if the provided value is zero. The dither noise + * is unfiltered with triangular distribution (TPDF), as a sensible common + * choice. No further filtering of questionable benefit. + * + * \param sh handle to work on + * \param dither Disable (0) or enable (1, actually nonzero) dithering. + * Positive values > 1 may trigger differing dither modes in future, but not + * now. + * \param seed optional address to read the initial seed value from (if non-zero) + * and to write the current value to + */ +MPG123_EXPORT +int syn123_dither(syn123_handle *sh, int dither, unsigned long *seed); + +/** Extract desired amount of data from the generator. + * \param sh handle + * \param dst destination buffer + * \param dst_bytes number of bytes to extract + * \return actual number of extracted bytes + * (might differ if dst_bytes is no multiple of the PCM frame size) + */ +MPG123_EXPORT +size_t syn123_read(syn123_handle *sh, void *dst, size_t dst_bytes); + +/** Wave types */ +enum syn123_wave_id +{ + SYN123_WAVE_INVALID = -1 /**< invalid wave pattern */ +, SYN123_WAVE_FLAT = 0 /**< flat line, silence */ +, SYN123_WAVE_SINE /**< sinusodial wave*/ +, SYN123_WAVE_SQUARE /**< square wave */ +, SYN123_WAVE_TRIANGLE /**< triangle wave */ +, SYN123_WAVE_SAWTOOTH /**< sawtooth wave */ +, SYN123_WAVE_GAUSS /**< Gaussian bell shape */ +, SYN123_WAVE_PULSE /**< pulse shape, x^2 exp(-A x^2)/S */ +, SYN123_WAVE_SHOT /**< shot (sharper pulse), x^2 exp(-A x)/S + * (different values for A and S) */ +, SYN123_WAVE_LIMIT /**< valid IDs below that. A newer release of + * the library might support more. */ +}; + +/** Setup periodic wave generator. + * This sets up a series of oscillators with differing wave shapes. + * They are multiplied/scaled with each other instead of mixed + * in a sum of signals. It's more fun this way to generate interesting + * sounds. If you want to mix differing streams with differing volumes, + * channel balance and phase shifts, just create multiple single-channel + * generators with a convenient format (float encoding comes to mind) + * and mix to your heart's desire. You can then still use this library + * to get your channel buffers interleaved and converted to something + * your output device likes. + * + * You can ensure strict periodicity without possible shifts in phases + * due to floating point rounding errors with the buffered variant. + * That may adjust your chosen frequencies to be able to keep the limit + * on buffer size, but the resulting data is then strictly periodic + * without any further computations that may introduce timing errors. + * Apart from possibly saving computing time via the precomputed table, + * this is the reason to pre-mix multiple waves into a common buffer at + * all. + * + * The adjustments of the wave frequencies also include limiting them + * between some minimal value and the Nyquist frequency. Without the + * buffer, you can happily choose waves that are not resolved at all + * by the sampling rate and get the nasty results. Things get nasty + * inside the buffer, too, when you approach the Nyquist limit, but that + * is life (and mathematics). + * + * The default wave is a 440 Hz sine without phase offset. If any setting + * is missing, the default is taken from that. + * + * \param sh handle + * \param count number of waves (if zero, one default wave is configured) + * \param id array of wave IDs (enum syn123_wave_id), may be NULL + * \param freq array of wave frequencies, may be NULL + * Your provided frequencies are overwritten with the actual + * values if the periodic buffer is chosen. + * \param phase array of wave phases, may be NULL + * \param backwards array of true (non-zero) or false (zero), indicating + whether the wave is being inverted in time, may be NULL + * \param period address to store the size of the period buffer + * in samples (zero if not using the buffer), ignored if NULL + * \return success code + */ +MPG123_EXPORT +int syn123_setup_waves( syn123_handle* sh, size_t count +, int *id, double *freq, double *phase, int* backwards +, size_t *period ); + +/** Query current wave generator setup and state. + * + * This lets you extract the setup of the wave generator and + * the current phases to be able to re-create it and continue + * seamlessly, or maybe intentionally in some tweaked form with + * slight phase or frequency shifts. + * + * You only need to set target pointers to non-NULL where you + * want the corresponding values extracted. You need to have + * the storage prepared for the correct wave count. A common + * mode of usage might be to make a first call to only query + * the count, allocate storage, then a do a second call for the + * wave data. + * + * \param sh handle + * \param count address to store number of waves + * \param id storage for array of wave IDs + * \param freq storage for array of wave frequencies + * \param phase storage for array of wave phases + * \param backwards storage for array of true (non-zero) or false (zero), + * indicating whether the wave is being inverted in time + * \param period address to store the size of the period buffer + * in samples (zero if not using the buffer) + * \return success code + */ +MPG123_EXPORT +int syn123_query_waves( syn123_handle* sh, size_t *count +, int *id, double *freq, double *phase, int* backwards +, size_t *period ); + +/** Return the name of the indicated wave pattern. + * \param id The numerical ID of the wave pattern + * (out of enum syn123_wave_id). + * \return The name string, guaranteed to be non-NULL. + * Invalid codes yield the string "???". + */ +MPG123_EXPORT +const char* syn123_wave_name(int id); + +/** Return the wave pattern id given a name string. + * \param name The name string. + * \return The numerical id (out of enum syn123_wave_id). + * + */ +MPG123_EXPORT +int syn123_wave_id(const char *name); + +/** Types of frequency sweeps. + * There are no functions mapping those to/from strings, + * as this list is supposed to be fixed and small. + * There are only so many types of sweeps that make sense. + */ +enum syn123_sweep_id +{ + SYN123_SWEEP_LIN = 0 /**< linear frequency change */ +, SYN123_SWEEP_QUAD /**< quadratic frequency change */ +, SYN123_SWEEP_EXP /**< exponential (octave per time unit) */ +, SYN123_SWEEP_LIMIT /**< valid IDs less than that */ +}; + +/** Frequency sweep generator. + * This generates a sweep from one frequency to another with one + * of the available wave shapes over a given time. + * While you can just extract your single sweep by exactly reading + * the requestet duration, the generator is set up to run the sweep + * a bit longer until the beginning phase is reached again + * (one sample before that, of course). That way, reasonably smooth + * periodic playback from the buffer is possible without that nasty jump. + * Still, a large freqency difference will result in an audible pop, + * but at least that is not whole spectrum due to a phase jump. + * \param sh handle + * \param wave_id wave ID (enum syn123_wave_id) + * \param f1 pointer to beginning frequency in Hz (>= 1e-4, please, + * a value <= 0 being replaced by the standard frequency and stored for you) + * \param f2 ending frequency in Hz (>= 1e-4, please, + * in case of exponential sweep: f2-f1 >= 1e-4, too, + * a value <= 0 being replaced by the standard frequency and stored for you) + * \param sweep_id choice of sweep curve (enum syn123_sweep_id) + * \param smooth enable the periodic smoothing, if sensible + * (extending signal beyond the sweep to avoid phase jumps, a continuing + * starting at given start phase, not the returned endphase) + * \param duration duration of sweep in samples (> 1, please) + * This theoretically should be an off_t relating to the size of a + * file you produce, but off_t in API headers causes headaches. + * A 32 bit size_t still gives you over 24 hours of sweeping with 44100 kHz + * rate. On top of that, you can use the returned endphase to chop + * your monster sweep into pieces. + * \param phase initial phase of the sweep + * \param backwards invert the waveform in time if true + * \param endphase address to store the normal phase that would + * smoothly continue the signal without the period correction + * (You can create a following sweep that continues smoothly to a new + * target frequency by handing in this endphase as initial phase. Combine + * that with phases of constant tone and you could simulate a Theremin + * player by approximating the reaction to hand movements via sweeps.) + * \param period address to store the periodic sample count, usually + * being a bit bigger than the duration for getting the phase + * back down; does not imply use of the internal period buffer + * \param buffer_period address to store the period count only if the + * period buffer is actually in use + */ +MPG123_EXPORT +int syn123_setup_sweep( syn123_handle* sh +, int wave_id, double phase, int backwards +, int sweep_id, double *f1, double *f2, int smooth, size_t duration +, double *endphase, size_t *period, size_t *buffer_period ); + +/** Set up pink noise generator. + * This employs the Gardner/McCartney method to the approximate + * the real thing. The number of rows in the tree pattern is tunable. + * The result is pink noise with around 2.5 dB/octave. Do not expect + * more than 32 bits of randomness (or anything;-). + * \param sh handle + * \param rows rows for the generator algorithm + * It maxes out at 30 rows. Below 1 chooses a default. + * \param seed a 32 bit seed value for the pseudo-random number generator + * \param period optional address to store the size of the enforced period + * (zero for endlessly freshly generated signal) + * \return success code + */ +MPG123_EXPORT +int syn123_setup_pink( syn123_handle *sh, int rows, unsigned long seed +, size_t *period ); + +/** Set up white noise generator. + * A simple white noise source using some cheap pseudo RNG. Do not + * expect more than 32 bits of randomness (or anything;-). + * \param sh handle + * \param seed a 32 bit seed value for the pseudo-random number generator + * \param period optional address to store the size of the + * enforced period (zero for endlessly freshly generated signal) + */ +MPG123_EXPORT +int syn123_setup_white(syn123_handle *sh, unsigned long seed, size_t *period); + +/** Set up Geiger counter simulator. + * This models a speaker that is triggered by the pulses from + * the Geiger-Mueller counter. That creepy ticking sound. + * \param sh handle + * \param activity average events per second + * \param seed a 32 bit seed value for the pseudo-random number generator + * \param period optional address to store the size of the enforced period + * (zero for endlessly freshly generated signal) + * \return success code + */ +MPG123_EXPORT +int syn123_setup_geiger( syn123_handle *sh, double activity +, unsigned long seed, size_t *period ); + +/** Set up silence. + * This goes back to the vanilla state. + * \return success code + */ +MPG123_EXPORT +int syn123_setup_silence(syn123_handle *sh); + +/** Convert between supported encodings. + * The buffers must not overlap. + * Note that syn123 converts -1.0 to -127 for 8 bit signed (and analogous for + * other encodings), but still clips asymmetrically at -128 as that is the + * range of the type. If you do explicit clipping using syn123_clip(), + * the resulting range will be symmetrical inside [-1.0:1.0] and hence + * only down to -127 for 8 bit signed encoding. + * The conversions only work directly either from anything to double/float or + * from double/float to anything. This process is wrapped in the routine if + * a handle is provided, using the fixed mixing buffer in that. Clipping + * is only handled for floating point to integer conversions. Also, NaN + * is set to zero on conversion and counted as clipped. + * The ulaw and alaw conversions use Sun's reference implementation of the + * G711 standard (differing from libmpg123's big lookup table). + * + * \param dst destination buffer + * \param dst_enc destination encoding (enum mpg123_enc_enum) + * \param dst_size size of destination buffer in bytes + * \param src source buffer + * \param src_enc source encoding + * \param src_bytes source buffer size in bytes + * \param dst_bytes optional address to store the written byte count to + * \param clipped optional address to store number of clipped samples to + * \param sh an optional syn123_handle which enables arbitrary encoding + * conversions by utilizing the contained buffer as intermediate storage, + * can be NULL, disabling any conversion not involving floating point + * input or output + * \return success code + */ +MPG123_EXPORT +int syn123_conv( void * MPG123_RESTRICT dst, int dst_enc, size_t dst_size +, void * MPG123_RESTRICT src, int src_enc, size_t src_bytes +, size_t *dst_bytes, size_t *clipped, syn123_handle * sh ); + +/** The range of decibel values handled by syn123 goes from + * -SYN123_DB_LIMIT to +SYN123_DB_LIMIT + * This value ensures that a resulting linear volume can still + * be expressed using single-precision float. + * The resulting amplitude from -500 dB is still small enough + * to drive a 32 bit integer sample value orders of magnitude below + * 1, so it is effectively a zero. Note that physical volume controls + * typically give a range as small as 60 dB. You might want to present + * a tighter range to the user than +/- 500 dB! + */ +#define SYN123_DB_LIMIT 500 + +/** Convert decibels to linear volume (amplitude factor). + * This just returns pow(10, db/20) in the supported range. + * The dB value is limited according to SYN123_DB_LIMIT, with + * NaN being put at the lower end of the range. Better silent + * than insanely loud. + * \param db relative volume in dB + * \return linear volume factor + */ +MPG123_EXPORT double syn123_db2lin(double db); + +/** Convert linear volume (amplitude factor) to decibels. + * This just returns 20*log10(volume) in the supported range. + * The returned value is limited according to SYN123_DB_LIMIT, with + * NaN being put at the lower end of the range. Better silent + * than insanely loud. + * \param volume linear volume factor + * \return relative volume in dB + */ +MPG123_EXPORT double syn123_lin2db(double volume); + +/** Amplify given buffer. + * This multiplies all samples by the given floating point value + * (possibly converting to/from floating point on the fly, if a + * handle with the included working buffer is given). + * Also an offset correction is provided. + * + * \param buf the buffer to work on + * \param encoding the sample encoding + * \param samples number of samples + * \param volume linear volume factor (use syn123_db2lin() for + * applying a change in dB) + * \param offset offset to add to the sample values before + * multiplication + * \param clipped optional address to store number of clipped samples to + * \param sh optional handle to enable work on non-float + * encodings + * \return success code (e.g. bad encoding without handle) + */ +MPG123_EXPORT +int syn123_amp( void* buf, int encoding, size_t samples +, double volume, double offset, size_t *clipped, syn123_handle *sh ); + +/** Clip samples in buffer to default range. + * This only does anything with floating point encoding, but you can always + * call it without damage as a no-op on other encodings. After this, the + * samples are guaranteed to be in the range [-1,+1]. NaNs are mapped + * to zero (and counted as clipped), so they will still sound bad. + * If you want to hard clip to a smaller range, use syn123_soft_clip() with + * a width of zero. + * \param buf buffer to work on + * \param encoding sample encoding + * \param samples total number of samples + * \return number of clipped samples + */ +MPG123_EXPORT +size_t syn123_clip(void *buf, int encoding, size_t samples); + +/** Soft clipping / cheap limiting. + * This limits the samples above the threshold of limit-width with a + * smooth curve, dampening the high-frequency content of the clipping. + * This is no proper frequency filter, but just an independent function on + * each sample value, also ignorant of the channel count. This can + * directly work on float encodings and does nothing on others unless + * a handle is provided for on-line conversion. + * \param buf buffer to work on + * \param encoding sample encoding + * \param samples total number of samples + * \param limit the limit to clip to (normally 1 for full scale) + * \param width smoothing range + * \param sh optional handle to work on non-float encodings + * \return number of clipped samples + */ +MPG123_EXPORT +size_t syn123_soft_clip( void *buf, int encoding, size_t samples +, double limit, double width, syn123_handle *sh ); + +/** Interleave given number of channels into one stream. + * A rather trivial functionality, here for completeness. As the + * algorithm is agnostic to what is actually stored as a "sample", + * the parameter types are so generic that you could use these + * functions to arrange huge structs (hence samplesize as size_t) + * or whatever. If that makes sense is up to you. + * The buffers shall not overlap! + * \param dst destination buffer + * \param src source buffer array (one per channel) + * \param channels channel count + * \param samplesize size of one sample + * \param samplecount count of samples per channel + */ +MPG123_EXPORT +void syn123_interleave( void * MPG123_RESTRICT dst, void** MPG123_RESTRICT src +, int channels, size_t samplesize, size_t samplecount ); + +/** Deinterleave given number of channels out of one stream. + * A rather trivial functionality, here for completeness. As the + * algorithm is agnostic to what is actually stored as a "sample", + * the parameter types are so generic that you could use these + * functions to arrange huge structs (hence samplesize as size_t) + * or whatever. If that makes sense is up to you. + * The buffers must not overlap! + * \param dst destination buffer array (one per channel) + * \param src source buffer + * \param channels channel count + * \param samplesize size of one sample (see MPG123_SAMPLESIZE) + * \param samplecount count of samples per channel + */ +MPG123_EXPORT +void syn123_deinterleave( void ** MPG123_RESTRICT dst, void * MPG123_RESTRICT src +, int channels, size_t samplesize, size_t samplecount ); + +/** Simply copies mono samples into an interleaved stream. + * This might be implemented by a call to syn123_interleave(), it might + * be optimized to something different. You could have fun measuring that. + * \param dst destination buffer + * \param src source buffer + * \param channels channel count + * \param samplesize size of one sample (see MPG123_SAMPLESIZE) + * \param samplecount count of samples per channel + */ +MPG123_EXPORT +void syn123_mono2many( void * MPG123_RESTRICT dst, void * MPG123_RESTRICT src +, int channels, size_t samplesize, size_t samplecount ); + +/** A little helper/reminder on how interleaved format works: + * Produce the offset of the given sample for the given channel. + */ +#define SYN123_IOFF(sample, channel, channels) ((sample)*(channels)+(channel)) + +/** Specify floating point encoding to use for preserving precision in + * intermediate computations for given source and destination encoding. + * This should return either MPG123_ENC_FLOAT_32 or MPG123_ENC_FLOAT_64, + * unless an uncertain future adds things like 16 bit fp ... + * This is what syn123_conv() and syn123_mix() will use internally if + * intermediate conversion is necessary. + * Note that 64 bit floating point material will be mixed in 32 bit if the + * destination encoding does not need more precision. + * \param src_enc source/input encoding + * \param dst_enc destination/output encoding + * \return encoding value, zero if none can be chosen (invalid parameters) + */ +MPG123_EXPORT +int syn123_mixenc(int src_enc, int dst_enc); + +/** Mix n input channels on top of m output channels. + * This takes an interleaved input stream and mixes its channels + * into the output stream given a channel matrix (m,n) where + * each of the m rows contains the n volume factors (weights) + * to apply when summing the samples from the n input channels. + * Sample values are added to what is already present unless + * initial silence is explicitly requested. + * This works directly with identical floating point encodings. It + * may have some optimization to work faster with mono or stereo on + * either side and slower generic code for arbitrary channel counts. + * You can use syn123_conv() to convert from/to input/output encodings + * or provide a syn123_handle to do it on the fly. + * There are no optimizations for special cases of mixing factors, so + * you should always be able to predict the number of floating point + * operations being executed. + * For fun, you could give the same problem to a BLAS implementation + * of your choice and compare the performance;-) + * \param dst destination buffer + * \param dst_enc output sample encoding, must be MPG123_ENC_FLOAT_32 or + * MPG123_ENC_FLOAT_64 unless a syn123_handle is provided + * \param dst_channels destination channel count (m) + * \param src source buffer + * \param src_enc input sample encoding, must be MPG123_ENC_FLOAT_32 or + * MPG123_ENC_FLOAT_64 unless a syn123_handle is provided + * \param src_channels source channel count (n) + * \param mixmatrix mixing factors ((m,n) matrix), same encoding as + * the audio data + * \param samples count of samples (PCM frames) to work on + * \param silence Set to non-zero value to intialize the output + * to a silent signal before adding the input. + * \param clipped optional address to store number of clipped samples to + * (in case of mixing to an integer encoding) + * \param sh an optional syn123_handle which enables work on non-float + * encodings by utilizing the contained buffer as intermediate storage, + * converting to/from float transparently; Note that this may limit + * the amount of channels depending on the fixed internal buffer space. + * As long as you have up to 128 channels, you should not worry. + * \return success code (e.g. bad encoding, channel counts ...) + */ +MPG123_EXPORT +int syn123_mix( void * MPG123_RESTRICT dst, int dst_enc, int dst_channels +, void * MPG123_RESTRICT src, int src_enc, int src_channels +, const double * mixmatrix +, size_t samples, int silence, size_t *clipped, syn123_handle *sh ); + +/** Set up a generic digital filter. + * + * This takes a filter order N and coefficient set to prepare + * the internal state of a digital filter defined by the transfer + * function + * \f[ + * + * H(z) = \frac + * {b_0 + b_1 z^{-1} + ... + b_N z^{-N}} + * {1 + a_1 z^{-1} + ... + a_N z^{-N}} + * \f] + * It is your task to come up with fun values for the coefficients + * b_n and a_n to implement various FIR and IIR filters. + * + * Since it is easy to do and useful, this configures not only a single + * filter but a chain of them. If you do configure a chain, the choice + * of mixenc and channels must match. No conversion between filters. + * + * \param sh mandatory handle + * \param append if true, append a filter to the chain, fresh chain otherwise + * \param order filter order N (filter length minus one) + * \param b nominator coefficients, starting with b_0 (order+1 elements) + * \param a denominator coefficients, starting with a_0=1 (order+1 elements). + * It is an error to provide a sequence that does not start with 1. + * For a non-recursive (FIR) filter, you can set all following + * values from a_1 on to zero or choose to provide a NULL pointer. + * \param mixenc either MPG123_ENC_FLOAT_32 or MPG123_ENC_FLOAT_64 for + * computation in single or double precision, can be zero to refer to + * the value demanded by an already present filter + * \param channels number of channels in the audio signal, can be zero + * to refer to the value demanded by an already present filter + * \param init_firstval If non-zero, initialize the filter history with + * a constant stream of the first encountered sample instead of zero. + * \return success code + */ +MPG123_EXPORT +int syn123_setup_filter( syn123_handle *sh +, int append, unsigned int order, double *b, double *a +, int mixenc, int channels, int init_firstval ); + +/** init_firstval is the effective setting (extreme coefficients may remove the distinction) */ + +MPG123_EXPORT +int syn123_query_filter( syn123_handle *sh, size_t position +, size_t *count, unsigned int *order, double *b, double *a +, int *mixenc, int *channels, int *init_firstval ); + +/** drop the n last filters */ +MPG123_EXPORT +void syn123_drop_filter(syn123_handle *sh, size_t count); + +/** Apply a prepared digital filter. + * + * This applies the filter prepared by syn123_setup_filter to yur + * provided buffer in single or double precision float. + * Handing in a non-float encoding is an error. You are supposed + * to convert and clip before/after applying the filters. + * + * If you got no filters configured, this always succeeds and + * does nothing. + * + * \param sh handle + * \param buf audio data to work on (channel count matching what + * was given to mpg123_setup_filter()) + * \param encoding audio encoding + * \param samples count of samples (PCM frames) in the buffer + * \return success code + */ +MPG123_EXPORT +int syn123_filter( syn123_handle *sh +, void* buf, int encoding, size_t samples ); + +/** Set up the resampler. + * + * This works independently of the signal generators. You can combine + * syn123_setup_resample() with syn123_setup_geiger(), for example. + * + * People can get worked up a lot about differing algorithms for resampling, + * while many folks can actually bear the simple drop/repeat method and most + * probably do not bother about the distortions from linear resampling. + * A testament to this is that in the 18 years of me maintaining mpg123, I + * got bugged about the missing dithering and on subtle bias in shuffling + * a playlist, but people seem to insist on using the NtoM resampoler inside + * libmpg123, despite me warning about its horrible consequences for audio + * quality. It is a plain drop-sample implementation. The only good things to + * say about it is that it is cheap and is embedded with the sample-accurate + * decoder so that you do not have to worry about offsets in terms of input + * and output samples. + * + * Anyhow, this is my take on a reasonably good and efficient resampler that is + * neither the best-sounding, nor the fastest in terms of CPU time, but gets + * by without significant latency. It needs far less computation than usual + * high-quality windowed-sinc resampling (libsamplerate), but cannot beat + * libsoxr with its FFT-based approach. The less stringent dirty mode (using + * only a 72 dB lowpass filter, in practice still close to CD-DA quality) + * comes quite close, though. + * + * The selling point is that it produces output samples as soon as you start + * feeding, without any buffering of future samples to fill a window for the + * FIR filter or the Fourier transform. It employs IIR filters for low-passing, + * possibly in multiple stages for decimation, and optimized interpolation + * formulas using up to 6 points. These formulas, based on research by + * Olli Niemitalo using using Differential Evolution, are what enables a + * dynamic range of 108 dB, well above 16 bit CD-DA quality. Simple + * cubic splines after low-passing distort up to around -40 dB in my tests. + * + * There is some effective signal delay well below 10 samples. The impulse + * response is about 3 samples late, so this is well inside the realm of + * (nonlinear) phase shift. The phase distortion looks bad on paper but does + * not matter much in the intended domain of application: the final change in + * sampling rate before playback on audio hardware, the last filter that is + * applied before the sound hits the speakers (or all the other filters + * implemented in your audio harware, that you can choose to be ignorant + * about). Use better resamplers for mixing in the studio. Use better + * resamplers for converting files on disk. For live playback, consider this + * one because it is good enough, fast enough, cheap enough. + * + * Note that if you call this function repeatedly, the internal history + * is only cleared if you change anything besides the sampling rates. If + * only the rates change, the state of the resampler is kept to enable + * you to continue on prior data. This means you can vary the resampling + * ratio during operation, somewhat smoothly depending on your buffer size. + * + * Also note that even on identical input and output rates, the resampler + * will apply the full filtering as for any ratio close to that, including + * oversampling. No special shortcuts. + * + * A returned error guarantees that the internal resampler setup has + * been cleared (frees a little bit of memory). You can provide zero + * inrate, outrate, and channel count at the same time to that effect + * without an error message being produced (but still SYN123_BAD_FMT + * being returned). + * + * \param sh mandatory handle + * \param inrate input sample rate (nominator of ratio) + * \param outrate output sample rate (denominator of ratio) + * \param channels number of interleaved channels + * \param dirty Enable (!= 0) the dirty mode for even more 'good enough' + * resampling with less computing time. Offers -72 dB low pass attentuation, + * worst-case distortion around that, too, and 85% worst-case bandwidth. + * With this set to zero, the normal mode is used, offering at least 108 dB + * dynamic range and worst-case bandwidth above 84%. + * \param smooth Enable (!=0) extra code smoothing the resampler response to + * on-the-fly changes of sampling rate ratio. This involves keeping + * some per-stage history to bootstrap additional decimation filters and the + * changed final lowpass/interpolation. + * \return success code + */ +MPG123_EXPORT +int syn123_setup_resample( syn123_handle *sh, long inrate, long outrate +, int channels, int dirty, int smooth ); + +/** Return the maximum allowed value for sample rates given to the resampler. + * + * Not every possible value of the underlying data type is a valid sample + * rate for the resampler. It needs some headroom for computations. This + * function returns the maximal rate you can specify. For 32-bit long, this + * will be above 1e9, for 64-bit long above 4e18. The minimum is 1, of course. + * So, with 32 bit, you can speed up/down by a factor of one million if you + * want to keep 0.1% precision in the rates. + * + * \return upper sample rate limit + */ +MPG123_EXPORT +long syn123_resample_maxrate(void); + +/** Give upper limit for output sample count from the resampler. + * + * Since there is some rounding involved, the exact number of output samples + * from the resampler, being given a certain amount of input samples, can + * vary (one more or less than expected). This function is here to give you + * a safe output buffer size given a certain input buffer size. If you intend + * to vary the output rate for a fixed input rate, you may compute the output + * buffer size for the largest intended output rate and use that throughout. + * The same applies to the input sample count. + * A return value of zero indicates an error (zero, negative, or too large + * rate given) unless the given input sample count is also zero. + * The resampler only produces output when given new input. + * \param inrate input sample rate + * \param outrate output sample rate + * \param ins input sample count for one buffer + * \return number of maximum output samples for one buffer, or zero + * if no sensible value exists + */ +MPG123_EXPORT +size_t syn123_resample_count(long inrate, long outrate, size_t ins); + +/** Return the amount of input samples needed to recreate resample filter state. + * + * This returns a number of input samples that should fill the internal + * filter states good enough for output being close to that produced from + * the full input since the beginning. Since recursive filters are employed, + * there is no exact number that recreates a state apart from the full sequence + * that created it the first time. This number here shall be more than the + * non-recursive history, but not by a huge factor. For extreme cases, this + * value may be saturated at SIZE_MAX and thus smaller than what is demanded + * by the above definition. It is assumed that you define a maximal practical + * size of history to consider for your application, anyway. + * + * \param inrate input sample rate + * \param outrate output sample rate + * \param dirty switch for dirty resampling mode (see syn123_setup_resample()) + * \return number of input samples to fill history, zero on error + */ +MPG123_EXPORT +size_t syn123_resample_history(long inrate, long outrate, int dirty); + +/** Compute the minimal input sample count needed for given output sample count. + * + * The reverse of syn123_resample_count(), in a way. This gives you the + * minimum amount of input samples to guarantee at least the desired amount + * of output samples. Once you got that, ensure to call syn123_resample_count() + * to get a safe buffer size for that amount of input and prepare accordingly. + * With this approach, you can ensure that you get your realtime output device + * buffer filled with each loop run fetching a bit of input, at the expense + * of handling some additional buffering for the returned sample counts above + * the minimum. + * + * \param input_rate input sample rate + * \param output_rate output sample rate + * \param outs desired minimal output sample count for one input buffer + * \return number of minimal input samples in one buffer, or zero if no + * sensible value exists (invalid input parameters, or zero outs) + */ +MPG123_EXPORT +size_t syn123_resample_incount(long input_rate, long output_rate, size_t outs); + +/** Compute the input sample count needed for close to given output sample + * count, but never more. + * + * Call this to get a safe fixed count of input samples to make best use + * of a preallocated output buffer, filling it as much as safely possible. + * This can also be achieved by calling syn123_resample_incount() and reducing + * the value until syn123_resample_count() fits into your buffer. + * + * \param input_rate input sample rate + * \param output_rate output sample rate + * \param outs desired output sample count for one input buffer + * \return number of input samples in one buffer, or zero if no + * sensible value exists (invalid input parameters, or zero outs) + */ +MPG123_EXPORT +size_t syn123_resample_fillcount(long input_rate, long output_rate, size_t outs); + + +/** Compute the maximum number of input samples for a resampling buffer. + * + * Upsampling means that you will get more output samples than input samples. + * This larger number still needs to fit into the data type for sample + * counts. So please don't feed more than the value returned here. + * + * \param input_rate input sample rate + * \param output_rate output sample rate + * \return maximum safe input sample count + */ +MPG123_EXPORT +size_t syn123_resample_maxincount(long input_rate, long output_rate); + +/** Give exact output sample count for feeding given input now. + * + * This gives you the exact number of samples you will get returned + * when feeding the resampler the given additional input samples now, + * given the current resampler state contained in the handle. + * + * On error, zero is returned and the error code is set to a nonzero + * syn123 error code. + * + * \param sh syn123 handle + * \param ins input sample count + * \param err location to store error code + * \return output sample count + */ +MPG123_EXPORT +size_t syn123_resample_out(syn123_handle *sh, size_t ins, int *err); + +/** Give minimum input sample count needed now for given output. + * + * This give you the minimal number of input samples needed right + * now to yield at least the specified amount of output samples. + * Since one input sample can result in several output sampels in one + * go, you have to check using syn123_resample_out() how many + * output samples to really expect. + * + * On error, zero is returned and the error code is set to a nonzero + * syn123 error code. + * + * \param sh syn123 handle + * \param outs output sample count + * \param err location to store error code + * \return minimal input sample count + */ +MPG123_EXPORT +size_t syn123_resample_in(syn123_handle *sh, size_t outs, int *err); + +/** Give exact output sample count for total input sample count. + * + * Use this to determine the total length of your output stream + * given the length of the input stream. The computation is exact. + * But: It is only valid for a constant sampling rate ratio. If you + * play with that during runtime, you need to figure out your output + * offset yourself. + * + * \param inrate input sample rate + * \param outrate output sample rate + * \param ins input sample count for the whole stream + * \return number of output samples or -1 if the computation fails + * (bad/too large sampling rates, integer overflow) + */ +MPG123_EXPORT +int64_t syn123_resample_total64(long inrate, long outrate, int64_t ins); + +/** Give minimum input sample count for total output sample count. + * + * You need to feed at least that amount of input samples to get + * the desired amount of output samples from the resampler. Depending + * on the resampling ratio, you may in fact get more than the desired + * amount (one input sample being worth multiple output samples during + * upsampling) so make sure to call syn123_resample_total() to get + * the exact number of samples you need to prepare for. + * Again, the output offset is only meaninful for a constant sampling + * rate ratio. + * + * \param inrate input sample rate + * \param outrate output sample rate + * \param outs output sample count for the whole stream + * \return number of input samples or -1 if the computation fails + * (bad/too large sampling rates, integer overflow) + */ +MPG123_EXPORT +int64_t syn123_resample_intotal64(long inrate, long outrate, int64_t outs); + +/** Resample input buffer to output buffer. + * + * This executes the resampling configured by syn123_setup_resample(). The + * input and output encoding is fixed at single-precision float + * (MPG123_ENC_FLOAT_32) and multiple channels are interleaved. There + * is no implicit conversion of other encodings since the fixed internal + * buffers for that may not fit your chosen extreme resampling ratios. Also, + * dealing with double precision does not make sense with the mathematical + * limitations of the employed filters. + * + * You are responsible for having your buffers prepared with the correct sizes. + * Use syn123_resample_count() to ensure that you are prepared for the correct + * number of output samples given your input sample count. + * + * Also, ensuring a minimal number of input samples using + * syn123_resample_incount() helps to identify an error situation where zero + * samples are returned (which would be valid for low input sample count). + * The only error apart from handing in an invalid/unprepared handle is + * a too large number of input samples. Check syn123_resample_maxincount(). + * + * \param sh handle with prepared resampling method + * If this is NULL or if the resampler has not been initialized before, the + * function returns zero instead of crashing randomly. + * \param dst destination buffer + * \param src source buffer + * \param samples input samples (PCM frames) in source buffer + * \return number of output samples (PCM frames) + */ +MPG123_EXPORT +size_t syn123_resample( syn123_handle *sh, + float * MPG123_RESTRICT dst, float * MPG123_RESTRICT src, size_t samples ); + +/** Swap byte order between little/big endian. + * \param buf buffer to work on + * \param samplesize size of one sample (see MPG123_SAMPLESIZE) + * \param samplecount count of samples + */ +MPG123_EXPORT +void syn123_swap_bytes(void* buf, size_t samplesize, size_t samplecount); + +/* Wrappers over the above to convert to/from syn123's native byte order + from/to little or big endian. */ + +/** Convert from host order to little endian. + * \param buf buffer to work on + * \param samplesize size of one sample (see MPG123_SAMPLESIZE) + * \param samplecount count of samples + */ +MPG123_EXPORT +void syn123_host2le(void *buf, size_t samplesize, size_t samplecount); + +/** Convert from host order to big endian. + * \param buf buffer to work on + * \param samplesize size of one sample (see MPG123_SAMPLESIZE) + * \param samplecount count of samples + */ +MPG123_EXPORT +void syn123_host2be(void *buf, size_t samplesize, size_t samplecount); + +/** Convert from little endian to host order. + * \param buf buffer to work on + * \param samplesize size of one sample (see MPG123_SAMPLESIZE) + * \param samplecount count of samples + */ +MPG123_EXPORT +void syn123_le2host(void *buf, size_t samplesize, size_t samplecount); + +/** Convert from big endian to host order. + * \param buf buffer to work on + * \param samplesize size of one sample (see MPG123_SAMPLESIZE) + * \param samplecount count of samples + */ +MPG123_EXPORT +void syn123_be2host(void *buf, size_t samplesize, size_t samplecount); + +// You are invited to defined SYN123_PORTABLE_API to avoid seeing shape-shifting off_t +// anywhere, also to avoid using non-standard types like ssize_t. +#if !defined(SYN123_PORTABLE_API) && !defined(SYN123_NO_LARGEFUNC) + +/** A little hack to help MSVC not having ssize_t, duplicated in internal header. */ +#ifdef _MSC_VER +#include +typedef ptrdiff_t syn123_ssize_t; +#else +typedef ssize_t syn123_ssize_t; +#endif + +/** Give exact output sample count for feeding given input now. + * + * Old variant of syn123_resample_out() that (ab)uses ssize_t. + * + * \deprecated Use syn123_resample_out() instead. + * The return of errors (integer overflow in + * calculation)is broken, as both the error codes and the valid results + * are positive integers. I screwed up. + * + * \param sh syn123 handle + * \param ins input sample count + * \return output sample count or error code, hard to distinguish + */ +MPG123_EXPORT +syn123_ssize_t syn123_resample_expect(syn123_handle *sh, size_t ins); + +/** Give minimum input sample count needed now for given output. + * + * Old variant of syn123_resample_in() that (ab)uses ssize_t. + * + * \deprecated Use syn123_resample_in() instead. + * The return of errors (integer overflow in + * calculation)is broken, as both the error codes and the valid results + * are positive integers. I screwed up. + * + * \param sh syn123 handle + * \param outs output sample count + * \return minimal input sample count or error code, hard to distinguish + */ +MPG123_EXPORT +syn123_ssize_t syn123_resample_inexpect(syn123_handle *sh, size_t outs); + +/* Lightweight large file hackery to enable worry-reduced use of off_t. + Depending on the size of off_t in your client build, the corresponding + library function needs to be chosen. */ + +#if defined(_FILE_OFFSET_BITS) && !defined(MPG123_NO_LARGENAME) +# if _FILE_OFFSET_BITS+0 == 32 +# define syn123_resample_total syn123_resample_total_32 +# define syn123_resample_intotal syn123_resample_intotal_32 +# elif _FILE_OFFSET_BITS+0 == 64 +# define syn123_resample_total syn123_resample_total_64 +# define syn123_resample_intotal syn123_resample_intotal_64 +# else +# error "Unpredicted _FILE_OFFSET_BITS value." +# endif +#endif + +/** Give exact output sample count for total input sample count. + * + * This is syn123_resample_total64() with shape-shifting off_t, + * possibly renamed by macro. For type safety, use the former. + * + * \deprecated Use syn123_resample_total64() instead. + * + * \param inrate input sample rate + * \param outrate output sample rate + * \param ins input sample count for the whole stream + * \return number of output samples or -1 if the computation fails + * (bad/too large sampling rates, integer overflow) + */ +MPG123_EXPORT +off_t syn123_resample_total(long inrate, long outrate, off_t ins); + +/** Give minimum input sample count for total output sample count. + * + * This is syn123_resample_intotal64() with shape-shifting off_t, + * possibly renamed by macro. For type safety, use the former. + * + * \deprecated Use syn123_resample_intotal64() instead. + * + * \param inrate input sample rate + * \param outrate output sample rate + * \param outs output sample count for the whole stream + * \return number of input samples or -1 if the computation fails + * (bad/too large sampling rates, integer overflow) + */ +MPG123_EXPORT +off_t syn123_resample_intotal(long inrate, long outrate, off_t outs); + +#endif + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/app/src/main/lib/mpg123/lib/x86_64/libmpg123.so b/app/src/main/lib/mpg123/lib/x86_64/libmpg123.so new file mode 100644 index 0000000000000000000000000000000000000000..e664a5065039351205fd55d24ca5da05e3282c8e GIT binary patch literal 337496 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

92=G5CMa_`jJwPN=t;0R&JZ@E;dq@nGC&^FuL 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%0DiS;lt7Wr&F_W8de#O!|?C@+fc} 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