mpg123.h

Go to the documentation of this file.

/*
    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"
 
#define MPG123_API_VERSION 48
#define MPG123_PATCHLEVEL  3
 
#ifndef MPG123_EXPORT
#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
 
#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 <stddef.h>
#include <stdint.h>
 
#ifndef MPG123_PORTABLE_API
#include <sys/types.h>
/* 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
 
 
/* 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. If explicit usage of 64 bit offsets is desired, the int64_t API
    (functions with 64 suffix without underscore, notablly mpg123_reader64()) can be used since
    API version 48 (mpg123 1.32).
 
    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 API and be happy. Both 32 and 64
    bit versions will be present where appropriate.
*/
 
#ifndef MPG123_PORTABLE_API
/*
    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_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
 
struct mpg123_handle_struct;
 
typedef struct mpg123_handle_struct mpg123_handle;
 
const char *mpg123_distversion(unsigned int *major, unsigned int *minor, unsigned int *patch);
 
unsigned int mpg123_libversion(unsigned int *patch);
 
MPG123_EXPORT int mpg123_init(void);
 
MPG123_EXPORT void mpg123_exit(void);
 
MPG123_EXPORT mpg123_handle *mpg123_new(const char* decoder, int *error);
 
MPG123_EXPORT void mpg123_delete(mpg123_handle *mh);
 
MPG123_EXPORT void mpg123_free(void *ptr);
 
enum mpg123_parms
{
    MPG123_VERBOSE = 0,        
    MPG123_FLAGS,          
    MPG123_ADD_FLAGS,      
    MPG123_FORCE_RATE,     
    MPG123_DOWN_SAMPLE,    
    MPG123_RVA,            
    MPG123_DOWNSPEED,      
    MPG123_UPSPEED,        
    MPG123_START_FRAME,    
    MPG123_DECODE_FRAMES,  
    MPG123_ICY_INTERVAL,   
    MPG123_OUTSCALE,       
    MPG123_TIMEOUT,        
    MPG123_REMOVE_FLAGS,   
    MPG123_RESYNC_LIMIT,   
    MPG123_INDEX_SIZE      
    ,MPG123_PREFRAMES 
    ,MPG123_FEEDPOOL  
    ,MPG123_FEEDBUFFER 
    ,MPG123_FREEFORMAT_SIZE 
};
 
enum mpg123_param_flags
{
     MPG123_FORCE_MONO   = 0x7  
    ,MPG123_MONO_LEFT    = 0x1  
    ,MPG123_MONO_RIGHT   = 0x2  
    ,MPG123_MONO_MIX     = 0x4  
    ,MPG123_FORCE_STEREO = 0x8  
    ,MPG123_FORCE_8BIT   = 0x10 
    ,MPG123_QUIET        = 0x20 
    ,MPG123_GAPLESS      = 0x40 
    ,MPG123_NO_RESYNC    = 0x80 
    ,MPG123_SEEKBUFFER   = 0x100 
    ,MPG123_FUZZY        = 0x200 
    ,MPG123_FORCE_FLOAT  = 0x400 
    ,MPG123_PLAIN_ID3TEXT = 0x800 
    ,MPG123_IGNORE_STREAMLENGTH = 0x1000 
    ,MPG123_SKIP_ID3V2 = 0x2000 
    ,MPG123_IGNORE_INFOFRAME = 0x4000 
    ,MPG123_AUTO_RESAMPLE = 0x8000 
    ,MPG123_PICTURE = 0x10000 
    ,MPG123_NO_PEEK_END    = 0x20000 
    ,MPG123_FORCE_SEEKABLE = 0x40000 
    ,MPG123_STORE_RAW_ID3  = 0x80000 
    ,MPG123_FORCE_ENDIAN   = 0x100000 
    ,MPG123_BIG_ENDIAN     = 0x200000 
    ,MPG123_NO_READAHEAD   = 0x400000 
    ,MPG123_FLOAT_FALLBACK = 0x800000 
    ,MPG123_NO_FRANKENSTEIN = 0x1000000 
};
 
enum mpg123_param_rva
{
     MPG123_RVA_OFF   = 0 
    ,MPG123_RVA_MIX   = 1 
    ,MPG123_RVA_ALBUM = 2 
    ,MPG123_RVA_MAX   = MPG123_RVA_ALBUM 
};
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT int mpg123_param( mpg123_handle *mh
,   enum mpg123_parms type, long value, double fvalue );
#endif
 
MPG123_EXPORT int mpg123_param2( mpg123_handle *mh
,   int type, long value, double fvalue );
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT int mpg123_getparam( mpg123_handle *mh
,   enum mpg123_parms type, long *value, double *fvalue );
#endif
 
MPG123_EXPORT int mpg123_getparam2( mpg123_handle *mh
,   int type, long *value, double *fvalue );
 
enum mpg123_feature_set
{
     MPG123_FEATURE_ABI_UTF8OPEN = 0     
    ,MPG123_FEATURE_OUTPUT_8BIT          
    ,MPG123_FEATURE_OUTPUT_16BIT         
    ,MPG123_FEATURE_OUTPUT_32BIT         
    ,MPG123_FEATURE_INDEX                
    ,MPG123_FEATURE_PARSE_ID3V2          
    ,MPG123_FEATURE_DECODE_LAYER1        
    ,MPG123_FEATURE_DECODE_LAYER2        
    ,MPG123_FEATURE_DECODE_LAYER3        
    ,MPG123_FEATURE_DECODE_ACCURATE      
    ,MPG123_FEATURE_DECODE_DOWNSAMPLE    
    ,MPG123_FEATURE_DECODE_NTOM          
    ,MPG123_FEATURE_PARSE_ICY            
    ,MPG123_FEATURE_TIMEOUT_READ         
    ,MPG123_FEATURE_EQUALIZER            
    ,MPG123_FEATURE_MOREINFO             
    ,MPG123_FEATURE_OUTPUT_FLOAT32      
    ,MPG123_FEATURE_OUTPUT_FLOAT64      
};
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT int mpg123_feature(const enum mpg123_feature_set key);
#endif
 
MPG123_EXPORT int mpg123_feature2(int key);
 
enum mpg123_errors
{
    MPG123_DONE=-12,    
    MPG123_NEW_FORMAT=-11,  
    MPG123_NEED_MORE=-10,   
    MPG123_ERR=-1,          
    MPG123_OK=0,            
    MPG123_BAD_OUTFORMAT,   
    MPG123_BAD_CHANNEL,     
    MPG123_BAD_RATE,        
    MPG123_ERR_16TO8TABLE,  
    MPG123_BAD_PARAM,       
    MPG123_BAD_BUFFER,      
    MPG123_OUT_OF_MEM,      
    MPG123_NOT_INITIALIZED, 
    MPG123_BAD_DECODER,     
    MPG123_BAD_HANDLE,      
    MPG123_NO_BUFFERS,      
    MPG123_BAD_RVA,         
    MPG123_NO_GAPLESS,      
    MPG123_NO_SPACE,        
    MPG123_BAD_TYPES,       
    MPG123_BAD_BAND,        
    MPG123_ERR_NULL,        
    MPG123_ERR_READER,      
    MPG123_NO_SEEK_FROM_END,
    MPG123_BAD_WHENCE,      
    MPG123_NO_TIMEOUT,      
    MPG123_BAD_FILE,        
    MPG123_NO_SEEK,         
    MPG123_NO_READER,       
    MPG123_BAD_PARS,        
    MPG123_BAD_INDEX_PAR,   
    MPG123_OUT_OF_SYNC, 
    MPG123_RESYNC_FAIL, 
    MPG123_NO_8BIT, 
    MPG123_BAD_ALIGN,   
    MPG123_NULL_BUFFER, 
    MPG123_NO_RELSEEK,  
    MPG123_NULL_POINTER, 
    MPG123_BAD_KEY, 
    MPG123_NO_INDEX,    
    MPG123_INDEX_FAIL,  
    MPG123_BAD_DECODER_SETUP,   
    MPG123_MISSING_FEATURE  
    ,MPG123_BAD_VALUE 
    ,MPG123_LSEEK_FAILED 
    ,MPG123_BAD_CUSTOM_IO 
    ,MPG123_LFS_OVERFLOW 
    ,MPG123_INT_OVERFLOW 
    ,MPG123_BAD_FLOAT 
};
 
MPG123_EXPORT const char* mpg123_plain_strerror(int errcode);
 
MPG123_EXPORT const char* mpg123_strerror(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_errcode(mpg123_handle *mh);
 
MPG123_EXPORT const char **mpg123_decoders(void);
 
MPG123_EXPORT const char **mpg123_supported_decoders(void);
 
MPG123_EXPORT int mpg123_decoder(mpg123_handle *mh, const char* decoder_name);
 
MPG123_EXPORT const char* mpg123_current_decoder(mpg123_handle *mh);
 
enum mpg123_channelcount
{
     MPG123_MONO   = 1 
    ,MPG123_STEREO = 2 
};
 
MPG123_EXPORT void mpg123_rates(const long **list, size_t *number);
 
MPG123_EXPORT void mpg123_encodings(const int **list, size_t *number);
 
MPG123_EXPORT int mpg123_encsize(int encoding);
 
MPG123_EXPORT int mpg123_format_none(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_format_all(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_format( mpg123_handle *mh
,   long rate, int channels, int encodings );
 
MPG123_EXPORT int mpg123_format2( mpg123_handle *mh
,   long rate, int channels, int encodings );
 
MPG123_EXPORT int mpg123_format_support( mpg123_handle *mh
,   long rate, int encoding );
 
MPG123_EXPORT int mpg123_getformat( mpg123_handle *mh
,   long *rate, int *channels, int *encoding );
 
MPG123_EXPORT int mpg123_getformat2( mpg123_handle *mh
,   long *rate, int *channels, int *encoding, int clear_flag );
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT int mpg123_open_fixed(mpg123_handle *mh, const char *path
,   int channels, int encoding);
 
MPG123_EXPORT int mpg123_open(mpg123_handle *mh, const char *path);
 
MPG123_EXPORT int mpg123_open_fd(mpg123_handle *mh, int fd);
#endif
 
MPG123_EXPORT int mpg123_open_handle(mpg123_handle *mh, void *iohandle);
 
MPG123_EXPORT int mpg123_open_feed(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_close(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_read(mpg123_handle *mh
,   void *outmemory, size_t outmemsize, size_t *done );
 
MPG123_EXPORT int mpg123_feed( mpg123_handle *mh
,   const unsigned char *in, size_t size );
 
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
MPG123_EXPORT int mpg123_decode_frame( mpg123_handle *mh
,   off_t *num, unsigned char **audio, size_t *bytes );
 
MPG123_EXPORT int mpg123_framebyframe_decode( mpg123_handle *mh
,   off_t *num, unsigned char **audio, size_t *bytes );
#endif /* un-portable API */
 
