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