ReactOS  0.4.15-dev-309-g7c8d563
parse.c
Go to the documentation of this file.
1 /*
2  parse: spawned from common; clustering around stream/frame parsing
3 
4  copyright ?-2014 by the mpg123 project - free software under the terms of the LGPL 2.1
5  see COPYING and AUTHORS files in distribution or http://mpg123.org
6  initially written by Michael Hipp & Thomas Orgis
7 */
8 
9 #include "mpg123lib_intern.h"
10 
11 #include <sys/stat.h>
12 #include <fcntl.h>
13 
14 #include "getbits.h"
15 
16 #if defined (WANT_WIN32_SOCKETS)
17 #include <winsock2.h>
18 #include <ws2tcpip.h>
19 #endif
20 
21 /* a limit for number of frames in a track; beyond that unsigned long may not be enough to hold byte addresses */
22 #ifdef HAVE_LIMITS_H
23 #include <limits.h>
24 #endif
25 #ifndef ULONG_MAX
26 /* hm, is this portable across preprocessors? */
27 #define ULONG_MAX ((unsigned long)-1)
28 #endif
29 #define TRACK_MAX_FRAMES ULONG_MAX/4/1152
30 
31 #include "mpeghead.h"
32 
33 #include "debug.h"
34 
35 #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) ) )
36 
37 /* PARSE_GOOD and PARSE_BAD have to be 1 and 0 (TRUE and FALSE), others can vary. */
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 };
48 
49 /* bitrates for [mpeg1/2][layer] */
50 static const int tabsel_123[2][3][16] =
51 {
52  {
53  {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,},
54  {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,},
55  {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,}
56  },
57  {
58  {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,},
59  {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,},
60  {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,}
61  }
62 };
63 
64 static const long freqs[9] = { 44100, 48000, 32000, 22050, 24000, 16000 , 11025 , 12000 , 8000 };
65 
66 static int decode_header(mpg123_handle *fr,unsigned long newhead, int *freeformat_count);
67 static int skip_junk(mpg123_handle *fr, unsigned long *newheadp, long *headcount);
68 static int do_readahead(mpg123_handle *fr, unsigned long newhead);
69 static int wetwork(mpg123_handle *fr, unsigned long *newheadp);
70 
71 /* These two are to be replaced by one function that gives all the frame parameters (for outsiders).*/
72 /* Those functions are unsafe regarding bad arguments (inside the mpg123_handle), but just returning anything would also be unsafe, the caller code has to be trusted. */
73 
75 {
76  return tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index];
77 }
78 
80 {
81  return freqs[fr->sampling_frequency];
82 }
83 
84 /* compiler is smart enought to inline this one or should I really do it as macro...? */
85 static int head_check(unsigned long head)
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 }
110 
111 /* This is moderately sized buffers. Int offset is enough. */
112 static unsigned long bit_read_long(unsigned char *buf, int *offset)
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 }
122 
123 static unsigned short bit_read_short(unsigned char *buf, int *offset)
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 }
131 
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 }
426 
427 /* Just tell if the header is some mono. */
428 static int header_mono(unsigned long newhead)
429 {
430  return HDR_CHANNEL_VAL(newhead) == MPG_MD_MONO ? TRUE : FALSE;
431 }
432 
433 /* true if the two headers will work with the same decoding routines */
434 static int head_compatible(unsigned long fred, unsigned long bret)
435 {
436  return ( (fred & HDR_CMPMASK) == (bret & HDR_CMPMASK)
437  && header_mono(fred) == header_mono(bret) );
438 }
439 
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 }
449 
450 /* If this returns 1, the next frame is the repetition. */
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 }
474 
475 /*
476  Temporary macro until we got this worked out.
477  Idea is to filter out special return values that shall trigger direct jumps to end / resync / read again.
478  Particularily, the generic ret==PARSE_BAD==0 and ret==PARSE_GOOD==1 are not affected.
479 */
480 #define JUMP_CONCLUSION(ret) \
481 { \
482 if(ret < 0){ debug1("%s", ret == MPG123_NEED_MORE ? "need more" : "read error"); goto read_frame_bad; } \
483 else if(ret == PARSE_AGAIN) goto read_again; \
484 else if(ret == PARSE_RESYNC) goto init_resync; \
485 else if(ret == PARSE_END){ ret=0; goto read_frame_bad; } \
486 }
487 
488 /*
489  That's a big one: read the next frame. 1 is success, <= 0 is some error
490  Special error READER_MORE means: Please feed more data and try again.
491 */
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 }
690 
691 
692 /*
693  * read ahead and find the next MPEG header, to guess framesize
694  * return value: success code
695  * PARSE_GOOD: found a valid frame size (stored in the handle).
696  * <0: error codes, possibly from feeder buffer (NEED_MORE)
697  * PARSE_BAD: cannot get the framesize for some reason and shall silentry try the next possible header (if this is no free format stream after all...)
698  */
699 static int guess_freeformat_framesize(mpg123_handle *fr, unsigned long oldhead)
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 }
729 
730 
731 /*
732  * decode a header and write the information
733  * into the frame structure
734  * Return values are compatible with those of read_frame, namely:
735  * 1: success
736  * 0: no valid header
737  * <0: some error
738  * You are required to do a head_check() before calling!
739  */
740 static int decode_header(mpg123_handle *fr,unsigned long newhead, int *freeformat_count)
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 }
880 
881 void set_pointer(mpg123_handle *fr, long backstep)
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 }
889 
890 /********************************/
891 
893 {
894  return (fr->framesize > 0) ? fr->framesize + 4.0 : 1.0;
895 }
896 
898 {
899  if(mh == NULL) return MPG123_ERR;
900 
901  return mh->firsthead ? mh->spf : MPG123_ERR;
902 }
903 
905 {
906  static int bs[4] = { 0,384,1152,1152 };
907  double tpf;
908  if(fr == NULL || !fr->firsthead) return MPG123_ERR;
909 
910  tpf = (double) bs[fr->lay];
911  tpf /= freqs[fr->sampling_frequency] << (fr->lsf);
912  return tpf;
913 }
914 
916  off_t *current_frame, off_t *frames_left,
917  double *current_seconds, double *seconds_left)
918 {
919  double tpf;
920  double dt = 0.0;
921  off_t cur, left;
922  double curs, lefts;
923 
924  if(!fr || !fr->rd) return MPG123_ERR;
925 
926  no += fr->num; /* no starts out as offset */
927  cur = no;
928  tpf = mpg123_tpf(fr);
929  if(buffsize > 0 && fr->af.rate > 0 && fr->af.channels > 0)
930  {
931  dt = (double) buffsize / fr->af.rate / fr->af.channels;
932  if(fr->af.encoding & MPG123_ENC_16) dt *= 0.5;
933  }
934 
935  left = 0;
936 
937  if((fr->track_frames != 0) && (fr->track_frames >= fr->num)) left = no < fr->track_frames ? fr->track_frames - no : 0;
938  else
939  if(fr->rdat.filelen >= 0)
940  {
941  double bpf;
942  off_t t = fr->rd->tell(fr);
943  bpf = fr->mean_framesize ? fr->mean_framesize : compute_bpf(fr);
944  left = (off_t)((double)(fr->rdat.filelen-t)/bpf);
945  /* no can be different for prophetic purposes, file pointer is always associated with fr->num! */
946  if(fr->num != no)
947  {
948  if(fr->num > no) left += fr->num - no;
949  else
950  {
951  if(left >= (no - fr->num)) left -= no - fr->num;
952  else left = 0; /* uh, oh! */
953  }
954  }
955  /* I totally don't understand why we should re-estimate the given correct(?) value */
956  /* fr->num = (unsigned long)((double)t/bpf); */
957  }
958 
959  /* beginning with 0 or 1?*/
960  curs = (double) no*tpf-dt;
961  lefts = (double)left*tpf+dt;
962 #if 0
963  curs = curs < 0 ? 0.0 : curs;
964 #endif
965  if(left < 0 || lefts < 0)
966  { /* That is the case for non-seekable streams. */
967  left = 0;
968  lefts = 0.0;
969  }
970  if(current_frame != NULL) *current_frame = cur;
971  if(frames_left != NULL) *frames_left = left;
972  if(current_seconds != NULL) *current_seconds = curs;
973  if(seconds_left != NULL) *seconds_left = lefts;
974  return MPG123_OK;
975 }
976 
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 }
993 
994 /* first attempt of read ahead check to find the real first header; cannot believe what junk is out there! */
995 static int do_readahead(mpg123_handle *fr, unsigned long newhead)
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 }
1049 
1050 static int handle_id3v2(mpg123_handle *fr, unsigned long newhead)
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 }
1062 
1063 static int handle_apetag(mpg123_handle *fr, unsigned long newhead)
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 }
1119 
1120 /* Advance a byte in stream to get next possible header and forget
1121  buffered data if possible (for feed reader). */
1122 #define FORGET_INTERVAL 1024 /* Used by callers to set forget flag each <n> bytes. */
1123 static int forget_head_shift(mpg123_handle *fr, unsigned long *newheadp, int forget)
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 }
1142 
1143 /* watch out for junk/tags on beginning of stream by invalid header */
1144 static int skip_junk(mpg123_handle *fr, unsigned long *newheadp, long *headcount)
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 }
1215 
1216 /* The newhead is bad, so let's check if it is something special, otherwise just resync. */
1217 static int wetwork(mpg123_handle *fr, unsigned long *newheadp)
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 }
#define JUMP_CONCLUSION(ret)
Definition: parse.c:480
long frame_freq(mpg123_handle *fr)
Definition: parse.c:79
void frame_gapless_init(mpg123_handle *fr, off_t framecount, off_t bskip, off_t eskip)
#define HDR_EMPHASIS_VAL(h)
Definition: mpeghead.h:69
#define TRUE
Definition: types.h:120
#define READER_SEEKABLE
Definition: reader.h:115
static int forget_head_shift(mpg123_handle *fr, unsigned long *newheadp, int forget)
Definition: parse.c:1123
parse_codes
Definition: parse.c:38
struct mpg123_pars_struct p
Definition: frame.h:287
#define error(str)
Definition: mkdosfs.c:1605
#define do_layer3
Definition: intsym.h:161
struct outqueuenode * head
Definition: adnsresfilter.c:66
static int decode_header(mpg123_handle *fr, unsigned long newhead, int *freeformat_count)
Definition: parse.c:740
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
long freeformat_framesize
Definition: frame.h:223
#define error1(s, a)
Definition: debug.h:109
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
int read_frame(mpg123_handle *fr)
Definition: parse.c:492
unsigned char * bsbufold
Definition: frame.h:253
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
__kernel_off_t off_t
Definition: linux.h:201
#define HDR_PADDING_VAL(h)
Definition: mpeghead.h:51
GLintptr offset
Definition: glext.h:5920
double mean_framesize
Definition: frame.h:246
GLdouble GLdouble t
Definition: gl.h:2047
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)
Definition: parse.c:915
#define debug4(s, a, b, c, d)
Definition: debug.h:55
voidpf uLong int origin
Definition: ioapi.h:142
unsigned char * wordpointer
Definition: frame.h:227
double compute_bpf(mpg123_handle *fr)
Definition: parse.c:892
#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
off_t input_offset
Definition: frame.h:216
#define HDR_VERSION_VAL(h)
Definition: mpeghead.h:36
int frame_bitrate(mpg123_handle *fr)
Definition: parse.c:74
struct reader_data rdat
Definition: frame.h:286
#define debug3(s, a, b, c)
Definition: debug.h:54
#define GAPLESS
Definition: config.h:45
static unsigned long bit_read_long(unsigned char *buf, int *offset)
Definition: parse.c:112
#define FORGET_INTERVAL
Definition: parse.c:1122
#define MPG_MD_MONO
GLint limit
Definition: glext.h:10326
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
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
static int skip_junk(mpg123_handle *fr, unsigned long *newheadp, long *headcount)
Definition: parse.c:1144
#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,...)
#define HDR_SAMPLERATE_VAL(h)
Definition: mpeghead.h:48
int attribute_align_arg mpg123_spf(mpg123_handle *mh)
Definition: parse.c:897
double attribute_align_arg mpg123_tpf(mpg123_handle *fr)
Definition: parse.c:904
int sampling_frequency
Definition: frame.h:204
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
#define VERBOSE2
smooth NULL
Definition: ftsmooth.c:416
unsigned char
Definition: typeof.h:29
#define READER_ERROR
Definition: reader.h:134
static int header_mono(unsigned long newhead)
Definition: parse.c:428
_Check_return_ _CRTIMP int __cdecl sscanf(_In_z_ const char *_Src, _In_z_ _Scanf_format_string_ const char *_Format,...)
#define HDR_LAYER_VAL(h)
Definition: mpeghead.h:39
#define off_t
Definition: dosfsck.h:5
#define VERBOSE3
static int head_compatible(unsigned long fred, unsigned long bret)
Definition: parse.c:434
#define fi_add
Definition: intsym.h:210
GLuint GLfloat * val
Definition: glext.h:7180
#define HDR_CHANEX_VAL(h)
Definition: mpeghead.h:60
static int handle_apetag(mpg123_handle *fr, unsigned long newhead)
Definition: parse.c:1063
int(* do_layer)(mpg123_handle *)
Definition: frame.h:201
#define frame_fill_toc
Definition: intsym.h:194
#define READER_ID3TAG
Definition: reader.h:114
unsigned int crc
Definition: frame.h:284
GLfloat f
Definition: glext.h:7540
off_t gapless_frames
Definition: frame.h:275
#define MPG123_ID3
Definition: mpg123.h:1240
static WCHAR no[MAX_STRING_RESOURCE_LEN]
Definition: object.c:2340
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
GLint left
Definition: glext.h:7726
#define HDR_CMPMASK
Definition: mpeghead.h:78
#define MAXFRAMESIZE
Definition: frame.h:30
#define NOQUIET
unsigned char bsspace[2][MAXFRAMESIZE+512]
Definition: frame.h:251
int ret
static int handle_id3v2(mpg123_handle *fr, unsigned long newhead)
Definition: parse.c:1050
#define parse_new_id3
Definition: intsym.h:205
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
void set_pointer(mpg123_handle *fr, long backstep)
Definition: parse.c:881
#define READER_BUFFERED
Definition: reader.h:116
static int do_readahead(mpg123_handle *fr, unsigned long newhead)
Definition: parse.c:995
#define HDR_SYNC
Definition: mpeghead.h:32
static void halfspeed_prepare(mpg123_handle *fr)
Definition: parse.c:440
unsigned long firsthead
Definition: frame.h:258
#define HDR_SAMEMASK
Definition: mpeghead.h:81
static int guess_freeformat_framesize(mpg123_handle *fr, unsigned long oldhead)
Definition: parse.c:699
static int halfspeed_do(mpg123_handle *fr)
Definition: parse.c:451
struct audioformat af
Definition: frame.h:266
unsigned char id3buf[128]
Definition: frame.h:294
static float(__cdecl *square_half_float)(float x
static const int tabsel_123[2][3][16]
Definition: parse.c:50
GLuint start
Definition: gl.h:1545
unsigned int bitreservoir
Definition: frame.h:250
#define major(rdev)
Definition: propsheet.cpp:916
#define long
Definition: qsort.c:33
static int wetwork(mpg123_handle *fr, unsigned long *newheadp)
Definition: parse.c:1217
struct frame_index index
Definition: frame.h:261
#define do_layer1
Definition: intsym.h:163
#define HDR_BITRATE
Definition: mpeghead.h:44
static int check_lame_tag(mpg123_handle *fr)
Definition: parse.c:132
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3706
#define HDR_CHANNEL_VAL(h)
Definition: mpeghead.h:57
#define TRACK_MAX_FRAMES
Definition: parse.c:29
long off_p
Definition: compat.h:130
static const long freqs[9]
Definition: parse.c:64
int get_songlen(mpg123_handle *fr, int no)
Definition: parse.c:977
FILE * stderr
#define HDR_BITRATE_VAL(h)
Definition: mpeghead.h:45
#define minor(rdev)
Definition: propsheet.cpp:917
#define debug(msg)
Definition: key_call.c:71
struct reader * rd
Definition: frame.h:285
#define do_rva
Definition: intsym.h:179
#define check_bytes_left(n)
#define attribute_align_arg
Definition: abi_align.h:30
unsigned char ssave[34]
Definition: frame.h:129
static struct msdos_boot_sector bs
Definition: mkdosfs.c:539
#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 HDR_CRC_VAL(h)
Definition: mpeghead.h:42
static unsigned short bit_read_short(unsigned char *buf, int *offset)
Definition: parse.c:123
#define HDR_PRIVATE_VAL(h)
Definition: mpeghead.h:54
enum mpg123_vbr vbr
Definition: frame.h:214
#define warning(s)
Definition: debug.h:71
#define HDR_COPYRIGHT_VAL(h)
Definition: mpeghead.h:63
#define getbits
Definition: intsym.h:195
unsigned char * bsbuf
Definition: frame.h:252
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define FI_NEXT(fi, framenum)
Definition: index.h:38