ReactOS 0.4.15-dev-7711-g5627da4
parse.c File Reference
#include "mpg123lib_intern.h"
#include <sys/stat.h>
#include <fcntl.h>
#include "getbits.h"
#include "mpeghead.h"
#include "debug.h"
Include dependency graph for parse.c:

Go to the source code of this file.

Macros

#define ULONG_MAX   ((unsigned long)-1)
 
#define TRACK_MAX_FRAMES   ULONG_MAX/4/1152
 
#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) ) )
 
#define check_bytes_left(n)
 
#define JUMP_CONCLUSION(ret)
 
#define FORGET_INTERVAL   1024 /* Used by callers to set forget flag each <n> bytes. */
 

Enumerations

enum  parse_codes {
  PARSE_MORE = MPG123_NEED_MORE , PARSE_ERR = MPG123_ERR , PARSE_END = 10 , PARSE_GOOD = 1 ,
  PARSE_BAD = 0 , PARSE_RESYNC = 2 , PARSE_AGAIN = 3
}
 

Functions

static int decode_header (mpg123_handle *fr, unsigned long newhead, int *freeformat_count)
 
static int skip_junk (mpg123_handle *fr, unsigned long *newheadp, long *headcount)
 
static int do_readahead (mpg123_handle *fr, unsigned long newhead)
 
static int wetwork (mpg123_handle *fr, unsigned long *newheadp)
 
int frame_bitrate (mpg123_handle *fr)
 
long frame_freq (mpg123_handle *fr)
 
static int head_check (unsigned long head)
 
static unsigned long bit_read_long (unsigned char *buf, int *offset)
 
static unsigned short bit_read_short (unsigned char *buf, int *offset)
 
static int check_lame_tag (mpg123_handle *fr)
 
static int header_mono (unsigned long newhead)
 
static int head_compatible (unsigned long fred, unsigned long bret)
 
static void halfspeed_prepare (mpg123_handle *fr)
 
static int halfspeed_do (mpg123_handle *fr)
 
int read_frame (mpg123_handle *fr)
 
static int guess_freeformat_framesize (mpg123_handle *fr, unsigned long oldhead)
 
void set_pointer (mpg123_handle *fr, int part2, long backstep)
 
double compute_bpf (mpg123_handle *fr)
 
int attribute_align_arg mpg123_spf (mpg123_handle *mh)
 
double attribute_align_arg mpg123_tpf (mpg123_handle *fr)
 
int attribute_align_arg mpg123_position (mpg123_handle *fr, off_t no, off_t buffsize, off_t *current_frame, off_t *frames_left, double *current_seconds, double *seconds_left)
 
int get_songlen (mpg123_handle *fr, int no)
 
static int handle_id3v2 (mpg123_handle *fr, unsigned long newhead)
 
static int handle_apetag (mpg123_handle *fr, unsigned long newhead)
 
static int forget_head_shift (mpg123_handle *fr, unsigned long *newheadp, int forget)
 

Variables

static const int tabsel_123 [2][3][16]
 
static const long freqs [9] = { 44100, 48000, 32000, 22050, 24000, 16000 , 11025 , 12000 , 8000 }
 

Macro Definition Documentation

◆ bsbufid

#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) ) )

Definition at line 41 of file parse.c.

◆ check_bytes_left

#define check_bytes_left (   n)
Value:
if(fr->framesize < lame_offset+n) \
goto check_lame_tag_yes
GLdouble n
Definition: glext.h:7729

◆ FORGET_INTERVAL

#define FORGET_INTERVAL   1024 /* Used by callers to set forget flag each <n> bytes. */

Definition at line 1198 of file parse.c.

◆ JUMP_CONCLUSION

#define JUMP_CONCLUSION (   ret)
Value:
{ \
if(ret < 0){ debug1("%s", ret == MPG123_NEED_MORE ? "need more" : "read error"); goto read_frame_bad; } \
else if(ret == PARSE_AGAIN) goto read_again; \
else if(ret == PARSE_RESYNC) goto init_resync; \
else if(ret == PARSE_END){ ret=0; goto read_frame_bad; } \
}
@ MPG123_NEED_MORE
Definition: mpg123.h:381
#define debug1(s, a)
Definition: debug.h:61
@ PARSE_AGAIN
Definition: parse.c:52
@ PARSE_END
Definition: parse.c:48
@ PARSE_RESYNC
Definition: parse.c:51
int ret

Definition at line 488 of file parse.c.

◆ TRACK_MAX_FRAMES

#define TRACK_MAX_FRAMES   ULONG_MAX/4/1152

Definition at line 35 of file parse.c.

◆ ULONG_MAX

#define ULONG_MAX   ((unsigned long)-1)

Definition at line 33 of file parse.c.

Enumeration Type Documentation

◆ parse_codes

Enumerator
PARSE_MORE 
PARSE_ERR 
PARSE_END 
PARSE_GOOD 
PARSE_BAD 
PARSE_RESYNC 
PARSE_AGAIN 

Definition at line 44 of file parse.c.

45{
48 ,PARSE_END = 10 /* No more audio data to find. */
49 ,PARSE_GOOD = 1 /* Everything's fine. */
50 ,PARSE_BAD = 0 /* Not fine (invalid data). */
51 ,PARSE_RESYNC = 2 /* Header not good, go into resync. */
52 ,PARSE_AGAIN = 3 /* Really start over, throw away and read a new header, again. */
53};
@ MPG123_ERR
Definition: mpg123.h:382
@ PARSE_BAD
Definition: parse.c:50
@ PARSE_MORE
Definition: parse.c:46
@ PARSE_GOOD
Definition: parse.c:49
@ PARSE_ERR
Definition: parse.c:47

Function Documentation

◆ bit_read_long()

static unsigned long bit_read_long ( unsigned char buf,
int offset 
)
static

Definition at line 118 of file parse.c.

119{
120 unsigned long val = /* 32 bit value */
121 (((unsigned long) buf[*offset]) << 24)
122 | (((unsigned long) buf[*offset+1]) << 16)
123 | (((unsigned long) buf[*offset+2]) << 8)
124 | ((unsigned long) buf[*offset+3]);
125 *offset += 4;
126 return val;
127}
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLuint GLfloat * val
Definition: glext.h:7180
GLintptr offset
Definition: glext.h:5920
#define long
Definition: qsort.c:33

Referenced by check_lame_tag().

◆ bit_read_short()

static unsigned short bit_read_short ( unsigned char buf,
int offset 
)
static

Definition at line 129 of file parse.c.

130{
131 unsigned short val = /* 16 bit value */
132 (((unsigned short) buf[*offset] ) << 8)
133 | ((unsigned short) buf[*offset+1]);
134 *offset += 2;
135 return val;
136}
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94

◆ check_lame_tag()

static int check_lame_tag ( mpg123_handle fr)
static

Definition at line 138 of file parse.c.

