|
Packit |
c32a2d |
/*
|
|
Packit |
c32a2d |
frame: Central data structures and opmitization hooks.
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
copyright 2007 by the mpg123 project - free software under the terms of the LGPL 2.1
|
|
Packit |
c32a2d |
see COPYING and AUTHORS files in distribution or http://mpg123.org
|
|
Packit |
c32a2d |
initially written by Thomas Orgis
|
|
Packit |
c32a2d |
*/
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
#ifndef MPG123_FRAME_H
|
|
Packit |
c32a2d |
#define MPG123_FRAME_H
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
#include <stdio.h>
|
|
Packit |
c32a2d |
#include "config.h"
|
|
Packit |
c32a2d |
#include "mpg123.h"
|
|
Packit |
c32a2d |
#include "optimize.h"
|
|
Packit |
c32a2d |
#include "id3.h"
|
|
Packit |
c32a2d |
#include "icy.h"
|
|
Packit |
c32a2d |
#include "reader.h"
|
|
Packit |
c32a2d |
#ifdef FRAME_INDEX
|
|
Packit |
c32a2d |
#include "index.h"
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
#include "synths.h"
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
#ifdef OPT_DITHER
|
|
Packit |
c32a2d |
#include "dither.h"
|
|
Packit |
c32a2d |
int frame_dither_init(mpg123_handle *fr);
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* max = 1728 */
|
|
Packit |
c32a2d |
#define MAXFRAMESIZE 3456
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
struct al_table
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
short bits;
|
|
Packit |
c32a2d |
short d;
|
|
Packit |
c32a2d |
};
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* the output buffer, used to be pcm_sample, pcm_point and audiobufsize */
|
|
Packit |
c32a2d |
struct outbuffer
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
unsigned char *data; /* main data pointer, aligned */
|
|
Packit |
c32a2d |
unsigned char *p; /* read pointer */
|
|
Packit |
c32a2d |
size_t fill; /* fill from read pointer */
|
|
Packit |
c32a2d |
size_t size;
|
|
Packit |
c32a2d |
unsigned char *rdata; /* unaligned base pointer */
|
|
Packit |
c32a2d |
};
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
struct audioformat
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
int encoding; /* Final encoding, after post-processing. */
|
|
Packit |
c32a2d |
int encsize; /* Size of one sample in bytes, plain int should be fine here... */
|
|
Packit |
c32a2d |
int dec_enc; /* Encoding of decoder synth. */
|
|
Packit |
c32a2d |
int dec_encsize; /* Size of one decoder sample. */
|
|
Packit |
c32a2d |
int channels;
|
|
Packit |
c32a2d |
long rate;
|
|
Packit |
c32a2d |
};
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
void invalidate_format(struct audioformat *af);
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
struct mpg123_pars_struct
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
int verbose; /* verbose level */
|
|
Packit |
c32a2d |
long flags; /* combination of above */
|
|
Packit |
c32a2d |
#ifndef NO_NTOM
|
|
Packit |
c32a2d |
long force_rate;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
int down_sample;
|
|
Packit |
c32a2d |
int rva; /* (which) rva to do: 0: nothing, 1: radio/mix/track 2: album/audiophile */
|
|
Packit |
c32a2d |
long halfspeed;
|
|
Packit |
c32a2d |
long doublespeed;
|
|
Packit |
c32a2d |
long timeout;
|
|
Packit |
c32a2d |
#define NUM_CHANNELS 2
|
|
Packit |
c32a2d |
char audio_caps[NUM_CHANNELS][MPG123_RATES+1][MPG123_ENCODINGS];
|
|
Packit |
c32a2d |
/* long start_frame; */ /* frame offset to begin with */
|
|
Packit |
c32a2d |
/* long frame_number;*/ /* number of frames to decode */
|
|
Packit |
c32a2d |
#ifndef NO_ICY
|
|
Packit |
c32a2d |
long icy_interval;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
double outscale;
|
|
Packit |
c32a2d |
long resync_limit;
|
|
Packit |
c32a2d |
long index_size; /* Long, because: negative values have a meaning. */
|
|
Packit |
c32a2d |
long preframes;
|
|
Packit |
c32a2d |
#ifndef NO_FEEDER
|
|
Packit |
c32a2d |
long feedpool;
|
|
Packit |
c32a2d |
long feedbuffer;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
};
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
enum frame_state_flags
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
FRAME_ACCURATE = 0x1 /**< 0001 Positions are considered accurate. */
|
|
Packit |
c32a2d |
,FRAME_FRANKENSTEIN = 0x2 /**< 0010 This stream is concatenated. */
|
|
Packit |
c32a2d |
,FRAME_FRESH_DECODER = 0x4 /**< 0100 Decoder is fleshly initialized. */
|
|
Packit |
c32a2d |
};
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* There is a lot to condense here... many ints can be merged as flags; though the main space is still consumed by buffers. */
|
|
Packit |
c32a2d |
struct mpg123_handle_struct
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
int fresh; /* to be moved into flags */
|
|
Packit |
c32a2d |
int new_format;
|
|
Packit |
c32a2d |
real hybrid_block[2][2][SBLIMIT*SSLIMIT];
|
|
Packit |
c32a2d |
int hybrid_blc[2];
|
|
Packit |
c32a2d |
/* the scratch vars for the decoders, sometimes real, sometimes short... sometimes int/long */
|
|
Packit |
c32a2d |
short *short_buffs[2][2];
|
|
Packit |
c32a2d |
real *real_buffs[2][2];
|
|
Packit |
c32a2d |
unsigned char *rawbuffs;
|
|
Packit |
c32a2d |
int rawbuffss;
|
|
Packit |
c32a2d |
#ifdef OPT_I486
|
|
Packit |
c32a2d |
int i486bo[2];
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
int bo; /* Just have it always here. */
|
|
Packit |
c32a2d |
#ifdef OPT_DITHER
|
|
Packit |
c32a2d |
int ditherindex;
|
|
Packit |
c32a2d |
float *dithernoise;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
unsigned char* rawdecwin; /* the block with all decwins */
|
|
Packit |
c32a2d |
int rawdecwins; /* size of rawdecwin memory */
|
|
Packit |
c32a2d |
real *decwin; /* _the_ decode table */
|
|
Packit |
c32a2d |
#ifdef OPT_MMXORSSE
|
|
Packit |
c32a2d |
/* I am not really sure that I need both of them... used in assembler */
|
|
Packit |
c32a2d |
float *decwin_mmx;
|
|
Packit |
c32a2d |
float *decwins;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
#ifndef NO_EQUALIZER
|
|
Packit |
c32a2d |
int have_eq_settings;
|
|
Packit |
c32a2d |
real equalizer[2][32];
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
/* for halfspeed mode */
|
|
Packit |
c32a2d |
unsigned char ssave[34];
|
|
Packit |
c32a2d |
int halfphase;
|
|
Packit |
c32a2d |
#ifndef NO_8BIT
|
|
Packit |
c32a2d |
/* a raw buffer and a pointer into the middle for signed short conversion, only allocated on demand */
|
|
Packit |
c32a2d |
unsigned char *conv16to8_buf;
|
|
Packit |
c32a2d |
unsigned char *conv16to8;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
/* There's some possible memory saving for stuff that is not _really_ dynamic. */
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* layer3 */
|
|
Packit |
c32a2d |
int longLimit[9][23];
|
|
Packit |
c32a2d |
int shortLimit[9][14];
|
|
Packit |
c32a2d |
real gainpow2[256+118+4]; /* not really dynamic, just different for mmx */
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* layer2 */
|
|
Packit |
c32a2d |
real muls[27][64]; /* also used by layer 1 */
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
#ifndef NO_NTOM
|
|
Packit |
c32a2d |
/* decode_ntom */
|
|
Packit |
c32a2d |
unsigned long ntom_val[2];
|
|
Packit |
c32a2d |
unsigned long ntom_step;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
/* special i486 fun */
|
|
Packit |
c32a2d |
#ifdef OPT_I486
|
|
Packit |
c32a2d |
int *int_buffs[2][2];
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
/* special altivec... */
|
|
Packit |
c32a2d |
#ifdef OPT_ALTIVEC
|
|
Packit |
c32a2d |
real *areal_buffs[4][4];
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
struct synth_s synths;
|
|
Packit |
c32a2d |
struct
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
#ifdef OPT_MULTI
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
#ifndef NO_LAYER3
|
|
Packit |
c32a2d |
#if (defined OPT_3DNOW_VINTAGE || defined OPT_3DNOWEXT_VINTAGE || defined OPT_SSE || defined OPT_X86_64 || defined OPT_AVX || defined OPT_NEON || defined OPT_NEON64)
|
|
Packit |
c32a2d |
void (*the_dct36)(real *,real *,real *,real *,real *);
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
enum optdec type;
|
|
Packit |
c32a2d |
enum optcla class;
|
|
Packit |
c32a2d |
} cpu_opts;
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
int verbose; /* 0: nothing, 1: just print chosen decoder, 2: be verbose */
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
const struct al_table *alloc;
|
|
Packit |
c32a2d |
/* The runtime-chosen decoding, based on input and output format. */
|
|
Packit |
c32a2d |
func_synth synth;
|
|
Packit |
c32a2d |
func_synth_stereo synth_stereo;
|
|
Packit |
c32a2d |
func_synth_mono synth_mono;
|
|
Packit |
c32a2d |
/* Yes, this function is runtime-switched, too. */
|
|
Packit |
c32a2d |
void (*make_decode_tables)(mpg123_handle *fr); /* That is the volume control. */
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
int stereo; /* I _think_ 1 for mono and 2 for stereo */
|
|
Packit |
c32a2d |
int jsbound;
|
|
Packit |
c32a2d |
#define SINGLE_STEREO -1
|
|
Packit |
c32a2d |
#define SINGLE_LEFT 0
|
|
Packit |
c32a2d |
#define SINGLE_RIGHT 1
|
|
Packit |
c32a2d |
#define SINGLE_MIX 3
|
|
Packit |
c32a2d |
int single;
|
|
Packit |
c32a2d |
int II_sblimit;
|
|
Packit |
c32a2d |
int down_sample_sblimit;
|
|
Packit |
c32a2d |
int lsf; /* 0: MPEG 1.0; 1: MPEG 2.0/2.5 -- both used as bool and array index! */
|
|
Packit |
c32a2d |
/* Many flags in disguise as integers... wasting bytes. */
|
|
Packit |
c32a2d |
int mpeg25;
|
|
Packit |
c32a2d |
int down_sample;
|
|
Packit |
c32a2d |
int header_change;
|
|
Packit |
c32a2d |
int lay;
|
|
Packit |
c32a2d |
long spf; /* cached count of samples per frame */
|
|
Packit |
c32a2d |
int (*do_layer)(mpg123_handle *);
|
|
Packit |
c32a2d |
int error_protection;
|
|
Packit |
c32a2d |
int bitrate_index;
|
|
Packit |
c32a2d |
int sampling_frequency;
|
|
Packit |
c32a2d |
int padding;
|
|
Packit |
c32a2d |
int extension;
|
|
Packit |
c32a2d |
int mode;
|
|
Packit |
c32a2d |
int mode_ext;
|
|
Packit |
c32a2d |
int copyright;
|
|
Packit |
c32a2d |
int original;
|
|
Packit |
c32a2d |
int emphasis;
|
|
Packit |
c32a2d |
int framesize; /* computed framesize */
|
|
Packit |
c32a2d |
int freesize; /* free format frame size */
|
|
Packit |
c32a2d |
enum mpg123_vbr vbr; /* 1 if variable bitrate was detected */
|
|
Packit |
c32a2d |
off_t num; /* frame offset ... */
|
|
Packit |
c32a2d |
off_t input_offset; /* byte offset of this frame in input stream */
|
|
Packit |
c32a2d |
off_t playnum; /* playback offset... includes repetitions, reset at seeks */
|
|
Packit |
c32a2d |
off_t audio_start; /* The byte offset in the file where audio data begins. */
|
|
Packit |
c32a2d |
int state_flags;
|
|
Packit |
c32a2d |
char silent_resync; /* Do not complain for the next n resyncs. */
|
|
Packit |
c32a2d |
unsigned char* xing_toc; /* The seek TOC from Xing header. */
|
|
Packit |
c32a2d |
int freeformat;
|
|
Packit |
c32a2d |
long freeformat_framesize;
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* bitstream info; bsi */
|
|
Packit |
c32a2d |
int bitindex;
|
|
Packit |
c32a2d |
unsigned char *wordpointer;
|
|
Packit |
c32a2d |
/* temporary storage for getbits stuff */
|
|
Packit |
c32a2d |
unsigned long ultmp;
|
|
Packit |
c32a2d |
unsigned char uctmp;
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* rva data, used in common.c, set in id3.c */
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
double maxoutburst; /* The maximum amplitude in current sample represenation. */
|
|
Packit |
c32a2d |
double lastscale;
|
|
Packit |
c32a2d |
struct
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
int level[2];
|
|
Packit |
c32a2d |
float gain[2];
|
|
Packit |
c32a2d |
float peak[2];
|
|
Packit |
c32a2d |
} rva;
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* input data */
|
|
Packit |
c32a2d |
off_t track_frames;
|
|
Packit |
c32a2d |
off_t track_samples;
|
|
Packit |
c32a2d |
double mean_framesize;
|
|
Packit |
c32a2d |
off_t mean_frames;
|
|
Packit |
c32a2d |
int fsizeold;
|
|
Packit |
c32a2d |
int ssize;
|
|
Packit |
c32a2d |
unsigned int bitreservoir;
|
|
Packit |
c32a2d |
unsigned char bsspace[2][MAXFRAMESIZE+512]; /* MAXFRAMESIZE */
|
|
Packit |
c32a2d |
unsigned char *bsbuf;
|
|
Packit |
c32a2d |
unsigned char *bsbufold;
|
|
Packit |
c32a2d |
int bsnum;
|
|
Packit |
c32a2d |
/* That is the header matching the last read frame body. */
|
|
Packit |
c32a2d |
unsigned long oldhead;
|
|
Packit |
c32a2d |
/* That is the header that is supposedly the first of the stream. */
|
|
Packit |
c32a2d |
unsigned long firsthead;
|
|
Packit |
c32a2d |
int abr_rate;
|
|
Packit |
c32a2d |
#ifdef FRAME_INDEX
|
|
Packit |
c32a2d |
struct frame_index index;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* output data */
|
|
Packit |
c32a2d |
struct outbuffer buffer;
|
|
Packit |
c32a2d |
struct audioformat af;
|
|
Packit |
c32a2d |
int own_buffer;
|
|
Packit |
c32a2d |
size_t outblock; /* number of bytes that this frame produces (upper bound) */
|
|
Packit |
c32a2d |
int to_decode; /* this frame holds data to be decoded */
|
|
Packit |
c32a2d |
int to_ignore; /* the same, somehow */
|
|
Packit |
c32a2d |
off_t firstframe; /* start decoding from here */
|
|
Packit |
c32a2d |
off_t lastframe; /* last frame to decode (for gapless or num_frames limit) */
|
|
Packit |
c32a2d |
off_t ignoreframe; /* frames to decode but discard before firstframe */
|
|
Packit |
c32a2d |
#ifdef GAPLESS
|
|
Packit |
c32a2d |
off_t gapless_frames; /* frame count for the gapless part */
|
|
Packit |
c32a2d |
off_t firstoff; /* number of samples to ignore from firstframe */
|
|
Packit |
c32a2d |
off_t lastoff; /* number of samples to use from lastframe */
|
|
Packit |
c32a2d |
off_t begin_s; /* overall begin offset in samples */
|
|
Packit |
c32a2d |
off_t begin_os;
|
|
Packit |
c32a2d |
off_t end_s; /* overall end offset in samples */
|
|
Packit |
c32a2d |
off_t end_os;
|
|
Packit |
c32a2d |
off_t fullend_os; /* gapless_frames translated to output samples */
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
unsigned int crc; /* Well, I need a safe 16bit type, actually. But wider doesn't hurt. */
|
|
Packit |
c32a2d |
struct reader *rd; /* pointer to the reading functions */
|
|
Packit |
c32a2d |
struct reader_data rdat; /* reader data and state info */
|
|
Packit |
c32a2d |
struct mpg123_pars_struct p;
|
|
Packit |
c32a2d |
int err;
|
|
Packit |
c32a2d |
int decoder_change;
|
|
Packit |
c32a2d |
int delayed_change;
|
|
Packit |
c32a2d |
long clip;
|
|
Packit |
c32a2d |
/* the meta crap */
|
|
Packit |
c32a2d |
int metaflags;
|
|
Packit |
c32a2d |
unsigned char id3buf[128];
|
|
Packit |
c32a2d |
#ifndef NO_ID3V2
|
|
Packit |
c32a2d |
mpg123_id3v2 id3v2;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
#ifndef NO_ICY
|
|
Packit |
c32a2d |
struct icy_meta icy;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
/*
|
|
Packit |
c32a2d |
More variables needed for decoders, layerX.c.
|
|
Packit |
c32a2d |
This time it is not about static variables but about the need for alignment which cannot be guaranteed on the stack by certain compilers (Sun Studio).
|
|
Packit |
c32a2d |
We do not require the compiler to align stuff for our hand-written assembly. We only hope that it's able to align stuff for SSE and similar ops it generates itself.
|
|
Packit |
c32a2d |
*/
|
|
Packit |
c32a2d |
/*
|
|
Packit |
c32a2d |
Those layer-specific structs could actually share memory, as they are not in use simultaneously. One might allocate on decoder switch, too.
|
|
Packit |
c32a2d |
They all reside in one lump of memory (after each other), allocated to layerscratch.
|
|
Packit |
c32a2d |
*/
|
|
Packit |
c32a2d |
real *layerscratch;
|
|
Packit |
c32a2d |
#ifndef NO_LAYER1
|
|
Packit |
c32a2d |
struct
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
real (*fraction)[SBLIMIT]; /* ALIGNED(16) real fraction[2][SBLIMIT]; */
|
|
Packit |
c32a2d |
} layer1;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
#ifndef NO_LAYER2
|
|
Packit |
c32a2d |
struct
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
real (*fraction)[4][SBLIMIT]; /* ALIGNED(16) real fraction[2][4][SBLIMIT] */
|
|
Packit |
c32a2d |
} layer2;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
#ifndef NO_LAYER3
|
|
Packit |
c32a2d |
/* These are significant chunks of memory already... */
|
|
Packit |
c32a2d |
struct
|
|
Packit |
c32a2d |
{
|
|
Packit |
c32a2d |
real (*hybrid_in)[SBLIMIT][SSLIMIT]; /* ALIGNED(16) real hybridIn[2][SBLIMIT][SSLIMIT]; */
|
|
Packit |
c32a2d |
real (*hybrid_out)[SSLIMIT][SBLIMIT]; /* ALIGNED(16) real hybridOut[2][SSLIMIT][SBLIMIT]; */
|
|
Packit |
c32a2d |
} layer3;
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
/* A place for storing additional data for the large file wrapper.
|
|
Packit |
c32a2d |
This is cruft! */
|
|
Packit |
c32a2d |
void *wrapperdata;
|
|
Packit |
c32a2d |
/* A callback used to properly destruct the wrapper data. */
|
|
Packit |
c32a2d |
void (*wrapperclean)(void*);
|
|
Packit |
c32a2d |
};
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* generic init, does not include dynamic buffers */
|
|
Packit |
c32a2d |
void frame_init(mpg123_handle *fr);
|
|
Packit |
c32a2d |
void frame_init_par(mpg123_handle *fr, mpg123_pars *mp);
|
|
Packit |
c32a2d |
/* output buffer and format */
|
|
Packit |
c32a2d |
int frame_outbuffer(mpg123_handle *fr);
|
|
Packit |
c32a2d |
int frame_output_format(mpg123_handle *fr);
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
int frame_buffers(mpg123_handle *fr); /* various decoder buffers, needed once */
|
|
Packit |
c32a2d |
int frame_reset(mpg123_handle* fr); /* reset for next track */
|
|
Packit |
c32a2d |
int frame_buffers_reset(mpg123_handle *fr);
|
|
Packit |
c32a2d |
void frame_exit(mpg123_handle *fr); /* end, free all buffers */
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* Index functions... */
|
|
Packit |
c32a2d |
/* Well... print it... */
|
|
Packit |
c32a2d |
int mpg123_print_index(mpg123_handle *fr, FILE* out);
|
|
Packit |
c32a2d |
/* Find a seek position in index. */
|
|
Packit |
c32a2d |
off_t frame_index_find(mpg123_handle *fr, off_t want_frame, off_t* get_frame);
|
|
Packit |
c32a2d |
/* Apply index_size setting. */
|
|
Packit |
c32a2d |
int frame_index_setup(mpg123_handle *fr);
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
void do_volume(mpg123_handle *fr, double factor);
|
|
Packit |
c32a2d |
void do_rva(mpg123_handle *fr);
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* samples per frame ...
|
|
Packit |
c32a2d |
Layer I
|
|
Packit |
c32a2d |
Layer II
|
|
Packit |
c32a2d |
Layer III
|
|
Packit |
c32a2d |
MPEG-1
|
|
Packit |
c32a2d |
384
|
|
Packit |
c32a2d |
1152
|
|
Packit |
c32a2d |
1152
|
|
Packit |
c32a2d |
MPEG-2 LSF
|
|
Packit |
c32a2d |
384
|
|
Packit |
c32a2d |
1152
|
|
Packit |
c32a2d |
576
|
|
Packit |
c32a2d |
MPEG 2.5
|
|
Packit |
c32a2d |
384
|
|
Packit |
c32a2d |
1152
|
|
Packit |
c32a2d |
576
|
|
Packit |
c32a2d |
*/
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
#ifdef GAPLESS
|
|
Packit |
c32a2d |
/* well, I take that one for granted... at least layer3 */
|
|
Packit |
c32a2d |
#define GAPLESS_DELAY 529
|
|
Packit |
c32a2d |
void frame_gapless_init(mpg123_handle *fr, off_t framecount, off_t bskip, off_t eskip);
|
|
Packit |
c32a2d |
void frame_gapless_realinit(mpg123_handle *fr);
|
|
Packit |
c32a2d |
void frame_gapless_update(mpg123_handle *mh, off_t total_samples);
|
|
Packit |
c32a2d |
/*void frame_gapless_position(mpg123_handle* fr);
|
|
Packit |
c32a2d |
void frame_gapless_bytify(mpg123_handle *fr);
|
|
Packit |
c32a2d |
void frame_gapless_ignore(mpg123_handle *fr, off_t frames);*/
|
|
Packit |
c32a2d |
/* void frame_gapless_buffercheck(mpg123_handle *fr); */
|
|
Packit |
c32a2d |
#endif
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* Number of samples the decoding of the current frame should yield. */
|
|
Packit |
c32a2d |
off_t frame_expect_outsamples(mpg123_handle *fr);
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/* Skip this frame... do some fake action to get away without actually decoding it. */
|
|
Packit |
c32a2d |
void frame_skip(mpg123_handle *fr);
|
|
Packit |
c32a2d |
|
|
Packit |
c32a2d |
/*
|
|
Packit |
c32a2d |
Seeking core functions:
|
|
Packit |
c32a2d |
- convert input sample offset to output sample offset
|
|
Packit |
c32a2d |
- convert frame offset to output sample offset
|
|
Packit |
c32a2d |
- get leading frame offset for output sample offset
|
|
Packit |
c32a2d |
The offsets are "unadjusted"/internal; resampling is being taken care of.
|
|
Packit |
c32a2d |
*/
|
|
Packit |
c32a2d |
off_t frame_ins2outs(mpg123_handle *fr, off_t ins);
|
|
Packit |
c32a2d |
off_t frame_outs(mpg123_handle *fr, off_t num);
|
|
Packit |
c32a2d |
/* This one just computes the expected sample count for _this_ frame. */
|
|
Packit |
c32a2d |
off_t frame_expect_outsampels(mpg123_handle *fr);
|
|
Packit |
c32a2d |
off_t frame_offset(mpg123_handle *fr, off_t outs);
|
|
Packit |
c32a2d |
void frame_set_frameseek(mpg123_handle *fr, off_t fe);
|
|
Packit |
c32a2d |
void frame_set_seek(mpg123_handle *fr, off_t sp);
|
|
Packit |
c32a2d |
off_t frame_tell_seek(mpg123_handle *fr);
|
|
Packit |
c32a2d |
/* Take a copy of the Xing VBR TOC for fuzzy seeking. */
|
|
Packit |
c32a2d |
int frame_fill_toc(mpg123_handle *fr, unsigned char* in);
|
|
Packit |
c32a2d |
#endif
|