reactos/include/reactos/libs/libmpg123/frame.h

   1 /*
   2         frame: Central data structures and opmitization hooks.
   3
   4         copyright 2007 by the mpg123 project - free software under the terms of the LGPL 2.1
   5         see COPYING and AUTHORS files in distribution or http://mpg123.org
   6         initially written by Thomas Orgis
   7 */
   8
   9 #ifndef MPG123_FRAME_H
  10 #define MPG123_FRAME_H
  11
  12 #include <stdio.h>
  13 #include "config.h"
  14 #include "mpg123.h"
  15 #include "optimize.h"
  16 #include "id3.h"
  17 #include "icy.h"
  18 #include "reader.h"
  19 #ifdef FRAME_INDEX
  20 #include "index.h"
  21 #endif
  22 #include "synths.h"
  23
  24 #ifdef OPT_DITHER
  25 #include "dither.h"
  26 int frame_dither_init(mpg123_handle *fr);
  27 #endif
  28
  29 /* max = 1728 */
  30 #define MAXFRAMESIZE 3456
  31
  32 struct al_table
  33 {
  34   short bits;
  35   short d;
  36 };
  37
  38 /* the output buffer, used to be pcm_sample, pcm_point and audiobufsize */
  39 struct outbuffer
  40 {
  41         unsigned char *data;
  42         unsigned char *p; /* read pointer  */
  43         size_t fill; /* fill from read pointer */
  44         size_t size; /* that's actually more like a safe size, after we have more than that, flush it */
  45 };
  46
  47 struct audioformat
  48 {
  49         int encoding;
  50         int encsize; /* Size of one sample in bytes, plain int should be fine here... */
  51         int channels;
  52         long rate;
  53 };
  54
  55 void invalidate_format(struct audioformat *af);
  56
  57 struct mpg123_pars_struct
  58 {
  59         int verbose;    /* verbose level */
  60         long flags; /* combination of above */
  61 #ifndef NO_NTOM
  62         long force_rate;
  63 #endif
  64         int down_sample;
  65         int rva; /* (which) rva to do: 0: nothing, 1: radio/mix/track 2: album/audiophile */
  66         long halfspeed;
  67         long doublespeed;
  68         long timeout;
  69 #define NUM_CHANNELS 2
  70         char audio_caps[NUM_CHANNELS][MPG123_RATES+1][MPG123_ENCODINGS];
  71 /*      long start_frame; */ /* frame offset to begin with */
  72 /*      long frame_number;*/ /* number of frames to decode */
  73 #ifndef NO_ICY
  74         long icy_interval;
  75 #endif
  76         double outscale;
  77         long resync_limit;
  78         long index_size; /* Long, because: negative values have a meaning. */
  79         long preframes;
  80 };
  81
  82
  83
  84 /* There is a lot to condense here... many ints can be merged as flags; though the main space is still consumed by buffers. */
  85 struct mpg123_handle_struct
  86 {
  87         int fresh; /* to be moved into flags */
  88         int new_format;
  89         real hybrid_block[2][2][SBLIMIT*SSLIMIT];
  90         int hybrid_blc[2];
  91         /* the scratch vars for the decoders, sometimes real, sometimes short... sometimes int/long */
  92         short *short_buffs[2][2];
  93         real *real_buffs[2][2];
  94         unsigned char *rawbuffs;
  95         int rawbuffss;
  96 #ifdef OPT_I486
  97         int i486bo[2];
  98 #endif
  99         int bo; /* Just have it always here. */
 100 #ifdef OPT_DITHER
 101         int ditherindex;
 102         float *dithernoise;
 103 #endif
 104         unsigned char* rawdecwin; /* the block with all decwins */
 105         int rawdecwins; /* size of rawdecwin memory */
 106         real *decwin; /* _the_ decode table */
 107 #ifdef OPT_MMXORSSE
 108         /* I am not really sure that I need both of them... used in assembler */
 109         float *decwin_mmx;
 110         float *decwins;
 111 #endif
 112         int have_eq_settings;
 113         real equalizer[2][32];
 114
 115         /* for halfspeed mode */
 116         unsigned char ssave[34];
 117         int halfphase;
 118 #ifndef NO_8BIT
 119         /* a raw buffer and a pointer into the middle for signed short conversion, only allocated on demand */
 120         unsigned char *conv16to8_buf;
 121         unsigned char *conv16to8;
 122 #endif
 123         /* There's some possible memory saving for stuff that is not _really_ dynamic. */
 124
 125         /* layer3 */
 126         int longLimit[9][23];
 127         int shortLimit[9][14];
 128         real gainpow2[256+118+4]; /* not really dynamic, just different for mmx */
 129
 130         /* layer2 */
 131         real muls[27][64];      /* also used by layer 1 */
 132
 133 #ifndef NO_NTOM
 134         /* decode_ntom */
 135         unsigned long ntom_val[2];
 136         unsigned long ntom_step;
 137 #endif
 138         /* special i486 fun */
 139 #ifdef OPT_I486
 140         int *int_buffs[2][2];
 141 #endif
 142         /* special altivec... */
 143 #ifdef OPT_ALTIVEC
 144         real *areal_buffs[4][4];
 145 #endif
 146         struct synth_s synths;
 147         struct
 148         {
 149 #ifdef OPT_MULTI
 150
 151 #ifndef NO_LAYER3
 152 #if (defined OPT_3DNOW || defined OPT_3DNOWEXT)
 153                 void (*the_dct36)(real *,real *,real *,real *,real *);
 154 #endif
 155 #endif
 156
 157 #endif
 158                 enum optdec type;
 159                 enum optcla class;
 160         } cpu_opts;
 161
 162         int verbose;    /* 0: nothing, 1: just print chosen decoder, 2: be verbose */
 163
 164         const struct al_table *alloc;
 165         /* The runtime-chosen decoding, based on input and output format. */
 166         func_synth synth;
 167         func_synth_stereo synth_stereo;
 168         func_synth_mono synth_mono;
 169         /* Yes, this function is runtime-switched, too. */
 170         void (*make_decode_tables)(mpg123_handle *fr); /* That is the volume control. */
 171
 172         int stereo; /* I _think_ 1 for mono and 2 for stereo */
 173         int jsbound;
 174 #define SINGLE_STEREO -1
 175 #define SINGLE_LEFT    0
 176 #define SINGLE_RIGHT   1
 177 #define SINGLE_MIX     3
 178         int single;
 179         int II_sblimit;
 180         int down_sample_sblimit;
 181         int lsf; /* 0: MPEG 1.0; 1: MPEG 2.0/2.5 -- both used as bool and array index! */
 182         /* Many flags in disguise as integers... wasting bytes. */
 183         int mpeg25;
 184         int down_sample;
 185         int header_change;
 186         int lay;
 187         int (*do_layer)(mpg123_handle *);
 188         int error_protection;
 189         int bitrate_index;
 190         int sampling_frequency;
 191         int padding;
 192         int extension;
 193         int mode;
 194         int mode_ext;
 195         int copyright;
 196         int original;
 197         int emphasis;
 198         int framesize; /* computed framesize */
 199         int freesize;  /* free format frame size */
 200         enum mpg123_vbr vbr; /* 1 if variable bitrate was detected */
 201         off_t num; /* frame offset ... */
 202         off_t playnum; /* playback offset... includes repetitions, reset at seeks */
 203         off_t audio_start; /* The byte offset in the file where audio data begins. */
 204         char accurate; /* Flag to see if we trust the frame number. */
 205         char silent_resync; /* Do not complain for the next n resyncs. */
 206         unsigned char* xing_toc; /* The seek TOC from Xing header. */
 207         int freeformat;
 208         long freeformat_framesize;
 209
 210         /* bitstream info; bsi */
 211         int bitindex;
 212         unsigned char *wordpointer;
 213         /* temporary storage for getbits stuff */
 214         unsigned long ultmp;
 215         unsigned char uctmp;
 216
 217         /* rva data, used in common.c, set in id3.c */
 218
 219         double maxoutburst; /* The maximum amplitude in current sample represenation. */
 220         double lastscale;
 221         struct
 222         {
 223                 int level[2];
 224                 float gain[2];
 225                 float peak[2];
 226         } rva;
 227
 228         /* input data */
 229         off_t track_frames;
 230         off_t track_samples;
 231         double mean_framesize;
 232         off_t mean_frames;
 233         int fsizeold;
 234         int ssize;
 235         unsigned int bitreservoir;
 236         unsigned char bsspace[2][MAXFRAMESIZE+512]; /* MAXFRAMESIZE */
 237         unsigned char *bsbuf;
 238         unsigned char *bsbufold;
 239         int bsnum;
 240         unsigned long oldhead;
 241         unsigned long firsthead;
 242         int abr_rate;
 243 #ifdef FRAME_INDEX
 244         struct frame_index index;
 245 #endif
 246
 247         /* output data */
 248         struct outbuffer buffer;
 249         struct audioformat af;
 250         int own_buffer;
 251         size_t outblock; /* number of bytes that this frame produces (upper bound) */
 252         int to_decode;   /* this frame holds data to be decoded */
 253         int to_ignore;   /* the same, somehow */
 254         off_t firstframe;  /* start decoding from here */
 255         off_t lastframe;   /* last frame to decode (for gapless or num_frames limit) */
 256         off_t ignoreframe; /* frames to decode but discard before firstframe */
 257 #ifdef GAPLESS
 258         off_t firstoff; /* number of samples to ignore from firstframe */
 259         off_t lastoff;  /* number of samples to use from lastframe */
 260         off_t begin_s;  /* overall begin offset in samples */
 261         off_t begin_os;
 262         off_t end_s;    /* overall end offset in samples */
 263         off_t end_os;
 264 #endif
 265         unsigned int crc; /* Well, I need a safe 16bit type, actually. But wider doesn't hurt. */
 266         struct reader *rd; /* pointer to the reading functions */
 267         struct reader_data rdat; /* reader data and state info */
 268         struct mpg123_pars_struct p;
 269         int err;
 270         int decoder_change;
 271         int delayed_change;
 272         long clip;
 273         /* the meta crap */
 274         int metaflags;
 275         unsigned char id3buf[128];
 276 #ifndef NO_ID3V2
 277         mpg123_id3v2 id3v2;
 278 #endif
 279 #ifndef NO_ICY
 280         struct icy_meta icy;
 281 #endif
 282         /*
 283                 More variables needed for decoders, layerX.c.
 284                 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).
 285                 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.
 286         */
 287         /*
 288                 Those layer-specific structs could actually share memory, as they are not in use simultaneously. One might allocate on decoder switch, too.
 289                 They all reside in one lump of memory (after each other), allocated to layerscratch.
 290         */
 291         real *layerscratch;
 292 #ifndef NO_LAYER1
 293         struct
 294         {
 295                 real (*fraction)[SBLIMIT]; /* ALIGNED(16) real fraction[2][SBLIMIT]; */
 296         } layer1;
 297 #endif
 298 #ifndef NO_LAYER2
 299         struct
 300         {
 301                 real (*fraction)[4][SBLIMIT]; /* ALIGNED(16) real fraction[2][4][SBLIMIT] */
 302         } layer2;
 303 #endif
 304 #ifndef NO_LAYER3
 305         /* These are significant chunks of memory already... */
 306         struct
 307         {
 308                 real (*hybrid_in)[SBLIMIT][SSLIMIT];  /* ALIGNED(16) real hybridIn[2][SBLIMIT][SSLIMIT]; */
 309                 real (*hybrid_out)[SSLIMIT][SBLIMIT]; /* ALIGNED(16) real hybridOut[2][SSLIMIT][SBLIMIT]; */
 310         } layer3;
 311 #endif
 312         /* A place for storing additional data for the large file wrapper.
 313            This is cruft! */
 314         void *wrapperdata;
 315         /* A callback used to properly destruct the wrapper data. */
 316         void (*wrapperclean)(void*);
 317 };
 318
 319 /* generic init, does not include dynamic buffers */
 320 void frame_init(mpg123_handle *fr);
 321 void frame_init_par(mpg123_handle *fr, mpg123_pars *mp);
 322 /* output buffer and format */
 323 int  frame_outbuffer(mpg123_handle *fr);
 324 int  frame_output_format(mpg123_handle *fr);
 325
 326 int frame_buffers(mpg123_handle *fr); /* various decoder buffers, needed once */
 327 int frame_reset(mpg123_handle* fr);   /* reset for next track */
 328 int frame_buffers_reset(mpg123_handle *fr);
 329 void frame_exit(mpg123_handle *fr);   /* end, free all buffers */
 330
 331 /* Index functions... */
 332 /* Well... print it... */
 333 int mpg123_print_index(mpg123_handle *fr, FILE* out);
 334 /* Find a seek position in index. */
 335 off_t frame_index_find(mpg123_handle *fr, off_t want_frame, off_t* get_frame);
 336 /* Apply index_size setting. */
 337 int frame_index_setup(mpg123_handle *fr);
 338
 339 void do_volume(mpg123_handle *fr, double factor);
 340 void do_rva(mpg123_handle *fr);
 341
 342 /* samples per frame ...
 343 Layer I
 344 Layer II
 345 Layer III
 346 MPEG-1
 347 384
 348 1152
 349 1152
 350 MPEG-2 LSF
 351 384
 352 1152
 353 576
 354 MPEG 2.5
 355 384
 356 1152
 357 576
 358 */
 359 #define spf(fr) ((fr)->lay == 1 ? 384 : ((fr)->lay==2 ? 1152 : ((fr)->lsf || (fr)->mpeg25 ? 576 : 1152)))
 360
 361 #ifdef GAPLESS
 362 /* well, I take that one for granted... at least layer3 */
 363 #define GAPLESS_DELAY 529
 364 /* still fine-tuning the "real music" window... see read_frame */
 365 void frame_gapless_init(mpg123_handle *fr, off_t b, off_t e);
 366 void frame_gapless_realinit(mpg123_handle *fr);
 367 void frame_gapless_update(mpg123_handle *mh, off_t total_samples);
 368 /*void frame_gapless_position(mpg123_handle* fr);
 369 void frame_gapless_bytify(mpg123_handle *fr);
 370 void frame_gapless_ignore(mpg123_handle *fr, off_t frames);*/
 371 /* void frame_gapless_buffercheck(mpg123_handle *fr); */
 372 #endif
 373
 374 /* Number of samples the decoding of the current frame should yield. */
 375 off_t frame_expect_outsamples(mpg123_handle *fr);
 376
 377 /* Skip this frame... do some fake action to get away without actually decoding it. */
 378 void frame_skip(mpg123_handle *fr);
 379
 380 /*
 381         Seeking core functions:
 382         - convert input sample offset to output sample offset
 383         - convert frame offset to output sample offset
 384         - get leading frame offset for output sample offset
 385         The offsets are "unadjusted"/internal; resampling is being taken care of.
 386 */
 387 off_t frame_ins2outs(mpg123_handle *fr, off_t ins);
 388 off_t frame_outs(mpg123_handle *fr, off_t num);
 389 /* This one just computes the expected sample count for _this_ frame. */
 390 off_t frame_expect_outsampels(mpg123_handle *fr);
 391 off_t frame_offset(mpg123_handle *fr, off_t outs);
 392 void frame_set_frameseek(mpg123_handle *fr, off_t fe);
 393 void frame_set_seek(mpg123_handle *fr, off_t sp);
 394 off_t frame_tell_seek(mpg123_handle *fr);
 395 /* Take a copy of the Xing VBR TOC for fuzzy seeking. */
 396 int frame_fill_toc(mpg123_handle *fr, unsigned char* in);
 397
 398
 399 /* adjust volume to current outscale and rva values if wanted */
 400 void do_rva(mpg123_handle *fr);
 401 #endif