139{
140 int i;
141 unsigned long xing_flags;
142 unsigned long long_tmp;
143 /*
144 going to look for Xing or Info at some position after the header
145 MPEG 1 MPEG 2/2.5 (LSF)
146 Stereo, Joint Stereo, Dual Channel 32 17
147 Mono 17 9
148 */
149 int lame_offset = (fr->stereo == 2)
150 ? (fr->lsf ? 17 : 32)
151 : (fr->lsf ? 9 : 17);
152
153 if(fr->p.flags & MPG123_IGNORE_INFOFRAME) goto check_lame_tag_no;
154
155 debug("do we have lame tag?");
156 /*
157 Note: CRC or not, that does not matter here.
158 But, there is any combination of Xing flags in the wild. There are headers
159 without the search index table! I cannot assume a reasonable minimal size
160 for the actual data, have to check if each byte of information is present.
161 But: 4 B Info/Xing + 4 B flags is bare minimum.
162 */
163 if(fr->framesize < lame_offset+8) goto check_lame_tag_no;
164
165 /* only search for tag when all zero before it (apart from checksum) */
166 for(i=2; i < lame_offset; ++i) if(fr->bsbuf[i] != 0) goto check_lame_tag_no;
167
168 debug("possibly...");
169 if
170 (
171 (fr->bsbuf[lame_offset] == 'I')
172 && (fr->bsbuf[lame_offset+1] == 'n')
173 && (fr->bsbuf[lame_offset+2] == 'f')
174 && (fr->bsbuf[lame_offset+3] == 'o')
175 )
176 {
177 /* We still have to see what there is */
178 }
179 else if
180 (
181 (fr->bsbuf[lame_offset] == 'X')
182 && (fr->bsbuf[lame_offset+1] == 'i')
183 && (fr->bsbuf[lame_offset+2] == 'n')
184 && (fr->bsbuf[lame_offset+3] == 'g')
185 )
186 {
187 fr->vbr = MPG123_VBR; /* Xing header means always VBR */
188 }
189 else goto check_lame_tag_no;
190
191 /* we have one of these headers... */
192 if(VERBOSE2) fprintf(stderr, "Note: Xing/Lame/Info header detected\n");
193 lame_offset += 4;
194 xing_flags = bit_read_long(fr->bsbuf, &lame_offset);
195 debug1("Xing: flags 0x%08lx", xing_flags);
196
197 /* From now on, I have to carefully check if the announced data is actually
198 there! I'm always returning 'yes', though. */
199 #define check_bytes_left(n) if(fr->framesize < lame_offset+n) \
200 goto check_lame_tag_yes
201 if(xing_flags & 1) /* total bitstream frames */
202 {
203 check_bytes_left(4); long_tmp = bit_read_long(fr->bsbuf, &lame_offset);
204 if(fr->p.flags & MPG123_IGNORE_STREAMLENGTH)
205 {
207 , "Note: Ignoring Xing frames because of MPG123_IGNORE_STREAMLENGTH\n");
208 }
209 else
210 {
211 /* Check for endless stream, but: TRACK_MAX_FRAMES sensible at all? */
212 fr->track_frames = long_tmp > TRACK_MAX_FRAMES ? 0 : (off_t) long_tmp;
213#ifdef GAPLESS
214 /* All or nothing: Only if encoder delay/padding is known, we'll cut
215 samples for gapless. */
216 if(fr->p.flags & MPG123_GAPLESS)
217 frame_gapless_init(fr, fr->track_frames, 0, 0);
218#endif
219 if(VERBOSE3) fprintf(stderr, "Note: Xing: %lu frames\n", long_tmp);
220 }
221 }
222 if(xing_flags & 0x2) /* total bitstream bytes */
223 {
224 check_bytes_left(4); long_tmp = bit_read_long(fr->bsbuf, &lame_offset);
225 if(fr->p.flags & MPG123_IGNORE_STREAMLENGTH)
226 {
228 , "Note: Ignoring Xing bytes because of MPG123_IGNORE_STREAMLENGTH\n");
229 }
230 else
231 {
232 /* The Xing bitstream length, at least as interpreted by the Lame
233 encoder, encompasses all data from the Xing header frame on,
234 ignoring leading ID3v2 data. Trailing tags (ID3v1) seem to be
235 included, though. */
236 if(fr->rdat.filelen < 1)
237 fr->rdat.filelen = (off_t) long_tmp + fr->audio_start; /* Overflow? */
238 else
239 {
240 if((off_t)long_tmp != fr->rdat.filelen - fr->audio_start && NOQUIET)
241 { /* 1/filelen instead of 1/(filelen-start), my decision */
242 double diff = 100.0/fr->rdat.filelen
243 * ( fr->rdat.filelen - fr->audio_start
244 - (off_t)long_tmp );
245 if(diff < 0.) diff = -diff;
246
248 , "Note: Xing stream size %lu differs by %f%% from determined/given file size!\n"
249 , long_tmp, diff);
250
251 if(diff > 1. && NOQUIET) fprintf(stderr
252 , "Warning: Xing stream size off by more than 1%%, fuzzy seeking may be even more fuzzy than by design!\n");
253 }
254 }
255
256 if(VERBOSE3) fprintf(stderr, "Note: Xing: %lu bytes\n", long_tmp);
257 }
258 }
259 if(xing_flags & 0x4) /* TOC */
260 {
261 check_bytes_left(100);
262 frame_fill_toc(fr, fr->bsbuf+lame_offset);
263 lame_offset += 100;
264 }
265 if(xing_flags & 0x8) /* VBR quality */
266 {
267 check_bytes_left(4); long_tmp = bit_read_long(fr->bsbuf, &lame_offset);
268 if(VERBOSE3) fprintf(stderr, "Note: Xing: quality = %lu\n", long_tmp);
269 }
270 /*
271 Either zeros/nothing, or:
272 0-8: LAME3.90a
273 9: revision/VBR method
274 10: lowpass
275 11-18: ReplayGain
276 19: encoder flags
277 20: ABR
278 21-23: encoder delays
279 */
280 check_bytes_left(24); /* I'm interested in 24 B of extra info. */
281 if(fr->bsbuf[lame_offset] != 0)
282 {
283 unsigned char lame_vbr;
284 float replay_gain[2] = {0,0};
285 float peak = 0;
286 float gain_offset = 0; /* going to be +6 for old lame that used 83dB */
287 char nb[10];
288 off_t pad_in;
289 off_t pad_out;
290 memcpy(nb, fr->bsbuf+lame_offset, 9);
291 nb[9] = 0;
292 if(VERBOSE3) fprintf(stderr, "Note: Info: Encoder: %s\n", nb);
293 if(!strncmp("LAME", nb, 4))
294 {
295 /* Lame versions before 3.95.1 used 83 dB reference level, later
296 versions 89 dB. We stick with 89 dB as being "normal", adding
297 6 dB. */
298 unsigned int major, minor;
299 char rest[6];
300 rest[0] = 0;
301 if(sscanf(nb+4, "%u.%u%s", &major, &minor, rest) >= 2)
302 {
303 debug3("LAME: %u/%u/%s", major, minor, rest);
304 /* We cannot detect LAME 3.95 reliably (same version string as
305 3.95.1), so this is a blind spot. Everything < 3.95 is safe,
306 though. */
307 if(major < 3 || (major == 3 && minor < 95))
308 {
309 gain_offset = 6;
311 , "Note: Info: Old LAME detected, using ReplayGain preamp of %f dB.\n"
312 , gain_offset);
313 }
314 }
315 else if(VERBOSE3) fprintf(stderr
316 , "Note: Info: Cannot determine LAME version.\n");
317 }
318 lame_offset += 9; /* 9 in */
319
320 /* The 4 big bits are tag revision, the small bits vbr method. */
321 lame_vbr = fr->bsbuf[lame_offset] & 15;
322 lame_offset += 1; /* 10 in */
323 if(VERBOSE3)
324 {
325 fprintf(stderr, "Note: Info: rev %u\n", fr->bsbuf[lame_offset] >> 4);
326 fprintf(stderr, "Note: Info: vbr mode %u\n", lame_vbr);
327 }
328 switch(lame_vbr)
329 {
330 /* from rev1 proposal... not sure if all good in practice */
331 case 1:
332 case 8: fr->vbr = MPG123_CBR; break;
333 case 2:
334 case 9: fr->vbr = MPG123_ABR; break;
335 default: fr->vbr = MPG123_VBR; /* 00==unknown is taken as VBR */
336 }
337 lame_offset += 1; /* 11 in, skipping lowpass filter value */
338
339 /* ReplayGain peak ampitude, 32 bit float -- why did I parse it as int
340 before?? Ah, yes, Lame seems to store it as int since some day in 2003;
341 I've only seen zeros anyway until now, bah! */
342 if
343 (
344 (fr->bsbuf[lame_offset] != 0)
345 || (fr->bsbuf[lame_offset+1] != 0)
346 || (fr->bsbuf[lame_offset+2] != 0)
347 || (fr->bsbuf[lame_offset+3] != 0)
348 )
349 {
350 debug("Wow! Is there _really_ a non-zero peak value? Now is it stored as float or int - how should I know?");
351 /* byte*peak_bytes = (byte*) &peak;
352 ... endianess ... just copy bytes to avoid floating point operation on unaligned memory?
353 peak_bytes[0] = ...
354 peak = *(float*) (fr->bsbuf+lame_offset); */
355 }
357 , "Note: Info: peak = %f (I won't use this)\n", peak);
358 peak = 0; /* until better times arrived */
359 lame_offset += 4; /* 15 in */
360
361 /* ReplayGain values - lame only writes radio mode gain...
362 16bit gain, 3 bits name, 3 bits originator, sign (1=-, 0=+),
363 dB value*10 in 9 bits (fixed point) ignore the setting if name or
364 originator == 000!
365 radio 0 0 1 0 1 1 1 0 0 1 1 1 1 1 0 1
366 audiophile 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0 */
367 for(i =0; i < 2; ++i)
368 {
369 unsigned char gt = fr->bsbuf[lame_offset] >> 5;
370 unsigned char origin = (fr->bsbuf[lame_offset] >> 2) & 0x7;
371 float factor = (fr->bsbuf[lame_offset] & 0x2) ? -0.1f : 0.1f;
372 unsigned short gain = bit_read_short(fr->bsbuf, &lame_offset) & 0x1ff; /* 19 in (2 cycles) */
373 if(origin == 0 || gt < 1 || gt > 2) continue;
374
375 --gt;
376 replay_gain[gt] = factor * (float) gain;
377 /* Apply gain offset for automatic origin. */
378 if(origin == 3) replay_gain[gt] += gain_offset;
379 }
380 if(VERBOSE3)
381 {
382 fprintf(stderr, "Note: Info: Radio Gain = %03.1fdB\n"
383 , replay_gain[0]);
384 fprintf(stderr, "Note: Info: Audiophile Gain = %03.1fdB\n"
385 , replay_gain[1]);
386 }
387 for(i=0; i < 2; ++i)
388 {
389 if(fr->rva.level[i] <= 0)
390 {
391 fr->rva.peak[i] = 0; /* TODO: use parsed peak? */
392 fr->rva.gain[i] = replay_gain[i];
393 fr->rva.level[i] = 0;
394 }
395 }
396
397 lame_offset += 1; /* 20 in, skipping encoding flags byte */
398
399 /* ABR rate */
400 if(fr->vbr == MPG123_ABR)
401 {
402 fr->abr_rate = fr->bsbuf[lame_offset];
403 if(VERBOSE3) fprintf(stderr, "Note: Info: ABR rate = %u\n"
404 , fr->abr_rate);
405 }
406 lame_offset += 1; /* 21 in */
407
408 /* Encoder delay and padding, two 12 bit values
409 ... lame does write them from int. */
410 pad_in = ( (((int) fr->bsbuf[lame_offset]) << 4)
411 | (((int) fr->bsbuf[lame_offset+1]) >> 4) );
412 pad_out = ( (((int) fr->bsbuf[lame_offset+1]) << 8)
413 | ((int) fr->bsbuf[lame_offset+2]) ) & 0xfff;
414 lame_offset += 3; /* 24 in */
415 if(VERBOSE3) fprintf(stderr, "Note: Encoder delay = %i; padding = %i\n"
416 , (int)pad_in, (int)pad_out);
417 /* Store even if libmpg123 does not do gapless decoding itself. */
418 fr->enc_delay = (int)pad_in;
419 fr->enc_padding = (int)pad_out;
420 #ifdef GAPLESS
421 if(fr->p.flags & MPG123_GAPLESS)
422 frame_gapless_init(fr, fr->track_frames, pad_in, pad_out);
423 #endif
424 /* final: 24 B LAME data */
425 }
426
427check_lame_tag_yes:
428 /* switch buffer back ... */
429 fr->bsbuf = fr->bsspace[fr->bsnum]+512;
430 fr->bsnum = (fr->bsnum + 1) & 1;
431 return 1;
432check_lame_tag_no:
433 return 0;
434}
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define off_t
Definition: dosfsck.h:5
__kernel_off_t off_t
Definition: linux.h:201
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint factor
Definition: glfuncs.h:178
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
@ MPG123_IGNORE_STREAMLENGTH
Definition: mpg123.h:226
@ MPG123_IGNORE_INFOFRAME
Definition: mpg123.h:228
@ MPG123_GAPLESS
Definition: mpg123.h:220
@ MPG123_CBR
Definition: mpg123.h:1006
@ MPG123_ABR
Definition: mpg123.h:1008
@ MPG123_VBR
Definition: mpg123.h:1007
#define stderr
Definition: stdio.h:100
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
_Check_return_ _CRTIMP int __cdecl sscanf(_In_z_ const char *_Src, _In_z_ _Scanf_format_string_ const char *_Format,...)
#define frame_fill_toc
Definition: intsym.h:205
#define frame_gapless_init
Definition: intsym.h:191
voidpf uLong int origin
Definition: ioapi.h:144
#define debug(msg)
Definition: key_call.c:71
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static float(__cdecl *square_half_float)(float x
#define VERBOSE2
#define NOQUIET
#define VERBOSE3
#define minor(rdev)
Definition: propsheet.cpp:929
#define major(rdev)
Definition: propsheet.cpp:928
#define debug3(s, a, b, c)
Definition: debug.h:63
#define TRACK_MAX_FRAMES
Definition: parse.c:35
static unsigned short bit_read_short(unsigned char *buf, int *offset)
Definition: parse.c:129
#define check_bytes_left(n)
static unsigned long bit_read_long(unsigned char *buf, int *offset)
Definition: parse.c:118
struct mpg123_pars_struct p
Definition: frame.h:289
struct mpg123_handle_struct::@3458 rva
off_t track_frames
Definition: frame.h:246
enum mpg123_vbr vbr
Definition: frame.h:215
unsigned char * bsbuf
Definition: frame.h:254
struct reader_data rdat
Definition: frame.h:288
unsigned char bsspace[2][MAXFRAMESIZE+512+4]
Definition: frame.h:253

Referenced by read_frame().

◆ compute_bpf()

double compute_bpf ( mpg123_handle fr)

Definition at line 968 of file parse.c.

969{
970 return (fr->framesize > 0) ? fr->framesize + 4.0 : 1.0;
971}

◆ decode_header()

static int decode_header ( mpg123_handle fr,
unsigned long  newhead,
int freeformat_count 
)
static

Definition at line 775 of file parse.c.

776{
777#ifdef DEBUG /* Do not waste cycles checking the header twice all the time. */
778 if(!head_check(newhead))
779 {
780 error1("trying to decode obviously invalid header 0x%08lx", newhead);
781 }
782#endif
783 /* For some reason, the layer and sampling freq settings used to be wrapped
784 in a weird conditional including MPG123_NO_RESYNC. What was I thinking?
785 This information has to be consistent. */
786 fr->lay = 4 - HDR_LAYER_VAL(newhead);
787
788 if(HDR_VERSION_VAL(newhead) & 0x2)
789 {
790 fr->lsf = (HDR_VERSION_VAL(newhead) & 0x1) ? 0 : 1;
791 fr->mpeg25 = 0;
792 fr->sampling_frequency = HDR_SAMPLERATE_VAL(newhead) + (fr->lsf*3);
793 }
794 else
795 {
796 fr->lsf = 1;
797 fr->mpeg25 = 1;
798 fr->sampling_frequency = 6 + HDR_SAMPLERATE_VAL(newhead);
799 }
800
801 #ifdef DEBUG
802 /* seen a file where this varies (old lame tag without crc, track with crc) */
803 if((HDR_CRC_VAL(newhead)^0x1) != fr->error_protection) debug("changed crc bit!");
804 #endif
805 fr->error_protection = HDR_CRC_VAL(newhead)^0x1;
806 fr->bitrate_index = HDR_BITRATE_VAL(newhead);
807 fr->padding = HDR_PADDING_VAL(newhead);
808 fr->extension = HDR_PRIVATE_VAL(newhead);
809 fr->mode = HDR_CHANNEL_VAL(newhead);
810 fr->mode_ext = HDR_CHANEX_VAL(newhead);
811 fr->copyright = HDR_COPYRIGHT_VAL(newhead);
812 fr->original = HDR_ORIGINAL_VAL(newhead);
813 fr->emphasis = HDR_EMPHASIS_VAL(newhead);
814 fr->freeformat = !(newhead & HDR_BITRATE);
815
816 fr->stereo = (fr->mode == MPG_MD_MONO) ? 1 : 2;
817
818 /* we can't use tabsel_123 for freeformat, so trying to guess framesize... */
819 if(fr->freeformat)
820 {
821 /* when we first encounter the frame with freeformat, guess framesize */
822 if(fr->freeformat_framesize < 0)
823 {
824 int ret;
825 if(fr->p.flags & MPG123_NO_READAHEAD)
826 {
827 if(VERBOSE3)
828 error("Got no free-format frame size and am not allowed to read ahead.");
829 return PARSE_BAD;
830 }
831 *freeformat_count += 1;
832 if(*freeformat_count > 5)
833 {
834 if(VERBOSE3) error("You fooled me too often. Refusing to guess free format frame size _again_.");
835 return PARSE_BAD;
836 }
837 ret = guess_freeformat_framesize(fr, newhead);
838 if(ret == PARSE_GOOD)
839 {
840 fr->freeformat_framesize = fr->framesize - fr->padding;
841 if(VERBOSE2)
842 fprintf(stderr, "Note: free format frame size %li\n", fr->freeformat_framesize);
843 }
844 else
845 {
846 if(ret == MPG123_NEED_MORE)
847 debug("Need more data to guess free format frame size.");
848 else if(VERBOSE3)
849 error("Encountered free format header, but failed to guess frame size.");
850
851 return ret;
852 }
853 }
854 /* freeformat should be CBR, so the same framesize can be used at the 2nd reading or later */
855 else
856 {
857 fr->framesize = fr->freeformat_framesize + fr->padding;
858 }
859 }
860
861 switch(fr->lay)
862 {
863#ifndef NO_LAYER1
864 case 1:
865 fr->spf = 384;
866 fr->do_layer = do_layer1;
867 if(!fr->freeformat)
868 {
869 long fs = (long) tabsel_123[fr->lsf][0][fr->bitrate_index] * 12000;
871 fs = ((fs+fr->padding)<<2)-4;
872 fr->framesize = (int)fs;
873 }
874 break;
875#endif
876#ifndef NO_LAYER2
877 case 2:
878 fr->spf = 1152;
879 fr->do_layer = do_layer2;
880 if(!fr->freeformat)
881 {
882 debug2("bitrate index: %i (%i)", fr->bitrate_index, tabsel_123[fr->lsf][1][fr->bitrate_index] );
883 long fs = (long) tabsel_123[fr->lsf][1][fr->bitrate_index] * 144000;
885 fs += fr->padding - 4;
886 fr->framesize = (int)fs;
887 }
888 break;
889#endif
890#ifndef NO_LAYER3
891 case 3:
892 fr->spf = fr->lsf ? 576 : 1152; /* MPEG 2.5 implies LSF.*/
893 fr->do_layer = do_layer3;
894 if(fr->lsf)
895 fr->ssize = (fr->stereo == 1) ? 9 : 17;
896 else
897 fr->ssize = (fr->stereo == 1) ? 17 : 32;
898
899 if(fr->error_protection)
900 fr->ssize += 2;
901
902 if(!fr->freeformat)
903 {
904 long fs = (long) tabsel_123[fr->lsf][2][fr->bitrate_index] * 144000;
905 fs /= freqs[fr->sampling_frequency]<<(fr->lsf);
906 fs += fr->padding - 4;
907 fr->framesize = fs;
908 }
909 if(fr->framesize < fr->ssize)
910 {
911 if(NOQUIET)
912 error2( "Frame smaller than mandatory side info (%i < %i)!"
913 , fr->framesize, fr->ssize );
914 return PARSE_BAD;
915 }
916 break;
917#endif
918 default:
919 if(NOQUIET) error1("Layer type %i not supported in this build!", fr->lay);
920
921 return PARSE_BAD;
922 }
923 if (fr->framesize > MAXFRAMESIZE)
924 {
925 if(NOQUIET) error1("Frame size too big: %d", fr->framesize+4-fr->padding);
926
927 return PARSE_BAD;
928 }
929 return PARSE_GOOD;
930}
#define MAXFRAMESIZE
Definition: frame.h:30
@ MPG123_NO_READAHEAD
Definition: mpg123.h:246
#define fs
Definition: i386-dis.c:444
#define do_layer2
Definition: intsym.h:173
#define do_layer3
Definition: intsym.h:172
#define do_layer1
Definition: intsym.h:174
#define error(str)
Definition: mkdosfs.c:1605
#define HDR_BITRATE_VAL(h)
Definition: mpeghead.h:45
#define HDR_ORIGINAL_VAL(h)
Definition: mpeghead.h:66
#define HDR_EMPHASIS_VAL(h)
Definition: mpeghead.h:69
#define HDR_CRC_VAL(h)
Definition: mpeghead.h:42
#define HDR_PRIVATE_VAL(h)
Definition: mpeghead.h:54
#define HDR_VERSION_VAL(h)
Definition: mpeghead.h:36
#define HDR_CHANEX_VAL(h)
Definition: mpeghead.h:60
#define HDR_BITRATE
Definition: mpeghead.h:44
#define HDR_LAYER_VAL(h)
Definition: mpeghead.h:39
#define HDR_CHANNEL_VAL(h)
Definition: mpeghead.h:57
#define HDR_SAMPLERATE_VAL(h)
Definition: mpeghead.h:48
#define HDR_COPYRIGHT_VAL(h)
Definition: mpeghead.h:63
#define HDR_PADDING_VAL(h)
Definition: mpeghead.h:51
#define MPG_MD_MONO
#define debug2(s, a, b)
Definition: debug.h:62
#define error2(s, a, b)
Definition: debug.h:126
#define error1(s, a)
Definition: debug.h:125
static const long freqs[9]
Definition: parse.c:70
static const int tabsel_123[2][3][16]
Definition: parse.c:56
static int head_check(unsigned long head)
Definition: parse.c:91
static int guess_freeformat_framesize(mpg123_handle *fr, unsigned long oldhead)
Definition: parse.c:734
Definition: ffs.h:70
int sampling_frequency
Definition: frame.h:205
int(* do_layer)(mpg123_handle *)
Definition: frame.h:202
long freeformat_framesize
Definition: frame.h:224

Referenced by read_frame(), and skip_junk().

◆ do_readahead()

static int do_readahead ( mpg123_handle fr,
unsigned long  newhead 
)
static

Definition at line 1071 of file parse.c.

1072{
1073 unsigned long nexthead = 0;
1074 int hd = 0;
1075 off_t start, oret;
1076 int ret;
1077
1078 if( ! (!fr->firsthead && fr->rdat.flags & (READER_SEEKABLE|READER_BUFFERED)) )
1079 return PARSE_GOOD;
1080
1081 start = fr->rd->tell(fr);
1082
1083 debug2("doing ahead check with BPF %d at %"OFF_P, fr->framesize+4, (off_p)start);
1084 /* step framesize bytes forward and read next possible header*/
1085 if((oret=fr->rd->skip_bytes(fr, fr->framesize))<0)
1086 {
1087 if(oret==READER_ERROR && NOQUIET) error("cannot seek!");
1088
1089 return oret == MPG123_NEED_MORE ? PARSE_MORE : PARSE_ERR;
1090 }
1091
1092 /* Read header, seek back. */
1093 hd = fr->rd->head_read(fr,&nexthead);
1094 if( fr->rd->back_bytes(fr, fr->rd->tell(fr)-start) < 0 )
1095 {
1096 if(NOQUIET) error("Cannot seek back!");
1097
1098 return PARSE_ERR;
1099 }
1100 if(hd == MPG123_NEED_MORE) return PARSE_MORE;
1101
1102 debug1("After fetching next header, at %"OFF_P, (off_p)fr->rd->tell(fr));
1103 if(!hd)
1104 {
1105 if(NOQUIET) warning("Cannot read next header, a one-frame stream? Duh...");
1106 return PARSE_END;
1107 }
1108
1109 debug2("does next header 0x%08lx match first 0x%08lx?", nexthead, newhead);
1110 if(!head_check(nexthead) || !head_compatible(newhead, nexthead))
1111 {
1112 debug("No, the header was not valid, start from beginning...");
1113 fr->oldhead = 0; /* start over */
1114 /* try next byte for valid header */
1115 if((ret=fr->rd->back_bytes(fr, 3))<0)
1116 {
1117 if(NOQUIET) error("Cannot seek 3 bytes back!");
1118
1119 return PARSE_ERR;
1120 }
1121 return PARSE_AGAIN;
1122 }
1123 else return PARSE_GOOD;
1124}
GLuint start
Definition: gl.h:1545
#define OFF_P
Definition: compat.h:131
long off_p
Definition: compat.h:132
#define warning(s)
Definition: debug.h:83
#define READER_BUFFERED
Definition: reader.h:116
#define READER_ERROR
Definition: reader.h:134
#define READER_SEEKABLE
Definition: reader.h:115
static int head_compatible(unsigned long fred, unsigned long bret)
Definition: parse.c:443
unsigned long oldhead
Definition: frame.h:258
struct reader * rd
Definition: frame.h:287
unsigned long firsthead
Definition: frame.h:260

Referenced by jread(), and read_frame().

◆ forget_head_shift()

static int forget_head_shift ( mpg123_handle fr,
unsigned long newheadp,
int  forget 
)
static

Definition at line 1199 of file parse.c.

1200{
1201 int ret;
1202 if((ret=fr->rd->head_shift(fr,newheadp))<=0) return ret;
1203 /* Try to forget buffered data as early as possible to speed up parsing where
1204 new data needs to be added for resync (and things would be re-parsed again
1205 and again because of the start from beginning after hitting end). */
1206 if(forget && fr->rd->forget != NULL)
1207 {
1208 /* Ensure that the last 4 bytes stay in buffers for reading the header
1209 anew. */
1210 if(!fr->rd->back_bytes(fr, 4))
1211 {
1212 fr->rd->forget(fr);
1213 fr->rd->back_bytes(fr, -4);
1214 }
1215 }
1216 return ret; /* No surprise here, error already triggered early return. */
1217}
#define NULL
Definition: types.h:112

Referenced by skip_junk(), and wetwork().

◆ frame_bitrate()

int frame_bitrate ( mpg123_handle fr)

Definition at line 80 of file parse.c.

81{
82 return tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index];
83}