MPG123_EXPORT int mpg123_decode_frame64( mpg123_handle *mh
,   int64_t *num, unsigned char **audio, size_t *bytes );
 
MPG123_EXPORT int mpg123_framebyframe_decode64( mpg123_handle *mh
,   int64_t *num, unsigned char **audio, size_t *bytes );
 
MPG123_EXPORT int mpg123_framebyframe_next(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_framedata( mpg123_handle *mh
,   unsigned long *header, unsigned char **bodydata, size_t *bodybytes );
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT off_t mpg123_framepos(mpg123_handle *mh);
#endif
 
MPG123_EXPORT int64_t mpg123_framepos64(mpg123_handle *mh);
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT off_t mpg123_tell(mpg123_handle *mh);
#endif
 
MPG123_EXPORT int64_t mpg123_tell64(mpg123_handle *mh);
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT off_t mpg123_tellframe(mpg123_handle *mh);
#endif
 
MPG123_EXPORT int64_t mpg123_tellframe64(mpg123_handle *mh);
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT off_t mpg123_tell_stream(mpg123_handle *mh);
#endif
 
MPG123_EXPORT int64_t mpg123_tell_stream64(mpg123_handle *mh);
 
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT off_t mpg123_seek( mpg123_handle *mh
,   off_t sampleoff, int whence );
#endif
 
MPG123_EXPORT int64_t mpg123_seek64( mpg123_handle *mh
,   int64_t sampleoff, int whence );
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT off_t mpg123_feedseek( mpg123_handle *mh
,   off_t sampleoff, int whence, off_t *input_offset );
#endif
 
MPG123_EXPORT int64_t mpg123_feedseek64( mpg123_handle *mh
,   int64_t sampleoff, int whence, int64_t *input_offset );
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT off_t mpg123_seek_frame( mpg123_handle *mh
,   off_t frameoff, int whence );
#endif
 
MPG123_EXPORT int64_t mpg123_seek_frame64( mpg123_handle *mh
,   int64_t frameoff, int whence );
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT off_t mpg123_timeframe(mpg123_handle *mh, double sec);
 
MPG123_EXPORT int mpg123_index( mpg123_handle *mh
,   off_t **offsets, off_t *step, size_t *fill );
#endif
 
MPG123_EXPORT int64_t mpg123_timeframe64(mpg123_handle *mh, double sec);
 
MPG123_EXPORT int mpg123_index64( mpg123_handle *mh
,   int64_t **offsets, int64_t *step, size_t *fill );
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT int mpg123_set_index( mpg123_handle *mh
,   off_t *offsets, off_t step, size_t fill );
#endif
 
MPG123_EXPORT int mpg123_set_index64( mpg123_handle *mh
,   int64_t *offsets, int64_t step, size_t fill );
 
 
#ifndef MPG123_PORTABLE_API
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
 
enum mpg123_channels
{
     MPG123_LEFT=0x1    
    ,MPG123_RIGHT=0x2   
    ,MPG123_LR=0x3  
};
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT int mpg123_eq( mpg123_handle *mh
,   enum mpg123_channels channel, int band, double val );
#endif
 
MPG123_EXPORT int mpg123_eq2( mpg123_handle *mh
,   int channel, int band, double val );
 
MPG123_EXPORT int mpg123_eq_bands( mpg123_handle *mh
,   int channel, int a, int b, double factor );
 
MPG123_EXPORT int mpg123_eq_change( mpg123_handle *mh
,   int channel, int a, int b, double db );
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT double mpg123_geteq(mpg123_handle *mh
                                 , enum mpg123_channels channel, int band);
#endif
 
MPG123_EXPORT double mpg123_geteq2(mpg123_handle *mh, int channel, int band);
 
MPG123_EXPORT int mpg123_reset_eq(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_volume(mpg123_handle *mh, double vol);
 
MPG123_EXPORT int mpg123_volume_change(mpg123_handle *mh, double change);
 
MPG123_EXPORT int mpg123_volume_change_db(mpg123_handle *mh, double db);
 
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? */
 
enum mpg123_vbr {
    MPG123_CBR=0,   
    MPG123_VBR,     
    MPG123_ABR      
};
 
enum mpg123_version {
    MPG123_1_0=0,   
    MPG123_2_0,     
    MPG123_2_5      
};
 
 
enum mpg123_mode {
    MPG123_M_STEREO=0,  
    MPG123_M_JOINT,     
    MPG123_M_DUAL,      
    MPG123_M_MONO       
};
 
 
enum mpg123_flags {
    MPG123_CRC=0x1,         
    MPG123_COPYRIGHT=0x2,   
    MPG123_PRIVATE=0x4,     
    MPG123_ORIGINAL=0x8 
};
 
#ifdef MPG123_ENUM_API
struct mpg123_frameinfo
{
    enum mpg123_version version;    
    int layer;                      
    long rate;                      
    enum mpg123_mode mode;          
    int mode_ext;                   
    int framesize;                  
    enum mpg123_flags flags;        
    int emphasis;                   
    int bitrate;                    
    int abr_rate;                   
    enum mpg123_vbr vbr;            
};
#endif
 
struct mpg123_frameinfo2
{
    int version;   
    int layer;     
    long rate;     
    int mode;      
    int mode_ext;  
    int framesize; 
    int flags;     
    int emphasis;  
    int bitrate;   
    int abr_rate;  
    int vbr;       
};
 
struct mpg123_moreinfo
{
    double xr[2][2][576];  
    double sfb[2][2][22];  
    double sfb_s[2][2][3*13]; 
    int qss[2][2];  
    int big_values[2][2]; 
    int sub_gain[2][2][3]; 
    int scalefac_scale[2][2]; 
    int preflag[2][2]; 
    int blocktype[2][2]; 
    int mixed[2][2]; 
    int mainbits[2][2]; 
    int sfbits[2][2]; 
    int scfsi[2]; 
    int maindata; 
    int padding; 
};
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT int mpg123_info(mpg123_handle *mh, struct mpg123_frameinfo *mi);
#endif
 
MPG123_EXPORT int mpg123_info2(mpg123_handle *mh, struct mpg123_frameinfo2 *mi);
 
MPG123_EXPORT int mpg123_set_moreinfo( mpg123_handle *mh
,   struct mpg123_moreinfo *mi );
 
MPG123_EXPORT size_t mpg123_safe_buffer(void);
 
MPG123_EXPORT int mpg123_scan(mpg123_handle *mh);
 
#ifndef MPG123_PORTABLE_API
MPG123_EXPORT off_t mpg123_framelength(mpg123_handle *mh);
 
MPG123_EXPORT off_t mpg123_length(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_set_filesize(mpg123_handle *mh, off_t size);
#endif
 
MPG123_EXPORT int64_t mpg123_framelength64(mpg123_handle *mh);
 
MPG123_EXPORT int64_t mpg123_length64(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_set_filesize64(mpg123_handle *mh, int64_t size);
 
MPG123_EXPORT double mpg123_tpf(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_spf(mpg123_handle *mh);
 
MPG123_EXPORT long mpg123_clip(mpg123_handle *mh);
 
 
enum mpg123_state
{
     MPG123_ACCURATE = 1 
    ,MPG123_BUFFERFILL   
    ,MPG123_FRANKENSTEIN 
    ,MPG123_FRESH_DECODER 
    ,MPG123_ENC_DELAY 
    ,MPG123_ENC_PADDING 
    ,MPG123_DEC_DELAY 
};
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT int mpg123_getstate( mpg123_handle *mh
,   enum mpg123_state key, long *val, double *fval );
#endif
 
MPG123_EXPORT int mpg123_getstate2( mpg123_handle *mh
,   int key, long *val, double *fval );
 
typedef struct 
{
    char* p;     
    size_t size; 
    size_t fill; 
} mpg123_string;
 
MPG123_EXPORT mpg123_string* mpg123_new_string(const char* val);
 
MPG123_EXPORT void mpg123_delete_string(mpg123_string* sb);
 
MPG123_EXPORT void mpg123_init_string(mpg123_string* sb);
 
MPG123_EXPORT void mpg123_free_string(mpg123_string* sb);
 
MPG123_EXPORT int mpg123_resize_string(mpg123_string* sb, size_t news);
 
MPG123_EXPORT int mpg123_grow_string(mpg123_string* sb, size_t news);
 
MPG123_EXPORT int mpg123_copy_string(mpg123_string* from, mpg123_string* to);
 
MPG123_EXPORT int mpg123_move_string(mpg123_string* from, mpg123_string* to);
 
MPG123_EXPORT int mpg123_add_string(mpg123_string* sb, const char* stuff);
 
MPG123_EXPORT int mpg123_add_substring( mpg123_string *sb
,   const char *stuff, size_t from, size_t count );
 
MPG123_EXPORT int mpg123_set_string(mpg123_string* sb, const char* stuff);
 
MPG123_EXPORT int mpg123_set_substring( mpg123_string *sb
,   const char *stuff, size_t from, size_t count );
 
MPG123_EXPORT size_t mpg123_strlen(mpg123_string *sb, int utf8);
 
MPG123_EXPORT int mpg123_chomp_string(mpg123_string *sb);
 
MPG123_EXPORT int mpg123_same_string(mpg123_string *a, mpg123_string *b);
 
enum mpg123_text_encoding
{
     mpg123_text_unknown  = 0 
    ,mpg123_text_utf8     = 1 
    ,mpg123_text_latin1   = 2 
    ,mpg123_text_icy      = 3 
    ,mpg123_text_cp1252   = 4 
    ,mpg123_text_utf16    = 5 
    ,mpg123_text_utf16bom = 6 
    ,mpg123_text_utf16be  = 7 
    ,mpg123_text_max      = 7 
};
 
enum mpg123_id3_enc
{
     mpg123_id3_latin1   = 0 
    ,mpg123_id3_utf16bom = 1 
    ,mpg123_id3_utf16be  = 2 
    ,mpg123_id3_utf8     = 3 
    ,mpg123_id3_enc_max  = 3 
};
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT enum mpg123_text_encoding mpg123_enc_from_id3(unsigned char id3_enc_byte);
#endif
 
MPG123_EXPORT int mpg123_enc_from_id3_2(unsigned char id3_enc_byte);
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT int mpg123_store_utf8(mpg123_string *sb, enum mpg123_text_encoding enc, const unsigned char *source, size_t source_size);
#endif
 
MPG123_EXPORT int mpg123_store_utf8_2(mpg123_string *sb
,   int enc, const unsigned char *source, size_t source_size);
 
typedef struct
{
    char lang[3]; 
    char id[4];   
    mpg123_string description; 
    mpg123_string text;        
} mpg123_text;
 
enum mpg123_id3_pic_type
{
     mpg123_id3_pic_other          =  0 
    ,mpg123_id3_pic_icon           =  1 
    ,mpg123_id3_pic_other_icon     =  2 
    ,mpg123_id3_pic_front_cover    =  3 
    ,mpg123_id3_pic_back_cover     =  4 
    ,mpg123_id3_pic_leaflet        =  5 
    ,mpg123_id3_pic_media          =  6 
    ,mpg123_id3_pic_lead           =  7 
    ,mpg123_id3_pic_artist         =  8 
    ,mpg123_id3_pic_conductor      =  9 
    ,mpg123_id3_pic_orchestra      = 10 
    ,mpg123_id3_pic_composer       = 11 
    ,mpg123_id3_pic_lyricist       = 12 
    ,mpg123_id3_pic_location       = 13 
    ,mpg123_id3_pic_recording      = 14 
    ,mpg123_id3_pic_performance    = 15 
    ,mpg123_id3_pic_video          = 16 
    ,mpg123_id3_pic_fish           = 17 
    ,mpg123_id3_pic_illustration   = 18 
    ,mpg123_id3_pic_artist_logo    = 19 
    ,mpg123_id3_pic_publisher_logo = 20 
};
 
typedef struct
{
    char type;                 
    mpg123_string description; 
    mpg123_string mime_type;   
    size_t size;               
    unsigned char* data;       
} mpg123_picture;
 
typedef struct
{
    unsigned char version; 
    mpg123_string *title;   
    mpg123_string *artist;  
    mpg123_string *album;   
    mpg123_string *year;    
    mpg123_string *genre;   
    mpg123_string *comment; 
    /* 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; 
    size_t          comments;     
    mpg123_text    *text;         
    size_t          texts;        
    mpg123_text    *extra;        
    size_t          extras;       
    mpg123_picture  *picture;     
    size_t           pictures;    
} mpg123_id3v2;
 
typedef struct
{
    char tag[3];         
    char title[30];      
    char artist[30];     
    char album[30];      
    char year[4];        
    char comment[30];    
    unsigned char genre; 
} mpg123_id3v1;
 
#define MPG123_ID3     0x3 
#define MPG123_NEW_ID3 0x1 
#define MPG123_ICY     0xc 
#define MPG123_NEW_ICY 0x4 
MPG123_EXPORT int mpg123_meta_check(mpg123_handle *mh);
 
MPG123_EXPORT void mpg123_meta_free(mpg123_handle *mh);
 
MPG123_EXPORT int mpg123_id3( mpg123_handle *mh
,   mpg123_id3v1 **v1, mpg123_id3v2 **v2 );
 
MPG123_EXPORT int mpg123_id3_raw( mpg123_handle *mh
,   unsigned char **v1, size_t *v1_size
,   unsigned char **v2, size_t *v2_size );
 
MPG123_EXPORT int mpg123_icy(mpg123_handle *mh, char **icy_meta);
 
MPG123_EXPORT char* mpg123_icy2utf8(const char* icy_text);
 
 
struct mpg123_pars_struct;
 
typedef struct mpg123_pars_struct   mpg123_pars;
 
MPG123_EXPORT mpg123_handle *mpg123_parnew( mpg123_pars *mp
,   const char* decoder, int *error );
 
MPG123_EXPORT mpg123_pars *mpg123_new_pars(int *error);
 
MPG123_EXPORT void mpg123_delete_pars(mpg123_pars* mp);
 
MPG123_EXPORT int mpg123_fmt_none(mpg123_pars *mp);
 
MPG123_EXPORT int mpg123_fmt_all(mpg123_pars *mp);
 
MPG123_EXPORT int mpg123_fmt(mpg123_pars *mp
,   long rate, int channels, int encodings);
 
MPG123_EXPORT int mpg123_fmt2(mpg123_pars *mp
,   long rate, int channels, int encodings);
 
MPG123_EXPORT int mpg123_fmt_support(mpg123_pars *mp, long rate, int encoding);
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT int mpg123_par( mpg123_pars *mp
,   enum mpg123_parms type, long value, double fvalue );
#endif
 
MPG123_EXPORT int mpg123_par2( mpg123_pars *mp
,   int type, long value, double fvalue );
 
#ifdef MPG123_ENUM_API
MPG123_EXPORT int mpg123_getpar( mpg123_pars *mp
,   enum mpg123_parms type, long *value, double *fvalue );
#endif
 
MPG123_EXPORT int mpg123_getpar2( mpg123_pars *mp
,   int type, long *value, double *fvalue );
 
MPG123_EXPORT int mpg123_replace_buffer(mpg123_handle *mh
,   void *data, size_t size);
 
MPG123_EXPORT size_t mpg123_outblock(mpg123_handle *mh);
 
#ifndef MPG123_PORTABLE_API
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)
);
 
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
 
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