/********************************************************************

 *                                                                  *

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

 *                                                                  *

 ********************************************************************/

#ifndef _OGGVORBIS_H

#define _OGGVORBIS_H

/*data types for ogg and vorbis that are required to be external*/

#ifndef ogg_int64_t	

#define ogg_int64_t int64_t

#endif

typedef struct {

	unsigned char *data;

	int storage;

	int fill;

	int returned;

	int unsynced;

	int headerbytes;

	int bodybytes;

} ogg_sync_state;

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;

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;

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 seperate abstraction

	 layer) also knows about the gap */

	ogg_int64_t   granulepos;

} ogg_stream_state;

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 {

	long endbyte;

	int  endbit;

	unsigned char *buffer;

	unsigned char *ptr;

	long storage;

} oggpack_buffer;

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;

typedef struct {

	size_t (*read_func)  (void *ptr, size_t size, size_t nmemb, void *datasource);

	int    (*seek_func)  (void *datasource, ogg_int64_t offset, int whence);

	int    (*close_func) (void *datasource);

	long   (*tell_func)  (void *datasource);

} ov_callbacks;

typedef struct OggVorbis_File {

	void            *datasource; /* Pointer to a FILE *, etc. */

	int              seekable;

	ogg_int64_t      offset;

	ogg_int64_t      end;

	ogg_sync_state   oy;

	/* If the FILE handle isn't seekable (eg, a pipe), only the current stream appears */

	int              links;

	ogg_int64_t     *offsets;

	ogg_int64_t     *dataoffsets;

	long            *serialnos;

	ogg_int64_t     *pcmlengths; 

	/* overloaded to maintain binary

	 compatability; x2 size, stores both

	 beginning and end values */

	vorbis_info     *vi;

	vorbis_comment  *vc;

	/* Decoding working state local storage */

	ogg_int64_t      pcm_offset;

	int              ready_state;

	long             current_serialno;

	int              current_link;

	double           bittrack;

	double           samptrack;

	ogg_stream_state os; /* take physical pages, weld into a logical stream of packets */

	vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */

	vorbis_block     vb; /* local working space for packet->PCM decode */

	ov_callbacks callbacks;

} OggVorbis_File;

extern int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes);

extern long ov_read(OggVorbis_File *vf,char *buffer,int length,int bigendianp,int word,int sgned,int *bitstream);

extern ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i);

extern long ov_read(OggVorbis_File *vf,char *buffer,int length,int bigendianp,int word,int sgned,int *bitstream);

extern vorbis_info *ov_info(OggVorbis_File *vf,int link);

extern vorbis_comment *ov_comment(OggVorbis_File *f, int num);

#endif /*_OGGVORBIS_H*/