|
562
|
1 /*
|
|
|
2 parse: spawned from common; clustering around stream/frame parsing
|
|
|
3
|
|
|
4 copyright ?-2008 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 Michael Hipp & Thomas Orgis
|
|
|
7 */
|
|
|
8
|
|
|
9 #include "mpg123lib_intern.h"
|
|
|
10
|
|
|
11 #include <sys/stat.h>
|
|
|
12 #include <fcntl.h>
|
|
|
13
|
|
|
14 #include "getbits.h"
|
|
|
15
|
|
|
16 #ifdef WIN32
|
|
|
17 #include <winsock.h>
|
|
|
18 #endif
|
|
|
19
|
|
|
20 /* a limit for number of frames in a track; beyond that unsigned long may not be enough to hold byte addresses */
|
|
|
21 #ifdef HAVE_LIMITS_H
|
|
|
22 #include <limits.h>
|
|
|
23 #endif
|
|
|
24 #ifndef ULONG_MAX
|
|
|
25 /* hm, is this portable across preprocessors? */
|
|
|
26 #define ULONG_MAX ((unsigned long)-1)
|
|
|
27 #endif
|
|
|
28 #define TRACK_MAX_FRAMES ULONG_MAX/4/1152
|
|
|
29
|
|
|
30 #include "debug.h"
|
|
|
31
|
|
|
32 #define bsbufid(fr) (fr)->bsbuf==(fr)->bsspace[0] ? 0 : ((fr)->bsbuf==fr->bsspace[1] ? 1 : ( (fr)->bsbuf==(fr)->bsspace[0]+512 ? 2 : ((fr)->bsbuf==fr->bsspace[1]+512 ? 3 : -1) ) )
|
|
|
33
|
|
|
34 /*
|
|
|
35 AAAAAAAA AAABBCCD EEEEFFGH IIJJKLMM
|
|
|
36 A: sync
|
|
|
37 B: mpeg version
|
|
|
38 C: layer
|
|
|
39 D: CRC
|
|
|
40 E: bitrate
|
|
|
41 F:sampling rate
|
|
|
42 G: padding
|
|
|
43 H: private
|
|
|
44 I: channel mode
|
|
|
45 J: mode ext
|
|
|
46 K: copyright
|
|
|
47 L: original
|
|
|
48 M: emphasis
|
|
|
49
|
|
|
50 old compare mask 0xfffffd00:
|
|
|
51 11111111 11111111 11111101 00000000
|
|
|
52
|
|
|
53 means: everything must match excluding padding and channel mode, ext mode, ...
|
|
|
54 But a vbr stream's headers will differ in bitrate!
|
|
|
55 We are already strict in allowing only frames of same type in stream, we should at least watch out for VBR while being strict.
|
|
|
56
|
|
|
57 So a better mask is:
|
|
|
58 11111111 11111111 00001101 00000000
|
|
|
59
|
|
|
60 Even more, I'll allow varying crc bit.
|
|
|
61 11111111 11111110 00001101 00000000
|
|
|
62
|
|
|
63 (still unsure about this private bit)
|
|
|
64 */
|
|
|
65 #define HDRCMPMASK 0xfffe0d00
|
|
|
66 #define HDRCHANMASK 0xc0 /* 11000000, selecting II bits (channel mode) */
|
|
|
67 #define HDRSAMPMASK 0xc00 /* 1100 00000000, FF bits (sample rate) */
|
|
|
68
|
|
|
69 /* bitrates for [mpeg1/2][layer] */
|
|
|
70 static const int tabsel_123[2][3][16] =
|
|
|
71 {
|
|
|
72 {
|
|
|
73 {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,},
|
|
|
74 {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,},
|
|
|
75 {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,}
|
|
|
76 },
|
|
|
77 {
|
|
|
78 {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,},
|
|
|
79 {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,},
|
|
|
80 {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,}
|
|
|
81 }
|
|
|
82 };
|
|
|
83
|
|
|
84 const long freqs[9] = { 44100, 48000, 32000, 22050, 24000, 16000 , 11025 , 12000 , 8000 };
|
|
|
85
|
|
|
86 static int decode_header(mpg123_handle *fr,unsigned long newhead);
|
|
|
87
|
|
|
88 int read_frame_init(mpg123_handle* fr)
|
|
|
89 {
|
|
|
90 if(frame_reset(fr) != 0) return -1;
|
|
|
91 return 0;
|
|
|
92 }
|
|
|
93
|
|
|
94 /* These two are to be replaced by one function that gives all the frame parameters (for outsiders).*/
|
|
|
95
|
|
|
96 int frame_bitrate(mpg123_handle *fr)
|
|
|
97 {
|
|
|
98 return tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index];
|
|
|
99 }
|
|
|
100
|
|
|
101 long frame_freq(mpg123_handle *fr)
|
|
|
102 {
|
|
|
103 return freqs[fr->sampling_frequency];
|
|
|
104 }
|
|
|
105
|
|
|
106 #define free_format_header(head) ( ((head & 0xffe00000) == 0xffe00000) && ((head>>17)&3) && (((head>>12)&0xf) == 0x0) && (((head>>10)&0x3) != 0x3 ))
|
|
|
107
|
|
|
108 /* compiler is smart enought to inline this one or should I really do it as macro...? */
|
|
|
109 int head_check(unsigned long head)
|
|
|
110 {
|
|
|
111 if
|
|
|
112 (
|
|
|
113 /* first 11 bits are set to 1 for frame sync */
|
|
|
114 ((head & 0xffe00000) != 0xffe00000)
|
|
|
115 ||
|
|
|
116 /* layer: 01,10,11 is 1,2,3; 00 is reserved */
|
|
|
117 (!((head>>17)&3))
|
|
|
118 ||
|
|
|
119 /* 1111 means bad bitrate */
|
|
|
120 (((head>>12)&0xf) == 0xf)
|
|
|
121 ||
|
|
|
122 /* 0000 means free format... which should be supported in future. */
|
|
|
123 (((head>>12)&0xf) == 0x0)
|
|
|
124 ||
|
|
|
125 /* sampling freq: 11 is reserved */
|
|
|
126 (((head>>10)&0x3) == 0x3 )
|
|
|
127 /* here used to be a mpeg 2.5 check... re-enabled 2.5 decoding due to lack of evidence that it is really not good */
|
|
|
128 )
|
|
|
129 {
|
|
|
130 return FALSE;
|
|
|
131 }
|
|
|
132 /* if no check failed, the header is valid (hopefully)*/
|
|
|
133 else
|
|
|
134 {
|
|
|
135 return TRUE;
|
|
|
136 }
|
|
|
137 }
|
|
|
138
|
|
|
139 static int check_lame_tag(mpg123_handle *fr)
|
|
|
140 {
|
|
|
141 /*
|
|
|
142 going to look for Xing or Info at some position after the header
|
|
|
143 MPEG 1 MPEG 2/2.5 (LSF)
|
|
|
144 Stereo, Joint Stereo, Dual Channel 32 17
|
|
|
145 Mono 17 9
|
|
|
146
|
|
|
147 Also, how to avoid false positives? I guess I should interpret more of the header to rule that out(?).
|
|
|
148 I hope that ensuring all zeros until tag start is enough.
|
|
|
149 */
|
|
|
150 size_t lame_offset = (fr->stereo == 2) ? (fr->lsf ? 17 : 32 ) : (fr->lsf ? 9 : 17);
|
|
|
151 /* At least skip the decoder delay. */
|
|
|
152 #ifdef GAPLESS
|
|
|
153 if(fr->begin_s == 0) frame_gapless_init(fr, GAPLESS_DELAY, 0);
|
|
|
154 #endif
|
|
|
155
|
|
|
156 if(fr->framesize >= 120+lame_offset) /* traditional Xing header is 120 bytes */
|
|
|
157 {
|
|
|
158 size_t i;
|
|
|
159 int lame_type = 0;
|
|
|
160 debug("do we have lame tag?");
|
|
|
161 /* only search for tag when all zero before it (apart from checksum) */
|
|
|
162 for(i=2; i < lame_offset; ++i) if(fr->bsbuf[i] != 0) break;
|
|
|
163 if(i == lame_offset)
|
|
|
164 {
|
|
|
165 debug("possibly...");
|
|
|
166 if
|
|
|
167 (
|
|
|
168 (fr->bsbuf[lame_offset] == 'I')
|
|
|
169 && (fr->bsbuf[lame_offset+1] == 'n')
|
|
|
170 && (fr->bsbuf[lame_offset+2] == 'f')
|
|
|
171 && (fr->bsbuf[lame_offset+3] == 'o')
|
|
|
172 )
|
|
|
173 {
|
|
|
174 lame_type = 1; /* We still have to see what there is */
|
|
|
175 }
|
|
|
176 else if
|
|
|
177 (
|
|
|
178 (fr->bsbuf[lame_offset] == 'X')
|
|
|
179 && (fr->bsbuf[lame_offset+1] == 'i')
|
|
|
180 && (fr->bsbuf[lame_offset+2] == 'n')
|
|
|
181 && (fr->bsbuf[lame_offset+3] == 'g')
|
|
|
182 )
|
|
|
183 {
|
|
|
184 lame_type = 2;
|
|
|
185 fr->vbr = MPG123_VBR; /* Xing header means always VBR */
|
|
|
186 }
|
|
|
187 if(lame_type)
|
|
|
188 {
|
|
|
189 unsigned long xing_flags;
|
|
|
190
|
|
|
191 /* we have one of these headers... */
|
|
|
192 if(VERBOSE2) fprintf(stderr, "Note: Xing/Lame/Info header detected\n");
|
|
|
193 /* now interpret the Xing part, I have 120 bytes total for sure */
|
|
|
194 /* there are 4 bytes for flags, but only the last byte contains known ones */
|
|
|
195 lame_offset += 4; /* now first byte after Xing/Name */
|
|
|
196 /* 4 bytes dword for flags */
|
|
|
197 #define make_long(a, o) ((((unsigned long) a[o]) << 24) | (((unsigned long) a[o+1]) << 16) | (((unsigned long) a[o+2]) << 8) | ((unsigned long) a[o+3]))
|
|
|
198 /* 16 bit */
|
|
|
199 #define make_short(a,o) ((((unsigned short) a[o]) << 8) | ((unsigned short) a[o+1]))
|
|
|
200 xing_flags = make_long(fr->bsbuf, lame_offset);
|
|
|
201 lame_offset += 4;
|
|
|
202 debug1("Xing: flags 0x%08lx", xing_flags);
|
|
|
203 if(xing_flags & 1) /* frames */
|
|
|
204 {
|
|
|
205 /*
|
|
|
206 In theory, one should use that value for skipping...
|
|
|
207 When I know the exact number of samples I could simply count in flush_output,
|
|
|
208 but that's problematic with seeking and such.
|
|
|
209 I still miss the real solution for detecting the end.
|
|
|
210 */
|
|
|
211 fr->track_frames = (off_t) make_long(fr->bsbuf, lame_offset);
|
|
|
212 if(fr->track_frames > TRACK_MAX_FRAMES) fr->track_frames = 0; /* endless stream? */
|
|
|
213 #ifdef GAPLESS
|
|
|
214 /* if no further info there, remove/add at least the decoder delay */
|
|
|
215 if(fr->p.flags & MPG123_GAPLESS)
|
|
|
216 {
|
|
|
217 off_t length = fr->track_frames * spf(fr);
|
|
|
218 if(length > 1)
|
|
|
219 frame_gapless_init(fr, GAPLESS_DELAY, length+GAPLESS_DELAY);
|
|
|
220 }
|
|
|
221 #endif
|
|
|
222 if(VERBOSE3) fprintf(stderr, "Note: Xing: %lu frames\n", (long unsigned)fr->track_frames);
|
|
|
223 lame_offset += 4;
|
|
|
224 }
|
|
|
225 if(xing_flags & 0x2) /* bytes */
|
|
|
226 {
|
|
|
227 unsigned long xing_bytes = make_long(fr->bsbuf, lame_offset); /* We assume that this is the _total_ size of the file, including Xing frame ... and ID3 frames...
|
|
|
228 It's not that clearly documented... */
|
|
|
229 if(fr->rdat.filelen < 1)
|
|
|
230 fr->rdat.filelen = (off_t) xing_bytes; /* One could start caring for overflow here. */
|
|
|
231 else
|
|
|
232 {
|
|
|
233 if((off_t) xing_bytes != fr->rdat.filelen && NOQUIET)
|
|
|
234 {
|
|
|
235 double diff = 1.0/fr->rdat.filelen * (fr->rdat.filelen - (off_t)xing_bytes);
|
|
|
236 if(diff < 0.) diff = -diff;
|
|
|
237
|
|
|
238 if(VERBOSE3)
|
|
|
239 fprintf(stderr, "Note: Xing stream size %lu differs by %f%% from determined/given file size!\n", xing_bytes, diff);
|
|
|
240
|
|
|
241 if(diff > 1.)
|
|
|
242 fprintf(stderr, "Warning: Xing stream size off by more than 1%%, fuzzy seeking may be even more fuzzy than by design!\n");
|
|
|
243 }
|
|
|
244 }
|
|
|
245
|
|
|
246 if(VERBOSE3)
|
|
|
247 fprintf(stderr, "Note: Xing: %lu bytes\n", (long unsigned)xing_bytes);
|
|
|
248
|
|
|
249 lame_offset += 4;
|
|
|
250 }
|
|
|
251 if(xing_flags & 0x4) /* TOC */
|
|
|
252 {
|
|
|
253 frame_fill_toc(fr, fr->bsbuf+lame_offset);
|
|
|
254 lame_offset += 100; /* just skip */
|
|
|
255 }
|
|
|
256 if(xing_flags & 0x8) /* VBR quality */
|
|
|
257 {
|
|
|
258 if(VERBOSE3)
|
|
|
259 {
|
|
|
260 unsigned long xing_quality = make_long(fr->bsbuf, lame_offset);
|
|
|
261 fprintf(stderr, "Note: Xing: quality = %lu\n", (long unsigned)xing_quality);
|
|
|
262 }
|
|
|
263 lame_offset += 4;
|
|
|
264 }
|
|
|
265 /* I guess that either 0 or LAME extra data follows */
|
|
|
266 /* there may this crc16 be floating around... (?) */
|
|
|
267 if(fr->bsbuf[lame_offset] != 0)
|
|
|
268 {
|
|
|
269 unsigned char lame_vbr;
|
|
|
270 float replay_gain[2] = {0,0};
|
|
|
271 float peak = 0;
|
|
|
272 float gain_offset = 0; /* going to be +6 for old lame that used 83dB */
|
|
|
273 char nb[10];
|
|
|
274 memcpy(nb, fr->bsbuf+lame_offset, 9);
|
|
|
275 nb[9] = 0;
|
|
|
276 if(VERBOSE3) fprintf(stderr, "Note: Info: Encoder: %s\n", nb);
|
|
|
277 if(!strncmp("LAME", nb, 4))
|
|
|
278 {
|
|
|
279 gain_offset = 6;
|
|
|
280 debug("TODO: finish lame detetcion...");
|
|
|
281 }
|
|
|
282 lame_offset += 9;
|
|
|
283 /* the 4 big bits are tag revision, the small bits vbr method */
|
|
|
284 lame_vbr = fr->bsbuf[lame_offset] & 15;
|
|
|
285 if(VERBOSE3)
|
|
|
286 {
|
|
|
287 fprintf(stderr, "Note: Info: rev %u\n", fr->bsbuf[lame_offset] >> 4);
|
|
|
288 fprintf(stderr, "Note: Info: vbr mode %u\n", lame_vbr);
|
|
|
289 }
|
|
|
290 lame_offset += 1;
|
|
|
291 switch(lame_vbr)
|
|
|
292 {
|
|
|
293 /* from rev1 proposal... not sure if all good in practice */
|
|
|
294 case 1:
|
|
|
295 case 8: fr->vbr = MPG123_CBR; break;
|
|
|
296 case 2:
|
|
|
297 case 9: fr->vbr = MPG123_ABR; break;
|
|
|
298 default: fr->vbr = MPG123_VBR; /* 00==unknown is taken as VBR */
|
|
|
299 }
|
|
|
300 /* skipping: lowpass filter value */
|
|
|
301 lame_offset += 1;
|
|
|
302 /* replaygain */
|
|
|
303 /* 32bit float: peak amplitude -- why did I parse it as int before??*/
|
|
|
304 /* Ah, yes, lame seems to store it as int since some day in 2003; I've only seen zeros anyway until now, bah! */
|
|
|
305 if
|
|
|
306 (
|
|
|
307 (fr->bsbuf[lame_offset] != 0)
|
|
|
308 || (fr->bsbuf[lame_offset+1] != 0)
|
|
|
309 || (fr->bsbuf[lame_offset+2] != 0)
|
|
|
310 || (fr->bsbuf[lame_offset+3] != 0)
|
|
|
311 )
|
|
|
312 {
|
|
|
313 debug("Wow! Is there _really_ a non-zero peak value? Now is it stored as float or int - how should I know?");
|
|
|
314 /* byte*peak_bytes = (byte*) &peak;
|
|
|
315 ... endianess ... just copy bytes to avoid floating point operation on unaligned memory?
|
|
|
316 peak_bytes[0] = ...
|
|
|
317 peak = *(float*) (fr->bsbuf+lame_offset); */
|
|
|
318 }
|
|
|
319 if(VERBOSE3) fprintf(stderr, "Note: Info: peak = %f (I won't use this)\n", peak);
|
|
|
320 peak = 0; /* until better times arrived */
|
|
|
321 lame_offset += 4;
|
|
|
322 /*
|
|
|
323 ReplayGain values - lame only writes radio mode gain...
|
|
|
324 16bit gain, 3 bits name, 3 bits originator, sign (1=-, 0=+), dB value*10 in 9 bits (fixed point)
|
|
|
325 ignore the setting if name or originator == 000!
|
|
|
326 radio 0 0 1 0 1 1 1 0 0 1 1 1 1 1 0 1
|
|
|
327 audiophile 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0
|
|
|
328 */
|
|
|
329
|
|
|
330 for(i =0; i < 2; ++i)
|
|
|
331 {
|
|
|
332 unsigned char origin = (fr->bsbuf[lame_offset] >> 2) & 0x7; /* the 3 bits after that... */
|
|
|
333 if(origin != 0)
|
|
|
334 {
|
|
|
335 unsigned char gt = fr->bsbuf[lame_offset] >> 5; /* only first 3 bits */
|
|
|
336 if(gt == 1) gt = 0; /* radio */
|
|
|
337 else if(gt == 2) gt = 1; /* audiophile */
|
|
|
338 else continue;
|
|
|
339 /* get the 9 bits into a number, divide by 10, multiply sign... happy bit banging */
|
|
|
340 replay_gain[0] = ((fr->bsbuf[lame_offset] & 0x2) ? -0.1 : 0.1) * (make_short(fr->bsbuf, lame_offset) & 0x1f);
|
|
|
341 }
|
|
|
342 lame_offset += 2;
|
|
|
343 }
|
|
|
344 if(VERBOSE3)
|
|
|
345 {
|
|
|
346 fprintf(stderr, "Note: Info: Radio Gain = %03.1fdB\n", replay_gain[0]);
|
|
|
347 fprintf(stderr, "Note: Info: Audiophile Gain = %03.1fdB\n", replay_gain[1]);
|
|
|
348 }
|
|
|
349 for(i=0; i < 2; ++i)
|
|
|
350 {
|
|
|
351 if(fr->rva.level[i] <= 0)
|
|
|
352 {
|
|
|
353 fr->rva.peak[i] = 0; /* at some time the parsed peak should be used */
|
|
|
354 fr->rva.gain[i] = replay_gain[i];
|
|
|
355 fr->rva.level[i] = 0;
|
|
|
356 }
|
|
|
357 }
|
|
|
358 lame_offset += 1; /* skipping encoding flags byte */
|
|
|
359 if(fr->vbr == MPG123_ABR)
|
|
|
360 {
|
|
|
361 fr->abr_rate = fr->bsbuf[lame_offset];
|
|
|
362 if(VERBOSE3) fprintf(stderr, "Note: Info: ABR rate = %u\n", fr->abr_rate);
|
|
|
363 }
|
|
|
364 lame_offset += 1;
|
|
|
365 /* encoder delay and padding, two 12 bit values... lame does write them from int ...*/
|
|
|
366 if(VERBOSE3)
|
|
|
367 fprintf(stderr, "Note: Encoder delay = %i; padding = %i\n",
|
|
|
368 ((((int) fr->bsbuf[lame_offset]) << 4) | (((int) fr->bsbuf[lame_offset+1]) >> 4)),
|
|
|
369 (((((int) fr->bsbuf[lame_offset+1]) << 8) | (((int) fr->bsbuf[lame_offset+2]))) & 0xfff) );
|
|
|
370 #ifdef GAPLESS
|
|
|
371 if(fr->p.flags & MPG123_GAPLESS)
|
|
|
372 {
|
|
|
373 off_t length = fr->track_frames * spf(fr);
|
|
|
374 off_t skipbegin = GAPLESS_DELAY + ((((int) fr->bsbuf[lame_offset]) << 4) | (((int) fr->bsbuf[lame_offset+1]) >> 4));
|
|
|
375 off_t skipend = -GAPLESS_DELAY + (((((int) fr->bsbuf[lame_offset+1]) << 8) | (((int) fr->bsbuf[lame_offset+2]))) & 0xfff);
|
|
|
376 debug3("preparing gapless mode for layer3: length %lu, skipbegin %lu, skipend %lu",
|
|
|
377 (long unsigned)length, (long unsigned)skipbegin, (long unsigned)skipend);
|
|
|
378 if(length > 1)
|
|
|
379 frame_gapless_init(fr, skipbegin, (skipend < length) ? length-skipend : length);
|
|
|
380 }
|
|
|
381 #endif
|
|
|
382 }
|
|
|
383 /* switch buffer back ... */
|
|
|
384 fr->bsbuf = fr->bsspace[fr->bsnum]+512;
|
|
|
385 fr->bsnum = (fr->bsnum + 1) & 1;
|
|
|
386 return 1; /* got it! */
|
|
|
387 }
|
|
|
388 }
|
|
|
389 }
|
|
|
390 return 0; /* no lame tag */
|
|
|
391 }
|
|
|
392
|
|
|
393
|
|
|
394 /*
|
|
|
395 That's a big one: read the next frame. 1 is success, <= 0 is some error
|
|
|
396 Special error READER_MORE means: Please feed more data and try again.
|
|
|
397 */
|
|
|
398 int read_frame(mpg123_handle *fr)
|
|
|
399 {
|
|
|
400 /* TODO: rework this thing */
|
|
|
401 unsigned long newhead;
|
|
|
402 off_t framepos;
|
|
|
403 int ret;
|
|
|
404 /* stuff that needs resetting if complete frame reading fails */
|
|
|
405 int oldsize = fr->framesize;
|
|
|
406 int oldphase = fr->halfphase;
|
|
|
407 fr->fsizeold=fr->framesize; /* for Layer3 */
|
|
|
408
|
|
|
409 /* Hm, I never tested this...*/
|
|
|
410 if (fr->p.halfspeed)
|
|
|
411 {
|
|
|
412 if(fr->halfphase) /* repeat last frame */
|
|
|
413 {
|
|
|
414 debug("repeat!");
|
|
|
415 fr->to_decode = fr->to_ignore = TRUE;
|
|
|
416 --fr->halfphase;
|
|
|
417 fr->bitindex = 0;
|
|
|
418 fr->wordpointer = (unsigned char *) fr->bsbuf;
|
|
|
419 if(fr->lay == 3) memcpy (fr->bsbuf, fr->ssave, fr->ssize);
|
|
|
420 if(fr->error_protection) fr->crc = getbits(fr, 16); /* skip crc */
|
|
|
421 return 1;
|
|
|
422 }
|
|
|
423 else
|
|
|
424 {
|
|
|
425 fr->halfphase = fr->p.halfspeed - 1;
|
|
|
426 }
|
|
|
427 }
|
|
|
428
|
|
|
429 read_again:
|
|
|
430 debug2("trying to get frame %li at 0x%lx", (long)fr->num+1, (unsigned long)fr->rd->tell(fr));
|
|
|
431 if((ret = fr->rd->head_read(fr,&newhead)) <= 0){ debug("need more?"); goto read_frame_bad;}
|
|
|
432
|
|
|
433 init_resync:
|
|
|
434
|
|
|
435 fr->header_change = 2; /* output format change is possible... */
|
|
|
436 if(fr->oldhead) /* check a following header for change */
|
|
|
437 {
|
|
|
438 /* If they have the same sample rate. Note that only is _not_ the case for the first header, as we enforce sample rate match for following frames.
|
|
|
439 So, during one stream, only change of stereoness is possible and indicated by header_change == 2. */
|
|
|
440 if((fr->oldhead & HDRSAMPMASK) == (newhead & HDRSAMPMASK))
|
|
|
441 {
|
|
|
442 /* Now if both channel modes are mono... */
|
|
|
443 if( (fr->oldhead & HDRCHANMASK) == 0 && (newhead & HDRCHANMASK) == 0)
|
|
|
444 fr->header_change = 1;
|
|
|
445 /* ...or stereo (of sorts), then we have a small header change */
|
|
|
446 else if( (fr->oldhead & HDRCHANMASK) > 0 && (newhead & HDRCHANMASK) > 0)
|
|
|
447 fr->header_change = 1;
|
|
|
448 }
|
|
|
449 }
|
|
|
450
|
|
|
451 #ifdef SKIP_JUNK
|
|
|
452 /* watch out for junk/tags on beginning of stream by invalid header */
|
|
|
453 if(!fr->firsthead && !head_check(newhead) && !free_format_header(newhead)) {
|
|
|
454 int i;
|
|
|
455
|
|
|
456 /* check for id3v2; first three bytes (of 4) are "ID3" */
|
|
|
457 if((newhead & (unsigned long) 0xffffff00) == (unsigned long) 0x49443300)
|
|
|
458 {
|
|
|
459 int id3ret = 0;
|
|
|
460 id3ret = parse_new_id3(fr, newhead);
|
|
|
461 if (id3ret < 0){ debug("need more?"); ret = id3ret; goto read_frame_bad; }
|
|
|
462 else if(id3ret > 0){ debug("got ID3v2"); fr->metaflags |= MPG123_NEW_ID3|MPG123_ID3; }
|
|
|
463 else debug("no useful ID3v2");
|
|
|
464
|
|
|
465 fr->oldhead = 0;
|
|
|
466 goto read_again; /* Also in case of invalid ID3 tag (ret==0), try to get on track again. */
|
|
|
467 }
|
|
|
468 else if(VERBOSE2 && fr->silent_resync == 0) fprintf(stderr,"Note: Junk at the beginning (0x%08lx)\n",newhead);
|
|
|
469
|
|
|
470 /* I even saw RIFF headers at the beginning of MPEG streams ;( */
|
|
|
471 if(newhead == ('R'<<24)+('I'<<16)+('F'<<8)+'F') {
|
|
|
472 if(VERBOSE2 && fr->silent_resync == 0) fprintf(stderr, "Note: Looks like a RIFF header.\n");
|
|
|
473
|
|
|
474 if((ret=fr->rd->head_read(fr,&newhead))<=0){ debug("need more?"); goto read_frame_bad; }
|
|
|
475
|
|
|
476 while(newhead != ('d'<<24)+('a'<<16)+('t'<<8)+'a')
|
|
|
477 {
|
|
|
478 if((ret=fr->rd->head_shift(fr,&newhead))<=0){ debug("need more?"); goto read_frame_bad; }
|
|
|
479 }
|
|
|
480 if((ret=fr->rd->head_read(fr,&newhead))<=0){ debug("need more?"); goto read_frame_bad; }
|
|
|
481
|
|
|
482 if(VERBOSE2 && fr->silent_resync == 0) fprintf(stderr,"Note: Skipped RIFF header!\n");
|
|
|
483
|
|
|
484 fr->oldhead = 0;
|
|
|
485 goto read_again;
|
|
|
486 }
|
|
|
487 /* unhandled junk... just continue search for a header */
|
|
|
488 /* step in byte steps through next 64K */
|
|
|
489 debug("searching for header...");
|
|
|
490 for(i=0;i<65536;i++) {
|
|
|
491 if((ret=fr->rd->head_shift(fr,&newhead))<=0){ debug("need more?"); goto read_frame_bad; }
|
|
|
492 /* if(head_check(newhead)) */
|
|
|
493 if(head_check(newhead) && decode_header(fr, newhead))
|
|
|
494 break;
|
|
|
495 }
|
|
|
496 if(i == 65536)
|
|
|
497 {
|
|
|
498 if(NOQUIET) error("Giving up searching valid MPEG header after 64K of junk.");
|
|
|
499 return 0;
|
|
|
500 }
|
|
|
501 else debug("hopefully found one...");
|
|
|
502 /*
|
|
|
503 * should we additionaly check, whether a new frame starts at
|
|
|
504 * the next expected position? (some kind of read ahead)
|
|
|
505 * We could implement this easily, at least for files.
|
|
|
506 */
|
|
|
507 }
|
|
|
508 #endif
|
|
|
509
|
|
|
510 /* first attempt of read ahead check to find the real first header; cannot believe what junk is out there! */
|
|
|
511 /* for now, a spurious first free format header screws up here; need free format support for detecting false free format headers... */
|
|
|
512 if(!fr->firsthead && fr->rdat.flags & (READER_SEEKABLE|READER_BUFFERED) && head_check(newhead) && decode_header(fr, newhead))
|
|
|
513 {
|
|
|
514 unsigned long nexthead = 0;
|
|
|
515 int hd = 0;
|
|
|
516 off_t start = fr->rd->tell(fr);
|
|
|
517 debug2("doing ahead check with BPF %d at %li", fr->framesize+4, (long)start);
|
|
|
518 /* step framesize bytes forward and read next possible header*/
|
|
|
519 if((ret=fr->rd->skip_bytes(fr, fr->framesize))<0)
|
|
|
520 {
|
|
|
521 if(ret==READER_ERROR && NOQUIET) error("cannot seek!");
|
|
|
522 goto read_frame_bad;
|
|
|
523 }
|
|
|
524 hd = fr->rd->head_read(fr,&nexthead);
|
|
|
525 if(hd==MPG123_NEED_MORE){ debug("need more?"); ret = hd; goto read_frame_bad; }
|
|
|
526 if((ret=fr->rd->back_bytes(fr, fr->rd->tell(fr)-start))<0)
|
|
|
527 {
|
|
|
528 if(ret==READER_ERROR && NOQUIET) error("cannot seek!");
|
|
|
529 else debug("need more?");
|
|
|
530 goto read_frame_bad;
|
|
|
531 }
|
|
|
532 debug1("After fetching next header, at %li", (long)fr->rd->tell(fr));
|
|
|
533 if(!hd)
|
|
|
534 {
|
|
|
535 if(NOQUIET) warning("cannot read next header, a one-frame stream? Duh...");
|
|
|
536 }
|
|
|
537 else
|
|
|
538 {
|
|
|
539 debug2("does next header 0x%08lx match first 0x%08lx?", nexthead, newhead);
|
|
|
540 /* not allowing free format yet */
|
|
|
541 if(!head_check(nexthead) || (nexthead & HDRCMPMASK) != (newhead & HDRCMPMASK))
|
|
|
542 {
|
|
|
543 debug("No, the header was not valid, start from beginning...");
|
|
|
544 fr->oldhead = 0; /* start over */
|
|
|
545 /* try next byte for valid header */
|
|
|
546 if((ret=fr->rd->back_bytes(fr, 3))<0)
|
|
|
547 {
|
|
|
548 if(NOQUIET) error("cannot seek!");
|
|
|
549 else debug("need more?");
|
|
|
550 goto read_frame_bad;
|
|
|
551 }
|
|
|
552 goto read_again;
|
|
|
553 }
|
|
|
554 }
|
|
|
555 }
|
|
|
556
|
|
|
557 /* why has this head check been avoided here before? */
|
|
|
558 if(!head_check(newhead))
|
|
|
559 {
|
|
|
560 if(!fr->firsthead && free_format_header(newhead))
|
|
|
561 {
|
|
|
562 if(NOQUIET) error1("Header 0x%08lx seems to indicate a free format stream; I do not handle that yet", newhead);
|
|
|
563
|
|
|
564 goto read_again;
|
|
|
565 }
|
|
|
566 /* and those ugly ID3 tags */
|
|
|
567 if((newhead & 0xffffff00) == ('T'<<24)+('A'<<16)+('G'<<8))
|
|
|
568 {
|
|
|
569 fr->id3buf[0] = (unsigned char) ((newhead >> 24) & 0xff);
|
|
|
570 fr->id3buf[1] = (unsigned char) ((newhead >> 16) & 0xff);
|
|
|
571 fr->id3buf[2] = (unsigned char) ((newhead >> 8) & 0xff);
|
|
|
572 fr->id3buf[3] = (unsigned char) ( newhead & 0xff);
|
|
|
573 if((ret=fr->rd->fullread(fr,fr->id3buf+4,124)) < 0){ debug("need more?"); goto read_frame_bad; }
|
|
|
574 fr->metaflags |= MPG123_NEW_ID3|MPG123_ID3;
|
|
|
575 fr->rdat.flags |= READER_ID3TAG; /* that marks id3v1 */
|
|
|
576 if (VERBOSE2) fprintf(stderr,"Note: Skipped ID3 Tag!\n");
|
|
|
577 goto read_again;
|
|
|
578 }
|
|
|
579 /* duplicated code from above! */
|
|
|
580 /* check for id3v2; first three bytes (of 4) are "ID3" */
|
|
|
581 if((newhead & (unsigned long) 0xffffff00) == (unsigned long) 0x49443300)
|
|
|
582 {
|
|
|
583 int id3length = 0;
|
|
|
584 id3length = parse_new_id3(fr, newhead);
|
|
|
585 if(id3length < 0){ debug("need more?"); ret = id3length; goto read_frame_bad; }
|
|
|
586
|
|
|
587 fr->metaflags |= MPG123_NEW_ID3|MPG123_ID3;
|
|
|
588 goto read_again;
|
|
|
589 }
|
|
|
590 else if(NOQUIET && fr->silent_resync == 0)
|
|
|
591 {
|
|
|
592 fprintf(stderr,"Note: Illegal Audio-MPEG-Header 0x%08lx at offset 0x%lx.\n",
|
|
|
593 newhead, (long unsigned int)fr->rd->tell(fr)-4);
|
|
|
594 }
|
|
|
595
|
|
|
596 if(NOQUIET && (newhead & 0xffffff00) == ('b'<<24)+('m'<<16)+('p'<<8)) fprintf(stderr,"Note: Could be a BMP album art.\n");
|
|
|
597 /* Do resync if not forbidden by flag.
|
|
|
598 I used to have a check for not-icy-meta here, but concluded that the desync issues came from a reader bug, not the stream. */
|
|
|
599 if( !(fr->p.flags & MPG123_NO_RESYNC) )
|
|
|
600 {
|
|
|
601 long try = 0;
|
|
|
602 long limit = fr->p.resync_limit;
|
|
|
603 /* TODO: make this more robust, I'd like to cat two mp3 fragments together (in a dirty way) and still have mpg123 beign able to decode all it somehow. */
|
|
|
604 if(NOQUIET && fr->silent_resync == 0) fprintf(stderr, "Note: Trying to resync...\n");
|
|
|
605 /* Read more bytes until we find something that looks
|
|
|
606 reasonably like a valid header. This is not a
|
|
|
607 perfect strategy, but it should get us back on the
|
|
|
608 track within a short time (and hopefully without
|
|
|
609 too much distortion in the audio output). */
|
|
|
610 do
|
|
|
611 {
|
|
|
612 ++try;
|
|
|
613 if(limit >= 0 && try >= limit) break;
|
|
|
614
|
|
|
615 if((ret=fr->rd->head_shift(fr,&newhead)) <= 0)
|
|
|
616 {
|
|
|
617 debug("need more?");
|
|
|
618 if(NOQUIET) fprintf (stderr, "Note: Hit end of (available) data during resync.\n");
|
|
|
619
|
|
|
620 goto read_frame_bad;
|
|
|
621 }
|
|
|
622 if(VERBOSE3) debug3("resync try %li at 0x%lx, got newhead 0x%08lx", try, (unsigned long)fr->rd->tell(fr), newhead);
|
|
|
623
|
|
|
624 if(!fr->oldhead)
|
|
|
625 {
|
|
|
626 debug("going to init_resync...");
|
|
|
627 goto init_resync; /* "considered harmful", eh? */
|
|
|
628 }
|
|
|
629 /* we should perhaps collect a list of valid headers that occured in file... there can be more */
|
|
|
630 /* Michael's new resync routine seems to work better with the one frame readahead (and some input buffering?) */
|
|
|
631 } while
|
|
|
632 (
|
|
|
633 !head_check(newhead) /* Simply check for any valid header... we have the readahead to get it straight now(?) */
|
|
|
634 /* (newhead & HDRCMPMASK) != (fr->oldhead & HDRCMPMASK)
|
|
|
635 && (newhead & HDRCMPMASK) != (fr->firsthead & HDRCMPMASK)*/
|
|
|
636 );
|
|
|
637 /* too many false positives
|
|
|
638 }while (!(head_check(newhead) && decode_header(fr, newhead))); */
|
|
|
639 if(NOQUIET && fr->silent_resync == 0) fprintf (stderr, "Note: Skipped %li bytes in input.\n", try);
|
|
|
640
|
|
|
641 if(limit >= 0 && try >= limit)
|
|
|
642 {
|
|
|
643 if(NOQUIET)
|
|
|
644 error1("Giving up resync after %li bytes - your stream is not nice... (maybe increasing resync limit could help).", try);
|
|
|
645
|
|
|
646 fr->err = MPG123_RESYNC_FAIL;
|
|
|
647 return READER_ERROR;
|
|
|
648 }
|
|
|
649 else
|
|
|
650 {
|
|
|
651 debug1("Found valid header 0x%lx... unsetting firsthead to reinit stream.", newhead);
|
|
|
652 fr->firsthead = 0;
|
|
|
653 goto init_resync;
|
|
|
654 }
|
|
|
655 }
|
|
|
656 else
|
|
|
657 {
|
|
|
658 if(NOQUIET) error("not attempting to resync...");
|
|
|
659
|
|
|
660 fr->err = MPG123_OUT_OF_SYNC;
|
|
|
661 return READER_ERROR;
|
|
|
662 }
|
|
|
663 }
|
|
|
664
|
|
|
665 if (!fr->firsthead)
|
|
|
666 {
|
|
|
667 if(!decode_header(fr,newhead))
|
|
|
668 {
|
|
|
669 if(NOQUIET) error("decode header failed before first valid one, going to read again");
|
|
|
670
|
|
|
671 goto read_again;
|
|
|
672 }
|
|
|
673 }
|
|
|
674 else
|
|
|
675 if(!decode_header(fr,newhead))
|
|
|
676 {
|
|
|
677 if(NOQUIET) error("decode header failed - goto resync");
|
|
|
678 /* return 0; */
|
|
|
679 goto init_resync;
|
|
|
680 }
|
|
|
681
|
|
|
682 /* if filepos is invalid, so is framepos */
|
|
|
683 framepos = fr->rd->tell(fr) - 4;
|
|
|
684 /* flip/init buffer for Layer 3 */
|
|
|
685 {
|
|
|
686 unsigned char *newbuf = fr->bsspace[fr->bsnum]+512;
|
|
|
687 /* read main data into memory */
|
|
|
688 if((ret=fr->rd->read_frame_body(fr,newbuf,fr->framesize))<0)
|
|
|
689 {
|
|
|
690 /* if failed: flip back */
|
|
|
691 debug("need more?");
|
|
|
692 goto read_frame_bad;
|
|
|
693 }
|
|
|
694 fr->bsbufold = fr->bsbuf;
|
|
|
695 fr->bsbuf = newbuf;
|
|
|
696 }
|
|
|
697 fr->bsnum = (fr->bsnum + 1) & 1;
|
|
|
698
|
|
|
699 if(!fr->firsthead)
|
|
|
700 {
|
|
|
701 fr->firsthead = newhead; /* _now_ it's time to store it... the first real header */
|
|
|
702 /* This is the first header of our current stream segment.
|
|
|
703 It is only the actual first header of the whole stream when fr->num is still below zero!
|
|
|
704 Think of resyncs where firsthead has been reset for format flexibility. */
|
|
|
705 if(fr->num < 0)
|
|
|
706 {
|
|
|
707 fr->audio_start = framepos;
|
|
|
708 /* Only check for LAME tag at beginning of whole stream
|
|
|
709 ... when there indeed is one in between, it's the user's problem. */
|
|
|
710 if(fr->lay == 3 && check_lame_tag(fr) == 1)
|
|
|
711 { /* ...in practice, Xing/LAME tags are layer 3 only. */
|
|
|
712 if(fr->rd->forget != NULL) fr->rd->forget(fr);
|
|
|
713
|
|
|
714 fr->oldhead = 0;
|
|
|
715 goto read_again;
|
|
|
716 }
|
|
|
717 /* now adjust volume */
|
|
|
718 do_rva(fr);
|
|
|
719 }
|
|
|
720
|
|
|
721 debug2("fr->firsthead: %08lx, audio_start: %li", fr->firsthead, (long int)fr->audio_start);
|
|
|
722 }
|
|
|
723
|
|
|
724 fr->bitindex = 0;
|
|
|
725 fr->wordpointer = (unsigned char *) fr->bsbuf;
|
|
|
726 /* Question: How bad does the floating point value get with repeated recomputation?
|
|
|
727 Also, considering that we can play the file or parts of many times. */
|
|
|
728 if(++fr->mean_frames != 0)
|
|
|
729 {
|
|
|
730 fr->mean_framesize = ((fr->mean_frames-1)*fr->mean_framesize+compute_bpf(fr)) / fr->mean_frames ;
|
|
|
731 }
|
|
|
732 ++fr->num; /* 0 for first frame! */
|
|
|
733 debug4("Frame %li %08lx %i, next filepos=0x%lx",
|
|
|
734 (long)fr->num, newhead, fr->framesize, (long unsigned)fr->rd->tell(fr));
|
|
|
735 /* save for repetition */
|
|
|
736 if(fr->p.halfspeed && fr->lay == 3)
|
|
|
737 {
|
|
|
738 debug("halfspeed - reusing old bsbuf ");
|
|
|
739 memcpy (fr->ssave, fr->bsbuf, fr->ssize);
|
|
|
740 }
|
|
|
741
|
|
|
742 /* index the position */
|
|
|
743 #ifdef FRAME_INDEX
|
|
|
744 /* Keep track of true frame positions in our frame index.
|
|
|
745 but only do so when we are sure that the frame number is accurate... */
|
|
|
746 if(fr->accurate && FI_NEXT(fr->index, fr->num))
|
|
|
747 fi_add(&fr->index, framepos);
|
|
|
748 #endif
|
|
|
749
|
|
|
750 if(fr->silent_resync > 0) --fr->silent_resync;
|
|
|
751
|
|
|
752 if(fr->rd->forget != NULL) fr->rd->forget(fr);
|
|
|
753
|
|
|
754 fr->to_decode = fr->to_ignore = TRUE;
|
|
|
755 if(fr->error_protection) fr->crc = getbits(fr, 16); /* skip crc */
|
|
|
756
|
|
|
757 return 1;
|
|
|
758 read_frame_bad:
|
|
|
759 fr->silent_resync = 0;
|
|
|
760 if(fr->err == MPG123_OK) fr->err = MPG123_ERR_READER;
|
|
|
761 fr->framesize = oldsize;
|
|
|
762 fr->halfphase = oldphase;
|
|
|
763 return ret;
|
|
|
764 }
|
|
|
765
|
|
|
766
|
|
|
767 /*
|
|
|
768 * decode a header and write the information
|
|
|
769 * into the frame structure
|
|
|
770 */
|
|
|
771 static int decode_header(mpg123_handle *fr,unsigned long newhead)
|
|
|
772 {
|
|
|
773 if(!head_check(newhead))
|
|
|
774 {
|
|
|
775 if(NOQUIET) error("tried to decode obviously invalid header");
|
|
|
776
|
|
|
777 return 0;
|
|
|
778 }
|
|
|
779 if( newhead & (1<<20) )
|
|
|
780 {
|
|
|
781 fr->lsf = (newhead & (1<<19)) ? 0x0 : 0x1;
|
|
|
782 fr->mpeg25 = 0;
|
|
|
783 }
|
|
|
784 else
|
|
|
785 {
|
|
|
786 fr->lsf = 1;
|
|
|
787 fr->mpeg25 = 1;
|
|
|
788 }
|
|
|
789
|
|
|
790 if( (fr->p.flags & MPG123_NO_RESYNC) || !fr->oldhead
|
|
|
791 || (((fr->oldhead>>19)&0x3) ^ ((newhead>>19)&0x3)) )
|
|
|
792 {
|
|
|
793 /* If "tryresync" is false, assume that certain
|
|
|
794 parameters do not change within the stream!
|
|
|
795 Force an update if lsf or mpeg25 settings
|
|
|
796 have changed. */
|
|
|
797 fr->lay = 4-((newhead>>17)&3);
|
|
|
798 if( ((newhead>>10)&0x3) == 0x3)
|
|
|
799 {
|
|
|
800 if(NOQUIET) error("Stream error");
|
|
|
801
|
|
|
802 return 0; /* exit() here really is too much, isn't it? */
|
|
|
803 }
|
|
|
804 if(fr->mpeg25)
|
|
|
805 fr->sampling_frequency = 6 + ((newhead>>10)&0x3);
|
|
|
806 else
|
|
|
807 fr->sampling_frequency = ((newhead>>10)&0x3) + (fr->lsf*3);
|
|
|
808 }
|
|
|
809
|
|
|
810 #ifdef DEBUG
|
|
|
811 if((((newhead>>16)&0x1)^0x1) != fr->error_protection) debug("changed crc bit!");
|
|
|
812 #endif
|
|
|
813 fr->error_protection = ((newhead>>16)&0x1)^0x1; /* seen a file where this varies (old lame tag without crc, track with crc) */
|
|
|
814 fr->bitrate_index = ((newhead>>12)&0xf);
|
|
|
815 fr->padding = ((newhead>>9)&0x1);
|
|
|
816 fr->extension = ((newhead>>8)&0x1);
|
|
|
817 fr->mode = ((newhead>>6)&0x3);
|
|
|
818 fr->mode_ext = ((newhead>>4)&0x3);
|
|
|
819 fr->copyright = ((newhead>>3)&0x1);
|
|
|
820 fr->original = ((newhead>>2)&0x1);
|
|
|
821 fr->emphasis = newhead & 0x3;
|
|
|
822
|
|
|
823 fr->stereo = (fr->mode == MPG_MD_MONO) ? 1 : 2;
|
|
|
824
|
|
|
825 fr->oldhead = newhead;
|
|
|
826
|
|
|
827 if(!fr->bitrate_index)
|
|
|
828 {
|
|
|
829 if(NOQUIET) error1("encountered free format header %08lx in decode_header - not supported yet",newhead);
|
|
|
830
|
|
|
831 return 0;
|
|
|
832 }
|
|
|
833
|
|
|
834 switch(fr->lay)
|
|
|
835 {
|
|
|
836 case 1:
|
|
|
837 fr->do_layer = do_layer1;
|
|
|
838 fr->framesize = (long) tabsel_123[fr->lsf][0][fr->bitrate_index] * 12000;
|
|
|
839 fr->framesize /= freqs[fr->sampling_frequency];
|
|
|
840 fr->framesize = ((fr->framesize+fr->padding)<<2)-4;
|
|
|
841 break;
|
|
|
842 case 2:
|
|
|
843 fr->do_layer = do_layer2;
|
|
|
844 debug2("bitrate index: %i (%i)", fr->bitrate_index, tabsel_123[fr->lsf][1][fr->bitrate_index] );
|
|
|
845 fr->framesize = (long) tabsel_123[fr->lsf][1][fr->bitrate_index] * 144000;
|
|
|
846 fr->framesize /= freqs[fr->sampling_frequency];
|
|
|
847 fr->framesize += fr->padding - 4;
|
|
|
848 break;
|
|
|
849 case 3:
|
|
|
850 fr->do_layer = do_layer3;
|
|
|
851 if(fr->lsf)
|
|
|
852 fr->ssize = (fr->stereo == 1) ? 9 : 17;
|
|
|
853 else
|
|
|
854 fr->ssize = (fr->stereo == 1) ? 17 : 32;
|
|
|
855
|
|
|
856 if(fr->error_protection)
|
|
|
857 fr->ssize += 2;
|
|
|
858
|
|
|
859 fr->framesize = (long) tabsel_123[fr->lsf][2][fr->bitrate_index] * 144000;
|
|
|
860 fr->framesize /= freqs[fr->sampling_frequency]<<(fr->lsf);
|
|
|
861 fr->framesize = fr->framesize + fr->padding - 4;
|
|
|
862 break;
|
|
|
863 default:
|
|
|
864 if(NOQUIET) error("unknown layer type (!!)");
|
|
|
865
|
|
|
866 return 0;
|
|
|
867 }
|
|
|
868 if (fr->framesize > MAXFRAMESIZE)
|
|
|
869 {
|
|
|
870 if(NOQUIET) error1("Frame size too big: %d", fr->framesize+4-fr->padding);
|
|
|
871
|
|
|
872 return (0);
|
|
|
873 }
|
|
|
874 return 1;
|
|
|
875 }
|
|
|
876
|
|
|
877 void set_pointer(mpg123_handle *fr, long backstep)
|
|
|
878 {
|
|
|
879 fr->wordpointer = fr->bsbuf + fr->ssize - backstep;
|
|
|
880 if (backstep)
|
|
|
881 memcpy(fr->wordpointer,fr->bsbufold+fr->fsizeold-backstep,backstep);
|
|
|
882
|
|
|
883 fr->bitindex = 0;
|
|
|
884 }
|
|
|
885
|
|
|
886 /********************************/
|
|
|
887
|
|
|
888 double compute_bpf(mpg123_handle *fr)
|
|
|
889 {
|
|
|
890 double bpf;
|
|
|
891
|
|
|
892 switch(fr->lay)
|
|
|
893 {
|
|
|
894 case 1:
|
|
|
895 bpf = tabsel_123[fr->lsf][0][fr->bitrate_index];
|
|
|
896 bpf *= 12000.0 * 4.0;
|
|
|
897 bpf /= freqs[fr->sampling_frequency] <<(fr->lsf);
|
|
|
898 break;
|
|
|
899 case 2:
|
|
|
900 case 3:
|
|
|
901 bpf = tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index];
|
|
|
902 bpf *= 144000;
|
|
|
903 bpf /= freqs[fr->sampling_frequency] << (fr->lsf);
|
|
|
904 break;
|
|
|
905 default:
|
|
|
906 bpf = 1.0;
|
|
|
907 }
|
|
|
908
|
|
|
909 return bpf;
|
|
|
910 }
|
|
|
911
|
|
|
912 double attribute_align_arg mpg123_tpf(mpg123_handle *fr)
|
|
|
913 {
|
|
|
914 static int bs[4] = { 0,384,1152,1152 };
|
|
|
915 double tpf;
|
|
|
916 if(fr == NULL) return -1;
|
|
|
917
|
|
|
918 tpf = (double) bs[fr->lay];
|
|
|
919 tpf /= freqs[fr->sampling_frequency] << (fr->lsf);
|
|
|
920 return tpf;
|
|
|
921 }
|
|
|
922
|
|
|
923 int attribute_align_arg mpg123_position(mpg123_handle *fr, off_t no, off_t buffsize,
|
|
|
924 off_t *current_frame, off_t *frames_left,
|
|
|
925 double *current_seconds, double *seconds_left)
|
|
|
926 {
|
|
|
927 double tpf;
|
|
|
928 double dt = 0.0;
|
|
|
929 off_t cur, left;
|
|
|
930 double curs, lefts;
|
|
|
931
|
|
|
932 if(!fr || !fr->rd) /* Isn't this too paranoid? */
|
|
|
933 {
|
|
|
934 debug("reader troubles!");
|
|
|
935 return MPG123_ERR;
|
|
|
936 }
|
|
|
937
|
|
|
938 no += fr->num; /* no starts out as offset */
|
|
|
939 cur = no;
|
|
|
940 tpf = mpg123_tpf(fr);
|
|
|
941 if(buffsize > 0 && fr->af.rate > 0 && fr->af.channels > 0)
|
|
|
942 {
|
|
|
943 dt = (double) buffsize / fr->af.rate / fr->af.channels;
|
|
|
944 if(fr->af.encoding & MPG123_ENC_16) dt *= 0.5;
|
|
|
945 }
|
|
|
946
|
|
|
947 left = 0;
|
|
|
948
|
|
|
949 if((fr->track_frames != 0) && (fr->track_frames >= fr->num)) left = no < fr->track_frames ? fr->track_frames - no : 0;
|
|
|
950 else
|
|
|
951 if(fr->rdat.filelen >= 0)
|
|
|
952 {
|
|
|
953 double bpf;
|
|
|
954 off_t t = fr->rd->tell(fr);
|
|
|
955 bpf = fr->mean_framesize ? fr->mean_framesize : compute_bpf(fr);
|
|
|
956 left = (off_t)((double)(fr->rdat.filelen-t)/bpf);
|
|
|
957 /* no can be different for prophetic purposes, file pointer is always associated with fr->num! */
|
|
|
958 if(fr->num != no)
|
|
|
959 {
|
|
|
960 if(fr->num > no) left += fr->num - no;
|
|
|
961 else
|
|
|
962 {
|
|
|
963 if(left >= (no - fr->num)) left -= no - fr->num;
|
|
|
964 else left = 0; /* uh, oh! */
|
|
|
965 }
|
|
|
966 }
|
|
|
967 /* I totally don't understand why we should re-estimate the given correct(?) value */
|
|
|
968 /* fr->num = (unsigned long)((double)t/bpf); */
|
|
|
969 }
|
|
|
970
|
|
|
971 /* beginning with 0 or 1?*/
|
|
|
972 curs = (double) no*tpf-dt;
|
|
|
973 lefts = (double)left*tpf+dt;
|
|
|
974 #if 0
|
|
|
975 curs = curs < 0 ? 0.0 : curs;
|
|
|
976 #endif
|
|
|
977 if(left < 0 || lefts < 0)
|
|
|
978 { /* That is the case for non-seekable streams. */
|
|
|
979 left = 0;
|
|
|
980 lefts = 0.0;
|
|
|
981 }
|
|
|
982 if(current_frame != NULL) *current_frame = cur;
|
|
|
983 if(frames_left != NULL) *frames_left = left;
|
|
|
984 if(current_seconds != NULL) *current_seconds = curs;
|
|
|
985 if(seconds_left != NULL) *seconds_left = lefts;
|
|
|
986 return MPG123_OK;
|
|
|
987 }
|
|
|
988
|
|
|
989 int get_songlen(mpg123_handle *fr,int no)
|
|
|
990 {
|
|
|
991 double tpf;
|
|
|
992
|
|
|
993 if(!fr)
|
|
|
994 return 0;
|
|
|
995
|
|
|
996 if(no < 0) {
|
|
|
997 if(!fr->rd || fr->rdat.filelen < 0)
|
|
|
998 return 0;
|
|
|
999 no = (double) fr->rdat.filelen / compute_bpf(fr);
|
|
|
1000 }
|
|
|
1001
|
|
|
1002 tpf = mpg123_tpf(fr);
|
|
|
1003 return no*tpf;
|
|
|
1004 }
|
|
|
1005
|
|
|
1006
|
|
|
1007
|
|
|
1008 /* take into account: channels, bytes per sample -- NOT resampling!*/
|
|
|
1009 off_t samples_to_bytes(mpg123_handle *fr , off_t s)
|
|
|
1010 {
|
|
|
1011 return s
|
|
|
1012 #ifdef FLOATOUT
|
|
|
1013 * 4
|
|
|
1014 #else
|
|
|
1015 * ((fr->af.encoding & MPG123_ENC_16) ? 2 : 1)
|
|
|
1016 #endif
|
|
|
1017 * fr->af.channels;
|
|
|
1018 }
|
|
|
1019
|
|
|
1020 off_t bytes_to_samples(mpg123_handle *fr , off_t b)
|
|
|
1021 {
|
|
|
1022 return b
|
|
|
1023 #ifdef FLOATOUT
|
|
|
1024 / 4
|
|
|
1025 #else
|
|
|
1026 / ((fr->af.encoding & MPG123_ENC_16) ? 2 : 1)
|
|
|
1027 #endif
|
|
|
1028 / fr->af.channels;
|
|
|
1029 }
|