◆ frame_freq()

long frame_freq ( mpg123_handle fr)

Definition at line 85 of file parse.c.

86{
87 return freqs[fr->sampling_frequency];
88}

◆ get_songlen()

int get_songlen ( mpg123_handle fr,
int  no 
)

Definition at line 1053 of file parse.c.

1054{
1055 double tpf;
1056
1057 if(!fr)
1058 return 0;
1059
1060 if(no < 0) {
1061 if(!fr->rd || fr->rdat.filelen < 0)
1062 return 0;
1063 no = (int) ((double) fr->rdat.filelen / compute_bpf(fr));
1064 }
1065
1066 tpf = mpg123_tpf(fr);
1067 return (int) (no*tpf);
1068}
static WCHAR no[MAX_STRING_RESOURCE_LEN]
Definition: object.c:2340
double attribute_align_arg mpg123_tpf(mpg123_handle *fr)
Definition: parse.c:980
#define compute_bpf
Definition: intsym.h:244

◆ guess_freeformat_framesize()

static int guess_freeformat_framesize ( mpg123_handle fr,
unsigned long  oldhead 
)
static

Definition at line 734 of file parse.c.

735{
736 long i;
737 int ret;
738 unsigned long head;
739 if(!(fr->rdat.flags & (READER_SEEKABLE|READER_BUFFERED)))
740 {
741 if(NOQUIET) error("Cannot look for freeformat frame size with non-seekable and non-buffered stream!");
742
743 return PARSE_BAD;
744 }
745 if((ret=fr->rd->head_read(fr,&head))<=0)
746 return ret;
747
748 /* We are already 4 bytes into it */
749 for(i=4;i<MAXFRAMESIZE+4;i++)
750 {
751 if((ret=fr->rd->head_shift(fr,&head))<=0) return ret;
752
753 /* No head_check needed, the mask contains all relevant bits. */
754 if((head & HDR_SAMEMASK) == (oldhead & HDR_SAMEMASK))
755 {
756 fr->rd->back_bytes(fr,i+1);
757 fr->framesize = i-3;
758 return PARSE_GOOD; /* Success! */
759 }
760 }
761 fr->rd->back_bytes(fr,i);
762 return PARSE_BAD;
763}
struct outqueuenode * head
Definition: adnsresfilter.c:66
#define HDR_SAMEMASK
Definition: mpeghead.h:81

