Subversion Repositories Kolibri OS

/*

	frame: Central data structures and opmitization hooks.

	copyright 2007 by the mpg123 project - free software under the terms of the LGPL 2.1

	see COPYING and AUTHORS files in distribution or http://mpg123.org

	initially written by Thomas Orgis

*/

#ifndef MPG123_FRAME_H

#define MPG123_FRAME_H

#include 

#include "config.h"

#include "mpg123.h"

#include "optimize.h"

#include "id3.h"

#include "icy.h"

#include "reader.h"

#ifdef FRAME_INDEX

#include "index.h"

#endif

#include "synths.h"

#ifdef OPT_DITHER

#include "dither.h"

int frame_dither_init(mpg123_handle *fr);

#endif

/* max = 1728 */

#define MAXFRAMESIZE 3456

struct al_table

{

  short bits;

  short d;

};

/* the output buffer, used to be pcm_sample, pcm_point and audiobufsize */

struct outbuffer

{

	unsigned char *data;

	unsigned char *p; /* read pointer  */

	size_t fill; /* fill from read pointer */

	size_t size; /* that's actually more like a safe size, after we have more than that, flush it */

};

struct audioformat

{

	int encoding;

	int encsize; /* Size of one sample in bytes, plain int should be fine here... */

	int channels;

	long rate;

};

void invalidate_format(struct audioformat *af);

struct mpg123_pars_struct

{

	int verbose;    /* verbose level */

	long flags; /* combination of above */

#ifndef NO_NTOM

	long force_rate;

#endif

	int down_sample;

	int rva; /* (which) rva to do: 0: nothing, 1: radio/mix/track 2: album/audiophile */

	long halfspeed;

	long doublespeed;

#ifndef WIN32

	long timeout;

#endif

#define NUM_CHANNELS 2

	char audio_caps[NUM_CHANNELS][MPG123_RATES+1][MPG123_ENCODINGS];

/*	long start_frame; */ /* frame offset to begin with */

/*	long frame_number;*/ /* number of frames to decode */

#ifndef NO_ICY

	long icy_interval;

#endif

	double outscale;

	long resync_limit;

	long index_size; /* Long, because: negative values have a meaning. */

	long preframes;

};

/* There is a lot to condense here... many ints can be merged as flags; though the main space is still consumed by buffers. */

struct mpg123_handle_struct

{

	int fresh; /* to be moved into flags */

	int new_format;

	real hybrid_block[2][2][SBLIMIT*SSLIMIT];

	int hybrid_blc[2];

	/* the scratch vars for the decoders, sometimes real, sometimes short... sometimes int/long */

	short *short_buffs[2][2];

	real *real_buffs[2][2];

	unsigned char *rawbuffs;

	int rawbuffss;

#ifdef OPT_I486

	int i486bo[2];

#endif

	int bo; /* Just have it always here. */

#ifdef OPT_DITHER

	int ditherindex;

	float *dithernoise;

#endif

	unsigned char* rawdecwin; /* the block with all decwins */

	int rawdecwins; /* size of rawdecwin memory */

	real *decwin; /* _the_ decode table */

#ifdef OPT_MMXORSSE

	/* I am not really sure that I need both of them... used in assembler */

	float *decwin_mmx;

	float *decwins;

#endif

	int have_eq_settings;

	real equalizer[2][32];

	/* for halfspeed mode */

	unsigned char ssave[34];

	int halfphase;

#ifndef NO_8BIT

	/* a raw buffer and a pointer into the middle for signed short conversion, only allocated on demand */

	unsigned char *conv16to8_buf;

	unsigned char *conv16to8;

#endif

	/* There's some possible memory saving for stuff that is not _really_ dynamic. */

	/* layer3 */

	int longLimit[9][23];

	int shortLimit[9][14];

	real gainpow2[256+118+4]; /* not really dynamic, just different for mmx */

	/* layer2 */

	real muls[27][64];	/* also used by layer 1 */

#ifndef NO_NTOM

	/* decode_ntom */

