diff --git a/README.md b/README.md index cb7459f94..0e6c0b389 100644 --- a/README.md +++ b/README.md @@ -89,6 +89,8 @@ Vinifera makes use of third-party libraries to help implement features. Below is - [LodePNG](https://lodev.org/lodepng/) - [Image-Resampler](https://github.com/ramenhut/image-resampler) - [XZip](https://www.codeproject.com/Articles/4135/XZip-and-XUnzip-Add-zip-and-or-unzip-to-your-app-w?msg=3792406) + - [libogg](https://github.com/xiph/ogg/) + - [libvorbis](https://github.com/xiph/vorbis) # Anti-virus Warning diff --git a/src/libs/libogg/ogg.h b/src/libs/libogg/ogg.h new file mode 100644 index 000000000..b79bac01b --- /dev/null +++ b/src/libs/libogg/ogg.h @@ -0,0 +1,209 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 * + * by the Xiph.Org Foundation http://www.xiph.org/ * + * * + ******************************************************************** + + function: toplevel libogg include + + ********************************************************************/ +#ifndef _OGG_H +#define _OGG_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +typedef struct { + void *iov_base; + size_t iov_len; +} ogg_iovec_t; + +typedef struct { + long endbyte; + int endbit; + + unsigned char *buffer; + unsigned char *ptr; + long storage; +} oggpack_buffer; + +/* ogg_page is used to encapsulate the data in one Ogg bitstream page *****/ + +typedef struct { + unsigned char *header; + long header_len; + unsigned char *body; + long body_len; +} ogg_page; + +/* ogg_stream_state contains the current encode/decode state of a logical + Ogg bitstream **********************************************************/ + +typedef struct { + unsigned char *body_data; /* bytes from packet bodies */ + long body_storage; /* storage elements allocated */ + long body_fill; /* elements stored; fill mark */ + long body_returned; /* elements of fill returned */ + + + int *lacing_vals; /* The values that will go to the segment table */ + ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact + this way, but it is simple coupled to the + lacing fifo */ + long lacing_storage; + long lacing_fill; + long lacing_packet; + long lacing_returned; + + unsigned char header[282]; /* working space for header encode */ + int header_fill; + + int e_o_s; /* set when we have buffered the last packet in the + logical bitstream */ + int b_o_s; /* set after we've written the initial page + of a logical bitstream */ + long serialno; + long pageno; + ogg_int64_t packetno; /* sequence number for decode; the framing + knows where there's a hole in the data, + but we need coupling so that the codec + (which is in a separate abstraction + layer) also knows about the gap */ + ogg_int64_t granulepos; + +} ogg_stream_state; + +/* ogg_packet is used to encapsulate the data and metadata belonging + to a single raw Ogg/Vorbis packet *************************************/ + +typedef struct { + unsigned char *packet; + long bytes; + long b_o_s; + long e_o_s; + + ogg_int64_t granulepos; + + ogg_int64_t packetno; /* sequence number for decode; the framing + knows where there's a hole in the data, + but we need coupling so that the codec + (which is in a separate abstraction + layer) also knows about the gap */ +} ogg_packet; + +typedef struct { + unsigned char *data; + int storage; + int fill; + int returned; + + int unsynced; + int headerbytes; + int bodybytes; +} ogg_sync_state; + +/* Ogg BITSTREAM PRIMITIVES: bitstream ************************/ + +extern void OGG_APIENTRY oggpack_writeinit(oggpack_buffer *b); +extern int OGG_APIENTRY oggpack_writecheck(oggpack_buffer *b); +extern void OGG_APIENTRY oggpack_writetrunc(oggpack_buffer *b,long bits); +extern void OGG_APIENTRY oggpack_writealign(oggpack_buffer *b); +extern void OGG_APIENTRY oggpack_writecopy(oggpack_buffer *b,void *source,long bits); +extern void OGG_APIENTRY oggpack_reset(oggpack_buffer *b); +extern void OGG_APIENTRY oggpack_writeclear(oggpack_buffer *b); +extern void OGG_APIENTRY oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes); +extern void OGG_APIENTRY oggpack_write(oggpack_buffer *b,unsigned long value,int bits); +extern long OGG_APIENTRY oggpack_look(oggpack_buffer *b,int bits); +extern long OGG_APIENTRY oggpack_look1(oggpack_buffer *b); +extern void OGG_APIENTRY oggpack_adv(oggpack_buffer *b,int bits); +extern void OGG_APIENTRY oggpack_adv1(oggpack_buffer *b); +extern long OGG_APIENTRY oggpack_read(oggpack_buffer *b,int bits); +extern long OGG_APIENTRY oggpack_read1(oggpack_buffer *b); +extern long OGG_APIENTRY oggpack_bytes(oggpack_buffer *b); +extern long OGG_APIENTRY oggpack_bits(oggpack_buffer *b); +extern unsigned char * OGG_APIENTRY oggpack_get_buffer(oggpack_buffer *b); + +extern void OGG_APIENTRY oggpackB_writeinit(oggpack_buffer *b); +extern int OGG_APIENTRY oggpackB_writecheck(oggpack_buffer *b); +extern void OGG_APIENTRY oggpackB_writetrunc(oggpack_buffer *b,long bits); +extern void OGG_APIENTRY oggpackB_writealign(oggpack_buffer *b); +extern void OGG_APIENTRY oggpackB_writecopy(oggpack_buffer *b,void *source,long bits); +extern void OGG_APIENTRY oggpackB_reset(oggpack_buffer *b); +extern void OGG_APIENTRY oggpackB_writeclear(oggpack_buffer *b); +extern void OGG_APIENTRY oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes); +extern void OGG_APIENTRY oggpackB_write(oggpack_buffer *b,unsigned long value,int bits); +extern long OGG_APIENTRY oggpackB_look(oggpack_buffer *b,int bits); +extern long OGG_APIENTRY oggpackB_look1(oggpack_buffer *b); +extern void OGG_APIENTRY oggpackB_adv(oggpack_buffer *b,int bits); +extern void OGG_APIENTRY oggpackB_adv1(oggpack_buffer *b); +extern long OGG_APIENTRY oggpackB_read(oggpack_buffer *b,int bits); +extern long OGG_APIENTRY oggpackB_read1(oggpack_buffer *b); +extern long OGG_APIENTRY oggpackB_bytes(oggpack_buffer *b); +extern long OGG_APIENTRY oggpackB_bits(oggpack_buffer *b); +extern unsigned char * OGG_APIENTRY oggpackB_get_buffer(oggpack_buffer *b); + +/* Ogg BITSTREAM PRIMITIVES: encoding **************************/ + +extern int OGG_APIENTRY ogg_stream_packetin(ogg_stream_state *os, ogg_packet *op); +extern int OGG_APIENTRY ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov, + int count, long e_o_s, ogg_int64_t granulepos); +extern int OGG_APIENTRY ogg_stream_pageout(ogg_stream_state *os, ogg_page *og); +extern int OGG_APIENTRY ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill); +extern int OGG_APIENTRY ogg_stream_flush(ogg_stream_state *os, ogg_page *og); +extern int OGG_APIENTRY ogg_stream_flush_fill(ogg_stream_state *os, ogg_page *og, int nfill); + +/* Ogg BITSTREAM PRIMITIVES: decoding **************************/ + +extern int OGG_APIENTRY ogg_sync_init(ogg_sync_state *oy); +extern int OGG_APIENTRY ogg_sync_clear(ogg_sync_state *oy); +extern int OGG_APIENTRY ogg_sync_reset(ogg_sync_state *oy); +extern int OGG_APIENTRY ogg_sync_destroy(ogg_sync_state *oy); +extern int OGG_APIENTRY ogg_sync_check(ogg_sync_state *oy); + +extern char *OGG_APIENTRY ogg_sync_buffer(ogg_sync_state *oy, long size); +extern int OGG_APIENTRY ogg_sync_wrote(ogg_sync_state *oy, long bytes); +extern long OGG_APIENTRY ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og); +extern int OGG_APIENTRY ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og); +extern int OGG_APIENTRY ogg_stream_pagein(ogg_stream_state *os, ogg_page *og); +extern int OGG_APIENTRY ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op); +extern int OGG_APIENTRY ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op); + +/* Ogg BITSTREAM PRIMITIVES: general ***************************/ + +extern int OGG_APIENTRY ogg_stream_init(ogg_stream_state *os,int serialno); +extern int OGG_APIENTRY ogg_stream_clear(ogg_stream_state *os); +extern int OGG_APIENTRY ogg_stream_reset(ogg_stream_state *os); +extern int OGG_APIENTRY ogg_stream_reset_serialno(ogg_stream_state *os,int serialno); +extern int OGG_APIENTRY ogg_stream_destroy(ogg_stream_state *os); +extern int OGG_APIENTRY ogg_stream_check(ogg_stream_state *os); +extern int OGG_APIENTRY ogg_stream_eos(ogg_stream_state *os); + +extern void OGG_APIENTRY ogg_page_checksum_set(ogg_page *og); + +extern int OGG_APIENTRY ogg_page_version(const ogg_page *og); +extern int OGG_APIENTRY ogg_page_continued(const ogg_page *og); +extern int OGG_APIENTRY ogg_page_bos(const ogg_page *og); +extern int OGG_APIENTRY ogg_page_eos(const ogg_page *og); +extern ogg_int64_t OGG_APIENTRY ogg_page_granulepos(const ogg_page *og); +extern int OGG_APIENTRY ogg_page_serialno(const ogg_page *og); +extern long OGG_APIENTRY ogg_page_pageno(const ogg_page *og); +extern int OGG_APIENTRY ogg_page_packets(const ogg_page *og); + +extern void OGG_APIENTRY ogg_packet_clear(ogg_packet *op); + + +#ifdef __cplusplus +} +#endif + +#endif /* _OGG_H */ diff --git a/src/libs/libogg/oggtypes.h b/src/libs/libogg/oggtypes.h new file mode 100644 index 000000000..2ce0ea9ed --- /dev/null +++ b/src/libs/libogg/oggtypes.h @@ -0,0 +1,162 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002 * + * by the Xiph.Org Foundation http://www.xiph.org/ * + * * + ******************************************************************** + + function: Define a consistent set of types on each platform. + + ********************************************************************/ +#ifndef _OS_TYPES_H +#define _OS_TYPES_H + +/* make it easy on the folks that want to compile the libs with a + different malloc than stdlib */ +#define _ogg_malloc malloc +#define _ogg_calloc calloc +#define _ogg_realloc realloc +#define _ogg_free free + +#if !defined(OGG_APIENTRY) + #define OGG_APIENTRY __cdecl +#endif + +#if defined(_WIN32) + +# if defined(__CYGWIN__) +# include + typedef int16_t ogg_int16_t; + typedef uint16_t ogg_uint16_t; + typedef int32_t ogg_int32_t; + typedef uint32_t ogg_uint32_t; + typedef int64_t ogg_int64_t; + typedef uint64_t ogg_uint64_t; +# elif defined(__MINGW32__) +# include + typedef short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long ogg_int64_t; + typedef unsigned long long ogg_uint64_t; +# elif defined(__MWERKS__) + typedef long long ogg_int64_t; + typedef unsigned long long ogg_uint64_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef short ogg_int16_t; + typedef unsigned short ogg_uint16_t; +# else +# if defined(_MSC_VER) && (_MSC_VER >= 1800) /* MSVC 2013 and newer */ +# include + typedef int16_t ogg_int16_t; + typedef uint16_t ogg_uint16_t; + typedef int32_t ogg_int32_t; + typedef uint32_t ogg_uint32_t; + typedef int64_t ogg_int64_t; + typedef uint64_t ogg_uint64_t; +# else + /* MSVC/Borland */ + typedef __int64 ogg_int64_t; + typedef __int32 ogg_int32_t; + typedef unsigned __int32 ogg_uint32_t; + typedef unsigned __int64 ogg_uint64_t; + typedef __int16 ogg_int16_t; + typedef unsigned __int16 ogg_uint16_t; +# endif +# endif + +#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */ + +# include + typedef int16_t ogg_int16_t; + typedef u_int16_t ogg_uint16_t; + typedef int32_t ogg_int32_t; + typedef u_int32_t ogg_uint32_t; + typedef int64_t ogg_int64_t; + typedef u_int64_t ogg_uint64_t; + +#elif defined(__HAIKU__) + + /* Haiku */ +# include + typedef short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long ogg_int64_t; + typedef unsigned long long ogg_uint64_t; + +#elif defined(__BEOS__) + + /* Be */ +# include + typedef int16_t ogg_int16_t; + typedef uint16_t ogg_uint16_t; + typedef int32_t ogg_int32_t; + typedef uint32_t ogg_uint32_t; + typedef int64_t ogg_int64_t; + typedef uint64_t ogg_uint64_t; + +#elif defined (__EMX__) + + /* OS/2 GCC */ + typedef short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long ogg_int64_t; + typedef unsigned long long ogg_uint64_t; + + +#elif defined (DJGPP) + + /* DJGPP */ + typedef short ogg_int16_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long ogg_int64_t; + typedef unsigned long long ogg_uint64_t; + +#elif defined(R5900) + + /* PS2 EE */ + typedef long ogg_int64_t; + typedef unsigned long ogg_uint64_t; + typedef int ogg_int32_t; + typedef unsigned ogg_uint32_t; + typedef short ogg_int16_t; + +#elif defined(__SYMBIAN32__) + + /* Symbian GCC */ + typedef signed short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef signed int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long int ogg_int64_t; + typedef unsigned long long int ogg_uint64_t; + +#elif defined(__TMS320C6X__) + + /* TI C64x compiler */ + typedef signed short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef signed int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long int ogg_int64_t; + typedef unsigned long long int ogg_uint64_t; + +#else + +# include + +#endif + +#endif /* _OS_TYPES_H */ diff --git a/src/libs/libvorbis/vorbiscodec.h b/src/libs/libvorbis/vorbiscodec.h new file mode 100644 index 000000000..81cd2ebf0 --- /dev/null +++ b/src/libs/libvorbis/vorbiscodec.h @@ -0,0 +1,248 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001 * + * by the Xiph.Org Foundation https://xiph.org/ * + + ******************************************************************** + + function: libvorbis codec headers + + ********************************************************************/ + +#ifndef _vorbis_codec_h_ +#define _vorbis_codec_h_ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#include + +#if defined(_WIN32) && !defined(VORBIS_APIENTRY) + #define VORBIS_APIENTRY __cdecl +#else + #define VORBIS_APIENTRY +#endif + +typedef struct vorbis_info{ + int version; + int channels; + long rate; + + /* The below bitrate declarations are *hints*. + Combinations of the three values carry the following implications: + + all three set to the same value: + implies a fixed rate bitstream + only nominal set: + implies a VBR stream that averages the nominal bitrate. No hard + upper/lower limit + upper and or lower set: + implies a VBR bitstream that obeys the bitrate limits. nominal + may also be set to give a nominal rate. + none set: + the coder does not care to speculate. + */ + + long bitrate_upper; + long bitrate_nominal; + long bitrate_lower; + long bitrate_window; + + void *codec_setup; +} vorbis_info; + +/* vorbis_dsp_state buffers the current vorbis audio + analysis/synthesis state. The DSP state belongs to a specific + logical bitstream ****************************************************/ +typedef struct vorbis_dsp_state{ + int analysisp; + vorbis_info *vi; + + float **pcm; + float **pcmret; + int pcm_storage; + int pcm_current; + int pcm_returned; + + int preextrapolate; + int eofflag; + + long lW; + long W; + long nW; + long centerW; + + ogg_int64_t granulepos; + ogg_int64_t sequence; + + ogg_int64_t glue_bits; + ogg_int64_t time_bits; + ogg_int64_t floor_bits; + ogg_int64_t res_bits; + + void *backend_state; +} vorbis_dsp_state; + +typedef struct vorbis_block{ + /* necessary stream state for linking to the framing abstraction */ + float **pcm; /* this is a pointer into local storage */ + oggpack_buffer opb; + + long lW; + long W; + long nW; + int pcmend; + int mode; + + int eofflag; + ogg_int64_t granulepos; + ogg_int64_t sequence; + vorbis_dsp_state *vd; /* For read-only access of configuration */ + + /* local storage to avoid remallocing; it's up to the mapping to + structure it */ + void *localstore; + long localtop; + long localalloc; + long totaluse; + struct alloc_chain *reap; + + /* bitmetrics for the frame */ + long glue_bits; + long time_bits; + long floor_bits; + long res_bits; + + void *internal; + +} vorbis_block; + +/* vorbis_block is a single block of data to be processed as part of +the analysis/synthesis stream; it belongs to a specific logical +bitstream, but is independent from other vorbis_blocks belonging to +that logical bitstream. *************************************************/ + +struct alloc_chain{ + void *ptr; + struct alloc_chain *next; +}; + +/* vorbis_info contains all the setup information specific to the + specific compression/decompression mode in progress (eg, + psychoacoustic settings, channel setup, options, codebook + etc). vorbis_info and substructures are in backends.h. +*********************************************************************/ + +/* the comments are not part of vorbis_info so that vorbis_info can be + static storage */ +typedef struct vorbis_comment{ + /* unlimited user comment fields. libvorbis writes 'libvorbis' + whatever vendor is set to in encode */ + char **user_comments; + int *comment_lengths; + int comments; + char *vendor; + +} vorbis_comment; + + +/* libvorbis encodes in two abstraction layers; first we perform DSP + and produce a packet (see docs/analysis.txt). The packet is then + coded into a framed OggSquish bitstream by the second layer (see + docs/framing.txt). Decode is the reverse process; we sync/frame + the bitstream and extract individual packets, then decode the + packet back into PCM audio. + + The extra framing/packetizing is used in streaming formats, such as + files. Over the net (such as with UDP), the framing and + packetization aren't necessary as they're provided by the transport + and the streaming layer is not used */ + +/* Vorbis PRIMITIVES: general ***************************************/ + +extern void VORBIS_APIENTRY vorbis_info_init(vorbis_info *vi); +extern void VORBIS_APIENTRY vorbis_info_clear(vorbis_info *vi); +extern int VORBIS_APIENTRY vorbis_info_blocksize(vorbis_info *vi,int zo); +extern void VORBIS_APIENTRY vorbis_comment_init(vorbis_comment *vc); +extern void VORBIS_APIENTRY vorbis_comment_add(vorbis_comment *vc, const char *comment); +extern void VORBIS_APIENTRY vorbis_comment_add_tag(vorbis_comment *vc, + const char *tag, const char *contents); +extern char *VORBIS_APIENTRY vorbis_comment_query(vorbis_comment *vc, const char *tag, int count); +extern int VORBIS_APIENTRY vorbis_comment_query_count(vorbis_comment *vc, const char *tag); +extern void VORBIS_APIENTRY vorbis_comment_clear(vorbis_comment *vc); + +extern int VORBIS_APIENTRY vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb); +extern int VORBIS_APIENTRY vorbis_block_clear(vorbis_block *vb); +extern void VORBIS_APIENTRY vorbis_dsp_clear(vorbis_dsp_state *v); +extern double VORBIS_APIENTRY vorbis_granule_time(vorbis_dsp_state *v, + int64_t granulepos); + +extern const char *VORBIS_APIENTRY vorbis_version_string(void); + +/* Vorbis PRIMITIVES: analysis/DSP layer ****************************/ + +extern int VORBIS_APIENTRY vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi); +extern int VORBIS_APIENTRY vorbis_commentheader_out(vorbis_comment *vc, ogg_packet *op); +extern int VORBIS_APIENTRY vorbis_analysis_headerout(vorbis_dsp_state *v, + vorbis_comment *vc, + ogg_packet *op, + ogg_packet *op_comm, + ogg_packet *op_code); +extern float **VORBIS_APIENTRY vorbis_analysis_buffer(vorbis_dsp_state *v,int vals); +extern int VORBIS_APIENTRY vorbis_analysis_wrote(vorbis_dsp_state *v,int vals); +extern int VORBIS_APIENTRY vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb); +extern int VORBIS_APIENTRY vorbis_analysis(vorbis_block *vb,ogg_packet *op); + +extern int VORBIS_APIENTRY vorbis_bitrate_addblock(vorbis_block *vb); +extern int VORBIS_APIENTRY vorbis_bitrate_flushpacket(vorbis_dsp_state *vd, + ogg_packet *op); + +/* Vorbis PRIMITIVES: synthesis layer *******************************/ +extern int VORBIS_APIENTRY vorbis_synthesis_idheader(ogg_packet *op); +extern int VORBIS_APIENTRY vorbis_synthesis_headerin(vorbis_info *vi,vorbis_comment *vc, + ogg_packet *op); + +extern int VORBIS_APIENTRY vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi); +extern int VORBIS_APIENTRY vorbis_synthesis_restart(vorbis_dsp_state *v); +extern int VORBIS_APIENTRY vorbis_synthesis(vorbis_block *vb,ogg_packet *op); +extern int VORBIS_APIENTRY vorbis_synthesis_trackonly(vorbis_block *vb,ogg_packet *op); +extern int VORBIS_APIENTRY vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb); +extern int VORBIS_APIENTRY vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm); +extern int VORBIS_APIENTRY vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm); +extern int VORBIS_APIENTRY vorbis_synthesis_read(vorbis_dsp_state *v,int samples); +extern long VORBIS_APIENTRY vorbis_packet_blocksize(vorbis_info *vi,ogg_packet *op); + +extern int VORBIS_APIENTRY vorbis_synthesis_halfrate(vorbis_info *v,int flag); +extern int VORBIS_APIENTRY vorbis_synthesis_halfrate_p(vorbis_info *v); + +/* Vorbis ERRORS and return codes ***********************************/ + +#define OV_FALSE -1 +#define OV_EOF -2 +#define OV_HOLE -3 + +#define OV_EREAD -128 +#define OV_EFAULT -129 +#define OV_EIMPL -130 +#define OV_EINVAL -131 +#define OV_ENOTVORBIS -132 +#define OV_EBADHEADER -133 +#define OV_EVERSION -134 +#define OV_ENOTAUDIO -135 +#define OV_EBADPACKET -136 +#define OV_EBADLINK -137 +#define OV_ENOSEEK -138 + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif + diff --git a/src/libs/libvorbis/vorbisenc.h b/src/libs/libvorbis/vorbisenc.h new file mode 100644 index 000000000..5c28479a3 --- /dev/null +++ b/src/libs/libvorbis/vorbisenc.h @@ -0,0 +1,439 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001 * + * by the Xiph.Org Foundation https://xiph.org/ * + * * + ******************************************************************** + + function: vorbis encode-engine setup + + ********************************************************************/ + +/** \file + * Libvorbisenc is a convenient API for setting up an encoding + * environment using libvorbis. Libvorbisenc encapsulates the + * actions needed to set up the encoder properly. + */ + +#ifndef _OV_ENC_H_ +#define _OV_ENC_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#include + +#if !defined(VORBIS_APIENTRY) + #define VORBIS_APIENTRY __cdecl +#endif + +/** + * This is the primary function within libvorbisenc for setting up managed + * bitrate modes. + * + * Before this function is called, the \ref vorbis_info + * struct should be initialized by using vorbis_info_init() from the libvorbis + * API. After encoding, vorbis_info_clear() should be called. + * + * The max_bitrate, nominal_bitrate, and min_bitrate settings are used to set + * constraints for the encoded file. This function uses these settings to + * select the appropriate encoding mode and set it up. + * + * \param vi Pointer to an initialized \ref vorbis_info struct. + * \param channels The number of channels to be encoded. + * \param rate The sampling rate of the source audio. + * \param max_bitrate Desired maximum bitrate (limit). -1 indicates unset. + * \param nominal_bitrate Desired average, or central, bitrate. -1 indicates unset. + * \param min_bitrate Desired minimum bitrate. -1 indicates unset. + * + * \return Zero for success, and negative values for failure. + * + * \retval 0 Success. + * \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption. + * \retval OV_EINVAL Invalid setup request, eg, out of range argument. + * \retval OV_EIMPL Unimplemented mode; unable to comply with bitrate request. + */ +extern int VORBIS_APIENTRY vorbis_encode_init(vorbis_info *vi, + long channels, + long rate, + + long max_bitrate, + long nominal_bitrate, + long min_bitrate); + +/** + * This function performs step-one of a three-step bitrate-managed encode + * setup. It functions similarly to the one-step setup performed by \ref + * vorbis_encode_init but allows an application to make further encode setup + * tweaks using \ref vorbis_encode_ctl before finally calling \ref + * vorbis_encode_setup_init to complete the setup process. + * + * Before this function is called, the \ref vorbis_info struct should be + * initialized by using vorbis_info_init() from the libvorbis API. After + * encoding, vorbis_info_clear() should be called. + * + * The max_bitrate, nominal_bitrate, and min_bitrate settings are used to set + * constraints for the encoded file. This function uses these settings to + * select the appropriate encoding mode and set it up. + * + * \param vi Pointer to an initialized vorbis_info struct. + * \param channels The number of channels to be encoded. + * \param rate The sampling rate of the source audio. + * \param max_bitrate Desired maximum bitrate (limit). -1 indicates unset. + * \param nominal_bitrate Desired average, or central, bitrate. -1 indicates unset. + * \param min_bitrate Desired minimum bitrate. -1 indicates unset. + * + * \return Zero for success, and negative for failure. + * + * \retval 0 Success + * \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption. + * \retval OV_EINVAL Invalid setup request, eg, out of range argument. + * \retval OV_EIMPL Unimplemented mode; unable to comply with bitrate request. + */ +extern int VORBIS_APIENTRY vorbis_encode_setup_managed(vorbis_info *vi, + long channels, + long rate, + + long max_bitrate, + long nominal_bitrate, + long min_bitrate); + +/** + * This function performs step-one of a three-step variable bitrate + * (quality-based) encode setup. It functions similarly to the one-step setup + * performed by \ref vorbis_encode_init_vbr() but allows an application to + * make further encode setup tweaks using \ref vorbis_encode_ctl() before + * finally calling \ref vorbis_encode_setup_init to complete the setup + * process. + * + * Before this function is called, the \ref vorbis_info struct should be + * initialized by using \ref vorbis_info_init() from the libvorbis API. After + * encoding, vorbis_info_clear() should be called. + * + * \param vi Pointer to an initialized vorbis_info struct. + * \param channels The number of channels to be encoded. + * \param rate The sampling rate of the source audio. + * \param quality Desired quality level, currently from -0.1 to 1.0 (lo to hi). + * + * \return Zero for success, and negative values for failure. + * + * \retval 0 Success + * \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption. + * \retval OV_EINVAL Invalid setup request, eg, out of range argument. + * \retval OV_EIMPL Unimplemented mode; unable to comply with quality level request. + */ +extern int VORBIS_APIENTRY vorbis_encode_setup_vbr(vorbis_info *vi, + long channels, + long rate, + + float quality + ); + +/** + * This is the primary function within libvorbisenc for setting up variable + * bitrate ("quality" based) modes. + * + * + * Before this function is called, the vorbis_info struct should be + * initialized by using vorbis_info_init() from the libvorbis API. After + * encoding, vorbis_info_clear() should be called. + * + * \param vi Pointer to an initialized vorbis_info struct. + * \param channels The number of channels to be encoded. + * \param rate The sampling rate of the source audio. + * \param base_quality Desired quality level, currently from -0.1 to 1.0 (lo to hi). + * + * + * \return Zero for success, or a negative number for failure. + * + * \retval 0 Success + * \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption. + * \retval OV_EINVAL Invalid setup request, eg, out of range argument. + * \retval OV_EIMPL Unimplemented mode; unable to comply with quality level request. + */ +extern int VORBIS_APIENTRY vorbis_encode_init_vbr(vorbis_info *vi, + long channels, + long rate, + + float base_quality + ); + +/** + * This function performs the last stage of three-step encoding setup, as + * described in the API overview under managed bitrate modes. + * + * Before this function is called, the \ref vorbis_info struct should be + * initialized by using vorbis_info_init() from the libvorbis API, one of + * \ref vorbis_encode_setup_managed() or \ref vorbis_encode_setup_vbr() called to + * initialize the high-level encoding setup, and \ref vorbis_encode_ctl() + * called if necessary to make encoding setup changes. + * vorbis_encode_setup_init() finalizes the highlevel encoding structure into + * a complete encoding setup after which the application may make no further + * setup changes. + * + * After encoding, vorbis_info_clear() should be called. + * + * \param vi Pointer to an initialized \ref vorbis_info struct. + * + * \return Zero for success, and negative values for failure. + * + * \retval 0 Success. + * \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption. + * + * \retval OV_EINVAL Attempt to use vorbis_encode_setup_init() without first + * calling one of vorbis_encode_setup_managed() or vorbis_encode_setup_vbr() to + * initialize the high-level encoding setup + * + */ +extern int VORBIS_APIENTRY vorbis_encode_setup_init(vorbis_info *vi); + +/** + * This function implements a generic interface to miscellaneous encoder + * settings similar to the classic UNIX 'ioctl()' system call. Applications + * may use vorbis_encode_ctl() to query or set bitrate management or quality + * mode details by using one of several \e request arguments detailed below. + * vorbis_encode_ctl() must be called after one of + * vorbis_encode_setup_managed() or vorbis_encode_setup_vbr(). When used + * to modify settings, \ref vorbis_encode_ctl() must be called before \ref + * vorbis_encode_setup_init(). + * + * \param vi Pointer to an initialized vorbis_info struct. + * + * \param number Specifies the desired action; See \ref encctlcodes "the list + * of available requests". + * + * \param arg void * pointing to a data structure matching the request + * argument. + * + * \retval 0 Success. Any further return information (such as the result of a + * query) is placed into the storage pointed to by *arg. + * + * \retval OV_EINVAL Invalid argument, or an attempt to modify a setting after + * calling vorbis_encode_setup_init(). + * + * \retval OV_EIMPL Unimplemented or unknown request + */ +extern int VORBIS_APIENTRY vorbis_encode_ctl(vorbis_info *vi,int number,void *arg); + +/** + * \deprecated This is a deprecated interface. Please use vorbis_encode_ctl() + * with the \ref ovectl_ratemanage2_arg struct and \ref + * OV_ECTL_RATEMANAGE2_GET and \ref OV_ECTL_RATEMANAGE2_SET calls in new code. + * + * The \ref ovectl_ratemanage_arg structure is used with vorbis_encode_ctl() + * and the \ref OV_ECTL_RATEMANAGE_GET, \ref OV_ECTL_RATEMANAGE_SET, \ref + * OV_ECTL_RATEMANAGE_AVG, \ref OV_ECTL_RATEMANAGE_HARD calls in order to + * query and modify specifics of the encoder's bitrate management + * configuration. +*/ +struct ovectl_ratemanage_arg { + int management_active; /**< nonzero if bitrate management is active*/ +/** hard lower limit (in kilobits per second) below which the stream bitrate + will never be allowed for any given bitrate_hard_window seconds of time.*/ + long bitrate_hard_min; +/** hard upper limit (in kilobits per second) above which the stream bitrate + will never be allowed for any given bitrate_hard_window seconds of time.*/ + long bitrate_hard_max; +/** the window period (in seconds) used to regulate the hard bitrate minimum + and maximum*/ + double bitrate_hard_window; +/** soft lower limit (in kilobits per second) below which the average bitrate + tracker will start nudging the bitrate higher.*/ + long bitrate_av_lo; +/** soft upper limit (in kilobits per second) above which the average bitrate + tracker will start nudging the bitrate lower.*/ + long bitrate_av_hi; +/** the window period (in seconds) used to regulate the average bitrate + minimum and maximum.*/ + double bitrate_av_window; +/** Regulates the relative centering of the average and hard windows; in + libvorbis 1.0 and 1.0.1, the hard window regulation overlapped but + followed the average window regulation. In libvorbis 1.1 a bit-reservoir + interface replaces the old windowing interface; the older windowing + interface is simulated and this field has no effect.*/ + double bitrate_av_window_center; +}; + +/** + * \name struct ovectl_ratemanage2_arg + * + * The ovectl_ratemanage2_arg structure is used with vorbis_encode_ctl() and + * the OV_ECTL_RATEMANAGE2_GET and OV_ECTL_RATEMANAGE2_SET calls in order to + * query and modify specifics of the encoder's bitrate management + * configuration. + * +*/ +struct ovectl_ratemanage2_arg { + int management_active; /**< nonzero if bitrate management is active */ +/** Lower allowed bitrate limit in kilobits per second */ + long bitrate_limit_min_kbps; +/** Upper allowed bitrate limit in kilobits per second */ + long bitrate_limit_max_kbps; + long bitrate_limit_reservoir_bits; /**struct ovectl_ratemanage2_arg * + * + * Used to query the current encoder bitrate management setting. Also used to + * initialize fields of an ovectl_ratemanage2_arg structure for use with + * \ref OV_ECTL_RATEMANAGE2_SET. + */ +#define OV_ECTL_RATEMANAGE2_GET 0x14 + +/** + * Set the current encoder bitrate management settings. + * + * Argument: struct ovectl_ratemanage2_arg * + * + * Used to set the current encoder bitrate management settings to the values + * listed in the ovectl_ratemanage2_arg. Passing a NULL pointer will disable + * bitrate management. +*/ +#define OV_ECTL_RATEMANAGE2_SET 0x15 + +/** + * Returns the current encoder hard-lowpass setting (kHz) in the double + * pointed to by arg. + * + * Argument: double * +*/ +#define OV_ECTL_LOWPASS_GET 0x20 + +/** + * Sets the encoder hard-lowpass to the value (kHz) pointed to by arg. Valid + * lowpass settings range from 2 to 99. + * + * Argument: double * +*/ +#define OV_ECTL_LOWPASS_SET 0x21 + +/** + * Returns the current encoder impulse block setting in the double pointed + * to by arg. + * + * Argument: double * +*/ +#define OV_ECTL_IBLOCK_GET 0x30 + +/** + * Sets the impulse block bias to the the value pointed to by arg. + * + * Argument: double * + * + * Valid range is -15.0 to 0.0 [default]. A negative impulse block bias will + * direct to encoder to use more bits when incoding short blocks that contain + * strong impulses, thus improving the accuracy of impulse encoding. + */ +#define OV_ECTL_IBLOCK_SET 0x31 + +/** + * Returns the current encoder coupling setting in the int pointed + * to by arg. + * + * Argument: int * +*/ +#define OV_ECTL_COUPLING_GET 0x40 + +/** + * Enables/disables channel coupling in multichannel encoding according to arg. + * + * Argument: int * + * + * Zero disables channel coupling for multichannel inputs, nonzer enables + * channel coupling. Setting has no effect on monophonic encoding or + * multichannel counts that do not offer coupling. At present, coupling is + * available for stereo and 5.1 encoding. + */ +#define OV_ECTL_COUPLING_SET 0x41 + + /* deprecated rate management supported only for compatibility */ + +/** + * Old interface to querying bitrate management settings. + * + * Deprecated after move to bit-reservoir style management in 1.1 rendered + * this interface partially obsolete. + + * \deprecated Please use \ref OV_ECTL_RATEMANAGE2_GET instead. + * + * Argument: struct ovectl_ratemanage_arg * + */ +#define OV_ECTL_RATEMANAGE_GET 0x10 +/** + * Old interface to modifying bitrate management settings. + * + * deprecated after move to bit-reservoir style management in 1.1 rendered + * this interface partially obsolete. + * + * \deprecated Please use \ref OV_ECTL_RATEMANAGE2_SET instead. + * + * Argument: struct ovectl_ratemanage_arg * + */ +#define OV_ECTL_RATEMANAGE_SET 0x11 +/** + * Old interface to setting average-bitrate encoding mode. + * + * Deprecated after move to bit-reservoir style management in 1.1 rendered + * this interface partially obsolete. + * + * \deprecated Please use \ref OV_ECTL_RATEMANAGE2_SET instead. + * + * Argument: struct ovectl_ratemanage_arg * + */ +#define OV_ECTL_RATEMANAGE_AVG 0x12 +/** + * Old interface to setting bounded-bitrate encoding modes. + * + * deprecated after move to bit-reservoir style management in 1.1 rendered + * this interface partially obsolete. + * + * \deprecated Please use \ref OV_ECTL_RATEMANAGE2_SET instead. + * + * Argument: struct ovectl_ratemanage_arg * + */ +#define OV_ECTL_RATEMANAGE_HARD 0x13 + +/*@}*/ + + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif diff --git a/src/libs/libvorbis/vorbisfile.h b/src/libs/libvorbis/vorbisfile.h new file mode 100644 index 000000000..7cfe7ab4f --- /dev/null +++ b/src/libs/libvorbis/vorbisfile.h @@ -0,0 +1,208 @@ +/******************************************************************** + * * + * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * + * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * + * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * + * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * + * * + * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 * + * by the Xiph.Org Foundation https://xiph.org/ * + * * + ******************************************************************** + + function: stdio-based convenience library for opening/seeking/decoding + + ********************************************************************/ + +#ifndef _OV_FILE_H_ +#define _OV_FILE_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#include +#include + +#if !defined(VORBIS_APIENTRY) + #define VORBIS_APIENTRY __cdecl +#endif + +/* The function prototypes for the callbacks are basically the same as for + * the stdio functions fread, fseek, fclose, ftell. + * The one difference is that the FILE * arguments have been replaced with + * a void * - this is to be used as a pointer to whatever internal data these + * functions might need. In the stdio case, it's just a FILE * cast to a void * + * + * If you use other functions, check the docs for these functions and return + * the right values. For seek_func(), you *MUST* return -1 if the stream is + * unseekable + */ +typedef struct { + size_t (VORBIS_APIENTRY *read_func) (void *ptr, size_t size, size_t nmemb, void *datasource); + int (VORBIS_APIENTRY *seek_func) (void *datasource, ogg_int64_t offset, int whence); + int (VORBIS_APIENTRY *close_func) (void *datasource); + long (VORBIS_APIENTRY *tell_func) (void *datasource); +} ov_callbacks; + +#ifndef OV_EXCLUDE_STATIC_CALLBACKS + +/* a few sets of convenient callbacks, especially for use under + * Windows where ov_open_callbacks() should always be used instead of + * ov_open() to avoid problems with incompatible crt.o version linking + * issues. */ + +static int _ov_header_fseek_wrap(FILE *f,ogg_int64_t off,int whence){ + if(f==NULL)return(-1); + +#ifdef __MINGW32__ + return fseeko64(f,off,whence); +#elif defined (_WIN32) + return _fseeki64(f,off,whence); +#else + return fseek(f,off,whence); +#endif +} + +/* These structs below (OV_CALLBACKS_DEFAULT etc) are defined here as + * static data. That means that every file which includes this header + * will get its own copy of these structs whether it uses them or + * not unless it #defines OV_EXCLUDE_STATIC_CALLBACKS. + * These static symbols are essential on platforms such as Windows on + * which several different versions of stdio support may be linked to + * by different DLLs, and we need to be certain we know which one + * we're using (the same one as the main application). + */ + +static ov_callbacks OV_CALLBACKS_DEFAULT = { + (size_t (VORBIS_APIENTRY *)(void *, size_t, size_t, void *)) fread, + (int (VORBIS_APIENTRY *)(void *, ogg_int64_t, int)) _ov_header_fseek_wrap, + (int (VORBIS_APIENTRY *)(void *)) fclose, + (long (VORBIS_APIENTRY *)(void *)) ftell +}; + +static ov_callbacks OV_CALLBACKS_NOCLOSE = { + (size_t (VORBIS_APIENTRY *)(void *, size_t, size_t, void *)) fread, + (int (VORBIS_APIENTRY *)(void *, ogg_int64_t, int)) _ov_header_fseek_wrap, + (int (VORBIS_APIENTRY *)(void *)) NULL, + (long (VORBIS_APIENTRY *)(void *)) ftell +}; + +static ov_callbacks OV_CALLBACKS_STREAMONLY = { + (size_t (VORBIS_APIENTRY *)(void *, size_t, size_t, void *)) fread, + (int (VORBIS_APIENTRY *)(void *, ogg_int64_t, int)) NULL, + (int (VORBIS_APIENTRY *)(void *)) fclose, + (long (VORBIS_APIENTRY *)(void *)) NULL +}; + +static ov_callbacks OV_CALLBACKS_STREAMONLY_NOCLOSE = { + (size_t (VORBIS_APIENTRY *)(void *, size_t, size_t, void *)) fread, + (int (VORBIS_APIENTRY *)(void *, ogg_int64_t, int)) NULL, + (int (VORBIS_APIENTRY *)(void *)) NULL, + (long (VORBIS_APIENTRY *)(void *)) NULL +}; + +#endif + +#define NOTOPEN 0 +#define PARTOPEN 1 +#define OPENED 2 +#define STREAMSET 3 +#define INITSET 4 + +typedef struct OggVorbis_File { + void *datasource; /* Pointer to a FILE *, etc. */ + int seekable; + ogg_int64_t offset; + ogg_int64_t end; + ogg_sync_state oy; + + /* If the FILE handle isn't seekable (eg, a pipe), only the current + stream appears */ + int links; + ogg_int64_t *offsets; + ogg_int64_t *dataoffsets; + long *serialnos; + ogg_int64_t *pcmlengths; /* overloaded to maintain binary + compatibility; x2 size, stores both + beginning and end values */ + vorbis_info *vi; + vorbis_comment *vc; + + /* Decoding working state local storage */ + ogg_int64_t pcm_offset; + int ready_state; + long current_serialno; + int current_link; + + double bittrack; + double samptrack; + + ogg_stream_state os; /* take physical pages, weld into a logical + stream of packets */ + vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */ + vorbis_block vb; /* local working space for packet->PCM decode */ + + ov_callbacks callbacks; + +} OggVorbis_File; + +typedef int (VORBIS_APIENTRY *LPOVCLEAR)(OggVorbis_File *vf); // ov_clear +typedef int (VORBIS_APIENTRY *LPOVFOPEN)(const char *path,OggVorbis_File *vf); // ov_fopen +typedef int (VORBIS_APIENTRY *LPOVOPEN)(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes); // ov_open +typedef int (VORBIS_APIENTRY *LPOVOPENCALLBACKS)(void *datasource, OggVorbis_File *vf, // ov_open_callbacks + const char *initial, long ibytes, ov_callbacks callbacks); + +typedef int (VORBIS_APIENTRY *LPOVTEST)(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes); // ov_test +typedef int (VORBIS_APIENTRY *LPOVTESTCALLBACKS)(void *datasource, OggVorbis_File *vf, // ov_test_callbacks + const char *initial, long ibytes, ov_callbacks callbacks); +typedef int (VORBIS_APIENTRY *LPOVTESTOPEN)(OggVorbis_File *vf); // ov_test_open + +typedef long (VORBIS_APIENTRY *LPOVBITRATE)(OggVorbis_File *vf,int i); // ov_bitrate +typedef long (VORBIS_APIENTRY *LPOVBITRATE_INSTANT)(OggVorbis_File *vf); // ov_bitrate_instant +typedef long (VORBIS_APIENTRY *LPOVSTREAMS)(OggVorbis_File *vf); // ov_streams +typedef long (VORBIS_APIENTRY *LPOVSEEKABLE)(OggVorbis_File *vf); // ov_seekable +typedef long (VORBIS_APIENTRY *LPOVSERIALNUMBER)(OggVorbis_File *vf,int i); // ov_serialnumber + +typedef ogg_int64_t (VORBIS_APIENTRY *LPOVRAWTOTAL)(OggVorbis_File *vf,int i); // ov_raw_total +typedef ogg_int64_t (VORBIS_APIENTRY *LPOVPCMTOTAL)(OggVorbis_File *vf,int i); // ov_pcm_total +typedef double (VORBIS_APIENTRY *LPOVTIMETOTAL)(OggVorbis_File *vf,int i); // ov_time_total + +typedef int (VORBIS_APIENTRY *LPOVRAWSEEK)(OggVorbis_File *vf,ogg_int64_t pos); // ov_raw_seek +typedef int (VORBIS_APIENTRY *LPOVPCMSEEK)(OggVorbis_File *vf,ogg_int64_t pos); // ov_pcm_seek +typedef int (VORBIS_APIENTRY *LPOVPCMSEEK_PAGE)(OggVorbis_File *vf,ogg_int64_t pos); // ov_pcm_seek_page +typedef int (VORBIS_APIENTRY *LPOVTIMESEEK)(OggVorbis_File *vf,double pos); // ov_time_seek +typedef int (VORBIS_APIENTRY *LPOVTIMESEEKPAGE)(OggVorbis_File *vf,double pos); // ov_time_seek_page + +typedef int (VORBIS_APIENTRY *LPOVRAWSEEKLAP)(OggVorbis_File *vf,ogg_int64_t pos); // ov_raw_seek_lap +typedef int (VORBIS_APIENTRY *LPOVPCMSEEKLAP)(OggVorbis_File *vf,ogg_int64_t pos); // ov_pcm_seek_lap +typedef int (VORBIS_APIENTRY *LPOVPCMSEEKPAGELAP)(OggVorbis_File *vf,ogg_int64_t pos); // ov_pcm_seek_page_lap +typedef int (VORBIS_APIENTRY *LPOVTIMESEEKLAP)(OggVorbis_File *vf,double pos); // ov_time_seek_lap +typedef int (VORBIS_APIENTRY *LPOVTIMESEEKPAGELAP)(OggVorbis_File *vf,double pos); // ov_time_seek_page_lap + +typedef ogg_int64_t (VORBIS_APIENTRY *LPOVRAWTELL)(OggVorbis_File *vf); // ov_raw_tell +typedef ogg_int64_t (VORBIS_APIENTRY *LPOVPCMTELL)(OggVorbis_File *vf); // ov_pcm_tell +typedef double (VORBIS_APIENTRY *LPOVTIMETELL)(OggVorbis_File *vf); // ov_time_tell + +typedef vorbis_info *(VORBIS_APIENTRY *LPOVINFO)(OggVorbis_File *vf,int link); // ov_info +typedef vorbis_comment *(VORBIS_APIENTRY *LPOVCOMMENT)(OggVorbis_File *vf,int link); // ov_comment + +typedef long (VORBIS_APIENTRY *LPOVREADFLOAT)(OggVorbis_File *vf,float ***pcm_channels,int samples, // ov_read_float + int *bitstream); +typedef long (VORBIS_APIENTRY *LPOVREADFILTER)(OggVorbis_File *vf,char *buffer,int length, // ov_read_filter + int bigendianp,int word,int sgned,int *bitstream, + void (*filter)(float **pcm,long channels,long samples,void *filter_param),void *filter_param); +typedef long (VORBIS_APIENTRY *LPOVREAD)(OggVorbis_File *vf,char *buffer,int length, // ov_read + int bigendianp,int word,int sgned,int *bitstream); +typedef int (VORBIS_APIENTRY *LPOVCROSSLAP)(OggVorbis_File *vf1,OggVorbis_File *vf2); // ov_crosslap + +typedef int (VORBIS_APIENTRY *LPOVHALFRATE)(OggVorbis_File *vf,int flag); // ov_halfrate +typedef int (VORBIS_APIENTRY *LPOVHALFRATE_P)(OggVorbis_File *vf); // ov_halfrate_p + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif +