Unit unaMpgLibAPI

Loads mpglib.

Unloads mpglib.

Loads libmpg123 library.

Parameters

proto

Routines prototypes.

libName

Name for library. Default '' means default name will be used.

Returns

MPG123_BAD_PARAM if some or all of exports could not be found.

Unloads libmpg123.

Parameters

proto

Routines prototypes.

– –

– –

– –

– –

#include "lame-analysis.h" #ifndef NOANALYSIS extern plotting_data *mpg123_pinfo; #endif – buf –

– framebuf –

– –

\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... * * @{ *

signed integer parameter

unsigned integer parameter

offset parameter or result code

float parameter

pointer to buffer parameter

signed integer result

pointer to array of chars

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. *

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. *

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. *

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. * * \return Non-NULL pointer when successful. *

Delete handle, mh is either a valid mpg123 handle or NULL. *

Enumeration of the parameters types that it is possible to set/get. *

Flag bits for MPG123_FLAGS, use the usual binary or to combine. *

choices for MPG123_RVA *

Set a specific parameter, for a specific mpg123_handle, using a parameter * type key chosen from the mpg123_parms enumeration, to the specified value. */

Get a specific parameter, for a specific mpg123_handle. * See the mpg123_parms enumeration for a list of available parameters. *

Enumeration of the message and error codes and returned by libmpg123 functions. *

Return a string describing that error errcode means. *

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. *

Return the plain errcode intead of a string. *

\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). * * @{ *

Return a NULL-terminated array of generally available decoder names (plain 8bit ASCII). *

Return a NULL-terminated array of the decoders supported by the CPU (plain 8bit ASCII). *

Set the chosen decoder to 'decoder_name' *

16 or 8 bits, signed or unsigned... all flags fit into 15 bits and are designed to have meaningful binary AND/OR. * Adding float and 32bit int definitions for experimental fun. Only 32bit (and possibly 64bit) float is * somewhat there with a dedicated library build. *

They can be combined into one number (3) to indicate mono and 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. *

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. *

Configure a mpg123 handle to accept no output format at all, * use before specifying supported formats with mpg123_format *

Configure mpg123 handle to accept all formats * (also any custom rate you may set) – this is default. *

Set the audio format support of a mpg123_handle in detail: * \param mh audio decoder 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. *

Check to see if a specific format at a specific rate is supported * by mpg123_handle. * \return 0 for no support (that includes invalid parameters), MPG123_STEREO, * MPG123_MONO or MPG123_STEREO|MPG123_MONO. *

Get the current output format written to the addresses givenr. *

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(). *

Use an already opened file descriptor as the bitstream input * mpg123_close() will _not_ close the file descriptor. *

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. *

Closes the source, if libmpg123 opened it. *

Read from stream and decode up to outmemsize bytes. * \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 error/message code (watch out for MPG123_DONE and friends!) *

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 in input buffer * \param size number of input bytes * \return error/message code. *

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 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) *

Decode next MPEG frame to internal buffer * or read a frame and return after setting a new format. * \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 *

Returns the current position in samples. * On the next read, you'd get that sample. *

Returns the frame number that the next read will give you data from. *

Returns the current byte offset in the input stream. *

Seek to a desired sample offset. * Set whence to SEEK_SET, SEEK_CUR or SEEK_END. * \return The resulting offset >= 0 or error/message code *

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 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 *

Seek to a desired MPEG frame index. * Set whence to SEEK_SET, SEEK_CUR or SEEK_END. * \return The resulting offset >= 0 or error/message code *

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 *

pointer to array of offsets

Give access to the frame index table that is managed for seeking. * You are asked not to modify the values... unless you are really aware of what you are doing. * \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 *

Get information about current and remaining frames/seconds. * WARNING: This function is there because of special usage by standalone mpg123 and may be removed in the final version of libmpg123! * You provide an offset (in frames) from now and a number of output bytes * served by libmpg123 but not yet played. You get the projected current frame * and seconds, as well as the remaining frames/seconds. This does _not_ care * about skipped samples due to gapless playback. *

* \defgroup mpg123_voleq mpg123 volume and equalizer

Set the 32 Band Audio Equalizer settings. * \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. *

Get the 32 Band Audio Equalizer settings. * \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. *

Reset the 32 Band Audio Equalizer settings to flat *

Set the absolute output volume including the RVA setting, * vol<0 just applies (a possibly changed) RVA setting. *

Adjust output volume including the RVA setting by chosen amount *

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. *