Referenced by decode_header().

◆ halfspeed_do()

static int halfspeed_do ( mpg123_handle fr)
static

Definition at line 460 of file parse.c.

461{
462 /* Speed-down hack: Play it again, Sam (the frame, I mean). */
463 if (fr->p.halfspeed)
464 {
465 if(fr->halfphase) /* repeat last frame */
466 {
467 debug("repeat!");
468 fr->to_decode = fr->to_ignore = TRUE;
469 --fr->halfphase;
470 set_pointer(fr, 0, 0);
471 if(fr->lay == 3) memcpy (fr->bsbuf, fr->ssave, fr->ssize);
472 if(fr->error_protection) fr->crc = getbits(fr, 16); /* skip crc */
473 return 1;
474 }
475 else
476 {
477 fr->halfphase = fr->p.halfspeed - 1;
478 }
479 }
480 return 0;
481}
#define TRUE
Definition: types.h:120
static unsigned int getbits(mpg123_handle *fr, int number_of_bits)
Definition: getbits.h:32
#define set_pointer
Definition: intsym.h:242
unsigned char ssave[34]
Definition: frame.h:130
unsigned int crc
Definition: frame.h:286

Referenced by read_frame().

◆ halfspeed_prepare()

static void halfspeed_prepare ( mpg123_handle fr)
static