	unsigned long ntom_val[2];

	unsigned long ntom_step;

#endif

	/* special i486 fun */

#ifdef OPT_I486

	int *int_buffs[2][2];

#endif

	/* special altivec... */

#ifdef OPT_ALTIVEC

	real *areal_buffs[4][4];

#endif

	struct synth_s synths;

	struct

	{

#ifdef OPT_MULTI

#ifndef NO_LAYER3

#if (defined OPT_3DNOW || defined OPT_3DNOWEXT)

		void (*dct36)(real *,real *,real *,real *,real *);

#endif

#endif

#endif

		enum optdec type;

		enum optcla class;

	} cpu_opts;

	int verbose;    /* 0: nothing, 1: just print chosen decoder, 2: be verbose */

	const struct al_table *alloc;

	/* The runtime-chosen decoding, based on input and output format. */

	func_synth synth;

	func_synth_stereo synth_stereo;

	func_synth_mono synth_mono;

	/* Yes, this function is runtime-switched, too. */

	void (*make_decode_tables)(mpg123_handle *fr); /* That is the volume control. */

	int stereo; /* I _think_ 1 for mono and 2 for stereo */

	int jsbound;

#define SINGLE_STEREO -1

#define SINGLE_LEFT    0

#define SINGLE_RIGHT   1

#define SINGLE_MIX     3

	int single;

	int II_sblimit;

	int down_sample_sblimit;

	int lsf; /* 0: MPEG 1.0; 1: MPEG 2.0/2.5 -- both used as bool and array index! */

	/* Many flags in disguise as integers... wasting bytes. */

	int mpeg25;

	int down_sample;

	int header_change;

	int lay;

	int (*do_layer)(mpg123_handle *);

	int error_protection;

	int bitrate_index;

	int sampling_frequency;

	int padding;

	int extension;

	int mode;

	int mode_ext;

	int copyright;

	int original;

	int emphasis;

	int framesize; /* computed framesize */

	int freesize;  /* free format frame size */

	enum mpg123_vbr vbr; /* 1 if variable bitrate was detected */

	off_t num; /* frame offset ... */

	off_t playnum; /* playback offset... includes repetitions, reset at seeks */

	off_t audio_start; /* The byte offset in the file where audio data begins. */

	char accurate; /* Flag to see if we trust the frame number. */

	char silent_resync; /* Do not complain for the next n resyncs. */

	unsigned char* xing_toc; /* The seek TOC from Xing header. */

	int freeformat;

	long freeformat_framesize;

	/* bitstream info; bsi */

	int bitindex;

	unsigned char *wordpointer;

	/* temporary storage for getbits stuff */

	unsigned long ultmp;

	unsigned char uctmp;

	/* rva data, used in common.c, set in id3.c */

	double maxoutburst; /* The maximum amplitude in current sample represenation. */

	double lastscale;

	struct

	{

		int level[2];

		float gain[2];

		float peak[2];

	} rva;

	/* input data */

	off_t track_frames;

	off_t track_samples;

	double mean_framesize;

	off_t mean_frames;

	int fsizeold;

	int ssize;

	unsigned int bitreservoir;

	unsigned char bsspace[2][MAXFRAMESIZE+512]; /* MAXFRAMESIZE */

	unsigned char *bsbuf;

	unsigned char *bsbufold;

	int bsnum;

	unsigned long oldhead;

	unsigned long firsthead;

	int abr_rate;

#ifdef FRAME_INDEX

	struct frame_index index;

#endif

	/* output data */

	struct outbuffer buffer;

	struct audioformat af;

	int own_buffer;

	size_t outblock; /* number of bytes that this frame produces (upper bound) */

	int to_decode;   /* this frame holds data to be decoded */

	int to_ignore;   /* the same, somehow */

	off_t firstframe;  /* start decoding from here */

	off_t lastframe;   /* last frame to decode (for gapless or num_frames limit) */

	off_t ignoreframe; /* frames to decode but discard before firstframe */

#ifdef GAPLESS