Enumeration of the mode types of Variable Bitrate *

Enumeration of the MPEG Versions *

Enumeration of the MPEG Audio mode. * Only the mono mode has 1 channel, the others have 2 channels. *

Enumeration of the MPEG Audio flag bits *

Data structure for storing information about a frame of MPEG Audio *

Get frame information about the MPEG audio bitstream and store it in a mpg123_frameinfo structure. *

Get the safe output buffer size for all cases (when you want to replace the internal buffer) *

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. * \return MPG123_OK or MPG123_ERR. *

Return, if possible, the full (expected) length of current track in samples. * \return length >= 0 or MPG123_ERR if there is no length guess possible. *

Override the value for file size in bytes. * Useful for getting sensible track length values in feed mode or for HTTP streams. * \return MPG123_OK or MPG123_ERR *

Returns the time (seconds) per frame; <0 is error. *

Get and reset the clip count. *

The key values for state information from mpg123_getstate(). *

Get various current decoder/stream state information. * \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 or MPG123_ERR for success *

Data structure for storing strings in a safer way than a standard C-String. * Can also hold a number of null-terminated strings. *

Create and allocate memory for a new mpg123_string *

Free-up mempory for an existing mpg123_string *

Change the size of a mpg123_string * \return 0 on error, 1 on success *

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. * \return 0 on error, 1 on success *

Copy the contents of one mpg123_string string to another. * \return 0 on error, 1 on success *

Append a C-String to an mpg123_string * \return 0 on error, 1 on success *

Append a C-substring to an mpg123 string * \return 0 on error, 1 on success * \param from offset to copy from * \param count number of characters to copy (a null-byte is always appended) *

Set the conents of a mpg123_string to a C-string * \return 0 on error, 1 on success *

Set the contents of a mpg123_string to a C-substring * \return 0 on error, 1 on success * \param from offset to copy from * \param count number of characters to copy (a null-byte is always appended) *

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 has 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). *

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. *

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[19] = track_number * It is your task to support ID3v1 only or ID3v1.1 ...*

Query if there is (new) meta info, be it ID3 or ICY (or something new in future). The check function returns a combination of flags. *

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 Return value is MPG123_OK or MPG123_ERR, *

Point icy_meta to existing data structure wich may change on any next read/decode function call. * \return Return value is MPG123_OK or MPG123_ERR, *

Decode from windows-1252 (the encoding ICY metainfo used) to UTF-8. * \param icy_text The input data in ICY encoding * \return pointer to newly allocated buffer with UTF-8 data (You free() it!) *

Opaque structure for the libmpg123 decoder parameters. *

Create a handle with preset parameters. *

Allocate memory for and return a pointer to a new mpg123_pars *

Delete and free up memory used by a mpg123_pars data structure *

Configure mpg123 parameters to accept no output format at all, * use before specifying supported formats with mpg123_format *

Configure mpg123 parameters to accept all formats * (also any custom rate you may set) – this is default. *

Set the audio format support of a mpg123_pars in detail: \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 0 on success, -1 if there was an error. / *

Check to see if a specific format at a specific rate is supported * by mpg123_pars. * \return 0 for no support (that includes invalid parameters), MPG123_STEREO, * MPG123_MONO or MPG123_STEREO|MPG123_MONO. *

Set a specific parameter, for a specific mpg123_pars, using a parameter * type key chosen from the mpg123_parms enumeration, to the specified value. *

Get a specific parameter, for a specific mpg123_pars. * See the mpg123_parms enumeration for a list of available parameters. *

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. *

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. *

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 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). *

libmpg123 prototype –

– –

copyToStream is not used

OnFormatChange prototype

Parameters

sender

Sender of event.

rate

Sampling rate (44100, etc)

numChannels

Number of channels (1 - mono, 2 - stereo)

numBits

Number of bits (8, 16, 24, etc)

encoding

Refer to MPG123_ENC_XXX constants.

AUDIOBUFSIZE = n*64 with n=1,2,3 ... */

sync_bitstream: int; error codes

*< MPEG Version 1.0 */

*< MPEG Version 2.0 */

*< Variable Bitrate Mode */

*< set all flags, p.ex val = MPG123_GAPLESS|MPG123_MONO_MIX (integer) */

*< No 8bit encoding possible. */

*< Incompatible numeric data types. */

*< Bad parameter id! */

*< Unable to set up output format! */

*< You didn't initialize the library! */

*< Build does not support stream timeouts. */