Definition at line 449 of file parse.c.

450{
451 /* save for repetition */
452 if(fr->p.halfspeed && fr->lay == 3)
453 {
454 debug("halfspeed - reusing old bsbuf ");
455 memcpy (fr->ssave, fr->bsbuf, fr->ssize);
456 }
457}

Referenced by read_frame().

◆ handle_apetag()

static int handle_apetag ( mpg123_handle fr,
unsigned long  newhead 
)
static

Definition at line 1139 of file parse.c.

1140{
1141 unsigned char apebuf[28];
1142 unsigned long val;
1143 int i, ret;
1144 /* How many bytes to backpedal to get back to just after the first byte of */
1145 /* the supposed header. */
1146 int back_bytes = 3;
1147 fr->oldhead = 0;
1148
1149 debug1("trying to read remaining APE header at %"OFF_P, (off_p)fr->rd->tell(fr));
1150 /* Apetag headers are 32 bytes, newhead contains 4, read the rest */
1151 if((ret=fr->rd->fullread(fr,apebuf,28)) < 0)
1152 return ret;
1153 back_bytes += ret;
1154 if(ret < 28)
1155 goto apetag_bad;
1156
1157 debug1("trying to parse APE header at %"OFF_P, (off_p)fr->rd->tell(fr));
1158 /* Apetags start with "APETAGEX", "APET" is already tested. */
1159 if(strncmp((char *)apebuf,"AGEX",4) != 0)
1160 goto apetag_bad;
1161
1162 /* Version must be 2.000 / 2000 */
1163 val = ((unsigned long)apebuf[7]<<24)
1164 | ((unsigned long)apebuf[6]<<16)
1165 | ((unsigned long)apebuf[5]<<8)
1166 | apebuf[4];
1167 if(val != 2000)
1168 goto apetag_bad;
1169
1170 /* Last 8 bytes must be 0 */
1171 for(i=20; i<28; i++)
1172 if(apebuf[i])
1173 goto apetag_bad;
1174
1175 /* Looks good, skip the rest. */
1176 val = ((unsigned long)apebuf[11]<<24)
1177 | ((unsigned long)apebuf[10]<<16)
1178 | ((unsigned long)apebuf[9]<<8)
1179 | apebuf[8];
1180 debug2( "skipping %lu bytes of APE data at %"OFF_P
1181 , val, (off_p)fr->rd->tell(fr) );
1182 /* If encountering EOF here, things are just at an end. */
1183 if((ret=fr->rd->skip_bytes(fr,val)) < 0)
1184 return ret;
1185
1186 return PARSE_AGAIN;
1187
1188apetag_bad:
1189 debug("no proper APE tag found, seeking back");
1190 if(fr->rd->back_bytes(fr,back_bytes) < 0 && NOQUIET)
1191 error1("Cannot seek %d bytes back!", back_bytes);
1192
1193 return PARSE_AGAIN; /* Give the resync code a chance to fix things */
1194}

