ReactOS  0.4.13-dev-73-gcfe54aa
libmpg123.c
Go to the documentation of this file.
1 /*
2  libmpg123: MPEG Audio Decoder library
3 
4  copyright 1995-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 
7 */
8 
9 #include "mpg123lib_intern.h"
10 #include "icy2utf8.h"
11 #include "debug.h"
12 
13 #include "gapless.h"
14 /* Want accurate rounding function regardless of decoder setup. */
15 #define FORCE_ACCURATE
16 #include "sample.h"
17 
18 #define SEEKFRAME(mh) ((mh)->ignoreframe < 0 ? 0 : (mh)->ignoreframe)
19 
20 static int initialized = 0;
21 
23 {
24  if((sizeof(short) != 2) || (sizeof(long) < 4)) return MPG123_BAD_TYPES;
25 
26  if(initialized) return MPG123_OK; /* no need to initialize twice */
27 
28 #ifndef NO_LAYER12
29  init_layer12(); /* inits also shared tables with layer1 */
30 #endif
31 #ifndef NO_LAYER3
32  init_layer3();
33 #endif
36  initialized = 1;
37 #if (defined REAL_IS_FLOAT) && (defined IEEE_FLOAT)
38  /* This is rather pointless but it eases my mind to check that we did
39  not enable the special rounding on a VAX or something. */
40  if(12346 != REAL_TO_SHORT_ACCURATE(12345.67f))
41  {
42  error("Bad IEEE 754 rounding. Re-build libmpg123 properly.");
43  return MPG123_ERR;
44  }
45 #endif
46  return MPG123_OK;
47 }
48 
50 {
51  /* nothing yet, but something later perhaps */
52 }
53 
54 /* create a new handle with specified decoder, decoder can be "", "auto" or NULL for auto-detection */
56 {
57  return mpg123_parnew(NULL, decoder, error);
58 }
59 
60 /* ...the full routine with optional initial parameters to override defaults. */
62 {
63  mpg123_handle *fr = NULL;
64  int err = MPG123_OK;
65 
66  if(initialized) fr = (mpg123_handle*) malloc(sizeof(mpg123_handle));
68  if(fr != NULL)
69  {
70  frame_init_par(fr, mp);
71  debug("cpu opt setting");
72  if(frame_cpu_opt(fr, decoder) != 1)
73  {
75  frame_exit(fr);
76  free(fr);
77  fr = NULL;
78  }
79  }
80  if(fr != NULL)
81  {
82  fr->decoder_change = 1;
83  }
84  else if(err == MPG123_OK) err = MPG123_OUT_OF_MEM;
85 
86  if(error != NULL) *error = err;
87  return fr;
88 }
89 
90 int attribute_align_arg mpg123_decoder(mpg123_handle *mh, const char* decoder)
91 {
92  enum optdec dt = dectype(decoder);
93 
94  if(mh == NULL) return MPG123_BAD_HANDLE;
95 
96  if(dt == nodec)
97  {
98  mh->err = MPG123_BAD_DECODER;
99  return MPG123_ERR;
100  }
101  if(dt == mh->cpu_opts.type) return MPG123_OK;
102 
103  /* Now really change. */
104  /* frame_exit(mh);
105  frame_init(mh); */
106  debug("cpu opt setting");
107  if(frame_cpu_opt(mh, decoder) != 1)
108  {
109  mh->err = MPG123_BAD_DECODER;
110  frame_exit(mh);
111  return MPG123_ERR;
112  }
113  /* New buffers for decoder are created in frame_buffers() */
114  if((frame_outbuffer(mh) != 0))
115  {
116  mh->err = MPG123_NO_BUFFERS;
117  frame_exit(mh);
118  return MPG123_ERR;
119  }
120  /* Do _not_ call decode_update here! That is only allowed after a first MPEG frame has been met. */
121  mh->decoder_change = 1;
122  return MPG123_OK;
123 }
124 
126 {
127  int r;
128 
129  if(mh == NULL) return MPG123_BAD_HANDLE;
130  r = mpg123_par(&mh->p, key, val, fval);
131  if(r != MPG123_OK){ mh->err = r; r = MPG123_ERR; }
132  else
133  { /* Special treatment for some settings. */
134 #ifdef FRAME_INDEX
135  if(key == MPG123_INDEX_SIZE)
136  { /* Apply frame index size and grow property on the fly. */
137  r = frame_index_setup(mh);
138  if(r != MPG123_OK) mh->err = MPG123_INDEX_FAIL;
139  }
140 #endif
141 #ifndef NO_FEEDER
142  /* Feeder pool size is applied right away, reader will react to that. */
144  bc_poolsize(&mh->rdat.buffer, mh->p.feedpool, mh->p.feedbuffer);
145 #endif
146  }
147  return r;
148 }
149 
151 {
152  int ret = MPG123_OK;
153 
154  if(mp == NULL) return MPG123_BAD_PARS;
155  switch(key)
156  {
157  case MPG123_VERBOSE:
158  mp->verbose = val;
159  break;
160  case MPG123_FLAGS:
161 #ifndef GAPLESS
163 #endif
164  if(ret == MPG123_OK) mp->flags = val;
165  debug1("set flags to 0x%lx", (unsigned long) mp->flags);
166  break;
167  case MPG123_ADD_FLAGS:
168 #ifndef GAPLESS
169  /* Enabling of gapless mode doesn't work when it's not there, but disabling (below) is no problem. */
171  else
172 #endif
173  mp->flags |= val;
174  debug1("set flags to 0x%lx", (unsigned long) mp->flags);
175  break;
176  case MPG123_REMOVE_FLAGS:
177  mp->flags &= ~val;
178  debug1("set flags to 0x%lx", (unsigned long) mp->flags);
179  break;
180  case MPG123_FORCE_RATE: /* should this trigger something? */
181 #ifdef NO_NTOM
182  if(val > 0)
184 #else
185  if(val > 96000) ret = MPG123_BAD_RATE;
186  else mp->force_rate = val < 0 ? 0 : val; /* >0 means enable, 0 disable */
187 #endif
188  break;
189  case MPG123_DOWN_SAMPLE:
190 #ifdef NO_DOWNSAMPLE
191  if(val != 0) ret = MPG123_BAD_RATE;
192 #else
194  else mp->down_sample = (int)val;
195 #endif
196  break;
197  case MPG123_RVA:
199  else mp->rva = (int)val;
200  break;
201  case MPG123_DOWNSPEED:
202  mp->halfspeed = val < 0 ? 0 : val;
203  break;
204  case MPG123_UPSPEED:
205  mp->doublespeed = val < 0 ? 0 : val;
206  break;
207  case MPG123_ICY_INTERVAL:
208 #ifndef NO_ICY
209  mp->icy_interval = val > 0 ? val : 0;
210 #else
211  if(val > 0) ret = MPG123_BAD_PARAM;
212 #endif
213  break;
214  case MPG123_OUTSCALE:
215  /* Choose the value that is non-zero, if any.
216  Downscaling integers to 1.0 . */
217  mp->outscale = val == 0 ? fval : (double)val/SHORT_SCALE;
218  break;
219  case MPG123_TIMEOUT:
220 #ifdef TIMEOUT_READ
221  mp->timeout = val >= 0 ? val : 0;
222 #else
223  if(val > 0) ret = MPG123_NO_TIMEOUT;
224 #endif
225  break;
226  case MPG123_RESYNC_LIMIT:
227  mp->resync_limit = val;
228  break;
229  case MPG123_INDEX_SIZE:
230 #ifdef FRAME_INDEX
231  mp->index_size = val;
232 #else
234 #endif
235  break;
236  case MPG123_PREFRAMES:
237  if(val >= 0) mp->preframes = val;
238  else ret = MPG123_BAD_VALUE;
239  break;
240  case MPG123_FEEDPOOL:
241 #ifndef NO_FEEDER
242  if(val >= 0) mp->feedpool = val;
243  else ret = MPG123_BAD_VALUE;
244 #else
246 #endif
247  break;
248  case MPG123_FEEDBUFFER:
249 #ifndef NO_FEEDER
250  if(val > 0) mp->feedbuffer = val;
251  else ret = MPG123_BAD_VALUE;
252 #else
254 #endif
255  break;
256  default:
258  }
259  return ret;
260 }
261 
263 {
264  int r;
265 
266  if(mh == NULL) return MPG123_BAD_HANDLE;
267  r = mpg123_getpar(&mh->p, key, val, fval);
268  if(r != MPG123_OK){ mh->err = r; r = MPG123_ERR; }
269  return r;
270 }
271 
273 {
274  int ret = 0;
275 
276  if(mp == NULL) return MPG123_BAD_PARS;
277  switch(key)
278  {
279  case MPG123_VERBOSE:
280  if(val) *val = mp->verbose;
281  break;
282  case MPG123_FLAGS:
283  case MPG123_ADD_FLAGS:
284  if(val) *val = mp->flags;
285  break;
286  case MPG123_FORCE_RATE:
287  if(val)
288 #ifdef NO_NTOM
289  *val = 0;
290 #else
291  *val = mp->force_rate;
292 #endif
293  break;
294  case MPG123_DOWN_SAMPLE:
295  if(val) *val = mp->down_sample;
296  break;
297  case MPG123_RVA:
298  if(val) *val = mp->rva;
299  break;
300  case MPG123_DOWNSPEED:
301  if(val) *val = mp->halfspeed;
302  break;
303  case MPG123_UPSPEED:
304  if(val) *val = mp->doublespeed;
305  break;
306  case MPG123_ICY_INTERVAL:
307 #ifndef NO_ICY
308  if(val) *val = (long)mp->icy_interval;
309 #else
310  if(val) *val = 0;
311 #endif
312  break;
313  case MPG123_OUTSCALE:
314  if(fval) *fval = mp->outscale;
315  if(val) *val = (long)(mp->outscale*SHORT_SCALE);
316  break;
317  case MPG123_RESYNC_LIMIT:
318  if(val) *val = mp->resync_limit;
319  break;
320  case MPG123_INDEX_SIZE:
321  if(val)
322 #ifdef FRAME_INDEX
323  *val = mp->index_size;
324 #else
325  *val = 0; /* graceful fallback: no index is index of zero size */
326 #endif
327  break;
328  case MPG123_PREFRAMES:
329  *val = mp->preframes;
330  break;
331  case MPG123_FEEDPOOL:
332 #ifndef NO_FEEDER
333  *val = mp->feedpool;
334 #else
336 #endif
337  break;
338  case MPG123_FEEDBUFFER:
339 #ifndef NO_FEEDER
340  *val = mp->feedbuffer;
341 #else
343 #endif
344  break;
345  default:
347  }
348  return ret;
349 }
350 
352 {
353  int ret = MPG123_OK;
354  long theval = 0;
355  double thefval = 0.;
356 
357  if(mh == NULL) return MPG123_BAD_HANDLE;
358 
359  switch(key)
360  {
361  case MPG123_ACCURATE:
362  theval = mh->state_flags & FRAME_ACCURATE;
363  break;
364  case MPG123_FRANKENSTEIN:
365  theval = mh->state_flags & FRAME_FRANKENSTEIN;
366  break;
367  case MPG123_BUFFERFILL:
368 #ifndef NO_FEEDER
369  {
370  size_t sval = bc_fill(&mh->rdat.buffer);
371  theval = (long)sval;
372  if(theval < 0 || (size_t)theval != sval)
373  {
374  mh->err = MPG123_INT_OVERFLOW;
375  ret = MPG123_ERR;
376  }
377  }
378 #else
380  ret = MPG123_ERR;
381 #endif
382  break;
384  theval = mh->state_flags & FRAME_FRESH_DECODER;
386  break;
387  default:
388  mh->err = MPG123_BAD_KEY;
389  ret = MPG123_ERR;
390  }
391 
392  if(val != NULL) *val = theval;
393  if(fval != NULL) *fval = thefval;
394 
395  return ret;
396 }
397 int attribute_align_arg mpg123_eq(mpg123_handle *mh, enum mpg123_channels channel, int band, double val)
398 {
399 #ifndef NO_EQUALIZER
400  if(mh == NULL) return MPG123_BAD_HANDLE;
401  if(band < 0 || band > 31){ mh->err = MPG123_BAD_BAND; return MPG123_ERR; }
402  switch(channel)
403  {
405  mh->equalizer[0][band] = mh->equalizer[1][band] = DOUBLE_TO_REAL(val);
406  break;
407  case MPG123_LEFT: mh->equalizer[0][band] = DOUBLE_TO_REAL(val); break;
408  case MPG123_RIGHT: mh->equalizer[1][band] = DOUBLE_TO_REAL(val); break;
409  default:
411  return MPG123_ERR;
412  }
413  mh->have_eq_settings = TRUE;
414 #endif
415  return MPG123_OK;
416 }
417 
419 {
420  double ret = 0.;
421 #ifndef NO_EQUALIZER
422 
423  /* Handle this gracefully. When there is no band, it has no volume. */
424  if(mh != NULL && band > -1 && band < 32)
425  switch(channel)
426  {
428  ret = 0.5*(REAL_TO_DOUBLE(mh->equalizer[0][band])+REAL_TO_DOUBLE(mh->equalizer[1][band]));
429  break;
430  case MPG123_LEFT: ret = REAL_TO_DOUBLE(mh->equalizer[0][band]); break;
431  case MPG123_RIGHT: ret = REAL_TO_DOUBLE(mh->equalizer[1][band]); break;
432  /* Default case is already handled: ret = 0 */
433  }
434 #endif
435  return ret;
436 }
437 
438 /* plain file access, no http! */
440 {
441  if(mh == NULL) return MPG123_BAD_HANDLE;
442 
443  mpg123_close(mh);
444  return open_stream(mh, path, -1);
445 }
446 
448 {
449  if(mh == NULL) return MPG123_BAD_HANDLE;
450 
451  mpg123_close(mh);
452  return open_stream(mh, NULL, fd);
453 }
454 
456 {
457  if(mh == NULL) return MPG123_BAD_HANDLE;
458 
459  mpg123_close(mh);
460  if(mh->rdat.r_read_handle == NULL)
461  {
463  return MPG123_ERR;
464  }
465  return open_stream_handle(mh, iohandle);
466 }
467 
469 {
470  if(mh == NULL) return MPG123_BAD_HANDLE;
471 
472  mpg123_close(mh);
473  return open_feed(mh);
474 }
475 
477  ssize_t (*r_read) (int, void *, size_t),
478  off_t (*r_lseek)(int, off_t, int) )
479 {
480  if(mh == NULL) return MPG123_BAD_HANDLE;
481 
482  mpg123_close(mh);
483  mh->rdat.r_read = r_read;
484  mh->rdat.r_lseek = r_lseek;
485  return MPG123_OK;
486 }
487 
489  ssize_t (*r_read) (void*, void *, size_t),
490  off_t (*r_lseek)(void*, off_t, int),
491  void (*cleanup)(void*) )
492 {
493  if(mh == NULL) return MPG123_BAD_HANDLE;
494 
495  mpg123_close(mh);
496  mh->rdat.r_read_handle = r_read;
497  mh->rdat.r_lseek_handle = r_lseek;
498  mh->rdat.cleanup_handle = cleanup;
499  return MPG123_OK;
500 }
501 
502 /* Update decoding engine for
503  a) a new choice of decoder
504  b) a changed native format of the MPEG stream
505  ... calls are only valid after parsing some MPEG frame! */
507 {
508  long native_rate;
509  int b;
510 
511  if(mh->num < 0)
512  {
513  if(!(mh->p.flags & MPG123_QUIET)) error("decode_update() has been called before reading the first MPEG frame! Internal programming error.");
514 
516  return MPG123_ERR;
517  }
518 
520  native_rate = frame_freq(mh);
521 
522  b = frame_output_format(mh); /* Select the new output format based on given constraints. */
523  if(b < 0) return MPG123_ERR;
524 
525  if(b == 1) mh->new_format = 1; /* Store for later... */
526 
527  debug3("updating decoder structure with native rate %li and af.rate %li (new format: %i)", native_rate, mh->af.rate, mh->new_format);
528  if(mh->af.rate == native_rate) mh->down_sample = 0;
529  else if(mh->af.rate == native_rate>>1) mh->down_sample = 1;
530  else if(mh->af.rate == native_rate>>2) mh->down_sample = 2;
531  else mh->down_sample = 3; /* flexible (fixed) rate */
532  switch(mh->down_sample)
533  {
534  case 0:
535  case 1:
536  case 2:
538  /* With downsampling I get less samples per frame */
539  mh->outblock = outblock_bytes(mh, (mh->spf>>mh->down_sample));
540  break;
541 #ifndef NO_NTOM
542  case 3:
543  {
544  if(synth_ntom_set_step(mh) != 0) return -1;
545  if(frame_freq(mh) > mh->af.rate)
546  {
547  mh->down_sample_sblimit = SBLIMIT * mh->af.rate;
548  mh->down_sample_sblimit /= frame_freq(mh);
549  }
550  else mh->down_sample_sblimit = SBLIMIT;
551  mh->outblock = outblock_bytes(mh,
552  ( ( NTOM_MUL-1+mh->spf
553  * (((size_t)NTOM_MUL*mh->af.rate)/frame_freq(mh))
554  )/NTOM_MUL ));
555  }
556  break;
557 #endif
558  }
559 
560  if(!(mh->p.flags & MPG123_FORCE_MONO))
561  {
562  if(mh->af.channels == 1) mh->single = SINGLE_MIX;
563  else mh->single = SINGLE_STEREO;
564  }
565  else mh->single = (mh->p.flags & MPG123_FORCE_MONO)-1;
566  if(set_synth_functions(mh) != 0) return -1;;
567 
568  /* The needed size of output buffer may have changed. */
569  if(frame_outbuffer(mh) != MPG123_OK) return -1;
570 
571  do_rva(mh);
572  debug3("done updating decoder structure with native rate %li and af.rate %li and down_sample %i", frame_freq(mh), mh->af.rate, mh->down_sample);
573 
574  return 0;
575 }
576 
578 {
579  /* real is the largest possible output (it's 32bit float, 32bit int or 64bit double). */
580  return sizeof(real)*2*1152*NTOM_MAX;
581 }
582 
584 {
585  /* Try to be helpful and never return zero output block size. */
586  if(mh != NULL && mh->outblock > 0) return mh->outblock;
587  else return mpg123_safe_buffer();
588 }
589 
590 /* Read in the next frame we actually want for decoding.
591  This includes skipping/ignoring frames, in additon to skipping junk in the parser. */
593 {
594  int change = mh->decoder_change;
595  /* Ensure we got proper decoder for ignoring frames.
596  Header can be changed from seeking around. But be careful: Only after at
597  least one frame got read, decoder update makes sense. */
598  if(mh->header_change > 1 && mh->num >= 0)
599  {
600  change = 1;
601  mh->header_change = 0;
602  debug("starting with big header change");
603  if(decode_update(mh) < 0)
604  return MPG123_ERR;
605  }
606 
607  do
608  {
609  int b;
610  /* Decode & discard some frame(s) before beginning. */
611  if(mh->to_ignore && mh->num < mh->firstframe && mh->num >= mh->ignoreframe)
612  {
613  debug1("ignoring frame %li", (long)mh->num);
614  /* Decoder structure must be current! decode_update has been called before... */
615  (mh->do_layer)(mh); mh->buffer.fill = 0;
616 #ifndef NO_NTOM
617  /* The ignored decoding may have failed. Make sure ntom stays consistent. */
618  if(mh->down_sample == 3) ntom_set_ntom(mh, mh->num+1);
619 #endif
620  mh->to_ignore = mh->to_decode = FALSE;
621  }
622  /* Read new frame data; possibly breaking out here for MPG123_NEED_MORE. */
623  debug("read frame");
624  mh->to_decode = FALSE;
625  b = read_frame(mh); /* That sets to_decode only if a full frame was read. */
626  debug4("read of frame %li returned %i (to_decode=%i) at sample %li", (long)mh->num, b, mh->to_decode, (long)mpg123_tell(mh));
627  if(b == MPG123_NEED_MORE) return MPG123_NEED_MORE; /* need another call with data */
628  else if(b <= 0)
629  {
630  /* More sophisticated error control? */
631  if(b==0 || (mh->rdat.filelen >= 0 && mh->rdat.filepos == mh->rdat.filelen))
632  { /* We simply reached the end. */
633  mh->track_frames = mh->num + 1;
634  debug("What about updating/checking gapless sample count here?");
635  return MPG123_DONE;
636  }
637  else return MPG123_ERR; /* Some real error. */
638  }
639  /* Now, there should be new data to decode ... and also possibly new stream properties */
640  if(mh->header_change > 1)
641  {
642  debug("big header change");
643  change = 1;
644  mh->header_change = 0;
645  /* Need to update decoder structure right away since frame might need to
646  be decoded on next loop iteration for properly ignoring its output. */
647  if(decode_update(mh) < 0)
648  return MPG123_ERR;
649  }
650  /* Now some accounting: Look at the numbers and decide if we want this frame. */
651  ++mh->playnum;
652  /* Plain skipping without decoding, only when frame is not ignored on next cycle. */
653  if(mh->num < mh->firstframe || (mh->p.doublespeed && (mh->playnum % mh->p.doublespeed)))
654  {
655  if(!(mh->to_ignore && mh->num < mh->firstframe && mh->num >= mh->ignoreframe))
656  {
657  frame_skip(mh);
658  /* Should one fix NtoM here or not?
659  It is not work the trouble for doublespeed, but what with leading frames? */
660  }
661  }
662  /* Or, we are finally done and have a new frame. */
663  else break;
664  } while(1);
665 
666  /* If we reach this point, we got a new frame ready to be decoded.
667  All other situations resulted in returns from the loop. */
668  if(change)
669  {
670  mh->decoder_change = 0;
671  if(mh->fresh)
672  {
673 #ifdef GAPLESS
674  int b=0;
675  /* Prepare offsets for gapless decoding. */
676  debug1("preparing gapless stuff with native rate %li", frame_freq(mh));
678  frame_set_frameseek(mh, mh->num);
679 #endif
680  mh->fresh = 0;
681 #ifdef GAPLESS
682  /* Could this possibly happen? With a real big gapless offset... */
683  if(mh->num < mh->firstframe) b = get_next_frame(mh);
684  if(b < 0) return b; /* Could be error, need for more, new format... */
685 #endif
686  }
687  }
688  return MPG123_OK;
689 }
690 
691 /* Assumption: A buffer full of zero samples can be constructed by repetition of this byte.
692  Oh, and it handles some format conversion.
693  Only to be used by decode_the_frame() ... */
694 static int zero_byte(mpg123_handle *fr)
695 {
696 #ifndef NO_8BIT
697  return fr->af.encoding & MPG123_ENC_8 ? fr->conv16to8[0] : 0;
698 #else
699  return 0; /* All normal signed formats have the zero here (even in byte form -- that may be an assumption for your funny machine...). */
700 #endif
701 }
702 
703 /*
704  Not part of the api. This just decodes the frame and fills missing bits with zeroes.
705  There can be frames that are broken and thus make do_layer() fail.
706 */
708 {
709  size_t needed_bytes = decoder_synth_bytes(fr, frame_expect_outsamples(fr));
710  fr->clip += (fr->do_layer)(fr);
711  /*fprintf(stderr, "frame %"OFF_P": got %"SIZE_P" / %"SIZE_P"\n", fr->num,(size_p)fr->buffer.fill, (size_p)needed_bytes);*/
712  /* There could be less data than promised.
713  Also, then debugging, we look out for coding errors that could result in _more_ data than expected. */
714 #ifdef DEBUG
715  if(fr->buffer.fill != needed_bytes)
716  {
717 #endif
718  if(fr->buffer.fill < needed_bytes)
719  {
720  if(VERBOSE2)
721  fprintf(stderr, "Note: broken frame %li, filling up with %"SIZE_P" zeroes, from %"SIZE_P"\n", (long)fr->num, (size_p)(needed_bytes-fr->buffer.fill), (size_p)fr->buffer.fill);
722 
723  /*
724  One could do a loop with individual samples instead... but zero is zero
725  Actually, that is wrong: zero is mostly a series of null bytes,
726  but we have funny 8bit formats that have a different opinion on zero...
727  Unsigned 16 or 32 bit formats are handled later.
728  */
729  memset( fr->buffer.data + fr->buffer.fill, zero_byte(fr), needed_bytes - fr->buffer.fill );
730 
731  fr->buffer.fill = needed_bytes;
732 #ifndef NO_NTOM
733  /* ntom_val will be wrong when the decoding wasn't carried out completely */
734  ntom_set_ntom(fr, fr->num+1);
735 #endif
736  }
737 #ifdef DEBUG
738  else
739  {
740  if(NOQUIET)
741  error2("I got _more_ bytes than expected (%"SIZE_P" / %"SIZE_P"), that should not be possible!", (size_p)fr->buffer.fill, (size_p)needed_bytes);
742  }
743  }
744 #endif
745  postprocess_buffer(fr);
746 }
747 
748 /*
749  Decode the current frame into the frame structure's buffer, accessible at the location stored in <audio>, with <bytes> bytes available.
750  <num> will contain the last decoded frame number. This function should be called after mpg123_framebyframe_next positioned the stream at a
751  valid mp3 frame. The buffer contents will get lost on the next call to mpg123_framebyframe_next or mpg123_framebyframe_decode.
752  returns
753  MPG123_OK -- successfully decoded or ignored the frame, you get your output data or in case of ignored frames 0 bytes
754  MPG123_DONE -- decoding finished, should not happen
755  MPG123_ERR -- some error occured.
756  MPG123_ERR_NULL -- audio or bytes are not pointing to valid storage addresses
757  MPG123_BAD_HANDLE -- mh has not been initialized
758  MPG123_NO_SPACE -- not enough space in buffer for safe decoding, should not happen
759 */
760 int attribute_align_arg mpg123_framebyframe_decode(mpg123_handle *mh, off_t *num, unsigned char **audio, size_t *bytes)
761 {
762  if(bytes == NULL) return MPG123_ERR_NULL;
763  if(audio == NULL) return MPG123_ERR_NULL;
764  if(mh == NULL) return MPG123_BAD_HANDLE;
765  if(mh->buffer.size < mh->outblock) return MPG123_NO_SPACE;
766 
767  *bytes = 0;
768  mh->buffer.fill = 0; /* always start fresh */
769  if(!mh->to_decode) return MPG123_OK;
770 
771  if(num != NULL) *num = mh->num;
772  debug("decoding");
773  decode_the_frame(mh);
774  mh->to_decode = mh->to_ignore = FALSE;
775  mh->buffer.p = mh->buffer.data;
776  FRAME_BUFFERCHECK(mh);
777  *audio = mh->buffer.p;
778  *bytes = mh->buffer.fill;
779  return MPG123_OK;
780 }
781 
782 /*
783  Find, read and parse the next mp3 frame while skipping junk and parsing id3 tags, lame headers, etc.
784  Prepares everything for decoding using mpg123_framebyframe_decode.
785  returns
786  MPG123_OK -- new frame was read and parsed, call mpg123_framebyframe_decode to actually decode
787  MPG123_NEW_FORMAT -- new frame was read, it results in changed output format, call mpg123_framebyframe_decode to actually decode
788  MPG123_BAD_HANDLE -- mh has not been initialized
789  MPG123_NEED_MORE -- more input data is needed to advance to the next frame. supply more input data using mpg123_feed
790 */
792 {
793  int b;
794  if(mh == NULL) return MPG123_BAD_HANDLE;
795 
796  mh->to_decode = mh->to_ignore = FALSE;
797  mh->buffer.fill = 0;
798 
799  b = get_next_frame(mh);
800  if(b < 0) return b;
801  debug1("got next frame, %i", mh->to_decode);
802 
803  /* mpg123_framebyframe_decode will return MPG123_OK with 0 bytes decoded if mh->to_decode is 0 */
804  if(!mh->to_decode)
805  return MPG123_OK;
806 
807  if(mh->new_format)
808  {
809  debug("notifiying new format");
810  mh->new_format = 0;
811  return MPG123_NEW_FORMAT;
812  }
813 
814  return MPG123_OK;
815 }
816 
817 /*
818  Put _one_ decoded frame into the frame structure's buffer, accessible at the location stored in <audio>, with <bytes> bytes available.
819  The buffer contents will be lost on next call to mpg123_decode_frame.
820  MPG123_OK -- successfully decoded the frame, you get your output data
821  MPg123_DONE -- This is it. End.
822  MPG123_ERR -- some error occured...
823  MPG123_NEW_FORMAT -- new frame was read, it results in changed output format -> will be decoded on next call
824  MPG123_NEED_MORE -- that should not happen as this function is intended for in-library stream reader but if you force it...
825  MPG123_NO_SPACE -- not enough space in buffer for safe decoding, also should not happen
826 
827  num will be updated to the last decoded frame number (may possibly _not_ increase, p.ex. when format changed).
828 */
829 int attribute_align_arg mpg123_decode_frame(mpg123_handle *mh, off_t *num, unsigned char **audio, size_t *bytes)
830 {
831  if(bytes != NULL) *bytes = 0;
832  if(mh == NULL) return MPG123_BAD_HANDLE;
833  if(mh->buffer.size < mh->outblock) return MPG123_NO_SPACE;
834  mh->buffer.fill = 0; /* always start fresh */
835  while(TRUE)
836  {
837  /* decode if possible */
838  if(mh->to_decode)
839  {
840  if(mh->new_format)
841  {
842  debug("notifiying new format");
843  mh->new_format = 0;
844  return MPG123_NEW_FORMAT;
845  }
846  if(num != NULL) *num = mh->num;
847  debug("decoding");
848 
849  decode_the_frame(mh);
850 
851  mh->to_decode = mh->to_ignore = FALSE;
852  mh->buffer.p = mh->buffer.data;
853  FRAME_BUFFERCHECK(mh);
854  if(audio != NULL) *audio = mh->buffer.p;
855  if(bytes != NULL) *bytes = mh->buffer.fill;
856 
857  return MPG123_OK;
858  }
859  else
860  {
861  int b = get_next_frame(mh);
862  if(b < 0) return b;
863  debug1("got next frame, %i", mh->to_decode);
864  }
865  }
866 }
867 
868 int attribute_align_arg mpg123_read(mpg123_handle *mh, unsigned char *out, size_t size, size_t *done)
869 {
870  return mpg123_decode(mh, NULL, 0, out, size, done);
871 }
872 
873 int attribute_align_arg mpg123_feed(mpg123_handle *mh, const unsigned char *in, size_t size)
874 {
875  if(mh == NULL) return MPG123_BAD_HANDLE;
876 #ifndef NO_FEEDER
877  if(size > 0)
878  {
879  if(in != NULL)
880  {
881  if(feed_more(mh, in, size) != 0) return MPG123_ERR;
882  else
883  {
884  /* The need for more data might have triggered an error.
885  This one is outdated now with the new data. */
886  if(mh->err == MPG123_ERR_READER) mh->err = MPG123_OK;
887 
888  return MPG123_OK;
889  }
890  }
891  else
892  {
893  mh->err = MPG123_NULL_BUFFER;
894  return MPG123_ERR;
895  }
896  }
897  return MPG123_OK;
898 #else
900  return MPG123_ERR;
901 #endif
902 }
903 
904 /*
905  The old picture:
906  while(1) {
907  len = read(0,buf,16384);
908  if(len <= 0)
909  break;
910  ret = decodeMP3(&mp,buf,len,out,8192,&size);
911  while(ret == MP3_OK) {
912  write(1,out,size);
913  ret = decodeMP3(&mp,NULL,0,out,8192,&size);
914  }
915  }
916 */
917 
918 int attribute_align_arg mpg123_decode(mpg123_handle *mh, const unsigned char *inmemory, size_t inmemsize, unsigned char *outmemory, size_t outmemsize, size_t *done)
919 {
920  int ret = MPG123_OK;
921  size_t mdone = 0;
922 
923  if(done != NULL) *done = 0;
924  if(mh == NULL) return MPG123_BAD_HANDLE;
925 #ifndef NO_FEEDER
926  if(inmemsize > 0 && mpg123_feed(mh, inmemory, inmemsize) != MPG123_OK)
927  {
928  ret = MPG123_ERR;
929  goto decodeend;
930  }
931  if(outmemory == NULL) outmemsize = 0; /* Not just give error, give chance to get a status message. */
932 
933  while(ret == MPG123_OK)
934  {
935  debug4("decode loop, fill %i (%li vs. %li); to_decode: %i", (int)mh->buffer.fill, (long)mh->num, (long)mh->firstframe, mh->to_decode);
936  /* Decode a frame that has been read before.
937  This only happens when buffer is empty! */
938  if(mh->to_decode)
939  {
940  if(mh->new_format)
941  {
942  debug("notifiying new format");
943  mh->new_format = 0;
945  goto decodeend;
946  }
947  if(mh->buffer.size - mh->buffer.fill < mh->outblock)
948  {
950  goto decodeend;
951  }
952  decode_the_frame(mh);
953  mh->to_decode = mh->to_ignore = FALSE;
954  mh->buffer.p = mh->buffer.data;
955  debug2("decoded frame %li, got %li samples in buffer", (long)mh->num, (long)(mh->buffer.fill / (samples_to_bytes(mh, 1))));
956  FRAME_BUFFERCHECK(mh);
957  }
958  if(mh->buffer.fill) /* Copy (part of) the decoded data to the caller's buffer. */
959  {
960  /* get what is needed - or just what is there */
961  int a = mh->buffer.fill > (outmemsize - mdone) ? outmemsize - mdone : mh->buffer.fill;
962  debug4("buffer fill: %i; copying %i (%i - %li)", (int)mh->buffer.fill, a, (int)outmemsize, (long)mdone);
963  memcpy(outmemory, mh->buffer.p, a);
964  /* less data in frame buffer, less needed, output pointer increase, more data given... */
965  mh->buffer.fill -= a;
966  outmemory += a;
967  mdone += a;
968  mh->buffer.p += a;
969  if(!(outmemsize > mdone)) goto decodeend;
970  }
971  else /* If we didn't have data, get a new frame. */
972  {
973  int b = get_next_frame(mh);
974  if(b < 0){ ret = b; goto decodeend; }
975  }
976  }
977 decodeend:
978  if(done != NULL) *done = mdone;
979  return ret;
980 #else
982  return MPG123_ERR;
983 #endif
984 }
985 
987 {
988  long ret = 0;
989 
990  if(mh != NULL)
991  {
992  ret = mh->clip;
993  mh->clip = 0;
994  }
995  return ret;
996 }
997 
998 /* Simples: Track needs initializtion if no initial frame has been read yet. */
999 #define track_need_init(mh) ((mh)->num < 0)
1000 
1001 static int init_track(mpg123_handle *mh)
1002 {
1003  if(track_need_init(mh))
1004  {
1005  /* Fresh track, need first frame for basic info. */
1006  int b = get_next_frame(mh);
1007  if(b < 0) return b;
1008  }
1009  return 0;
1010 }
1011 
1013 {
1014  int b;
1015 
1016  if(mh == NULL) return MPG123_BAD_HANDLE;
1017  if(mi == NULL)
1018  {
1019  mh->err = MPG123_ERR_NULL;
1020  return MPG123_ERR;
1021  }
1022  b = init_track(mh);
1023  if(b < 0) return b;
1024 
1025  mi->version = mh->mpeg25 ? MPG123_2_5 : (mh->lsf ? MPG123_2_0 : MPG123_1_0);
1026  mi->layer = mh->lay;
1027  mi->rate = frame_freq(mh);
1028  switch(mh->mode)
1029  {
1030  case 0: mi->mode = MPG123_M_STEREO; break;
1031  case 1: mi->mode = MPG123_M_JOINT; break;
1032  case 2: mi->mode = MPG123_M_DUAL; break;
1033  case 3: mi->mode = MPG123_M_MONO; break;
1034  default: error("That mode cannot be!");
1035  }
1036  mi->mode_ext = mh->mode_ext;
1037  mi->framesize = mh->framesize+4; /* Include header. */
1038  mi->flags = 0;
1039  if(mh->error_protection) mi->flags |= MPG123_CRC;
1040  if(mh->copyright) mi->flags |= MPG123_COPYRIGHT;
1041  if(mh->extension) mi->flags |= MPG123_PRIVATE;
1042  if(mh->original) mi->flags |= MPG123_ORIGINAL;
1043  mi->emphasis = mh->emphasis;
1044  mi->bitrate = frame_bitrate(mh);
1045  mi->abr_rate = mh->abr_rate;
1046  mi->vbr = mh->vbr;
1047  return MPG123_OK;
1048 }
1049 
1051 , long *rate, int *channels, int *encoding, int clear_flag )
1052 {
1053  int b;
1054 
1055  if(mh == NULL) return MPG123_BAD_HANDLE;
1056  b = init_track(mh);
1057  if(b < 0) return b;
1058 
1059  if(rate != NULL) *rate = mh->af.rate;
1060  if(channels != NULL) *channels = mh->af.channels;
1061  if(encoding != NULL) *encoding = mh->af.encoding;
1062  if(clear_flag) mh->new_format = 0;
1063  return MPG123_OK;
1064 }
1065 
1067 {
1068  return mpg123_getformat2(mh, rate, channels, encoding, 1);
1069 }
1070 
1072 {
1073  off_t b;
1074 
1075  if(mh == NULL) return MPG123_ERR;
1076  b = init_track(mh);
1077  if(b<0) return b;
1078  return (off_t)(seconds/mpg123_tpf(mh));
1079 }
1080 
1081 /*
1082  Now, where are we? We need to know the last decoded frame... and what's left of it in buffer.
1083  The current frame number can mean the last decoded frame or the to-be-decoded frame.
1084  If mh->to_decode, then mh->num frames have been decoded, the frame mh->num now coming next.
1085  If not, we have the possibility of mh->num+1 frames being decoded or nothing at all.
1086  Then, there is firstframe...when we didn't reach it yet, then the next data will come from there.
1087  mh->num starts with -1
1088 */
1090 {
1091  if(mh == NULL) return MPG123_ERR;
1092  if(track_need_init(mh)) return 0;
1093  /* Now we have all the info at hand. */
1094  debug5("tell: %li/%i first %li buffer %lu; frame_outs=%li", (long)mh->num, mh->to_decode, (long)mh->firstframe, (unsigned long)mh->buffer.fill, (long)frame_outs(mh, mh->num));
1095 
1096  { /* Funny block to keep C89 happy. */
1097  off_t pos = 0;
1098  if((mh->num < mh->firstframe) || (mh->num == mh->firstframe && mh->to_decode))
1099  { /* We are at the beginning, expect output from firstframe on. */
1100  pos = frame_outs(mh, mh->firstframe);
1101 #ifdef GAPLESS
1102  pos += mh->firstoff;
1103 #endif
1104  }
1105  else if(mh->to_decode)
1106  { /* We start fresh with this frame. Buffer should be empty, but we make sure to count it in. */
1107  pos = frame_outs(mh, mh->num) - bytes_to_samples(mh, mh->buffer.fill);
1108  }
1109  else
1110  { /* We serve what we have in buffer and then the beginning of next frame... */
1111  pos = frame_outs(mh, mh->num+1) - bytes_to_samples(mh, mh->buffer.fill);
1112  }
1113  /* Substract padding and delay from the beginning. */
1114  pos = SAMPLE_ADJUST(mh,pos);
1115  /* Negative sample offsets are not right, less than nothing is still nothing. */
1116  return pos>0 ? pos : 0;
1117  }
1118 }
1119 
1121 {
1122  if(mh == NULL) return MPG123_ERR;
1123  if(mh->num < mh->firstframe) return mh->firstframe;
1124  if(mh->to_decode) return mh->num;
1125  /* Consider firstoff? */
1126  return mh->buffer.fill ? mh->num : mh->num + 1;
1127 }
1128 
1130 {
1131  if(mh == NULL) return MPG123_ERR;
1132  /* mh->rd is at least a bad_reader, so no worry. */
1133  return mh->rd->tell(mh);
1134 }
1135 
1137 {
1138  int b;
1139  off_t fnum = SEEKFRAME(mh);
1140  mh->buffer.fill = 0;
1141 
1142  /* If we are inside the ignoreframe - firstframe window, we may get away without actual seeking. */
1143  if(mh->num < mh->firstframe)
1144  {
1145  mh->to_decode = FALSE; /* In any case, don't decode the current frame, perhaps ignore instead. */
1146  if(mh->num > fnum) return MPG123_OK;
1147  }
1148 
1149  /* If we are already there, we are fine either for decoding or for ignoring. */
1150  if(mh->num == fnum && (mh->to_decode || fnum < mh->firstframe)) return MPG123_OK;
1151  /* We have the frame before... just go ahead as normal. */
1152  if(mh->num == fnum-1)
1153  {
1154  mh->to_decode = FALSE;
1155  return MPG123_OK;
1156  }
1157 
1158  /* OK, real seeking follows... clear buffers and go for it. */
1159  frame_buffers_reset(mh);
1160 #ifndef NO_NTOM
1161  if(mh->down_sample == 3)
1162  {
1163  ntom_set_ntom(mh, fnum);
1164  debug3("fixed ntom for frame %"OFF_P" to %lu, num=%"OFF_P, (off_p)fnum, mh->ntom_val[0], (off_p)mh->num);
1165  }
1166 #endif
1167  b = mh->rd->seek_frame(mh, fnum);
1168  if(mh->header_change > 1)
1169  {
1170  if(decode_update(mh) < 0) return MPG123_ERR;
1171  mh->header_change = 0;
1172  }
1173  debug1("seek_frame returned: %i", b);
1174  if(b<0) return b;
1175  /* Only mh->to_ignore is TRUE. */
1176  if(mh->num < mh->firstframe) mh->to_decode = FALSE;
1177 
1178  mh->playnum = mh->num;
1179  return 0;
1180 }
1181 
1183 {
1184  int b;
1185  off_t pos;
1186 
1187  pos = mpg123_tell(mh); /* adjusted samples */
1188  /* pos < 0 also can mean that simply a former seek failed at the lower levels.
1189  In that case, we only allow absolute seeks. */
1190  if(pos < 0 && whence != SEEK_SET)
1191  { /* Unless we got the obvious error of NULL handle, this is a special seek failure. */
1192  if(mh != NULL) mh->err = MPG123_NO_RELSEEK;
1193  return MPG123_ERR;
1194  }
1195  if((b=init_track(mh)) < 0) return b;
1196  switch(whence)
1197  {
1198  case SEEK_CUR: pos += sampleoff; break;
1199  case SEEK_SET: pos = sampleoff; break;
1200  case SEEK_END:
1201  /* When we do not know the end already, we can try to find it. */
1202  if(mh->track_frames < 1 && (mh->rdat.flags & READER_SEEKABLE))
1203  mpg123_scan(mh);
1204  if(mh->track_frames > 0) pos = SAMPLE_ADJUST(mh,frame_outs(mh, mh->track_frames)) - sampleoff;
1205 #ifdef GAPLESS
1206  else if(mh->end_os > 0) pos = SAMPLE_ADJUST(mh,mh->end_os) - sampleoff;
1207 #endif
1208  else
1209  {
1211  return MPG123_ERR;
1212  }
1213  break;
1214  default: mh->err = MPG123_BAD_WHENCE; return MPG123_ERR;
1215  }
1216  if(pos < 0) pos = 0;
1217  /* pos now holds the wanted sample offset in adjusted samples */
1219  pos = do_the_seek(mh);
1220  if(pos < 0) return pos;
1221 
1222  return mpg123_tell(mh);
1223 }
1224 
1225 /*
1226  A bit more tricky... libmpg123 does not do the seeking itself.
1227  All it can do is to ignore frames until the wanted one is there.
1228  The caller doesn't know where a specific frame starts and mpg123 also only knows the general region after it scanned the file.
1229  Well, it is tricky...
1230 */
1231 off_t attribute_align_arg mpg123_feedseek(mpg123_handle *mh, off_t sampleoff, int whence, off_t *input_offset)
1232 {
1233  int b;
1234  off_t pos;
1235 
1236  pos = mpg123_tell(mh); /* adjusted samples */
1237  debug3("seek from %li to %li (whence=%i)", (long)pos, (long)sampleoff, whence);
1238  /* The special seek error handling does not apply here... there is no lowlevel I/O. */
1239  if(pos < 0) return pos; /* mh == NULL is covered in mpg123_tell() */
1240 #ifndef NO_FEEDER
1241  if(input_offset == NULL)
1242  {
1243  mh->err = MPG123_NULL_POINTER;
1244  return MPG123_ERR;
1245  }
1246 
1247  if((b=init_track(mh)) < 0) return b; /* May need more to do anything at all. */
1248 
1249  switch(whence)
1250  {
1251  case SEEK_CUR: pos += sampleoff; break;
1252  case SEEK_SET: pos = sampleoff; break;
1253  case SEEK_END:
1254  if(mh->track_frames > 0) pos = SAMPLE_ADJUST(mh,frame_outs(mh, mh->track_frames)) - sampleoff;
1255 #ifdef GAPLESS
1256  else if(mh->end_os >= 0) pos = SAMPLE_ADJUST(mh,mh->end_os) - sampleoff;
1257 #endif
1258  else
1259  {
1261  return MPG123_ERR;
1262  }
1263  break;
1264  default: mh->err = MPG123_BAD_WHENCE; return MPG123_ERR;
1265  }
1266  if(pos < 0) pos = 0;
1268  pos = SEEKFRAME(mh);
1269  mh->buffer.fill = 0;
1270 
1271  /* Shortcuts without modifying input stream. */
1272  *input_offset = mh->rdat.buffer.fileoff + mh->rdat.buffer.size;
1273  if(mh->num < mh->firstframe) mh->to_decode = FALSE;
1274  if(mh->num == pos && mh->to_decode) goto feedseekend;
1275  if(mh->num == pos-1) goto feedseekend;
1276  /* Whole way. */
1277  *input_offset = feed_set_pos(mh, frame_index_find(mh, SEEKFRAME(mh), &pos));
1278  mh->num = pos-1; /* The next read frame will have num = pos. */
1279  if(*input_offset < 0) return MPG123_ERR;
1280 
1281 feedseekend:
1282  return mpg123_tell(mh);
1283 #else
1285  return MPG123_ERR;
1286 #endif
1287 }
1288 
1290 {
1291  int b;
1292  off_t pos = 0;
1293 
1294  if(mh == NULL) return MPG123_ERR;
1295  if((b=init_track(mh)) < 0) return b;
1296 
1297  /* Could play games here with to_decode... */
1298  pos = mh->num;
1299  switch(whence)
1300  {
1301  case SEEK_CUR: pos += offset; break;
1302  case SEEK_SET: pos = offset; break;
1303  case SEEK_END:
1304  if(mh->track_frames > 0) pos = mh->track_frames - offset;
1305  else
1306  {
1308  return MPG123_ERR;
1309  }
1310  break;
1311  default:
1312  mh->err = MPG123_BAD_WHENCE;
1313  return MPG123_ERR;
1314  }
1315  if(pos < 0) pos = 0;
1316  /* Not limiting the possible position on end for the chance that there might be more to the stream than announced via track_frames. */
1317 
1318  frame_set_frameseek(mh, pos);
1319  pos = do_the_seek(mh);
1320  if(pos < 0) return pos;
1321 
1322  return mpg123_tellframe(mh);
1323 }
1324 
1326 {
1327  if(mh == NULL) return MPG123_BAD_HANDLE;
1328 
1329  mh->rdat.filelen = size;
1330  return MPG123_OK;
1331 }
1332 
1334 {
1335  int b;
1336  if(mh == NULL)
1337  return MPG123_ERR;
1338  b = init_track(mh);
1339  if(b<0)
1340  return b;
1341  if(mh->track_frames > 0)
1342  return mh->track_frames;
1343  if(mh->rdat.filelen > 0)
1344  { /* A bad estimate. Ignoring tags 'n stuff. */
1345  double bpf = mh->mean_framesize > 0.
1346  ? mh->mean_framesize
1347  : compute_bpf(mh);
1348  return (off_t)((double)(mh->rdat.filelen)/bpf+0.5);
1349  }
1350  /* Last resort: No view of the future, can at least count the frames that
1351  were already parsed. */
1352  if(mh->num > -1)
1353  return mh->num+1;
1354  /* Giving up. */
1355  return MPG123_ERR;
1356 }
1357 
1359 {
1360  int b;
1361  off_t length;
1362 
1363  if(mh == NULL) return MPG123_ERR;
1364  b = init_track(mh);
1365  if(b<0) return b;
1366  if(mh->track_samples > -1) length = mh->track_samples;
1367  else if(mh->track_frames > 0) length = mh->track_frames*mh->spf;
1368  else if(mh->rdat.filelen > 0) /* Let the case of 0 length just fall through. */
1369  {
1370  /* A bad estimate. Ignoring tags 'n stuff. */
1371  double bpf = mh->mean_framesize ? mh->mean_framesize : compute_bpf(mh);
1372  length = (off_t)((double)(mh->rdat.filelen)/bpf*mh->spf);
1373  }
1374  else if(mh->rdat.filelen == 0) return mpg123_tell(mh); /* we could be in feeder mode */
1375  else return MPG123_ERR; /* No length info there! */
1376 
1377  debug1("mpg123_length: internal sample length: %"OFF_P, (off_p)length);
1378 
1379  length = frame_ins2outs(mh, length);
1380  debug1("mpg123_length: external sample length: %"OFF_P, (off_p)length);
1381  length = SAMPLE_ADJUST(mh,length);
1382  return length;
1383 }
1384 
1385 
1387 {
1388  int b;
1389  off_t oldpos;
1390  off_t track_frames = 0;
1391  off_t track_samples = 0;
1392 
1393  if(mh == NULL) return MPG123_BAD_HANDLE;
1394  if(!(mh->rdat.flags & READER_SEEKABLE)){ mh->err = MPG123_NO_SEEK; return MPG123_ERR; }
1395  /* Scan through the _whole_ file, since the current position is no count but computed assuming constant samples per frame. */
1396  /* Also, we can just keep the current buffer and seek settings. Just operate on input frames here. */
1397  debug("issuing scan");
1398  b = init_track(mh); /* mh->num >= 0 !! */
1399  if(b<0)
1400  {
1401  if(b == MPG123_DONE) return MPG123_OK;
1402  else return MPG123_ERR; /* Must be error here, NEED_MORE is not for seekable streams. */
1403  }
1404  oldpos = mpg123_tell(mh);
1405  b = mh->rd->seek_frame(mh, 0);
1406  if(b<0 || mh->num != 0) return MPG123_ERR;
1407  /* One frame must be there now. */
1408  track_frames = 1;
1409  track_samples = mh->spf; /* Internal samples. */
1410  debug("TODO: We should disable gapless code when encountering inconsistent mh->spf!");
1411  debug(" ... at least unset MPG123_ACCURATE.");
1412  /* Do not increment mh->track_frames in the loop as tha would confuse Frankenstein detection. */
1413  while(read_frame(mh) == 1)
1414  {
1415  ++track_frames;
1416  track_samples += mh->spf;
1417  }
1418  mh->track_frames = track_frames;
1419  mh->track_samples = track_samples;
1420  debug2("Scanning yielded %"OFF_P" track samples, %"OFF_P" frames.", (off_p)mh->track_samples, (off_p)mh->track_frames);
1421 #ifdef GAPLESS
1422  /* Also, think about usefulness of that extra value track_samples ... it could be used for consistency checking. */
1423  if(mh->p.flags & MPG123_GAPLESS) frame_gapless_update(mh, mh->track_samples);
1424 #endif
1425  return mpg123_seek(mh, oldpos, SEEK_SET) >= 0 ? MPG123_OK : MPG123_ERR;
1426 }
1427 
1429 {
1430  if(mh != NULL) return mh->metaflags;
1431  else return 0;
1432 }
1433 
1435 {
1436  if(mh == NULL) return;
1437 
1438  reset_id3(mh);
1439  reset_icy(&mh->icy);
1440 }
1441 
1443 {
1444  if(v1 != NULL) *v1 = NULL;
1445  if(v2 != NULL) *v2 = NULL;
1446  if(mh == NULL) return MPG123_BAD_HANDLE;
1447 
1448  if(mh->metaflags & MPG123_ID3)
1449  {
1450  id3_link(mh);
1451  if(v1 != NULL && mh->rdat.flags & READER_ID3TAG) *v1 = (mpg123_id3v1*) mh->id3buf;
1452  if(v2 != NULL)
1453 #ifdef NO_ID3V2
1454  *v2 = NULL;
1455 #else
1456  *v2 = &mh->id3v2;
1457 #endif
1458 
1459  mh->metaflags |= MPG123_ID3;
1460  mh->metaflags &= ~MPG123_NEW_ID3;
1461  }
1462  return MPG123_OK;
1463 }
1464 
1466 {
1467  if(mh == NULL) return MPG123_BAD_HANDLE;
1468 #ifndef NO_ICY
1469  if(icy_meta == NULL)
1470  {
1471  mh->err = MPG123_NULL_POINTER;
1472  return MPG123_ERR;
1473  }
1474  *icy_meta = NULL;
1475 
1476  if(mh->metaflags & MPG123_ICY)
1477  {
1478  *icy_meta = mh->icy.data;
1479  mh->metaflags |= MPG123_ICY;
1480  mh->metaflags &= ~MPG123_NEW_ICY;
1481  }
1482  return MPG123_OK;
1483 #else
1485  return MPG123_ERR;
1486 #endif
1487 }
1488 
1489 char* attribute_align_arg mpg123_icy2utf8(const char* icy_text)
1490 {
1491 #ifndef NO_ICY
1492  return icy2utf8(icy_text, 0);
1493 #else
1494  return NULL;
1495 #endif
1496 }
1497 
1498 /* That one is always defined... it's not worth it to remove it for NO_ID3V2. */
1500 {
1501  switch(id3_enc_byte)
1502  {
1504  case mpg123_id3_utf16bom: return mpg123_text_utf16bom; /* ID3v2.3 has UCS-2 with BOM here. */
1506  case mpg123_id3_utf8: return mpg123_text_utf8;
1507  default: return mpg123_text_unknown;
1508  }
1509 }
1510 
1511 #ifndef NO_STRING
1512 int mpg123_store_utf8(mpg123_string *sb, enum mpg123_text_encoding enc, const unsigned char *source, size_t source_size)
1513 {
1514  switch(enc)
1515  {
1516 #ifndef NO_ID3V2
1517  /* The encodings we get from ID3v2 tags. */
1518  case mpg123_text_utf8:
1519  id3_to_utf8(sb, mpg123_id3_utf8, source, source_size, 0);
1520  break;
1521  case mpg123_text_latin1:
1522  id3_to_utf8(sb, mpg123_id3_latin1, source, source_size, 0);
1523  break;
1524  case mpg123_text_utf16bom:
1525  case mpg123_text_utf16:
1526  id3_to_utf8(sb, mpg123_id3_utf16bom, source, source_size, 0);
1527  break;
1528  /* Special because one cannot skip zero bytes here. */
1529  case mpg123_text_utf16be:
1530  id3_to_utf8(sb, mpg123_id3_utf16be, source, source_size, 0);
1531  break;
1532 #endif
1533 #ifndef NO_ICY
1534  /* ICY encoding... */
1535  case mpg123_text_icy:
1536  case mpg123_text_cp1252:
1537  {
1539  /* Paranoia: Make sure that the string ends inside the buffer... */
1540  if(source[source_size-1] == 0)
1541  {
1542  /* Convert from ICY encoding... with force applied or not. */
1543  char *tmpstring = icy2utf8((const char*)source, enc == mpg123_text_cp1252 ? 1 : 0);
1544  if(tmpstring != NULL)
1545  {
1546  mpg123_set_string(sb, tmpstring);
1547  free(tmpstring);
1548  }
1549  }
1550  }
1551  break;
1552 #endif
1553  default:
1555  }
1556  /* At least a trailing null of some form should be there... */
1557  return (sb->fill > 0) ? 1 : 0;
1558 }
1559 #endif
1560 
1561 int attribute_align_arg mpg123_index(mpg123_handle *mh, off_t **offsets, off_t *step, size_t *fill)
1562 {
1563  if(mh == NULL) return MPG123_BAD_HANDLE;
1564  if(offsets == NULL || step == NULL || fill == NULL)
1565  {
1566  mh->err = MPG123_BAD_INDEX_PAR;
1567  return MPG123_ERR;
1568  }
1569 #ifdef FRAME_INDEX
1570  *offsets = mh->index.data;
1571  *step = mh->index.step;
1572  *fill = mh->index.fill;
1573 #else
1574  *offsets = NULL;
1575  *step = 0;
1576  *fill = 0;
1577 #endif
1578  return MPG123_OK;
1579 }
1580 
1582 {
1583  if(mh == NULL) return MPG123_BAD_HANDLE;
1584 #ifdef FRAME_INDEX
1585  if(step == 0)
1586  {
1587  mh->err = MPG123_BAD_INDEX_PAR;
1588  return MPG123_ERR;
1589  }
1590  if(fi_set(&mh->index, offsets, step, fill) == -1)
1591  {
1592  mh->err = MPG123_OUT_OF_MEM;
1593  return MPG123_ERR;
1594  }
1595  return MPG123_OK;
1596 #else
1598  return MPG123_ERR;
1599 #endif
1600 }
1601 
1603 {
1604  if(mh == NULL) return MPG123_BAD_HANDLE;
1605 
1606  /* mh->rd is never NULL! */
1607  if(mh->rd->close != NULL) mh->rd->close(mh);
1608 
1609  if(mh->new_format)
1610  {
1611  debug("Hey, we are closing a track before the new format has been queried...");
1612  invalidate_format(&mh->af);
1613  mh->new_format = 0;
1614  }
1615  /* Always reset the frame buffers on close, so we cannot forget it in funky opening routines (wrappers, even). */
1616  frame_reset(mh);
1617  return MPG123_OK;
1618 }
1619 
1621 {
1622  if(mh != NULL)
1623  {
1624  mpg123_close(mh);
1625  frame_exit(mh); /* free buffers in frame */
1626  free(mh); /* free struct; cast? */
1627  }
1628 }
1629 
1630 static const char *mpg123_error[] =
1631 {
1632  "No error... (code 0)",
1633  "Unable to set up output format! (code 1)",
1634  "Invalid channel number specified. (code 2)",
1635  "Invalid sample rate specified. (code 3)",
1636  "Unable to allocate memory for 16 to 8 converter table! (code 4)",
1637  "Bad parameter id! (code 5)",
1638  "Bad buffer given -- invalid pointer or too small size. (code 6)",
1639  "Out of memory -- some malloc() failed. (code 7)",
1640  "You didn't initialize the library! (code 8)",
1641  "Invalid decoder choice. (code 9)",
1642  "Invalid mpg123 handle. (code 10)",
1643  "Unable to initialize frame buffers (out of memory?)! (code 11)",
1644  "Invalid RVA mode. (code 12)",
1645  "This build doesn't support gapless decoding. (code 13)",
1646  "Not enough buffer space. (code 14)",
1647  "Incompatible numeric data types. (code 15)",
1648  "Bad equalizer band. (code 16)",
1649  "Null pointer given where valid storage address needed. (code 17)",
1650  "Error reading the stream. (code 18)",
1651  "Cannot seek from end (end is not known). (code 19)",
1652  "Invalid 'whence' for seek function. (code 20)",
1653  "Build does not support stream timeouts. (code 21)",
1654  "File access error. (code 22)",
1655  "Seek not supported by stream. (code 23)",
1656  "No stream opened. (code 24)",
1657  "Bad parameter handle. (code 25)",
1658  "Invalid parameter addresses for index retrieval. (code 26)",
1659  "Lost track in the bytestream and did not attempt resync. (code 27)",
1660  "Failed to find valid MPEG data within limit on resync. (code 28)",
1661  "No 8bit encoding possible. (code 29)",
1662  "Stack alignment is not good. (code 30)",
1663  "You gave me a NULL buffer? (code 31)",
1664  "File position is screwed up, please do an absolute seek (code 32)",
1665  "Inappropriate NULL-pointer provided.",
1666  "Bad key value given.",
1667  "There is no frame index (disabled in this build).",
1668  "Frame index operation failed.",
1669  "Decoder setup failed (invalid combination of settings?)",
1670  "Feature not in this build."
1671  ,"Some bad value has been provided."
1672  ,"Low-level seeking has failed (call to lseek(), usually)."
1673  ,"Custom I/O obviously not prepared."
1674  ,"Overflow in LFS (large file support) conversion."
1675  ,"Overflow in integer conversion."
1676 };
1677 
1679 {
1680  if(errcode >= 0 && errcode < sizeof(mpg123_error)/sizeof(char*))
1681  return mpg123_error[errcode];
1682  else switch(errcode)
1683  {
1684  case MPG123_ERR:
1685  return "A generic mpg123 error.";
1686  case MPG123_DONE:
1687  return "Message: I am done with this track.";
1688  case MPG123_NEED_MORE:
1689  return "Message: Feed me more input data!";
1690  case MPG123_NEW_FORMAT:
1691  return "Message: Prepare for a changed audio format (query the new one)!";
1692  default:
1693  return "I have no idea - an unknown error code!";
1694  }
1695 }
1696 
1698 {
1699  if(mh != NULL) return mh->err;
1700  return MPG123_BAD_HANDLE;
1701 }
1702 
1704 {
1706 }
real equalizer[2][32]
Definition: frame.h:126
#define frame_outs
Definition: intsym.h:188
off_t attribute_align_arg mpg123_timeframe(mpg123_handle *mh, double seconds)
Definition: libmpg123.c:1071
int attribute_align_arg mpg123_decode(mpg123_handle *mh, const unsigned char *inmemory, size_t inmemsize, unsigned char *outmemory, size_t outmemsize, size_t *done)
Definition: libmpg123.c:918
#define frame_init_par
Definition: intsym.h:169
int attribute_align_arg mpg123_par(mpg123_pars *mp, enum mpg123_parms key, long val, double fval)
Definition: libmpg123.c:150
int decode_update(mpg123_handle *mh)
Definition: libmpg123.c:506
#define SEEK_CUR
Definition: util.h:63
long index_size
Definition: frame.h:81
int attribute_align_arg mpg123_id3(mpg123_handle *mh, mpg123_id3v1 **v1, mpg123_id3v2 **v2)
Definition: libmpg123.c:1442
#define TRUE
Definition: types.h:120
int attribute_align_arg mpg123_getformat2(mpg123_handle *mh, long *rate, int *channels, int *encoding, int clear_flag)
Definition: libmpg123.c:1050
#define READER_SEEKABLE
Definition: reader.h:115
static int initialized
Definition: libmpg123.c:20
Definition: icy.h:16
int attribute_align_arg mpg123_open_feed(mpg123_handle *mh)
Definition: libmpg123.c:468
#define prepare_decode_tables
Definition: intsym.h:155
off_t attribute_align_arg mpg123_feedseek(mpg123_handle *mh, off_t sampleoff, int whence, off_t *input_offset)
Definition: libmpg123.c:1231
#define reset_id3
Definition: intsym.h:203
#define frame_reset
Definition: intsym.h:173
double attribute_align_arg mpg123_geteq(mpg123_handle *mh, enum mpg123_channels channel, int band)
Definition: libmpg123.c:418
long preframes
Definition: frame.h:82
struct mpg123_pars_struct p
Definition: frame.h:287
#define error(str)
Definition: mkdosfs.c:1605
struct mpg123_handle_struct::@3290 cpu_opts
long feedbuffer
Definition: frame.h:85
#define DOUBLE_TO_REAL(x)
mpg123_parms
Definition: mpg123.h:168
int attribute_align_arg mpg123_errcode(mpg123_handle *mh)
Definition: libmpg123.c:1697
#define frame_expect_outsamples
Definition: intsym.h:185
char *attribute_align_arg mpg123_icy2utf8(const char *icy_text)
Definition: libmpg123.c:1489
superblock * sb
Definition: btrfs.c:3876
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define reset_icy
Definition: intsym.h:200
#define SINGLE_STEREO
Definition: frame.h:187
#define open_feed
Definition: intsym.h:243
#define invalidate_format
Definition: intsym.h:167
off_t attribute_align_arg mpg123_tell_stream(mpg123_handle *mh)
Definition: libmpg123.c:1129
int attribute_align_arg mpg123_getformat(mpg123_handle *mh, long *rate, int *channels, int *encoding)
Definition: libmpg123.c:1066
#define free
Definition: debug_ros.c:5
__kernel_off_t off_t
Definition: linux.h:201
#define SBLIMIT
GLintptr offset
Definition: glext.h:5920
double mean_framesize
Definition: frame.h:246
off_t attribute_align_arg mpg123_tell(mpg123_handle *mh)
Definition: libmpg123.c:1089
#define debug4(s, a, b, c, d)
Definition: debug.h:55
#define frame_index_find
Definition: intsym.h:176
#define NTOM_MUL
Definition: decode.h:32
_Tp _STLP_CALL real(const complex< _Tp > &__z)
Definition: _complex.h:727
mpg123_handle attribute_align_arg * mpg123_new(const char *decoder, int *error)
Definition: libmpg123.c:55
struct outbuffer buffer
Definition: frame.h:265
MPG123_EXPORT void mpg123_free_string(mpg123_string *sb)
Definition: stringbuf.c:25
int This channels
Definition: rdpsnd_libao.c:37
static int fd
Definition: io.c:51
#define frame_exit
Definition: intsym.h:175
long icy_interval
Definition: frame.h:77
static MONITORINFO mi
Definition: win.c:7331
#define open_stream_handle
Definition: intsym.h:242
int rate
Definition: pcmconverter.c:98
#define debug2(s, a, b)
Definition: debug.h:53
#define outblock_bytes
Definition: intsym.h:219
long doublespeed
Definition: frame.h:70
int attribute_align_arg mpg123_init(void)
Definition: libmpg123.c:22
#define id3_to_utf8
Definition: intsym.h:206
struct reader_data rdat
Definition: frame.h:286
#define frame_skip
Definition: intsym.h:186
#define debug3(s, a, b, c)
Definition: debug.h:54
#define set_synth_functions
Definition: intsym.h:222
#define SAMPLE_ADJUST(mh, x)
Definition: gapless.h:109
long halfspeed
Definition: frame.h:69
#define id3_link
Definition: intsym.h:204
static void decode_the_frame(mpg123_handle *fr)
Definition: libmpg123.c:707
int attribute_align_arg mpg123_framebyframe_decode(mpg123_handle *mh, off_t *num, unsigned char **audio, size_t *bytes)
Definition: libmpg123.c:760
int down_sample_sblimit
Definition: frame.h:193
int attribute_align_arg mpg123_eq(mpg123_handle *mh, enum mpg123_channels channel, int band, double val)
Definition: libmpg123.c:397
off_t track_frames
Definition: frame.h:244
#define MPG123_NEW_ICY
Definition: mpg123.h:1243
#define dectype
Definition: intsym.h:223
int attribute_align_arg mpg123_icy(mpg123_handle *mh, char **icy_meta)
Definition: libmpg123.c:1465
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
size_t attribute_align_arg mpg123_outblock(mpg123_handle *mh)
Definition: libmpg123.c:583
int attribute_align_arg mpg123_param(mpg123_handle *mh, enum mpg123_parms key, long val, double fval)
Definition: libmpg123.c:125
int attribute_align_arg mpg123_feed(mpg123_handle *mh, const unsigned char *in, size_t size)
Definition: libmpg123.c:873
#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 a
Definition: ke_i.h:78
#define REAL_TO_DOUBLE(x)
int attribute_align_arg mpg123_getparam(mpg123_handle *mh, enum mpg123_parms key, long *val, double *fval)
Definition: libmpg123.c:262
int attribute_align_arg mpg123_close(mpg123_handle *mh)
Definition: libmpg123.c:1602
MPG123_EXPORT double mpg123_tpf(mpg123_handle *mh)
Definition: parse.c:902
#define frame_set_seek
Definition: intsym.h:192
#define bc_poolsize
Definition: intsym.h:239
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
struct icy_meta icy
Definition: frame.h:299
#define postprocess_buffer
Definition: intsym.h:220
#define decoder_synth_bytes
Definition: intsym.h:216
#define VERBOSE2
smooth NULL
Definition: ftsmooth.c:416
int attribute_align_arg mpg123_info(mpg123_handle *mh, struct mpg123_frameinfo *mi)
Definition: libmpg123.c:1012
static int zero_byte(mpg123_handle *fr)
Definition: libmpg123.c:694
unsigned char * conv16to8
Definition: frame.h:134
void attribute_align_arg mpg123_delete(mpg123_handle *mh)
Definition: libmpg123.c:1620
MPG123_EXPORT int mpg123_set_string(mpg123_string *sb, const char *stuff)
Definition: stringbuf.c:141
#define off_t
Definition: dosfsck.h:5
ssize_t(* r_read)(int, void *, size_t)
Definition: lfs_wrap.c:85
const char *attribute_align_arg mpg123_plain_strerror(int errcode)
Definition: libmpg123.c:1678
mpg123_handle attribute_align_arg * mpg123_parnew(mpg123_pars *mp, const char *decoder, int *error)
Definition: libmpg123.c:61
#define b
Definition: ke_i.h:79
#define error2(s, a, b)
Definition: debug.h:110
GLuint GLfloat * val
Definition: glext.h:7180
int(* do_layer)(mpg123_handle *)
Definition: frame.h:201
static const char * mpg123_error[]
Definition: libmpg123.c:1630
#define SEEK_SET
Definition: jmemansi.c:26
off_t attribute_align_arg mpg123_tellframe(mpg123_handle *mh)
Definition: libmpg123.c:1120
#define READER_ID3TAG
Definition: reader.h:114
#define frame_outbuffer
Definition: intsym.h:170
int errcode
Definition: crtdefs.h:352
GLfloat f
Definition: glext.h:7540
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define MPG123_ID3
Definition: mpg123.h:1240
unsigned long size_p
Definition: compat.h:138
GLsizeiptr size
Definition: glext.h:5919
#define open_stream
Definition: intsym.h:241
#define fi_set
Definition: intsym.h:211
int attribute_align_arg mpg123_replace_reader_handle(mpg123_handle *mh, ssize_t(*r_read)(void *, void *, size_t), off_t(*r_lseek)(void *, off_t, int), void(*cleanup)(void *))
Definition: libmpg123.c:488
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
_STLP_MOVE_TO_STD_NAMESPACE void fill(_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
Definition: _algobase.h:449
off_t attribute_align_arg mpg123_framelength(mpg123_handle *mh)
Definition: libmpg123.c:1333
off_t attribute_align_arg mpg123_seek(mpg123_handle *mh, off_t sampleoff, int whence)
Definition: libmpg123.c:1182
void attribute_align_arg mpg123_meta_free(mpg123_handle *mh)
Definition: libmpg123.c:1434
static FILE * out
Definition: regtests2xml.c:44
long force_rate
Definition: frame.h:65
GLuint GLuint num
Definition: glext.h:9618
int attribute_align_arg mpg123_open(mpg123_handle *mh, const char *path)
Definition: libmpg123.c:439
#define samples_to_bytes
Definition: intsym.h:217
int attribute_align_arg mpg123_framebyframe_next(mpg123_handle *mh)
Definition: libmpg123.c:791
#define feed_more
Definition: intsym.h:244
int attribute_align_arg mpg123_decoder(mpg123_handle *mh, const char *decoder)
Definition: libmpg123.c:90
enum mpg123_text_encoding attribute_align_arg mpg123_enc_from_id3(unsigned char id3_enc_byte)
Definition: libmpg123.c:1499
long(* r_lseek)(int, long, int)
Definition: lfs_wrap.c:86
#define NOQUIET
int attribute_align_arg mpg123_set_index(mpg123_handle *mh, off_t *offsets, off_t step, size_t fill)
Definition: libmpg123.c:1581
optdec
Definition: optimize.h:94
int ret
#define init_layer12
Definition: intsym.h:152
int attribute_align_arg mpg123_read(mpg123_handle *mh, unsigned char *out, size_t size, size_t *done)
Definition: libmpg123.c:868
int frame_index_setup(mpg123_handle *fr)
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
int ssize_t
Definition: rosdhcp.h:48
int attribute_align_arg mpg123_meta_check(mpg123_handle *mh)
Definition: libmpg123.c:1428
#define err(...)
unsigned long ntom_val[2]
Definition: frame.h:148
#define frame_ins2outs
Definition: intsym.h:187
void frame_gapless_realinit(mpg123_handle *fr)
#define SEEKFRAME(mh)
Definition: libmpg123.c:18
#define feed_set_pos
Definition: intsym.h:246
ed encoding
Definition: write.c:2847
#define SHORT_SCALE
long resync_limit
Definition: frame.h:80
#define synth_ntom_set_step
Definition: intsym.h:143
long attribute_align_arg mpg123_clip(mpg123_handle *mh)
Definition: libmpg123.c:986
mpg123_text_encoding
Definition: mpg123.h:1101
size_t attribute_align_arg mpg123_safe_buffer(void)
Definition: libmpg123.c:577
mpg123_id3v2 id3v2
Definition: frame.h:296
int attribute_align_arg mpg123_open_handle(mpg123_handle *mh, void *iohandle)
Definition: libmpg123.c:455
int attribute_align_arg mpg123_scan(mpg123_handle *mh)
Definition: libmpg123.c:1386
#define MPG123_ICY
Definition: mpg123.h:1242
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
#define icy2utf8
Definition: intsym.h:197
int attribute_align_arg mpg123_replace_reader(mpg123_handle *mh, ssize_t(*r_read)(int, void *, size_t), off_t(*r_lseek)(int, off_t, int))
Definition: libmpg123.c:476
#define compute_bpf
Definition: intsym.h:234
int attribute_align_arg mpg123_getpar(mpg123_pars *mp, enum mpg123_parms key, long *val, double *fval)
Definition: libmpg123.c:272
const char *attribute_align_arg mpg123_strerror(mpg123_handle *mh)
Definition: libmpg123.c:1703
struct audioformat af
Definition: frame.h:266
GLuint in
Definition: glext.h:9616
#define read_frame
Definition: intsym.h:231
int mpg123_store_utf8(mpg123_string *sb, enum mpg123_text_encoding enc, const unsigned char *source, size_t source_size)
Definition: libmpg123.c:1512
#define NTOM_MAX
Definition: decode.h:30
unsigned char id3buf[128]
Definition: frame.h:294
#define SAMPLE_UNADJUST(mh, x)
Definition: gapless.h:110
#define long
Definition: qsort.c:33
#define frame_buffers_reset
Definition: intsym.h:174
#define SIZE_P
Definition: compat.h:137
Definition: services.c:325
off_t attribute_align_arg mpg123_length(mpg123_handle *mh)
Definition: libmpg123.c:1358
int attribute_align_arg mpg123_index(mpg123_handle *mh, off_t **offsets, off_t *step, size_t *fill)
Definition: libmpg123.c:1561
static int init_track(mpg123_handle *mh)
Definition: libmpg123.c:1001
struct frame_index index
Definition: frame.h:261
static int do_the_seek(mpg123_handle *mh)
Definition: libmpg123.c:1136
mpg123_state
Definition: mpg123.h:978
static int get_next_frame(mpg123_handle *mh)
Definition: libmpg123.c:592
#define frame_set_frameseek
Definition: intsym.h:191
void attribute_align_arg mpg123_exit(void)
Definition: libmpg123.c:49
double outscale
Definition: frame.h:79
off_t attribute_align_arg mpg123_seek_frame(mpg123_handle *mh, off_t offset, int whence)
Definition: libmpg123.c:1289
long off_p
Definition: compat.h:130
mpg123_channels
Definition: mpg123.h:799
FILE * stderr
#define SEEK_END
Definition: cabinet.c:27
char * cleanup(char *str)
Definition: wpickclick.c:99
#define debug(msg)
Definition: key_call.c:71
#define frame_cpu_opt
Definition: intsym.h:221
int attribute_align_arg mpg123_set_filesize(mpg123_handle *mh, off_t size)
Definition: libmpg123.c:1325
#define malloc
Definition: debug_ros.c:4
#define frame_bitrate
Definition: intsym.h:228
struct reader * rd
Definition: frame.h:285
#define init_layer3
Definition: intsym.h:149
#define debug5(s, a, b, c, d, e)
Definition: debug.h:56
#define bc_fill
Definition: intsym.h:240
int attribute_align_arg mpg123_open_fd(mpg123_handle *mh, int fd)
Definition: libmpg123.c:447
#define do_rva
Definition: intsym.h:179
void frame_gapless_update(mpg123_handle *mh, off_t total_samples)
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
#define attribute_align_arg
Definition: abi_align.h:30
off_t track_samples
Definition: frame.h:245
#define bytes_to_samples
Definition: intsym.h:218
#define frame_freq
Definition: intsym.h:229
#define frame_output_format
Definition: intsym.h:171
#define memset(x, y, z)
Definition: compat.h:39
#define FRAME_BUFFERCHECK(mh)
Definition: gapless.h:111
#define debug1(s, a)
Definition: debug.h:52
GLfloat GLfloat v1
Definition: glext.h:6062
#define track_need_init(mh)
Definition: libmpg123.c:999
#define SINGLE_MIX
Definition: frame.h:190
int attribute_align_arg mpg123_decode_frame(mpg123_handle *mh, off_t *num, unsigned char **audio, size_t *bytes)
Definition: libmpg123.c:829
#define OFF_P
Definition: compat.h:129
#define ntom_set_ntom
Definition: intsym.h:21
enum mpg123_vbr vbr
Definition: frame.h:214
int attribute_align_arg mpg123_getstate(mpg123_handle *mh, enum mpg123_state key, long *val, double *fval)
Definition: libmpg123.c:351
Definition: path.c:42
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define check_decoders
Definition: intsym.h:226