ReactOS  0.4.14-dev-828-g8dc90a4
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, 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 35 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 1122 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; } \
}
int ret
#define debug1(s, a)
Definition: debug.h:52

Definition at line 480 of file parse.c.

◆ TRACK_MAX_FRAMES

#define TRACK_MAX_FRAMES   ULONG_MAX/4/1152

Definition at line 29 of file parse.c.

◆ ULONG_MAX

#define ULONG_MAX   ((unsigned long)-1)

Definition at line 27 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 38 of file parse.c.

39 {
42  ,PARSE_END = 10 /* No more audio data to find. */
43  ,PARSE_GOOD = 1 /* Everything's fine. */
44  ,PARSE_BAD = 0 /* Not fine (invalid data). */
45  ,PARSE_RESYNC = 2 /* Header not good, go into resync. */
46  ,PARSE_AGAIN = 3 /* Really start over, throw away and read a new header, again. */
47 };

Function Documentation

◆ bit_read_long()

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

Definition at line 112 of file parse.c.

113 {
114  unsigned long val = /* 32 bit value */
115  (((unsigned long) buf[*offset]) << 24)
116  | (((unsigned long) buf[*offset+1]) << 16)
117  | (((unsigned long) buf[*offset+2]) << 8)
118  | ((unsigned long) buf[*offset+3]);
119  *offset += 4;
120  return val;
121 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLintptr offset
Definition: glext.h:5920
GLuint GLfloat * val
Definition: glext.h:7180
#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 123 of file parse.c.

124 {
125  unsigned short val = /* 16 bit value */
126  (((unsigned short) buf[*offset] ) << 8)
127  | ((unsigned short) buf[*offset+1]);
128  *offset += 2;
129  return val;
130 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLintptr offset
Definition: glext.h:5920
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
GLuint GLfloat * val
Definition: glext.h:7180

◆ check_lame_tag()

static int check_lame_tag ( mpg123_handle fr)
static

Definition at line 132 of file parse.c.

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

Referenced by read_frame().

◆ compute_bpf()

double compute_bpf ( mpg123_handle fr)

Definition at line 892 of file parse.c.

893 {
894  return (fr->framesize > 0) ? fr->framesize + 4.0 : 1.0;
895 }

Referenced by get_songlen(), mpg123_position(), and read_frame().

◆ decode_header()

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

Definition at line 740 of file parse.c.

741 {
742 #ifdef DEBUG /* Do not waste cycles checking the header twice all the time. */
743  if(!head_check(newhead))
744  {
745  error1("trying to decode obviously invalid header 0x%08lx", newhead);
746  }
747 #endif
748  /* For some reason, the layer and sampling freq settings used to be wrapped
749  in a weird conditional including MPG123_NO_RESYNC. What was I thinking?
750  This information has to be consistent. */
751  fr->lay = 4 - HDR_LAYER_VAL(newhead);
752 
753  if(HDR_VERSION_VAL(newhead) & 0x2)
754  {
755  fr->lsf = (HDR_VERSION_VAL(newhead) & 0x1) ? 0 : 1;
756  fr->mpeg25 = 0;
757  fr->sampling_frequency = HDR_SAMPLERATE_VAL(newhead) + (fr->lsf*3);
758  }
759  else
760  {
761  fr->lsf = 1;
762  fr->mpeg25 = 1;
763  fr->sampling_frequency = 6 + HDR_SAMPLERATE_VAL(newhead);
764  }
765 
766  #ifdef DEBUG
767  /* seen a file where this varies (old lame tag without crc, track with crc) */
768  if((HDR_CRC_VAL(newhead)^0x1) != fr->error_protection) debug("changed crc bit!");
769  #endif
770  fr->error_protection = HDR_CRC_VAL(newhead)^0x1;
771  fr->bitrate_index = HDR_BITRATE_VAL(newhead);
772  fr->padding = HDR_PADDING_VAL(newhead);
773  fr->extension = HDR_PRIVATE_VAL(newhead);
774  fr->mode = HDR_CHANNEL_VAL(newhead);
775  fr->mode_ext = HDR_CHANEX_VAL(newhead);
776  fr->copyright = HDR_COPYRIGHT_VAL(newhead);
777  fr->original = HDR_ORIGINAL_VAL(newhead);
778  fr->emphasis = HDR_EMPHASIS_VAL(newhead);
779  fr->freeformat = !(newhead & HDR_BITRATE);
780 
781  fr->stereo = (fr->mode == MPG_MD_MONO) ? 1 : 2;
782 
783  /* we can't use tabsel_123 for freeformat, so trying to guess framesize... */
784  if(fr->freeformat)
785  {
786  /* when we first encounter the frame with freeformat, guess framesize */
787  if(fr->freeformat_framesize < 0)
788  {
789  int ret;
790  *freeformat_count += 1;
791  if(*freeformat_count > 5)
792  {
793  if(VERBOSE3) error("You fooled me too often. Refusing to guess free format frame size _again_.");
794  return PARSE_BAD;
795  }
796  ret = guess_freeformat_framesize(fr, newhead);
797  if(ret == PARSE_GOOD)
798  {
799  fr->freeformat_framesize = fr->framesize - fr->padding;
800  if(VERBOSE2)
801  fprintf(stderr, "Note: free format frame size %li\n", fr->freeformat_framesize);
802  }
803  else
804  {
805  if(ret == MPG123_NEED_MORE)
806  debug("Need more data to guess free format frame size.");
807  else if(VERBOSE3)
808  error("Encountered free format header, but failed to guess frame size.");
809 
810  return ret;
811  }
812  }
813  /* freeformat should be CBR, so the same framesize can be used at the 2nd reading or later */
814  else
815  {
816  fr->framesize = fr->freeformat_framesize + fr->padding;
817  }
818  }
819 
820  switch(fr->lay)
821  {
822 #ifndef NO_LAYER1
823  case 1:
824  fr->spf = 384;
825  fr->do_layer = do_layer1;
826  if(!fr->freeformat)
827  {
828  fr->framesize = (long) tabsel_123[fr->lsf][0][fr->bitrate_index] * 12000;
829  fr->framesize /= freqs[fr->sampling_frequency];
830  fr->framesize = ((fr->framesize+fr->padding)<<2)-4;
831  }
832  break;
833 #endif
834 #ifndef NO_LAYER2
835  case 2:
836  fr->spf = 1152;
837  fr->do_layer = do_layer2;
838  if(!fr->freeformat)
839  {
840  debug2("bitrate index: %i (%i)", fr->bitrate_index, tabsel_123[fr->lsf][1][fr->bitrate_index] );
841  fr->framesize = (long) tabsel_123[fr->lsf][1][fr->bitrate_index] * 144000;
842  fr->framesize /= freqs[fr->sampling_frequency];
843  fr->framesize += fr->padding - 4;
844  }
845  break;
846 #endif
847 #ifndef NO_LAYER3
848  case 3:
849  fr->spf = fr->lsf ? 576 : 1152; /* MPEG 2.5 implies LSF.*/
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  if(!fr->freeformat)
860  {
861  fr->framesize = (long) tabsel_123[fr->lsf][2][fr->bitrate_index] * 144000;
862  fr->framesize /= freqs[fr->sampling_frequency]<<(fr->lsf);
863  fr->framesize = fr->framesize + fr->padding - 4;
864  }
865  break;
866 #endif
867  default:
868  if(NOQUIET) error1("Layer type %i not supported in this build!", fr->lay);
869 
870  return PARSE_BAD;
871  }
872  if (fr->framesize > MAXFRAMESIZE)
873  {
874  if(NOQUIET) error1("Frame size too big: %d", fr->framesize+4-fr->padding);
875 
876  return PARSE_BAD;
877  }
878  return PARSE_GOOD;
879 }
#define HDR_EMPHASIS_VAL(h)
Definition: mpeghead.h:69
#define error(str)
Definition: mkdosfs.c:1605
#define do_layer3
Definition: intsym.h:161
long freeformat_framesize
Definition: frame.h:223
#define error1(s, a)
Definition: debug.h:109
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
#define HDR_PADDING_VAL(h)
Definition: mpeghead.h:51
#define do_layer2
Definition: intsym.h:162
#define debug2(s, a, b)
Definition: debug.h:53
#define HDR_ORIGINAL_VAL(h)
Definition: mpeghead.h:66
#define HDR_VERSION_VAL(h)
Definition: mpeghead.h:36
#define MPG_MD_MONO
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define HDR_SAMPLERATE_VAL(h)
Definition: mpeghead.h:48
int sampling_frequency
Definition: frame.h:204
#define VERBOSE2
#define HDR_LAYER_VAL(h)
Definition: mpeghead.h:39
#define VERBOSE3
#define HDR_CHANEX_VAL(h)
Definition: mpeghead.h:60
int(* do_layer)(mpg123_handle *)
Definition: frame.h:201
#define MAXFRAMESIZE
Definition: frame.h:30
#define NOQUIET
int ret
static int guess_freeformat_framesize(mpg123_handle *fr, unsigned long oldhead)
Definition: parse.c:699
static const int tabsel_123[2][3][16]
Definition: parse.c:50
#define long
Definition: qsort.c:33
#define do_layer1
Definition: intsym.h:163
#define HDR_BITRATE
Definition: mpeghead.h:44
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3706
#define HDR_CHANNEL_VAL(h)
Definition: mpeghead.h:57
static const long freqs[9]
Definition: parse.c:64
FILE * stderr
#define HDR_BITRATE_VAL(h)
Definition: mpeghead.h:45
#define debug(msg)
Definition: key_call.c:71
static int head_check(unsigned long head)
Definition: parse.c:85
#define HDR_CRC_VAL(h)
Definition: mpeghead.h:42
#define HDR_PRIVATE_VAL(h)
Definition: mpeghead.h:54
#define HDR_COPYRIGHT_VAL(h)
Definition: mpeghead.h:63

Referenced by read_frame(), and skip_junk().

◆ do_readahead()

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

Definition at line 995 of file parse.c.

996 {
997  unsigned long nexthead = 0;
998  int hd = 0;
999  off_t start, oret;
1000  int ret;
1001 
1002  if( ! (!fr->firsthead && fr->rdat.flags & (READER_SEEKABLE|READER_BUFFERED)) )
1003  return PARSE_GOOD;
1004 
1005  start = fr->rd->tell(fr);
1006 
1007  debug2("doing ahead check with BPF %d at %"OFF_P, fr->framesize+4, (off_p)start);
1008  /* step framesize bytes forward and read next possible header*/
1009  if((oret=fr->rd->skip_bytes(fr, fr->framesize))<0)
1010  {
1011  if(oret==READER_ERROR && NOQUIET) error("cannot seek!");
1012 
1013  return oret == MPG123_NEED_MORE ? PARSE_MORE : PARSE_ERR;
1014  }
1015 
1016  /* Read header, seek back. */
1017  hd = fr->rd->head_read(fr,&nexthead);
1018  if( fr->rd->back_bytes(fr, fr->rd->tell(fr)-start) < 0 )
1019  {
1020  if(NOQUIET) error("Cannot seek back!");
1021 
1022  return PARSE_ERR;
1023  }
1024  if(hd == MPG123_NEED_MORE) return PARSE_MORE;
1025 
1026  debug1("After fetching next header, at %"OFF_P, (off_p)fr->rd->tell(fr));
1027  if(!hd)
1028  {
1029  if(NOQUIET) warning("Cannot read next header, a one-frame stream? Duh...");
1030  return PARSE_END;
1031  }
1032 
1033  debug2("does next header 0x%08lx match first 0x%08lx?", nexthead, newhead);
1034  if(!head_check(nexthead) || !head_compatible(newhead, nexthead))
1035  {
1036  debug("No, the header was not valid, start from beginning...");
1037  fr->oldhead = 0; /* start over */
1038  /* try next byte for valid header */
1039  if((ret=fr->rd->back_bytes(fr, 3))<0)
1040  {
1041  if(NOQUIET) error("Cannot seek 3 bytes back!");
1042 
1043  return PARSE_ERR;
1044  }
1045  return PARSE_AGAIN;
1046  }
1047  else return PARSE_GOOD;
1048 }
#define READER_SEEKABLE
Definition: reader.h:115
#define error(str)
Definition: mkdosfs.c:1605
__kernel_off_t off_t
Definition: linux.h:201
#define debug2(s, a, b)
Definition: debug.h:53
struct reader_data rdat
Definition: frame.h:286
#define READER_ERROR
Definition: reader.h:134
static int head_compatible(unsigned long fred, unsigned long bret)
Definition: parse.c:434
#define NOQUIET
int ret
#define READER_BUFFERED
Definition: reader.h:116
unsigned long firsthead
Definition: frame.h:258
GLuint start
Definition: gl.h:1545
long off_p
Definition: compat.h:130
#define debug(msg)
Definition: key_call.c:71
struct reader * rd
Definition: frame.h:285
#define debug1(s, a)
Definition: debug.h:52
static int head_check(unsigned long head)
Definition: parse.c:85
unsigned long oldhead
Definition: frame.h:256
#define OFF_P
Definition: compat.h:129
#define warning(s)
Definition: debug.h:71

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 1123 of file parse.c.

1124 {
1125  int ret;
1126  if((ret=fr->rd->head_shift(fr,newheadp))<=0) return ret;
1127  /* Try to forget buffered data as early as possible to speed up parsing where
1128  new data needs to be added for resync (and things would be re-parsed again
1129  and again because of the start from beginning after hitting end). */
1130  if(forget && fr->rd->forget != NULL)
1131  {
1132  /* Ensure that the last 4 bytes stay in buffers for reading the header
1133  anew. */
1134  if(!fr->rd->back_bytes(fr, 4))
1135  {
1136  fr->rd->forget(fr);
1137  fr->rd->back_bytes(fr, -4);
1138  }
1139  }
1140  return ret; /* No surprise here, error already triggered early return. */
1141 }
smooth NULL
Definition: ftsmooth.c:416
int ret
struct reader * rd
Definition: frame.h:285

Referenced by skip_junk(), and wetwork().

◆ frame_bitrate()

int frame_bitrate ( mpg123_handle fr)

Definition at line 74 of file parse.c.

75 {
76  return tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index];
77 }
static const int tabsel_123[2][3][16]
Definition: parse.c:50

◆ frame_freq()

long frame_freq ( mpg123_handle fr)

Definition at line 79 of file parse.c.

80 {
81  return freqs[fr->sampling_frequency];
82 }
int sampling_frequency
Definition: frame.h:204
static const long freqs[9]
Definition: parse.c:64

◆ get_songlen()

int get_songlen ( mpg123_handle fr,
int  no 
)

Definition at line 977 of file parse.c.

978 {
979  double tpf;
980 
981  if(!fr)
982  return 0;
983 
984  if(no < 0) {
985  if(!fr->rd || fr->rdat.filelen < 0)
986  return 0;
987  no = (int) ((double) fr->rdat.filelen / compute_bpf(fr));
988  }
989 
990  tpf = mpg123_tpf(fr);
991  return (int) (no*tpf);
992 }
double compute_bpf(mpg123_handle *fr)
Definition: parse.c:892
struct reader_data rdat
Definition: frame.h:286
double attribute_align_arg mpg123_tpf(mpg123_handle *fr)
Definition: parse.c:904
static WCHAR no[MAX_STRING_RESOURCE_LEN]
Definition: object.c:2340
struct reader * rd
Definition: frame.h:285
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

◆ guess_freeformat_framesize()

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

Definition at line 699 of file parse.c.

700 {
701  long i;
702  int ret;
703  unsigned long head;
704  if(!(fr->rdat.flags & (READER_SEEKABLE|READER_BUFFERED)))
705  {
706  if(NOQUIET) error("Cannot look for freeformat frame size with non-seekable and non-buffered stream!");
707 
708  return PARSE_BAD;
709  }
710  if((ret=fr->rd->head_read(fr,&head))<=0)
711  return ret;
712 
713  /* We are already 4 bytes into it */
714  for(i=4;i<MAXFRAMESIZE+4;i++)
715  {
716  if((ret=fr->rd->head_shift(fr,&head))<=0) return ret;
717 
718  /* No head_check needed, the mask contains all relevant bits. */
719  if((head & HDR_SAMEMASK) == (oldhead & HDR_SAMEMASK))
720  {
721  fr->rd->back_bytes(fr,i+1);
722  fr->framesize = i-3;
723  return PARSE_GOOD; /* Success! */
724  }
725  }
726  fr->rd->back_bytes(fr,i);
727  return PARSE_BAD;
728 }
#define READER_SEEKABLE
Definition: reader.h:115
#define error(str)
Definition: mkdosfs.c:1605
struct outqueuenode * head
Definition: adnsresfilter.c:66
struct reader_data rdat
Definition: frame.h:286
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
#define MAXFRAMESIZE
Definition: frame.h:30
#define NOQUIET
int ret
#define READER_BUFFERED
Definition: reader.h:116
#define HDR_SAMEMASK
Definition: mpeghead.h:81
struct reader * rd
Definition: frame.h:285

Referenced by decode_header().

◆ halfspeed_do()

static int halfspeed_do ( mpg123_handle fr)
static

Definition at line 451 of file parse.c.

452 {
453  /* Speed-down hack: Play it again, Sam (the frame, I mean). */
454  if (fr->p.halfspeed)
455  {
456  if(fr->halfphase) /* repeat last frame */
457  {
458  debug("repeat!");
459  fr->to_decode = fr->to_ignore = TRUE;
460  --fr->halfphase;
461  fr->bitindex = 0;
462  fr->wordpointer = (unsigned char *) fr->bsbuf;
463  if(fr->lay == 3) memcpy (fr->bsbuf, fr->ssave, fr->ssize);
464  if(fr->error_protection) fr->crc = getbits(fr, 16); /* skip crc */
465  return 1;
466  }
467  else
468  {
469  fr->halfphase = fr->p.halfspeed - 1;
470  }
471  }
472  return 0;
473 }
#define TRUE
Definition: types.h:120
struct mpg123_pars_struct p
Definition: frame.h:287
unsigned char * wordpointer
Definition: frame.h:227
unsigned int crc
Definition: frame.h:284
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define debug(msg)
Definition: key_call.c:71
unsigned char ssave[34]
Definition: frame.h:129
#define getbits
Definition: intsym.h:195
unsigned char * bsbuf
Definition: frame.h:252

Referenced by read_frame().

◆ halfspeed_prepare()

static void halfspeed_prepare ( mpg123_handle fr)
static

Definition at line 440 of file parse.c.

441 {
442  /* save for repetition */
443  if(fr->p.halfspeed && fr->lay == 3)
444  {
445  debug("halfspeed - reusing old bsbuf ");
446  memcpy (fr->ssave, fr->bsbuf, fr->ssize);
447  }
448 }
struct mpg123_pars_struct p
Definition: frame.h:287
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define debug(msg)
Definition: key_call.c:71
unsigned char ssave[34]
Definition: frame.h:129
unsigned char * bsbuf
Definition: frame.h:252

Referenced by read_frame().

◆ handle_apetag()

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

Definition at line 1063 of file parse.c.

1064 {
1065  unsigned char apebuf[28];
1066  unsigned long val;
1067  int i, ret;
1068  /* How many bytes to backpedal to get back to just after the first byte of */
1069  /* the supposed header. */
1070  int back_bytes = 3;
1071  fr->oldhead = 0;
1072 
1073  debug1("trying to read remaining APE header at %"OFF_P, (off_p)fr->rd->tell(fr));
1074  /* Apetag headers are 32 bytes, newhead contains 4, read the rest */
1075  if((ret=fr->rd->fullread(fr,apebuf,28)) < 0)
1076  return ret;
1077  back_bytes += ret;
1078  if(ret < 28)
1079  goto apetag_bad;
1080 
1081  debug1("trying to parse APE header at %"OFF_P, (off_p)fr->rd->tell(fr));
1082  /* Apetags start with "APETAGEX", "APET" is already tested. */
1083  if(strncmp((char *)apebuf,"AGEX",4) != 0)
1084  goto apetag_bad;
1085 
1086  /* Version must be 2.000 / 2000 */
1087  val = ((unsigned long)apebuf[7]<<24)
1088  | ((unsigned long)apebuf[6]<<16)
1089  | ((unsigned long)apebuf[5]<<8)
1090  | apebuf[4];
1091  if(val != 2000)
1092  goto apetag_bad;
1093 
1094  /* Last 8 bytes must be 0 */
1095  for(i=20; i<28; i++)
1096  if(apebuf[i])
1097  goto apetag_bad;
1098 
1099  /* Looks good, skip the rest. */
1100  val = ((unsigned long)apebuf[11]<<24)
1101  | ((unsigned long)apebuf[10]<<16)
1102  | ((unsigned long)apebuf[9]<<8)
1103  | apebuf[8];
1104  debug2( "skipping %lu bytes of APE data at %"OFF_P
1105  , val, (off_p)fr->rd->tell(fr) );
1106  /* If encountering EOF here, things are just at an end. */
1107  if((ret=fr->rd->skip_bytes(fr,val)) < 0)
1108  return ret;
1109 
1110  return PARSE_AGAIN;
1111 
1112 apetag_bad:
1113  debug("no proper APE tag found, seeking back");
1114  if(fr->rd->back_bytes(fr,back_bytes) < 0 && NOQUIET)
1115  error1("Cannot seek %d bytes back!", back_bytes);
1116 
1117  return PARSE_AGAIN; /* Give the resync code a chance to fix things */
1118 }
#define error1(s, a)
Definition: debug.h:109
#define debug2(s, a, b)
Definition: debug.h:53
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
GLuint GLfloat * val
Definition: glext.h:7180
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
#define NOQUIET
int ret
#define long
Definition: qsort.c:33
long off_p
Definition: compat.h:130
#define debug(msg)
Definition: key_call.c:71
struct reader * rd
Definition: frame.h:285
#define debug1(s, a)
Definition: debug.h:52
unsigned long oldhead
Definition: frame.h:256
#define OFF_P
Definition: compat.h:129

Referenced by wetwork().

◆ handle_id3v2()

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

Definition at line 1050 of file parse.c.

1051 {
1052  int ret;
1053  fr->oldhead = 0; /* Think about that. Used to be present only for skipping of junk, not resync-style wetwork. */
1054  ret = parse_new_id3(fr, newhead);
1055  if (ret < 0) return ret;
1056 #ifndef NO_ID3V2
1057  else if(ret > 0){ debug("got ID3v2"); fr->metaflags |= MPG123_NEW_ID3|MPG123_ID3; }
1058  else debug("no useful ID3v2");
1059 #endif
1060  return PARSE_AGAIN;
1061 }
#define MPG123_NEW_ID3
Definition: mpg123.h:1241
#define MPG123_ID3
Definition: mpg123.h:1240
int ret
#define parse_new_id3
Definition: intsym.h:205
#define debug(msg)
Definition: key_call.c:71
unsigned long oldhead
Definition: frame.h:256

Referenced by skip_junk(), and wetwork().

◆ head_check()

static int head_check ( unsigned long  head)
static

Definition at line 85 of file parse.c.

86 {
87  if
88  (
89  ((head & HDR_SYNC) != HDR_SYNC)
90  ||
91  /* layer: 01,10,11 is 1,2,3; 00 is reserved */
92  (!(HDR_LAYER_VAL(head)))
93  ||
94  /* 1111 means bad bitrate */
95  (HDR_BITRATE_VAL(head) == 0xf)
96  ||
97  /* sampling freq: 11 is reserved */
98  (HDR_SAMPLERATE_VAL(head) == 0x3)
99  /* 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 */
100  )
101  {
102  return FALSE;
103  }
104  /* if no check failed, the header is valid (hopefully)*/
105  else
106  {
107  return TRUE;
108  }
109 }
#define TRUE
Definition: types.h:120
struct outqueuenode * head
Definition: adnsresfilter.c:66
#define HDR_SAMPLERATE_VAL(h)
Definition: mpeghead.h:48
#define HDR_LAYER_VAL(h)
Definition: mpeghead.h:39
#define HDR_SYNC
Definition: mpeghead.h:32
#define HDR_BITRATE_VAL(h)
Definition: mpeghead.h:45

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 434 of file parse.c.

435 {
436  return ( (fred & HDR_CMPMASK) == (bret & HDR_CMPMASK)
437  && header_mono(fred) == header_mono(bret) );
438 }
static int header_mono(unsigned long newhead)
Definition: parse.c:428
#define HDR_CMPMASK
Definition: mpeghead.h:78

Referenced by do_readahead(), and read_frame().

◆ header_mono()

static int header_mono ( unsigned long  newhead)
static

Definition at line 428 of file parse.c.

429 {
430  return HDR_CHANNEL_VAL(newhead) == MPG_MD_MONO ? TRUE : FALSE;
431 }
#define TRUE
Definition: types.h:120
#define MPG_MD_MONO
#define HDR_CHANNEL_VAL(h)
Definition: mpeghead.h:57

Referenced by head_compatible().

◆ read_frame()

int read_frame ( mpg123_handle fr)

Definition at line 492 of file parse.c.

493 {
494  /* TODO: rework this thing */
495  int freeformat_count = 0;
496  unsigned long newhead;
497  off_t framepos;
498  int ret;
499  /* stuff that needs resetting if complete frame reading fails */
500  int oldsize = fr->framesize;
501  int oldphase = fr->halfphase;
502 
503  /* The counter for the search-first-header loop.
504  It is persistent outside the loop to prevent seemingly endless loops
505  when repeatedly headers are found that do not have valid followup headers. */
506  long headcount = 0;
507 
508  fr->fsizeold=fr->framesize; /* for Layer3 */
509 
510  if(halfspeed_do(fr) == 1) return 1;
511 
512  /* From now on, old frame data is tainted by parsing attempts. */
513  fr->to_decode = fr->to_ignore = FALSE;
514 read_again:
515  /* In case we are looping to find a valid frame, discard any buffered data before the current position.
516  This is essential to prevent endless looping, always going back to the beginning when feeder buffer is exhausted. */
517  if(fr->rd->forget != NULL) fr->rd->forget(fr);
518 
519  debug2("trying to get frame %"OFF_P" at %"OFF_P, (off_p)fr->num+1, (off_p)fr->rd->tell(fr));
520  if((ret = fr->rd->head_read(fr,&newhead)) <= 0){ debug1("need more? (%i)", ret); goto read_frame_bad;}
521 
522 init_resync:
523 
524 #ifdef SKIP_JUNK
525  if(!fr->firsthead && !head_check(newhead))
526  {
527  ret = skip_junk(fr, &newhead, &headcount);
529  }
530 #endif
531 
532  ret = head_check(newhead);
533  if(ret) ret = decode_header(fr, newhead, &freeformat_count);
534 
535  JUMP_CONCLUSION(ret); /* That only continues for ret == PARSE_BAD or PARSE_GOOD. */
536  if(ret == PARSE_BAD)
537  { /* Header was not good. */
538  ret = wetwork(fr, &newhead); /* Messy stuff, handle junk, resync ... */
540  /* Normally, we jumped already. If for some reason everything's fine to continue, do continue. */
541  if(ret != PARSE_GOOD) goto read_frame_bad;
542  }
543 
544  if(!fr->firsthead)
545  {
546  ret = do_readahead(fr, newhead);
547  /* readahead can fail mit NEED_MORE, in which case we must also make the just read header available again for next go */
548  if(ret < 0) fr->rd->back_bytes(fr, 4);
550  }
551 
552  /* Now we should have our valid header and proceed to reading the frame. */
553 
554  /* if filepos is invalid, so is framepos */
555  framepos = fr->rd->tell(fr) - 4;
556  /* flip/init buffer for Layer 3 */
557  {
558  unsigned char *newbuf = fr->bsspace[fr->bsnum]+512;
559  /* read main data into memory */
560  if((ret=fr->rd->read_frame_body(fr,newbuf,fr->framesize))<0)
561  {
562  /* if failed: flip back */
563  debug("need more?");
564  goto read_frame_bad;
565  }
566  fr->bsbufold = fr->bsbuf;
567  fr->bsbuf = newbuf;
568  }
569  fr->bsnum = (fr->bsnum + 1) & 1;
570 
571  if(!fr->firsthead)
572  {
573  fr->firsthead = newhead; /* _now_ it's time to store it... the first real header */
574  /* This is the first header of our current stream segment.
575  It is only the actual first header of the whole stream when fr->num is still below zero!
576  Think of resyncs where firsthead has been reset for format flexibility. */
577  if(fr->num < 0)
578  {
579  fr->audio_start = framepos;
580  /* Only check for LAME tag at beginning of whole stream
581  ... when there indeed is one in between, it's the user's problem. */
582  if(fr->lay == 3 && check_lame_tag(fr) == 1)
583  { /* ...in practice, Xing/LAME tags are layer 3 only. */
584  if(fr->rd->forget != NULL) fr->rd->forget(fr);
585 
586  fr->oldhead = 0;
587  goto read_again;
588  }
589  /* now adjust volume */
590  do_rva(fr);
591  }
592 
593  debug2("fr->firsthead: %08lx, audio_start: %li", fr->firsthead, (long int)fr->audio_start);
594  }
595 
596  fr->bitindex = 0;
597  fr->wordpointer = (unsigned char *) fr->bsbuf;
598  /* Question: How bad does the floating point value get with repeated recomputation?
599  Also, considering that we can play the file or parts of many times. */
600  if(++fr->mean_frames != 0)
601  {
602  fr->mean_framesize = ((fr->mean_frames-1)*fr->mean_framesize+compute_bpf(fr)) / fr->mean_frames ;
603  }
604  ++fr->num; /* 0 for first frame! */
605  debug4("Frame %"OFF_P" %08lx %i, next filepos=%"OFF_P,
606  (off_p)fr->num, newhead, fr->framesize, (off_p)fr->rd->tell(fr));
607  if(!(fr->state_flags & FRAME_FRANKENSTEIN) && (
608  (fr->track_frames > 0 && fr->num >= fr->track_frames)
609 #ifdef GAPLESS
610  || (fr->gapless_frames > 0 && fr->num >= fr->gapless_frames)
611 #endif
612  ))
613  {
615  if(NOQUIET) fprintf(stderr, "\nWarning: Encountered more data after announced end of track (frame %"OFF_P"/%"OFF_P"). Frankenstein!\n", (off_p)fr->num,
616 #ifdef GAPLESS
617  fr->gapless_frames > 0 ? (off_p)fr->gapless_frames :
618 #endif
619  (off_p)fr->track_frames);
620  }
621 
622  halfspeed_prepare(fr);
623 
624  /* index the position */
625  fr->input_offset = framepos;
626 #ifdef FRAME_INDEX
627  /* Keep track of true frame positions in our frame index.
628  but only do so when we are sure that the frame number is accurate... */
629  if((fr->state_flags & FRAME_ACCURATE) && FI_NEXT(fr->index, fr->num))
630  fi_add(&fr->index, framepos);
631 #endif
632 
633  if(fr->silent_resync > 0) --fr->silent_resync;
634 
635  if(fr->rd->forget != NULL) fr->rd->forget(fr);
636 
637  fr->to_decode = fr->to_ignore = TRUE;
638  if(fr->error_protection) fr->crc = getbits(fr, 16); /* skip crc */
639 
640  /*
641  Let's check for header change after deciding that the new one is good
642  and actually having read a frame.
643 
644  header_change > 1: decoder structure has to be updated
645  Preserve header_change value from previous runs if it is serious.
646  If we still have a big change pending, it should be dealt with outside,
647  fr->header_change set to zero afterwards.
648  */
649  if(fr->header_change < 2)
650  {
651  fr->header_change = 2; /* output format change is possible... */
652  if(fr->oldhead) /* check a following header for change */
653  {
654  if(fr->oldhead == newhead) fr->header_change = 0;
655  else
656  /* Headers that match in this test behave the same for the outside world.
657  namely: same decoding routines, same amount of decoded data. */
658  if(head_compatible(fr->oldhead, newhead))
659  fr->header_change = 1;
660  else
661  {
663  if(NOQUIET)
664  fprintf(stderr, "\nWarning: Big change (MPEG version, layer, rate). Frankenstein stream?\n");
665  }
666  }
667  else if(fr->firsthead && !head_compatible(fr->firsthead, newhead))
668  {
670  if(NOQUIET)
671  fprintf(stderr, "\nWarning: Big change from first (MPEG version, layer, rate). Frankenstein stream?\n");
672  }
673  }
674 
675  fr->oldhead = newhead;
676 
677  return 1;
678 read_frame_bad:
679  /* Also if we searched for valid data in vein, we can forget skipped data.
680  Otherwise, the feeder would hold every dead old byte in memory until the first valid frame! */
681  if(fr->rd->forget != NULL) fr->rd->forget(fr);
682 
683  fr->silent_resync = 0;
684  if(fr->err == MPG123_OK) fr->err = MPG123_ERR_READER;
685  fr->framesize = oldsize;
686  fr->halfphase = oldphase;
687  /* That return code might be inherited from some feeder action, or reader error. */
688  return ret;
689 }
#define JUMP_CONCLUSION(ret)
Definition: parse.c:480
#define TRUE
Definition: types.h:120
static int decode_header(mpg123_handle *fr, unsigned long newhead, int *freeformat_count)
Definition: parse.c:740
unsigned char * bsbufold
Definition: frame.h:253
__kernel_off_t off_t
Definition: linux.h:201
double mean_framesize
Definition: frame.h:246
#define debug4(s, a, b, c, d)
Definition: debug.h:55
unsigned char * wordpointer
Definition: frame.h:227
double compute_bpf(mpg123_handle *fr)
Definition: parse.c:892
#define debug2(s, a, b)
Definition: debug.h:53
off_t input_offset
Definition: frame.h:216
#define GAPLESS
Definition: config.h:45
off_t track_frames
Definition: frame.h:244
static int skip_junk(mpg123_handle *fr, unsigned long *newheadp, long *headcount)
Definition: parse.c:1144
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
smooth NULL
Definition: ftsmooth.c:416
static int head_compatible(unsigned long fred, unsigned long bret)
Definition: parse.c:434
#define fi_add
Definition: intsym.h:210
unsigned int crc
Definition: frame.h:284
off_t gapless_frames
Definition: frame.h:275
#define NOQUIET
unsigned char bsspace[2][MAXFRAMESIZE+512]
Definition: frame.h:251
int ret
static int do_readahead(mpg123_handle *fr, unsigned long newhead)
Definition: parse.c:995
static void halfspeed_prepare(mpg123_handle *fr)
Definition: parse.c:440
unsigned long firsthead
Definition: frame.h:258
static int halfspeed_do(mpg123_handle *fr)
Definition: parse.c:451
static int wetwork(mpg123_handle *fr, unsigned long *newheadp)
Definition: parse.c:1217
struct frame_index index
Definition: frame.h:261
static int check_lame_tag(mpg123_handle *fr)
Definition: parse.c:132
long off_p
Definition: compat.h:130
FILE * stderr
#define debug(msg)
Definition: key_call.c:71
struct reader * rd
Definition: frame.h:285
#define do_rva
Definition: intsym.h:179
#define debug1(s, a)
Definition: debug.h:52
static int head_check(unsigned long head)
Definition: parse.c:85
unsigned long oldhead
Definition: frame.h:256
#define OFF_P
Definition: compat.h:129
#define getbits
Definition: intsym.h:195
unsigned char * bsbuf
Definition: frame.h:252
#define FI_NEXT(fi, framenum)
Definition: index.h:38

◆ set_pointer()

void set_pointer ( mpg123_handle fr,
long  backstep 
)

Definition at line 881 of file parse.c.

882 {
883  fr->wordpointer = fr->bsbuf + fr->ssize - backstep;
884  if (backstep)
885  memcpy(fr->wordpointer,fr->bsbufold+fr->fsizeold-backstep,backstep);
886 
887  fr->bitindex = 0;
888 }
unsigned char * bsbufold
Definition: frame.h:253
unsigned char * wordpointer
Definition: frame.h:227
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned char * bsbuf
Definition: frame.h:252

◆ skip_junk()

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

Definition at line 1144 of file parse.c.

1145 {
1146  int ret;
1147  int freeformat_count = 0;
1148  long limit = 65536;
1149  unsigned long newhead = *newheadp;
1150  unsigned int forgetcount = 0;
1151  /* check for id3v2; first three bytes (of 4) are "ID3" */
1152  if((newhead & (unsigned long) 0xffffff00) == (unsigned long) 0x49443300)
1153  {
1154  return handle_id3v2(fr, newhead);
1155  }
1156  else if(VERBOSE2 && fr->silent_resync == 0) fprintf(stderr,"Note: Junk at the beginning (0x%08lx)\n",newhead);
1157 
1158  /* I even saw RIFF headers at the beginning of MPEG streams ;( */
1159  if(newhead == ('R'<<24)+('I'<<16)+('F'<<8)+'F')
1160  {
1161  if(VERBOSE2 && fr->silent_resync == 0) fprintf(stderr, "Note: Looks like a RIFF header.\n");
1162 
1163  if((ret=fr->rd->head_read(fr,&newhead))<=0) return ret;
1164 
1165  while(newhead != ('d'<<24)+('a'<<16)+('t'<<8)+'a')
1166  {
1167  if(++forgetcount > FORGET_INTERVAL) forgetcount = 0;
1168  if((ret=forget_head_shift(fr,&newhead,!forgetcount))<=0) return ret;
1169  }
1170  if((ret=fr->rd->head_read(fr,&newhead))<=0) return ret;
1171 
1172  if(VERBOSE2 && fr->silent_resync == 0) fprintf(stderr,"Note: Skipped RIFF header!\n");
1173 
1174  fr->oldhead = 0;
1175  *newheadp = newhead;
1176  return PARSE_AGAIN;
1177  }
1178 
1179  /*
1180  Unhandled junk... just continue search for a header, stepping in single bytes through next 64K.
1181  This is rather identical to the resync loop.
1182  */
1183  debug("searching for header...");
1184  *newheadp = 0; /* Invalidate the external value. */
1185  ret = 0; /* We will check the value after the loop. */
1186 
1187  /* We prepare for at least the 64K bytes as usual, unless
1188  user explicitly wanted more (even infinity). Never less. */
1189  if(fr->p.resync_limit < 0 || fr->p.resync_limit > limit)
1190  limit = fr->p.resync_limit;
1191 
1192  do
1193  {
1194  ++(*headcount);
1195  if(limit >= 0 && *headcount >= limit) break;
1196 
1197  if(++forgetcount > FORGET_INTERVAL) forgetcount = 0;
1198  if((ret=forget_head_shift(fr, &newhead, !forgetcount))<=0) return ret;
1199 
1200  if(head_check(newhead) && (ret=decode_header(fr, newhead, &freeformat_count))) break;
1201  } while(1);
1202  if(ret<0) return ret;
1203 
1204  if(limit >= 0 && *headcount >= limit)
1205  {
1206  if(NOQUIET) error1("Giving up searching valid MPEG header after %li bytes of junk.", *headcount);
1207  return PARSE_END;
1208  }
1209  else debug1("hopefully found one at %"OFF_P, (off_p)fr->rd->tell(fr));
1210 
1211  /* If the new header ist good, it is already decoded. */
1212  *newheadp = newhead;
1213  return PARSE_GOOD;
1214 }
static int forget_head_shift(mpg123_handle *fr, unsigned long *newheadp, int forget)
Definition: parse.c:1123
struct mpg123_pars_struct p
Definition: frame.h:287
static int decode_header(mpg123_handle *fr, unsigned long newhead, int *freeformat_count)
Definition: parse.c:740
#define error1(s, a)
Definition: debug.h:109
#define FORGET_INTERVAL
Definition: parse.c:1122
GLint limit
Definition: glext.h:10326
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define VERBOSE2
#define NOQUIET
int ret
static int handle_id3v2(mpg123_handle *fr, unsigned long newhead)
Definition: parse.c:1050
long off_p
Definition: compat.h:130
FILE * stderr
#define debug(msg)
Definition: key_call.c:71
struct reader * rd
Definition: frame.h:285
#define debug1(s, a)
Definition: debug.h:52
static int head_check(unsigned long head)
Definition: parse.c:85
unsigned long oldhead
Definition: frame.h:256
#define OFF_P
Definition: compat.h:129

Referenced by read_frame().

◆ wetwork()

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

Definition at line 1217 of file parse.c.

1218 {
1219  int ret = PARSE_ERR;
1220  unsigned long newhead = *newheadp;
1221  *newheadp = 0;
1222 
1223  /* Classic ID3 tags. Read, then start parsing again. */
1224  if((newhead & 0xffffff00) == ('T'<<24)+('A'<<16)+('G'<<8))
1225  {
1226  fr->id3buf[0] = (unsigned char) ((newhead >> 24) & 0xff);
1227  fr->id3buf[1] = (unsigned char) ((newhead >> 16) & 0xff);
1228  fr->id3buf[2] = (unsigned char) ((newhead >> 8) & 0xff);
1229  fr->id3buf[3] = (unsigned char) ( newhead & 0xff);
1230 
1231  if((ret=fr->rd->fullread(fr,fr->id3buf+4,124)) < 0) return ret;
1232 
1234  fr->rdat.flags |= READER_ID3TAG; /* that marks id3v1 */
1235  if(VERBOSE3) fprintf(stderr,"Note: Skipped ID3v1 tag.\n");
1236 
1237  return PARSE_AGAIN;
1238  }
1239  /* This is similar to initial junk skipping code... */
1240  /* Check for id3v2; first three bytes (of 4) are "ID3" */
1241  if((newhead & (unsigned long) 0xffffff00) == (unsigned long) 0x49443300)
1242  {
1243  return handle_id3v2(fr, newhead);
1244  }
1245  /* Check for an apetag header */
1246  if(newhead == ('A'<<24)+('P'<<16)+('E'<<8)+'T')
1247  {
1248  return handle_apetag(fr, newhead);
1249  }
1250  else if(NOQUIET && fr->silent_resync == 0)
1251  {
1252  fprintf(stderr,"Note: Illegal Audio-MPEG-Header 0x%08lx at offset %"OFF_P".\n",
1253  newhead, (off_p)fr->rd->tell(fr)-4);
1254  }
1255 
1256  /* Now we got something bad at hand, try to recover. */
1257 
1258  if(NOQUIET && (newhead & 0xffffff00) == ('b'<<24)+('m'<<16)+('p'<<8)) fprintf(stderr,"Note: Could be a BMP album art.\n");
1259 
1260  if( !(fr->p.flags & MPG123_NO_RESYNC) )
1261  {
1262  long try = 0;
1263  long limit = fr->p.resync_limit;
1264  unsigned int forgetcount = 0;
1265 
1266  /* If a resync is needed the bitreservoir of previous frames is no longer valid */
1267  fr->bitreservoir = 0;
1268 
1269  if(NOQUIET && fr->silent_resync == 0) fprintf(stderr, "Note: Trying to resync...\n");
1270 
1271  do /* ... shift the header with additional single bytes until be found something that could be a header. */
1272  {
1273  ++try;
1274  if(limit >= 0 && try >= limit) break;
1275 
1276  if(++forgetcount > FORGET_INTERVAL) forgetcount = 0;
1277  if((ret=forget_head_shift(fr,&newhead,!forgetcount)) <= 0)
1278  {
1279  *newheadp = newhead;
1280  if(NOQUIET) fprintf (stderr, "Note: Hit end of (available) data during resync.\n");
1281 
1282  return ret ? ret : PARSE_END;
1283  }
1284  if(VERBOSE3) debug3("resync try %li at %"OFF_P", got newhead 0x%08lx", try, (off_p)fr->rd->tell(fr), newhead);
1285  } while(!head_check(newhead));
1286 
1287  *newheadp = newhead;
1288  if(NOQUIET && fr->silent_resync == 0) fprintf (stderr, "Note: Skipped %li bytes in input.\n", try);
1289 
1290  /* Now we either got something that could be a header, or we gave up. */
1291  if(limit >= 0 && try >= limit)
1292  {
1293  if(NOQUIET)
1294  error1("Giving up resync after %li bytes - your stream is not nice... (maybe increasing resync limit could help).", try);
1295 
1296  fr->err = MPG123_RESYNC_FAIL;
1297  return PARSE_ERR;
1298  }
1299  else
1300  {
1301  debug1("Found possibly valid header 0x%lx... unsetting oldhead to reinit stream.", newhead);
1302  fr->oldhead = 0;
1303  return PARSE_RESYNC;
1304  }
1305  }
1306  else
1307  {
1308  if(NOQUIET) error("not attempting to resync...");
1309 
1310  fr->err = MPG123_OUT_OF_SYNC;
1311  return PARSE_ERR;
1312  }
1313  /* Control never goes here... we return before that. */
1314 }
static int forget_head_shift(mpg123_handle *fr, unsigned long *newheadp, int forget)
Definition: parse.c:1123
struct mpg123_pars_struct p
Definition: frame.h:287
#define error(str)
Definition: mkdosfs.c:1605
#define error1(s, a)
Definition: debug.h:109
struct reader_data rdat
Definition: frame.h:286
#define debug3(s, a, b, c)
Definition: debug.h:54
#define FORGET_INTERVAL
Definition: parse.c:1122
GLint limit
Definition: glext.h:10326
#define MPG123_NEW_ID3
Definition: mpg123.h:1241
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
unsigned char
Definition: typeof.h:29
#define VERBOSE3
static int handle_apetag(mpg123_handle *fr, unsigned long newhead)
Definition: parse.c:1063
#define READER_ID3TAG
Definition: reader.h:114
#define MPG123_ID3
Definition: mpg123.h:1240
#define NOQUIET
int ret
static int handle_id3v2(mpg123_handle *fr, unsigned long newhead)
Definition: parse.c:1050
unsigned char id3buf[128]
Definition: frame.h:294
unsigned int bitreservoir
Definition: frame.h:250
long off_p
Definition: compat.h:130
FILE * stderr
struct reader * rd
Definition: frame.h:285
#define debug1(s, a)
Definition: debug.h:52
static int head_check(unsigned long head)
Definition: parse.c:85
unsigned long oldhead
Definition: frame.h:256
#define OFF_P
Definition: compat.h:129

Referenced by read_frame().

Variable Documentation

◆ freqs

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

Definition at line 64 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 50 of file parse.c.

Referenced by decode_header(), and frame_bitrate().