Referenced by wetwork().

◆ handle_id3v2()

static int handle_id3v2 ( mpg123_handle fr,
unsigned long  newhead 
)
static

Definition at line 1126 of file parse.c.

1127{
1128 int ret;
1129 fr->oldhead = 0; /* Think about that. Used to be present only for skipping of junk, not resync-style wetwork. */
1130 ret = parse_new_id3(fr, newhead);
1131 if (ret < 0) return ret;
1132#ifndef NO_ID3V2
1133 else if(ret > 0){ debug("got ID3v2"); fr->metaflags |= MPG123_NEW_ID3|MPG123_ID3; }
1134 else debug("no useful ID3v2");
1135#endif
1136 return PARSE_AGAIN;
1137}
#define MPG123_NEW_ID3
Definition: mpg123.h:1465
#define MPG123_ID3
Definition: mpg123.h:1464
#define parse_new_id3
Definition: intsym.h:215

Referenced by skip_junk(), and wetwork().

◆ head_check()

static int head_check ( unsigned long  head)
static

Definition at line 91 of file parse.c.

92{
93 if
94 (
95 ((head & HDR_SYNC) != HDR_SYNC)
96 ||
97 /* layer: 01,10,11 is 1,2,3; 00 is reserved */
99 ||
100 /* 1111 means bad bitrate */
101 (HDR_BITRATE_VAL(head) == 0xf)
102 ||
103 /* sampling freq: 11 is reserved */
104 (HDR_SAMPLERATE_VAL(head) == 0x3)
105 /* 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 */
106 )
107 {
108 return FALSE;
109 }
110 /* if no check failed, the header is valid (hopefully)*/
111 else
112 {
113 return TRUE;
114 }
115}
#define FALSE
Definition: types.h:117
#define HDR_SYNC
Definition: mpeghead.h:32

Referenced by decode_header(), do_readahead(), read_frame(), skip_junk(), and wetwork().

◆ head_compatible()

static int head_compatible ( unsigned long  fred,
unsigned long  bret 
)
static

Definition at line 443 of file parse.c.

444{
445 return ( (fred & HDR_CMPMASK) == (bret & HDR_CMPMASK)
446 && header_mono(fred) == header_mono(bret) );
447}
#define HDR_CMPMASK
Definition: mpeghead.h:78
static int header_mono(unsigned long newhead)
Definition: parse.c:437

Referenced by do_readahead(), and read_frame().

◆ header_mono()

static int header_mono ( unsigned long  newhead)
static

Definition at line 437 of file parse.c.

438{
439 return HDR_CHANNEL_VAL(newhead) == MPG_MD_MONO ? TRUE : FALSE;
440}

Referenced by head_compatible().

◆ read_frame()

int read_frame ( mpg123_handle fr)

Definition at line 500 of file parse.c.