	off_t firstoff; /* number of samples to ignore from firstframe */

	off_t lastoff;  /* number of samples to use from lastframe */

	off_t begin_s;  /* overall begin offset in samples */

	off_t begin_os;

	off_t end_s;    /* overall end offset in samples */

	off_t end_os;

#endif

	unsigned int crc; /* Well, I need a safe 16bit type, actually. But wider doesn't hurt. */

	struct reader *rd; /* pointer to the reading functions */

	struct reader_data rdat; /* reader data and state info */

	struct mpg123_pars_struct p;

	int err;

	int decoder_change;

	int delayed_change;

	long clip;

	/* the meta crap */

	int metaflags;

	unsigned char id3buf[128];

#ifndef NO_ID3V2

	mpg123_id3v2 id3v2;

#endif

#ifndef NO_ICY

	struct icy_meta icy;

#endif

};

/* generic init, does not include dynamic buffers */

void frame_init(mpg123_handle *fr);

void frame_init_par(mpg123_handle *fr, mpg123_pars *mp);

/* output buffer and format */

int  frame_outbuffer(mpg123_handle *fr);

int  frame_output_format(mpg123_handle *fr);

int frame_buffers(mpg123_handle *fr); /* various decoder buffers, needed once */

int frame_reset(mpg123_handle* fr);   /* reset for next track */

int frame_buffers_reset(mpg123_handle *fr);

void frame_exit(mpg123_handle *fr);   /* end, free all buffers */

/* Index functions... */

/* Well... print it... */

int mpg123_print_index(mpg123_handle *fr, FILE* out);

/* Find a seek position in index. */

off_t frame_index_find(mpg123_handle *fr, off_t want_frame, off_t* get_frame);

/* Apply index_size setting. */

int frame_index_setup(mpg123_handle *fr);

void do_volume(mpg123_handle *fr, double factor);

void do_rva(mpg123_handle *fr);

/* samples per frame ...

Layer I

Layer II

Layer III

MPEG-1

384

1152

1152

MPEG-2 LSF

384

1152

576

MPEG 2.5

384

1152

576

*/

#define spf(fr) ((fr)->lay == 1 ? 384 : ((fr)->lay==2 ? 1152 : ((fr)->lsf || (fr)->mpeg25 ? 576 : 1152)))

#ifdef GAPLESS

/* well, I take that one for granted... at least layer3 */

#define GAPLESS_DELAY 529

/* still fine-tuning the "real music" window... see read_frame */

void frame_gapless_init(mpg123_handle *fr, off_t b, off_t e);

void frame_gapless_realinit(mpg123_handle *fr);

void frame_gapless_update(mpg123_handle *mh, off_t total_samples);

/*void frame_gapless_position(mpg123_handle* fr);

void frame_gapless_bytify(mpg123_handle *fr);

void frame_gapless_ignore(mpg123_handle *fr, off_t frames);*/

/* void frame_gapless_buffercheck(mpg123_handle *fr); */

#endif

/* Skip this frame... do some fake action to get away without actually decoding it. */

void frame_skip(mpg123_handle *fr);

/*

	Seeking core functions:

	- convert input sample offset to output sample offset

	- convert frame offset to output sample offset

	- get leading frame offset for output sample offset

	The offsets are "unadjusted"/internal; resampling is being taken care of.

*/

off_t frame_ins2outs(mpg123_handle *fr, off_t ins);

off_t frame_outs(mpg123_handle *fr, off_t num);

off_t frame_offset(mpg123_handle *fr, off_t outs);

void frame_set_frameseek(mpg123_handle *fr, off_t fe);

void frame_set_seek(mpg123_handle *fr, off_t sp);

off_t frame_tell_seek(mpg123_handle *fr);

/* Take a copy of the Xing VBR TOC for fuzzy seeking. */

int frame_fill_toc(mpg123_handle *fr, unsigned char* in);

/* adjust volume to current outscale and rva values if wanted */

void do_rva(mpg123_handle *fr);

#endif