*< Invalid decoder choice. */

*< Bad parameter handle. */

*< You gave a null pointer somewhere where you shouldn't have. */

*< Success */

*< Unable to allocate memory for 16 to 8 converter table! */

*< No stream opened. */

*< Invalid channel number specified. */

*< Unable to initialize frame buffers (out of memory?). */

*< Not enough buffer space. */

*< Cannot seek from end (end is not known). */

*< The bitstream is error protected using 16-bit CRC. */

*< start with this frame (skip frames before that, integer) */

*< one of the RVA choices above (integer) */

*< when value > 0, force output rate to that value (integer) */

*< 0000 0000 1111 Some 8 bit integer encoding. */

*< 0000 0100 0000 Some 16 bit integer encoding. */

*< 0000 0000 0100 ulaw 8 bit*/

*< 0100 0000 0000 64bit float */

*< 0000 1000 0000 Some signed integer encoding. */

*< 0001 0010 0000 unsigned 32 bit */

*< 0010 0000 0000 32bit float */

*< 0001 0000 0000 Some 32 bit integer encoding. */

*< 1110 0000 0000 Some float encoding. */

*< 0000 0000 1000 alaw 8 bit */

*< 0000 0000 0001 unsigned 8 bit*/

*< 0000 1000 0010 signed 8 bit*/

*< 0000 1101 0000 signed 16 bit */

*< 0001 1001 0000 signed 32 bit */

*< 0000 0110 0000 unsigned 16 bit*/

*< Message: For feed reader: "Feed me more!" */

*< Invalid sample rate specified. */

*< Bad equalizer band. */

*< Null pointer given where valid storage address needed. */

*< set verbosity value for enabling messages to stderr, >= 0 makes sense (integer) */

*< 1000 Force stereo output. */

*< add some flags (integer) */

*< 0100 Force playback of mixed mono. */

*< 000100000000 Enable small buffer on non-seekable streams to allow some peek-ahead (for better MPEG sync). */

*< 00100000 Suppress any printouts (overrules verbose). */

*< 0001 There is ID3 info that changed since last call to mpg123_id3. */

*< decode only this number of frames (integer) */

*< Genre index. */

*< No frame index in this build. */

*< Try resync on frame parsing for that many bytes or until end of stream (<0 ... integer). */

*< The Right Channel. */

*< 0111 Force some mono mode: This is a test bitmask for seeing if any mono forcing is active. */

*< 0010 Force playback of right channel only. */

*< 0001 Force playback of left channel only. */

*< Joint Stereo. */

*< Standard Stereo. */

*< Dual Channel. */

*< Message: Output format will be different on next call. */

*< Message: Track ended. */

*< 1100 There is some ICY info. Also matches 0100 or NEW_ICY.*/

*< 0011 There is some ID3 info. Also matches 0010 or NEW_ID3. */

*< Out of memory – some malloc() failed. */

*< Resync failed to find valid MPEG data. */

*< Invalid mpg123 handle. */

*< Invalid RVA mode. */

*< Bad key value given. */

*< Seek not supported by stream. */

*< NULL input buffer with non-zero size... */

*< 01000000 Enable gapless decoding (default on if libmpg123 has support). */

*< File access error. */

*< Error reading the stream. */

*< This build doesn't support gapless decoding. */

*< Invalid 'whence' for seek function.*/

*< Stack aligmnent error */

*< Relative seek not possible (screwed up file offset) */

*< Generic Error */

*< The private bit has been set. */

*< stream contains ICY metadata with this interval (integer) */

*< Bad buffer given – invalid pointer or too small size. */

*< Bad parameters to mpg123_index() */

*< The bitstream is copyrighted. */

*< 00010000 Force 8bit formats. */

*< timeout for reading from a stream (not supported on win32, integer) */

*< Lost track in bytestream and did not try to resync. */

*< remove some flags (inverse of MPG123_ADD_FLAGS, integer) */

*< The Left Channel. */

*< 0=native rate, 1=half rate, 2=quarter rate (integer) */

*< Use mix/track/radio gain. */

*< Use album/audiophile gain */

*< RVA disabled (default). */

*< 10000000 Disable resync stream after error. */

*< play every Nth frame (integer) */

*< the scale for output samples (amplitude - integer or float according to mpg123 output format, normally integer) */

*< play a frame N times (integer) */

*< Constant Bitrate Mode (default) */

additional

Layer 2 */

————– mpg123.h ————–

—— common.c ————