501{
502 /* TODO: rework this thing */
503 int freeformat_count = 0;
504 unsigned long newhead;
505 off_t framepos;
506 int ret;
507 /* stuff that needs resetting if complete frame reading fails */
508 int oldsize = fr->framesize;
509 int oldphase = fr->halfphase;
510
511 /* The counter for the search-first-header loop.
512 It is persistent outside the loop to prevent seemingly endless loops
513 when repeatedly headers are found that do not have valid followup headers. */
514 long headcount = 0;
515
516 fr->fsizeold=fr->framesize; /* for Layer3 */
517
518 if(halfspeed_do(fr) == 1) return 1;
519
520 /* From now on, old frame data is tainted by parsing attempts. */
521 fr->to_decode = fr->to_ignore = FALSE;
522
523 if( fr->p.flags & MPG123_NO_FRANKENSTEIN &&
524 ( (fr->track_frames > 0 && fr->num >= fr->track_frames-1)
525#ifdef GAPLESS
526 || (fr->gapless_frames > 0 && fr->num >= fr->gapless_frames-1)
527#endif
528 ) )
529 {
530 mdebug( "stopping parsing at %"OFF_P
531 " frames as indicated fixed track length"
532 , (off_p)fr->num+1 );
533 return 0;
534 }
535
536read_again:
537 /* In case we are looping to find a valid frame, discard any buffered data before the current position.
538 This is essential to prevent endless looping, always going back to the beginning when feeder buffer is exhausted. */
539 if(fr->rd->forget != NULL) fr->rd->forget(fr);
540
541 debug2("trying to get frame %"OFF_P" at %"OFF_P, (off_p)fr->num+1, (off_p)fr->rd->tell(fr));
542 if((ret = fr->rd->head_read(fr,&newhead)) <= 0){ debug1("need more? (%i)", ret); goto read_frame_bad;}
543
544init_resync:
545
546#ifdef SKIP_JUNK
547 if(!fr->firsthead && !head_check(newhead))
548 {
549 ret = skip_junk(fr, &newhead, &headcount);
551 }
552#endif
553
554 ret = head_check(newhead);
555 if(ret) ret = decode_header(fr, newhead, &freeformat_count);
556
557 JUMP_CONCLUSION(ret); /* That only continues for ret == PARSE_BAD or PARSE_GOOD. */
558 if(ret == PARSE_BAD)
559 { /* Header was not good. */
560 ret = wetwork(fr, &newhead); /* Messy stuff, handle junk, resync ... */
562 /* Normally, we jumped already. If for some reason everything's fine to continue, do continue. */
563 if(ret != PARSE_GOOD) goto read_frame_bad;
564 }
565
566 if(!fr->firsthead)
567 {
568 ret = fr->p.flags & MPG123_NO_READAHEAD
569 ? PARSE_GOOD
570 : do_readahead(fr, newhead);
571 /* readahead can fail mit NEED_MORE, in which case we must also make the just read header available again for next go */
572 if(ret < 0) fr->rd->back_bytes(fr, 4);
574 }
575
576 /* Now we should have our valid header and proceed to reading the frame. */
577
578 if(fr->p.flags & MPG123_NO_FRANKENSTEIN)
579 {
580 if(fr->firsthead && !head_compatible(fr->firsthead, newhead))
581 {
582 mdebug( "stopping before reading frame %"OFF_P
583 " as its header indicates Frankenstein coming for you", (off_p)fr->num );
584 return 0;
585 }
586 }
587
588 /* if filepos is invalid, so is framepos */
589 framepos = fr->rd->tell(fr) - 4;
590 /* flip/init buffer for Layer 3 */
591 {
592 unsigned char *newbuf = fr->bsspace[fr->bsnum]+512;
593 /* read main data into memory */
594 debug2("read frame body of %i at %"OFF_P, fr->framesize, framepos+4);
595 if((ret=fr->rd->read_frame_body(fr,newbuf,fr->framesize))<0)
596 {
597 /* if failed: flip back */
598 debug1("%s", ret == MPG123_NEED_MORE ? "need more" : "read error");
599 goto read_frame_bad;
600 }
601 fr->bsbufold = fr->bsbuf;
602 fr->bsbuf = newbuf;
603 }
604 fr->bsnum = (fr->bsnum + 1) & 1;
605
606 if(!fr->firsthead)
607 {
608 fr->firsthead = newhead; /* _now_ it's time to store it... the first real header */
609 /* This is the first header of our current stream segment.
610 It is only the actual first header of the whole stream when fr->num is still below zero!
611 Think of resyncs where firsthead has been reset for format flexibility. */
612 if(fr->num < 0)
613 {
614 fr->audio_start = framepos;
615 /* Only check for LAME tag at beginning of whole stream
616 ... when there indeed is one in between, it's the user's problem. */
617 if(fr->lay == 3 && check_lame_tag(fr) == 1)
618 { /* ...in practice, Xing/LAME tags are layer 3 only. */
619 if(fr->rd->forget != NULL) fr->rd->forget(fr);
620
621 fr->oldhead = 0;
622 goto read_again;
623 }
624 /* now adjust volume */
625 do_rva(fr);
626 }
627
628 debug2("fr->firsthead: %08lx, audio_start: %li", fr->firsthead, (long int)fr->audio_start);
629 }
630
631 set_pointer(fr, 0, 0);
632
633 /* Question: How bad does the floating point value get with repeated recomputation?
634 Also, considering that we can play the file or parts of many times. */
635 if(++fr->mean_frames != 0)
636 {
637 fr->mean_framesize = ((fr->mean_frames-1)*fr->mean_framesize+compute_bpf(fr)) / fr->mean_frames ;
638 }
639 ++fr->num; /* 0 for first frame! */
640 debug4("Frame %"OFF_P" %08lx %i, next filepos=%"OFF_P,
641 (off_p)fr->num, newhead, fr->framesize, (off_p)fr->rd->tell(fr));
642 if(!(fr->state_flags & FRAME_FRANKENSTEIN) && (
643 (fr->track_frames > 0 && fr->num >= fr->track_frames)
644#ifdef GAPLESS
645 || (fr->gapless_frames > 0 && fr->num >= fr->gapless_frames)
646#endif
647 ))
648 {
650 if(NOQUIET) fprintf(stderr, "\nWarning: Encountered more data after announced end of track (frame %"OFF_P"/%"OFF_P"). Frankenstein!\n", (off_p)fr->num,
651#ifdef GAPLESS
652 fr->gapless_frames > 0 ? (off_p)fr->gapless_frames :
653#endif
654 (off_p)fr->track_frames);
655 }
656
658
659 /* index the position */
660 fr->input_offset = framepos;
661#ifdef FRAME_INDEX
662 /* Keep track of true frame positions in our frame index.
663 but only do so when we are sure that the frame number is accurate... */
664 if((fr->state_flags & FRAME_ACCURATE) && FI_NEXT(fr->index, fr->num))
665 fi_add(&fr->index, framepos);
666#endif
667
668 if(fr->silent_resync > 0) --fr->silent_resync;
669
670 if(fr->rd->forget != NULL) fr->rd->forget(fr);
671
672 fr->to_decode = fr->to_ignore = TRUE;
673 if(fr->error_protection) fr->crc = getbits(fr, 16); /* skip crc */
674
675 /*
676 Let's check for header change after deciding that the new one is good
677 and actually having read a frame.
678
679 header_change > 1: decoder structure has to be updated
680 Preserve header_change value from previous runs if it is serious.
681 If we still have a big change pending, it should be dealt with outside,
682 fr->header_change set to zero afterwards.
683 */
684 if(fr->header_change < 2)
685 {
686 fr->header_change = 2; /* output format change is possible... */
687 if(fr->oldhead) /* check a following header for change */
688 {
689 if(fr->oldhead == newhead) fr->header_change = 0;
690 else
691 /* Headers that match in this test behave the same for the outside world.
692 namely: same decoding routines, same amount of decoded data. */
693 if(head_compatible(fr->oldhead, newhead))
694 fr->header_change = 1;
695 else
696 {
698 if(NOQUIET)
699 fprintf(stderr, "\nWarning: Big change (MPEG version, layer, rate). Frankenstein stream?\n");
700 }
701 }
702 else if(fr->firsthead && !head_compatible(fr->firsthead, newhead))
703 {
705 if(NOQUIET)
706 fprintf(stderr, "\nWarning: Big change from first (MPEG version, layer, rate). Frankenstein stream?\n");
707 }
708 }
709
710 fr->oldhead = newhead;
711
712 return 1;
713read_frame_bad:
714 /* Also if we searched for valid data in vein, we can forget skipped data.
715 Otherwise, the feeder would hold every dead old byte in memory until the first valid frame! */
716 if(fr->rd->forget != NULL) fr->rd->forget(fr);
717
718 fr->silent_resync = 0;
719 if(fr->err == MPG123_OK) fr->err = MPG123_ERR_READER;
720 fr->framesize = oldsize;
721 fr->halfphase = oldphase;
722 /* That return code might be inherited from some feeder action, or reader error. */
723 return ret;
724}
@ FRAME_ACCURATE
Definition: frame.h:92
@ FRAME_FRANKENSTEIN
Definition: frame.h:93
@ MPG123_ERR_READER
Definition: mpg123.h:401
@ MPG123_OK
Definition: mpg123.h:383
@ MPG123_NO_FRANKENSTEIN
Definition: mpg123.h:261
#define FI_NEXT(fi, framenum)
Definition: index.h:38
#define do_rva
Definition: intsym.h:190
#define fi_add
Definition: intsym.h:220
#define GAPLESS
Definition: config.h:45
#define mdebug(s,...)
Definition: debug.h:58
#define debug4(s, a, b, c, d)
Definition: debug.h:64
static int do_readahead(mpg123_handle *fr, unsigned long newhead)
Definition: parse.c:1071
#define JUMP_CONCLUSION(ret)
Definition: parse.c:488
static int decode_header(mpg123_handle *fr, unsigned long newhead, int *freeformat_count)
Definition: parse.c:775
static void halfspeed_prepare(mpg123_handle *fr)
Definition: parse.c:449
static int halfspeed_do(mpg123_handle *fr)
Definition: parse.c:460
static int check_lame_tag(mpg123_handle *fr)
Definition: parse.c:138
static int wetwork(mpg123_handle *fr, unsigned long *newheadp)
Definition: parse.c:1294
static int skip_junk(mpg123_handle *fr, unsigned long *newheadp, long *headcount)
Definition: parse.c:1220
struct frame_index index
Definition: frame.h:263
unsigned char * bsbufold
Definition: frame.h:255
double mean_framesize
Definition: frame.h:248
off_t input_offset
Definition: frame.h:217
off_t gapless_frames
Definition: frame.h:277

◆ set_pointer()

void set_pointer ( mpg123_handle fr,
int  part2,
long  backstep 
)

Definition at line 940 of file parse.c.

941{
942 fr->bitindex = 0;
943 if(fr->lay == 3)
944 {
945 if(part2)
946 {
947 fr->wordpointer = fr->bsbuf + fr->ssize - backstep;
948 if(backstep)
949 memcpy( fr->wordpointer, fr->bsbufold+fr->fsizeold-backstep
950 , backstep );
951 fr->bits_avail = (long)(fr->framesize - fr->ssize + backstep)*8;
952 }
953 else
954 {
955 fr->wordpointer = fr->bsbuf;
956 fr->bits_avail = fr->ssize*8;
957 }
958 }
959 else
960 {
961 fr->wordpointer = fr->bsbuf;
962 fr->bits_avail = fr->framesize*8;
963 }
964}
unsigned char * wordpointer
Definition: frame.h:229

◆ skip_junk()

static int skip_junk ( mpg123_handle fr,
unsigned long newheadp,
long headcount 
)
static

Definition at line 1220 of file parse.c.

1221{
1222 int ret;
1223 int freeformat_count = 0;
1224 long limit = 65536;
1225 unsigned long newhead = *newheadp;
1226 unsigned int forgetcount = 0;
1227 /* check for id3v2; first three bytes (of 4) are "ID3" */
1228 if((newhead & (unsigned long) 0xffffff00) == (unsigned long) 0x49443300)
1229 {
1230 return handle_id3v2(fr, newhead);
1231 }
1232 else if(VERBOSE2 && fr->silent_resync == 0) fprintf(stderr,"Note: Junk at the beginning (0x%08lx)\n",newhead);
1233
1234 /* I even saw RIFF headers at the beginning of MPEG streams ;( */
1235 if(newhead == ('R'<<24)+('I'<<16)+('F'<<8)+'F')
1236 {
1237 if(VERBOSE2 && fr->silent_resync == 0) fprintf(stderr, "Note: Looks like a RIFF header.\n");
1238
1239 if((ret=fr->rd->head_read(fr,&newhead))<=0) return ret;
1240
1241 while(newhead != ('d'<<24)+('a'<<16)+('t'<<8)+'a')
1242 {
1243 if(++forgetcount > FORGET_INTERVAL) forgetcount = 0;
1244 if((ret=forget_head_shift(fr,&newhead,!forgetcount))<=0) return ret;
1245 }
1246 if((ret=fr->rd->head_read(fr,&newhead))<=0) return ret;
1247
1248 if(VERBOSE2 && fr->silent_resync == 0) fprintf(stderr,"Note: Skipped RIFF header!\n");
1249
1250 fr->oldhead = 0;
1251 *newheadp = newhead;
1252 return PARSE_AGAIN;
1253 }
1254
1255 /*
1256 Unhandled junk... just continue search for a header, stepping in single bytes through next 64K.
1257 This is rather identical to the resync loop.
1258 */
1259 debug("searching for header...");
1260 *newheadp = 0; /* Invalidate the external value. */
1261 ret = 0; /* We will check the value after the loop. */
1262
1263 /* We prepare for at least the 64K bytes as usual, unless
1264 user explicitly wanted more (even infinity). Never less. */
1265 if(fr->p.resync_limit < 0 || fr->p.resync_limit > limit)
1266 limit = fr->p.resync_limit;
1267
1268 do
1269 {
1270 ++(*headcount);
1271 if(limit >= 0 && *headcount >= limit) break;
1272
1273 if(++forgetcount > FORGET_INTERVAL) forgetcount = 0;
1274 if((ret=forget_head_shift(fr, &newhead, !forgetcount))<=0) return ret;
1275
1276 if(head_check(newhead) && (ret=decode_header(fr, newhead, &freeformat_count))) break;
1277 } while(1);
1278 if(ret<0) return ret;
1279
1280 if(limit >= 0 && *headcount >= limit)
1281 {
1282 if(NOQUIET) error1("Giving up searching valid MPEG header after %li bytes of junk.", *headcount);
1283 fr->err = MPG123_RESYNC_FAIL;
1284 return PARSE_ERR;
1285 }
1286 else debug1("hopefully found one at %"OFF_P, (off_p)fr->rd->tell(fr));
1287
1288 /* If the new header ist good, it is already decoded. */
1289 *newheadp = newhead;
1290 return PARSE_GOOD;
1291}
GLint limit
Definition: glext.h:10326
@ MPG123_RESYNC_FAIL
Definition: mpg123.h:411
static int forget_head_shift(mpg123_handle *fr, unsigned long *newheadp, int forget)
Definition: parse.c:1199
static int handle_id3v2(mpg123_handle *fr, unsigned long newhead)
Definition: parse.c:1126
#define FORGET_INTERVAL
Definition: parse.c:1198

Referenced by read_frame().

◆ wetwork()

static int wetwork ( mpg123_handle fr,
unsigned long newheadp 
)
static

Definition at line 1294 of file parse.c.

1295{
1296 int ret = PARSE_ERR;
1297 unsigned long newhead = *newheadp;
1298 *newheadp = 0;
1299
1300 /* Classic ID3 tags. Read, then start parsing again. */
1301 if((newhead & 0xffffff00) == ('T'<<24)+('A'<<16)+('G'<<8))
1302 {
1303 fr->id3buf[0] = (unsigned char) ((newhead >> 24) & 0xff);
1304 fr->id3buf[1] = (unsigned char) ((newhead >> 16) & 0xff);
1305 fr->id3buf[2] = (unsigned char) ((newhead >> 8) & 0xff);
1306 fr->id3buf[3] = (unsigned char) ( newhead & 0xff);
1307
1308 if((ret=fr->rd->fullread(fr,fr->id3buf+4,124)) < 0) return ret;
1309
1311 fr->rdat.flags |= READER_ID3TAG; /* that marks id3v1 */
1312 if(VERBOSE3) fprintf(stderr,"Note: Skipped ID3v1 tag.\n");
1313
1314 return PARSE_AGAIN;
1315 }
1316 /* This is similar to initial junk skipping code... */
1317 /* Check for id3v2; first three bytes (of 4) are "ID3" */
1318 if((newhead & (unsigned long) 0xffffff00) == (unsigned long) 0x49443300)
1319 {
1320 return handle_id3v2(fr, newhead);
1321 }
1322 /* Check for an apetag header */
1323 if(newhead == ('A'<<24)+('P'<<16)+('E'<<8)+'T')
1324 {
1325 return handle_apetag(fr, newhead);
1326 }
1327 else if(NOQUIET && fr->silent_resync == 0)
1328 {
1329 fprintf(stderr,"Note: Illegal Audio-MPEG-Header 0x%08lx at offset %"OFF_P".\n",
1330 newhead, (off_p)fr->rd->tell(fr)-4);
1331 }
1332
1333 /* Now we got something bad at hand, try to recover. */
1334
1335 if(NOQUIET && (newhead & 0xffffff00) == ('b'<<24)+('m'<<16)+('p'<<8)) fprintf(stderr,"Note: Could be a BMP album art.\n");
1336
1337 if( !(fr->p.flags & MPG123_NO_RESYNC) )
1338 {
1339 long try = 0;
1340 long limit = fr->p.resync_limit;
1341 unsigned int forgetcount = 0;
1342
1343 /* If a resync is needed the bitreservoir of previous frames is no longer valid */
1344 fr->bitreservoir = 0;
1345
1346 if(NOQUIET && fr->silent_resync == 0) fprintf(stderr, "Note: Trying to resync...\n");
1347
1348 do /* ... shift the header with additional single bytes until be found something that could be a header. */
1349 {
1350 ++try;
1351 if(limit >= 0 && try >= limit) break;
1352
1353 if(++forgetcount > FORGET_INTERVAL) forgetcount = 0;
1354 if((ret=forget_head_shift(fr,&newhead,!forgetcount)) <= 0)
1355 {
1356 *newheadp = newhead;
1357 if(NOQUIET) fprintf (stderr, "Note: Hit end of (available) data during resync.\n");
1358
1359 return ret ? ret : PARSE_END;
1360 }
1361 if(VERBOSE3) debug3("resync try %li at %"OFF_P", got newhead 0x%08lx", try, (off_p)fr->rd->tell(fr), newhead);
1362 } while(!head_check(newhead));
1363
1364 *newheadp = newhead;
1365 if(NOQUIET && fr->silent_resync == 0) fprintf (stderr, "Note: Skipped %li bytes in input.\n", try);
1366
1367 /* Now we either got something that could be a header, or we gave up. */
1368 if(limit >= 0 && try >= limit)
1369 {
1370 if(NOQUIET)
1371 error1("Giving up resync after %li bytes - your stream is not nice... (maybe increasing resync limit could help).", try);
1372
1373 fr->err = MPG123_RESYNC_FAIL;
1374 return PARSE_ERR;
1375 }
1376 else
1377 {
1378 debug1("Found possibly valid header 0x%lx... unsetting oldhead to reinit stream.", newhead);
1379 fr->oldhead = 0;
1380 return PARSE_RESYNC;
1381 }
1382 }
1383 else
1384 {
1385 if(NOQUIET) error("not attempting to resync...");
1386
1387 fr->err = MPG123_OUT_OF_SYNC;
1388 return PARSE_ERR;
1389 }
1390 /* Control never goes here... we return before that. */
1391}
unsigned char
Definition: typeof.h:29
@ MPG123_OUT_OF_SYNC
Definition: mpg123.h:410
@ MPG123_NO_RESYNC
Definition: mpg123.h:221
#define READER_ID3TAG
Definition: reader.h:114
static int handle_apetag(mpg123_handle *fr, unsigned long newhead)
Definition: parse.c:1139
unsigned int bitreservoir
Definition: frame.h:252
unsigned char id3buf[128]
Definition: frame.h:296

Referenced by read_frame().

Variable Documentation

◆ freqs

const long freqs[9] = { 44100, 48000, 32000, 22050, 24000, 16000 , 11025 , 12000 , 8000 }
static

Definition at line 70 of file parse.c.

Referenced by decode_header(), frame_freq(), and mpg123_tpf().

◆ tabsel_123

const int tabsel_123[2][3][16]
static
Initial value:
=
{
{
{0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,},
{0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,},
{0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,}
},
{
{0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,},
{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,},
{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,}
}
}

Definition at line 56 of file parse.c.

Referenced by decode_header(), and frame_bitrate().