ReactOS  0.4.14-dev-98-gb0d4763
frame.c
Go to the documentation of this file.
1 /*
2  frame: Heap of routines dealing with the core mpg123 data structure.
3 
4  copyright 2008-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 Thomas Orgis
7 */
8 
9 #include "mpg123lib_intern.h"
10 #include "getcpuflags.h"
11 #include "debug.h"
12 
13 static void frame_fixed_reset(mpg123_handle *fr);
14 
15 /* that's doubled in decode_ntom.c */
16 #define NTOM_MUL (32768)
17 
18 #define aligned_pointer(p, type, alignment) align_the_pointer(p, alignment)
19 static void *align_the_pointer(void *base, unsigned int alignment)
20 {
21  /*
22  Work in unsigned integer realm, explicitly.
23  Tricking the compiler into integer operations like % by invoking base-NULL is dangerous: It results into ptrdiff_t, which gets negative on big addresses. Big screw up, that.
24  I try to do it "properly" here: Casting only to uintptr_t and no artihmethic with void*.
25  */
26  uintptr_t baseval = (uintptr_t)(char*)base;
27  uintptr_t aoff = baseval % alignment;
28 
29  debug3("align_the_pointer: pointer %p is off by %u from %u",
30  base, (unsigned int)aoff, alignment);
31 
32  if(aoff) return (char*)base+alignment-aoff;
33  else return base;
34 }
35 
37 {
38  mp->outscale = 1.0;
39  mp->flags = 0;
40 #ifdef GAPLESS
41  mp->flags |= MPG123_GAPLESS;
42 #endif
44 #ifndef NO_NTOM
45  mp->force_rate = 0;
46 #endif
47  mp->down_sample = 0;
48  mp->rva = 0;
49  mp->halfspeed = 0;
50  mp->doublespeed = 0;
51  mp->verbose = 0;
52 #ifndef NO_ICY
53  mp->icy_interval = 0;
54 #endif
55  mp->timeout = 0;
56  mp->resync_limit = 1024;
57 #ifdef FRAME_INDEX
58  mp->index_size = INDEX_SIZE;
59 #endif
60  mp->preframes = 4; /* That's good for layer 3 ISO compliance bitstream. */
61  mpg123_fmt_all(mp);
62  /* Default of keeping some 4K buffers at hand, should cover the "usual" use case (using 16K pipe buffers as role model). */
63 #ifndef NO_FEEDER
64  mp->feedpool = 5;
65  mp->feedbuffer = 4096;
66 #endif
67 }
68 
70 {
71  frame_init_par(fr, NULL);
72 }
73 
75 {
76  fr->own_buffer = TRUE;
77  fr->buffer.data = NULL;
78  fr->buffer.rdata = NULL;
79  fr->buffer.fill = 0;
80  fr->buffer.size = 0;
81  fr->rawbuffs = NULL;
82  fr->rawbuffss = 0;
83  fr->rawdecwin = NULL;
84  fr->rawdecwins = 0;
85 #ifndef NO_8BIT
86  fr->conv16to8_buf = NULL;
87 #endif
88 #ifdef OPT_DITHER
89  fr->dithernoise = NULL;
90 #endif
91  fr->layerscratch = NULL;
92  fr->xing_toc = NULL;
93  fr->cpu_opts.type = defdec();
94  fr->cpu_opts.class = decclass(fr->cpu_opts.type);
95 #ifndef NO_NTOM
96  /* these two look unnecessary, check guarantee for synth_ntom_set_step (in control_generic, even)! */
97  fr->ntom_val[0] = NTOM_MUL>>1;
98  fr->ntom_val[1] = NTOM_MUL>>1;
99  fr->ntom_step = NTOM_MUL;
100 #endif
101  /* unnecessary: fr->buffer.size = fr->buffer.fill = 0; */
102  mpg123_reset_eq(fr);
103  init_icy(&fr->icy);
104  init_id3(fr);
105  /* frame_outbuffer is missing... */
106  /* frame_buffers is missing... that one needs cpu opt setting! */
107  /* after these... frame_reset is needed before starting full decode */
108  invalidate_format(&fr->af);
109  fr->rdat.r_read = NULL;
110  fr->rdat.r_lseek = NULL;
111  fr->rdat.iohandle = NULL;
112  fr->rdat.r_read_handle = NULL;
113  fr->rdat.r_lseek_handle = NULL;
114  fr->rdat.cleanup_handle = NULL;
115  fr->wrapperdata = NULL;
116  fr->wrapperclean = NULL;
117  fr->decoder_change = 1;
118  fr->err = MPG123_OK;
119  if(mp == NULL) frame_default_pars(&fr->p);
120  else memcpy(&fr->p, mp, sizeof(struct mpg123_pars_struct));
121 
122 #ifndef NO_FEEDER
123  bc_prepare(&fr->rdat.buffer, fr->p.feedpool, fr->p.feedbuffer);
124 #endif
125 
126  fr->down_sample = 0; /* Initialize to silence harmless errors when debugging. */
127  frame_fixed_reset(fr); /* Reset only the fixed data, dynamic buffers are not there yet! */
128  fr->synth = NULL;
129  fr->synth_mono = NULL;
130  fr->make_decode_tables = NULL;
131 #ifdef FRAME_INDEX
132  fi_init(&fr->index);
133  frame_index_setup(fr); /* Apply the size setting. */
134 #endif
135 }
136 
137 #ifdef OPT_DITHER
138 /* Also, only allocate the memory for the table on demand.
139  In future, one could create special noise for different sampling frequencies(?). */
141 {
142  /* run-time dither noise table generation */
143  if(fr->dithernoise == NULL)
144  {
145  fr->dithernoise = malloc(sizeof(float)*DITHERSIZE);
146  if(fr->dithernoise == NULL) return 0;
147 
148  dither_table_init(fr->dithernoise);
149  }
150  return 1;
151 }
152 #endif
153 
155 {
156  mpg123_pars *mp = malloc(sizeof(struct mpg123_pars_struct));
157  if(mp != NULL){ frame_default_pars(mp); if(error != NULL) *error = MPG123_OK; }
158  else if(error != NULL) *error = MPG123_OUT_OF_MEM;
159  return mp;
160 }
161 
163 {
164  if(mp != NULL) free(mp);
165 }
166 
168 {
169  int i;
170  if(mh == NULL) return MPG123_BAD_HANDLE;
171 #ifndef NO_EQUALIZER
172  mh->have_eq_settings = 0;
173  for(i=0; i < 32; ++i) mh->equalizer[0][i] = mh->equalizer[1][i] = DOUBLE_TO_REAL(1.0);
174 #endif
175  return MPG123_OK;
176 }
177 
179 {
180  size_t size = fr->outblock;
181  if(!fr->own_buffer)
182  {
183  if(fr->buffer.size < size)
184  {
185  fr->err = MPG123_BAD_BUFFER;
186  if(NOQUIET) error2("have external buffer of size %"SIZE_P", need %"SIZE_P, (size_p)fr->buffer.size, (size_p)size);
187 
188  return MPG123_ERR;
189  }
190  }
191 
192  debug1("need frame buffer of %"SIZE_P, (size_p)size);
193  if(fr->buffer.rdata != NULL && fr->buffer.size != size)
194  {
195  free(fr->buffer.rdata);
196  fr->buffer.rdata = NULL;
197  }
198  fr->buffer.size = size;
199  fr->buffer.data = NULL;
200  /* be generous: use 16 byte alignment */
201  if(fr->buffer.rdata == NULL) fr->buffer.rdata = (unsigned char*) malloc(fr->buffer.size+15);
202  if(fr->buffer.rdata == NULL)
203  {
204  fr->err = MPG123_OUT_OF_MEM;
205  return MPG123_ERR;
206  }
207  fr->buffer.data = aligned_pointer(fr->buffer.rdata, unsigned char*, 16);
208  fr->own_buffer = TRUE;
209  fr->buffer.fill = 0;
210  return MPG123_OK;
211 }
212 
214 {
215  debug2("replace buffer with %p size %"SIZE_P, data, (size_p)size);
216  if(mh == NULL) return MPG123_BAD_HANDLE;
217  /* Will accept any size, the error comes later... */
218  if(data == NULL)
219  {
220  mh->err = MPG123_BAD_BUFFER;
221  return MPG123_ERR;
222  }
223  if(mh->buffer.rdata != NULL) free(mh->buffer.rdata);
224  mh->own_buffer = FALSE;
225  mh->buffer.rdata = NULL;
226  mh->buffer.data = data;
227  mh->buffer.size = size;
228  mh->buffer.fill = 0;
229  return MPG123_OK;
230 }
231 
232 #ifdef FRAME_INDEX
234 {
235  int ret = MPG123_ERR;
236  if(fr->p.index_size >= 0)
237  { /* Simple fixed index. */
238  fr->index.grow_size = 0;
239  debug1("resizing index to %li", fr->p.index_size);
240  ret = fi_resize(&fr->index, (size_t)fr->p.index_size);
241  debug2("index resized... %lu at %p", (unsigned long)fr->index.size, (void*)fr->index.data);
242  }
243  else
244  { /* A growing index. We give it a start, though. */
245  fr->index.grow_size = (size_t)(- fr->p.index_size);
246  if(fr->index.size < fr->index.grow_size)
247  ret = fi_resize(&fr->index, fr->index.grow_size);
248  else
249  ret = MPG123_OK; /* We have minimal size already... and since growing is OK... */
250  }
251  debug2("set up frame index of size %lu (ret=%i)", (unsigned long)fr->index.size, ret);
252 
253  return ret;
254 }
255 #endif
256 
258 {
259  if(fr->rawbuffs) /* memset(NULL, 0, 0) not desired */
260  memset(fr->rawbuffs, 0, fr->rawbuffss);
261 }
262 
264 {
265  int buffssize = 0;
266  debug1("frame %p buffer", (void*)fr);
267 /*
268  the used-to-be-static buffer of the synth functions, has some subtly different types/sizes
269 
270  2to1, 4to1, ntom, generic, i386: real[2][2][0x110]
271  mmx, sse: short[2][2][0x110]
272  i586(_dither): 4352 bytes; int/long[2][2][0x110]
273  i486: int[2][2][17*FIR_BUFFER_SIZE]
274  altivec: static real __attribute__ ((aligned (16))) buffs[4][4][0x110]
275 
276  Huh, altivec looks like fun. Well, let it be large... then, the 16 byte alignment seems to be implicit on MacOSX malloc anyway.
277  Let's make a reasonable attempt to allocate enough memory...
278  Keep in mind: biggest ones are i486 and altivec (mutually exclusive!), then follows i586 and normal real.
279  mmx/sse use short but also real for resampling.
280  Thus, minimum is 2*2*0x110*sizeof(real).
281 */
282  if(fr->cpu_opts.type == altivec) buffssize = 4*4*0x110*sizeof(real);
283 #ifdef OPT_I486
284  else if(fr->cpu_opts.type == ivier) buffssize = 2*2*17*FIR_BUFFER_SIZE*sizeof(int);
285 #endif
286  else if(fr->cpu_opts.type == ifuenf || fr->cpu_opts.type == ifuenf_dither || fr->cpu_opts.type == dreidnow)
287  buffssize = 2*2*0x110*4; /* don't rely on type real, we need 4352 bytes */
288 
289  if(2*2*0x110*sizeof(real) > buffssize)
290  buffssize = 2*2*0x110*sizeof(real);
291  buffssize += 15; /* For 16-byte alignment (SSE likes that). */
292 
293  if(fr->rawbuffs != NULL && fr->rawbuffss != buffssize)
294  {
295  free(fr->rawbuffs);
296  fr->rawbuffs = NULL;
297  }
298 
299  if(fr->rawbuffs == NULL) fr->rawbuffs = (unsigned char*) malloc(buffssize);
300  if(fr->rawbuffs == NULL) return -1;
301  fr->rawbuffss = buffssize;
302  fr->short_buffs[0][0] = aligned_pointer(fr->rawbuffs,short,16);
303  fr->short_buffs[0][1] = fr->short_buffs[0][0] + 0x110;
304  fr->short_buffs[1][0] = fr->short_buffs[0][1] + 0x110;
305  fr->short_buffs[1][1] = fr->short_buffs[1][0] + 0x110;
306  fr->real_buffs[0][0] = aligned_pointer(fr->rawbuffs,real,16);
307  fr->real_buffs[0][1] = fr->real_buffs[0][0] + 0x110;
308  fr->real_buffs[1][0] = fr->real_buffs[0][1] + 0x110;
309  fr->real_buffs[1][1] = fr->real_buffs[1][0] + 0x110;
310 #ifdef OPT_I486
311  if(fr->cpu_opts.type == ivier)
312  {
313  fr->int_buffs[0][0] = (int*) fr->rawbuffs;
314  fr->int_buffs[0][1] = fr->int_buffs[0][0] + 17*FIR_BUFFER_SIZE;
315  fr->int_buffs[1][0] = fr->int_buffs[0][1] + 17*FIR_BUFFER_SIZE;
316  fr->int_buffs[1][1] = fr->int_buffs[1][0] + 17*FIR_BUFFER_SIZE;
317  }
318 #endif
319 #ifdef OPT_ALTIVEC
320  if(fr->cpu_opts.type == altivec)
321  {
322  int i,j;
323  fr->areal_buffs[0][0] = (real*) fr->rawbuffs;
324  for(i=0; i<4; ++i) for(j=0; j<4; ++j)
325  fr->areal_buffs[i][j] = fr->areal_buffs[0][0] + (i*4+j)*0x110;
326  }
327 #endif
328  /* now the different decwins... all of the same size, actually */
329  /* The MMX ones want 32byte alignment, which I'll try to ensure manually */
330  {
331  int decwin_size = (512+32)*sizeof(real);
332 #ifdef OPT_MMXORSSE
333 #ifdef OPT_MULTI
334  if(fr->cpu_opts.class == mmxsse)
335  {
336 #endif
337  /* decwin_mmx will share, decwins will be appended ... sizeof(float)==4 */
338  if(decwin_size < (512+32)*4) decwin_size = (512+32)*4;
339 
340  /* the second window + alignment zone -- we align for 32 bytes for SSE as
341  requirement, 64 byte for matching cache line size (that matters!) */
342  decwin_size += (512+32)*4 + 63;
343  /* (512+32)*4/32 == 2176/32 == 68, so one decwin block retains alignment for 32 or 64 bytes */
344 #ifdef OPT_MULTI
345  }
346 #endif
347 #endif
348 #if defined(OPT_ALTIVEC) || defined(OPT_ARM)
349  /* sizeof(real) >= 4 ... yes, it could be 8, for example.
350  We got it intialized to at least (512+32)*sizeof(real).*/
351  decwin_size += 512*sizeof(real);
352 #endif
353  /* Hm, that's basically realloc() ... */
354  if(fr->rawdecwin != NULL && fr->rawdecwins != decwin_size)
355  {
356  free(fr->rawdecwin);
357  fr->rawdecwin = NULL;
358  }
359 
360  if(fr->rawdecwin == NULL)
361  fr->rawdecwin = (unsigned char*) malloc(decwin_size);
362 
363  if(fr->rawdecwin == NULL) return -1;
364 
365  fr->rawdecwins = decwin_size;
366  fr->decwin = (real*) fr->rawdecwin;
367 #ifdef OPT_MMXORSSE
368 #ifdef OPT_MULTI
369  if(fr->cpu_opts.class == mmxsse)
370  {
371 #endif
372  /* align decwin, assign that to decwin_mmx, append decwins */
373  /* I need to add to decwin what is missing to the next full 64 byte -- also I want to make gcc -pedantic happy... */
374  fr->decwin = aligned_pointer(fr->rawdecwin,real,64);
375  debug1("aligned decwin: %p", (void*)fr->decwin);
376  fr->decwin_mmx = (float*)fr->decwin;
377  fr->decwins = fr->decwin_mmx+512+32;
378 #ifdef OPT_MULTI
379  }
380  else debug("no decwins/decwin_mmx for that class");
381 #endif
382 #endif
383  }
384 
385  /* Layer scratch buffers are of compile-time fixed size, so allocate only once. */
386  if(fr->layerscratch == NULL)
387  {
388  /* Allocate specific layer1/2/3 buffers, so that we know they'll work for SSE. */
389  size_t scratchsize = 0;
390  real *scratcher;
391 #ifndef NO_LAYER1
392  scratchsize += sizeof(real) * 2 * SBLIMIT;
393 #endif
394 #ifndef NO_LAYER2
395  scratchsize += sizeof(real) * 2 * 4 * SBLIMIT;
396 #endif
397 #ifndef NO_LAYER3
398  scratchsize += sizeof(real) * 2 * SBLIMIT * SSLIMIT; /* hybrid_in */
399  scratchsize += sizeof(real) * 2 * SSLIMIT * SBLIMIT; /* hybrid_out */
400 #endif
401  /*
402  Now figure out correct alignment:
403  We need 16 byte minimum, smallest unit of the blocks is 2*SBLIMIT*sizeof(real), which is 64*4=256. Let's do 64bytes as heuristic for cache line (as proven useful in buffs above).
404  */
405  fr->layerscratch = malloc(scratchsize+63);
406  if(fr->layerscratch == NULL) return -1;
407 
408  /* Get aligned part of the memory, then divide it up. */
409  scratcher = aligned_pointer(fr->layerscratch,real,64);
410  /* Those funky pointer casts silence compilers...
411  One might change the code at hand to really just use 1D arrays, but in practice, that would not make a (positive) difference. */
412 #ifndef NO_LAYER1
413  fr->layer1.fraction = (real(*)[SBLIMIT])scratcher;
414  scratcher += 2 * SBLIMIT;
415 #endif
416 #ifndef NO_LAYER2
417  fr->layer2.fraction = (real(*)[4][SBLIMIT])scratcher;
418  scratcher += 2 * 4 * SBLIMIT;
419 #endif
420 #ifndef NO_LAYER3
421  fr->layer3.hybrid_in = (real(*)[SBLIMIT][SSLIMIT])scratcher;
422  scratcher += 2 * SBLIMIT * SSLIMIT;
423  fr->layer3.hybrid_out = (real(*)[SSLIMIT][SBLIMIT])scratcher;
424  scratcher += 2 * SSLIMIT * SBLIMIT;
425 #endif
426  /* Note: These buffers don't need resetting here. */
427  }
428 
429  /* Only reset the buffers we created just now. */
431 
432  debug1("frame %p buffer done", (void*)fr);
433  return 0;
434 }
435 
437 {
438  fr->buffer.fill = 0; /* hm, reset buffer fill... did we do a flush? */
439  fr->bsnum = 0;
440  /* Wondering: could it be actually _wanted_ to retain buffer contents over different files? (special gapless / cut stuff) */
441  fr->bsbuf = fr->bsspace[1];
442  fr->bsbufold = fr->bsbuf;
443  fr->bitreservoir = 0;
445  memset(fr->bsspace, 0, 2*(MAXFRAMESIZE+512));
446  memset(fr->ssave, 0, 34);
447  fr->hybrid_blc[0] = fr->hybrid_blc[1] = 0;
448  memset(fr->hybrid_block, 0, sizeof(real)*2*2*SBLIMIT*SSLIMIT);
449  return 0;
450 }
451 
453 {
454 #ifndef NO_ICY
455  if(fr->icy.data != NULL) free(fr->icy.data);
456  fr->icy.data = NULL;
457  fr->icy.interval = 0;
458  fr->icy.next = 0;
459 #endif
460 }
461 
463 {
464  if(fr->xing_toc != NULL){ free(fr->xing_toc); fr->xing_toc = NULL; }
465 }
466 
467 /* Just copy the Xing TOC over... */
468 int frame_fill_toc(mpg123_handle *fr, unsigned char* in)
469 {
470  if(fr->xing_toc == NULL) fr->xing_toc = malloc(100);
471  if(fr->xing_toc != NULL)
472  {
473  memcpy(fr->xing_toc, in, 100);
474 #ifdef DEBUG
475  debug("Got a TOC! Showing the values...");
476  {
477  int i;
478  for(i=0; i<100; ++i)
479  debug2("entry %i = %i", i, fr->xing_toc[i]);
480  }
481 #endif
482  return TRUE;
483  }
484  return FALSE;
485 }
486 
487 /* Prepare the handle for a new track.
488  Reset variables, buffers... */
490 {
492  frame_fixed_reset(fr);
493  frame_free_toc(fr);
494 #ifdef FRAME_INDEX
495  fi_reset(&fr->index);
496 #endif
497 
498  return 0;
499 }
500 
501 /* Reset everythign except dynamic memory. */
503 {
504  frame_icy_reset(fr);
505  open_bad(fr);
506  fr->to_decode = FALSE;
507  fr->to_ignore = FALSE;
508  fr->metaflags = 0;
509  fr->outblock = 0; /* This will be set before decoding! */
510  fr->num = -1;
511  fr->input_offset = -1;
512  fr->playnum = -1;
514  fr->silent_resync = 0;
515  fr->audio_start = 0;
516  fr->clip = 0;
517  fr->oldhead = 0;
518  fr->firsthead = 0;
519  fr->lay = 0;
520  fr->vbr = MPG123_CBR;
521  fr->abr_rate = 0;
522  fr->track_frames = 0;
523  fr->track_samples = -1;
524  fr->framesize=0;
525  fr->mean_frames = 0;
526  fr->mean_framesize = 0;
527  fr->freesize = 0;
528  fr->lastscale = -1;
529  fr->rva.level[0] = -1;
530  fr->rva.level[1] = -1;
531  fr->rva.gain[0] = 0;
532  fr->rva.gain[1] = 0;
533  fr->rva.peak[0] = 0;
534  fr->rva.peak[1] = 0;
535  fr->fsizeold = 0;
536  fr->firstframe = 0;
537  fr->ignoreframe = fr->firstframe-fr->p.preframes;
538  fr->header_change = 0;
539  fr->lastframe = -1;
540  fr->fresh = 1;
541  fr->new_format = 0;
542 #ifdef GAPLESS
543  frame_gapless_init(fr,-1,0,0);
544  fr->lastoff = 0;
545  fr->firstoff = 0;
546 #endif
547 #ifdef OPT_I486
548  fr->i486bo[0] = fr->i486bo[1] = FIR_SIZE-1;
549 #endif
550  fr->bo = 1; /* the usual bo */
551 #ifdef OPT_DITHER
552  fr->ditherindex = 0;
553 #endif
554  reset_id3(fr);
555  reset_icy(&fr->icy);
556  /* ICY stuff should go into icy.c, eh? */
557 #ifndef NO_ICY
558  fr->icy.interval = 0;
559  fr->icy.next = 0;
560 #endif
561  fr->halfphase = 0; /* here or indeed only on first-time init? */
562  fr->error_protection = 0;
563  fr->freeformat_framesize = -1;
564 }
565 
567 {
568  if(fr->rawbuffs != NULL) free(fr->rawbuffs);
569  fr->rawbuffs = NULL;
570  fr->rawbuffss = 0;
571  if(fr->rawdecwin != NULL) free(fr->rawdecwin);
572  fr->rawdecwin = NULL;
573  fr->rawdecwins = 0;
574 #ifndef NO_8BIT
575  if(fr->conv16to8_buf != NULL) free(fr->conv16to8_buf);
576  fr->conv16to8_buf = NULL;
577 #endif
578  if(fr->layerscratch != NULL) free(fr->layerscratch);
579 }
580 
582 {
583  if(fr->buffer.rdata != NULL)
584  {
585  debug1("freeing buffer at %p", (void*)fr->buffer.rdata);
586  free(fr->buffer.rdata);
587  }
588  fr->buffer.rdata = NULL;
589  frame_free_buffers(fr);
590  frame_free_toc(fr);
591 #ifdef FRAME_INDEX
592  fi_exit(&fr->index);
593 #endif
594 #ifdef OPT_DITHER
595  if(fr->dithernoise != NULL)
596  {
597  free(fr->dithernoise);
598  fr->dithernoise = NULL;
599  }
600 #endif
601  exit_id3(fr);
602  clear_icy(&fr->icy);
603  /* Clean up possible mess from LFS wrapper. */
604  if(fr->wrapperclean != NULL)
605  {
606  fr->wrapperclean(fr->wrapperdata);
607  fr->wrapperdata = NULL;
608  }
609 #ifndef NO_FEEDER
610  bc_cleanup(&fr->rdat.buffer);
611 #endif
612 }
613 
614 int attribute_align_arg mpg123_framedata(mpg123_handle *mh, unsigned long *header, unsigned char **bodydata, size_t *bodybytes)
615 {
616  if(mh == NULL) return MPG123_BAD_HANDLE;
617  if(!mh->to_decode) return MPG123_ERR;
618 
619  if(header != NULL) *header = mh->oldhead;
620  if(bodydata != NULL) *bodydata = mh->bsbuf;
621  if(bodybytes != NULL) *bodybytes = mh->framesize;
622 
623  return MPG123_OK;
624 }
625 
626 /*
627  Fuzzy frame offset searching (guessing).
628  When we don't have an accurate position, we may use an inaccurate one.
629  Possibilities:
630  - use approximate positions from Xing TOC (not yet parsed)
631  - guess wildly from mean framesize and offset of first frame / beginning of file.
632 */
633 
634 static off_t frame_fuzzy_find(mpg123_handle *fr, off_t want_frame, off_t* get_frame)
635 {
636  /* Default is to go to the beginning. */
637  off_t ret = fr->audio_start;
638  *get_frame = 0;
639 
640  /* But we try to find something better. */
641  /* Xing VBR TOC works with relative positions, both in terms of audio frames and stream bytes.
642  Thus, it only works when whe know the length of things.
643  Oh... I assume the offsets are relative to the _total_ file length. */
644  if(fr->xing_toc != NULL && fr->track_frames > 0 && fr->rdat.filelen > 0)
645  {
646  /* One could round... */
647  int toc_entry = (int) ((double)want_frame*100./fr->track_frames);
648  /* It is an index in the 100-entry table. */
649  if(toc_entry < 0) toc_entry = 0;
650  if(toc_entry > 99) toc_entry = 99;
651 
652  /* Now estimate back what frame we get. */
653  *get_frame = (off_t) ((double)toc_entry/100. * fr->track_frames);
654  fr->state_flags &= ~FRAME_ACCURATE;
655  fr->silent_resync = 1;
656  /* Question: Is the TOC for whole file size (with/without ID3) or the "real" audio data only?
657  ID3v1 info could also matter. */
658  ret = (off_t) ((double)fr->xing_toc[toc_entry]/256.* fr->rdat.filelen);
659  }
660  else if(fr->mean_framesize > 0)
661  { /* Just guess with mean framesize (may be exact with CBR files). */
662  /* Query filelen here or not? */
663  fr->state_flags &= ~FRAME_ACCURATE; /* Fuzzy! */
664  fr->silent_resync = 1;
665  *get_frame = want_frame;
666  ret = (off_t) (fr->audio_start+fr->mean_framesize*want_frame);
667  }
668  debug5("fuzzy: want %li of %li, get %li at %li B of %li B",
669  (long)want_frame, (long)fr->track_frames, (long)*get_frame, (long)ret, (long)(fr->rdat.filelen-fr->audio_start));
670  return ret;
671 }
672 
673 /*
674  find the best frame in index just before the wanted one, seek to there
675  then step to just before wanted one with read_frame
676  do not care tabout the stuff that was in buffer but not played back
677  everything that left the decoder is counted as played
678 
679  Decide if you want low latency reaction and accurate timing info or stable long-time playback with buffer!
680 */
681 
682 off_t frame_index_find(mpg123_handle *fr, off_t want_frame, off_t* get_frame)
683 {
684  /* default is file start if no index position */
685  off_t gopos = 0;
686  *get_frame = 0;
687 #ifdef FRAME_INDEX
688  /* Possibly use VBRI index, too? I'd need an example for this... */
689  if(fr->index.fill)
690  {
691  /* find in index */
692  size_t fi;
693  /* at index fi there is frame step*fi... */
694  fi = want_frame/fr->index.step;
695  if(fi >= fr->index.fill) /* If we are beyond the end of frame index...*/
696  {
697  /* When fuzzy seek is allowed, we have some limited tolerance for the frames we want to read rather then jump over. */
698  if(fr->p.flags & MPG123_FUZZY && want_frame - (fr->index.fill-1)*fr->index.step > 10)
699  {
700  gopos = frame_fuzzy_find(fr, want_frame, get_frame);
701  if(gopos > fr->audio_start) return gopos; /* Only in that case, we have a useful guess. */
702  /* Else... just continue, fuzzyness didn't help. */
703  }
704  /* Use the last available position, slowly advancing from that one. */
705  fi = fr->index.fill - 1;
706  }
707  /* We have index position, that yields frame and byte offsets. */
708  *get_frame = fi*fr->index.step;
709  gopos = fr->index.data[fi];
710  fr->state_flags |= FRAME_ACCURATE; /* When using the frame index, we are accurate. */
711  }
712  else
713  {
714 #endif
715  if(fr->p.flags & MPG123_FUZZY)
716  return frame_fuzzy_find(fr, want_frame, get_frame);
717  /* A bit hackish here... but we need to be fresh when looking for the first header again. */
718  fr->firsthead = 0;
719  fr->oldhead = 0;
720 #ifdef FRAME_INDEX
721  }
722 #endif
723  debug2("index: 0x%lx for frame %li", (unsigned long)gopos, (long) *get_frame);
724  return gopos;
725 }
726 
728 {
729  off_t outs = 0;
730  switch(fr->down_sample)
731  {
732  case 0:
733 # ifndef NO_DOWNSAMPLE
734  case 1:
735  case 2:
736 # endif
737  outs = ins>>fr->down_sample;
738  break;
739 # ifndef NO_NTOM
740  case 3: outs = ntom_ins2outs(fr, ins); break;
741 # endif
742  default: error1("Bad down_sample (%i) ... should not be possible!!", fr->down_sample);
743  }
744  return outs;
745 }
746 
748 {
749  off_t outs = 0;
750  switch(fr->down_sample)
751  {
752  case 0:
753 # ifndef NO_DOWNSAMPLE
754  case 1:
755  case 2:
756 # endif
757  outs = (fr->spf>>fr->down_sample)*num;
758  break;
759 #ifndef NO_NTOM
760  case 3: outs = ntom_frmouts(fr, num); break;
761 #endif
762  default: error1("Bad down_sample (%i) ... should not be possible!!", fr->down_sample);
763  }
764  return outs;
765 }
766 
767 /* Compute the number of output samples we expect from this frame.
768  This is either simple spf() or a tad more elaborate for ntom. */
770 {
771  off_t outs = 0;
772  switch(fr->down_sample)
773  {
774  case 0:
775 # ifndef NO_DOWNSAMPLE
776  case 1:
777  case 2:
778 # endif
779  outs = fr->spf>>fr->down_sample;
780  break;
781 #ifndef NO_NTOM
782  case 3: outs = ntom_frame_outsamples(fr); break;
783 #endif
784  default: error1("Bad down_sample (%i) ... should not be possible!!", fr->down_sample);
785  }
786  return outs;
787 }
788 
790 {
791  off_t num = 0;
792  switch(fr->down_sample)
793  {
794  case 0:
795 # ifndef NO_DOWNSAMPLE
796  case 1:
797  case 2:
798 # endif
799  num = outs/(fr->spf>>fr->down_sample);
800  break;
801 #ifndef NO_NTOM
802  case 3: num = ntom_frameoff(fr, outs); break;
803 #endif
804  default: error("Bad down_sample ... should not be possible!!");
805  }
806  return num;
807 }
808 
809 #ifdef GAPLESS
810 /* input in _input_ samples */
811 void frame_gapless_init(mpg123_handle *fr, off_t framecount, off_t bskip, off_t eskip)
812 {
813  debug3("frame_gapless_init: given %"OFF_P" frames, skip %"OFF_P" and %"OFF_P, (off_p)framecount, (off_p)bskip, (off_p)eskip);
814  fr->gapless_frames = framecount;
815  if(fr->gapless_frames > 0 && bskip >=0 && eskip >= 0)
816  {
817  fr->begin_s = bskip+GAPLESS_DELAY;
818  fr->end_s = framecount*fr->spf-eskip+GAPLESS_DELAY;
819  }
820  else fr->begin_s = fr->end_s = 0;
821  /* These will get proper values later, from above plus resampling info. */
822  fr->begin_os = 0;
823  fr->end_os = 0;
824  fr->fullend_os = 0;
825  debug2("frame_gapless_init: from %"OFF_P" to %"OFF_P" samples", (off_p)fr->begin_s, (off_p)fr->end_s);
826 }
827 
829 {
830  fr->begin_os = frame_ins2outs(fr, fr->begin_s);
831  fr->end_os = frame_ins2outs(fr, fr->end_s);
832  if(fr->gapless_frames > 0)
833  fr->fullend_os = frame_ins2outs(fr, fr->gapless_frames*fr->spf);
834  else fr->fullend_os = 0;
835 
836  debug4("frame_gapless_realinit: from %"OFF_P" to %"OFF_P" samples (%"OFF_P", %"OFF_P")", (off_p)fr->begin_os, (off_p)fr->end_os, (off_p)fr->fullend_os, (off_p)fr->gapless_frames);
837 }
838 
839 /* At least note when there is trouble... */
840 void frame_gapless_update(mpg123_handle *fr, off_t total_samples)
841 {
842  off_t gapless_samples = fr->gapless_frames*fr->spf;
843  if(fr->gapless_frames < 1) return;
844 
845  debug2("gapless update with new sample count %"OFF_P" as opposed to known %"OFF_P, total_samples, gapless_samples);
846  if(NOQUIET && total_samples != gapless_samples)
847  fprintf(stderr, "\nWarning: Real sample count %"OFF_P" differs from given gapless sample count %"OFF_P". Frankenstein stream?\n"
848  , total_samples, gapless_samples);
849 
850  if(gapless_samples > total_samples)
851  {
852  if(NOQUIET) error2("End sample count smaller than gapless end! (%"OFF_P" < %"OFF_P"). Disabling gapless mode from now on.", (off_p)total_samples, (off_p)fr->end_s);
853  /* This invalidates the current position... but what should I do? */
854  frame_gapless_init(fr, -1, 0, 0);
856  fr->lastframe = -1;
857  fr->lastoff = 0;
858  }
859 }
860 
861 #endif
862 
863 /* Compute the needed frame to ignore from, for getting accurate/consistent output for intended firstframe. */
865 {
866  off_t preshift = fr->p.preframes;
867  /* Layer 3 _really_ needs at least one frame before. */
868  if(fr->lay==3 && preshift < 1) preshift = 1;
869  /* Layer 1 & 2 reall do not need more than 2. */
870  if(fr->lay!=3 && preshift > 2) preshift = 2;
871 
872  return fr->firstframe - preshift;
873 }
874 
875 /* The frame seek... This is not simply the seek to fe*fr->spf samples in output because we think of _input_ frames here.
876  Seek to frame offset 1 may be just seek to 200 samples offset in output since the beginning of first frame is delay/padding.
877  Hm, is that right? OK for the padding stuff, but actually, should the decoder delay be better totally hidden or not?
878  With gapless, even the whole frame position could be advanced further than requested (since Homey don't play dat). */
880 {
881  fr->firstframe = fe;
882 #ifdef GAPLESS
883  if(fr->p.flags & MPG123_GAPLESS && fr->gapless_frames > 0)
884  {
885  /* Take care of the beginning... */
886  off_t beg_f = frame_offset(fr, fr->begin_os);
887  if(fe <= beg_f)
888  {
889  fr->firstframe = beg_f;
890  fr->firstoff = fr->begin_os - frame_outs(fr, beg_f);
891  }
892  else fr->firstoff = 0;
893  /* The end is set once for a track at least, on the frame_set_frameseek called in get_next_frame() */
894  if(fr->end_os > 0)
895  {
896  fr->lastframe = frame_offset(fr,fr->end_os);
897  fr->lastoff = fr->end_os - frame_outs(fr, fr->lastframe);
898  } else {fr->lastframe = -1; fr->lastoff = 0; }
899  } else { fr->firstoff = fr->lastoff = 0; fr->lastframe = -1; }
900 #endif
901  fr->ignoreframe = ignoreframe(fr);
902 #ifdef GAPLESS
903  debug5("frame_set_frameseek: begin at %li frames and %li samples, end at %li and %li; ignore from %li",
904  (long) fr->firstframe, (long) fr->firstoff,
905  (long) fr->lastframe, (long) fr->lastoff, (long) fr->ignoreframe);
906 #else
907  debug3("frame_set_frameseek: begin at %li frames, end at %li; ignore from %li",
908  (long) fr->firstframe, (long) fr->lastframe, (long) fr->ignoreframe);
909 #endif
910 }
911 
913 {
914 #ifndef NO_LAYER3
915  if(fr->lay == 3) set_pointer(fr, 512);
916 #endif
917 }
918 
919 /* Sample accurate seek prepare for decoder. */
920 /* This gets unadjusted output samples and takes resampling into account */
922 {
923  fr->firstframe = frame_offset(fr, sp);
924  debug1("frame_set_seek: from %"OFF_P, fr->num);
925 #ifndef NO_NTOM
926  if(fr->down_sample == 3) ntom_set_ntom(fr, fr->firstframe);
927 #endif
928  fr->ignoreframe = ignoreframe(fr);
929 #ifdef GAPLESS /* The sample offset is used for non-gapless mode, too! */
930  fr->firstoff = sp - frame_outs(fr, fr->firstframe);
931  debug5("frame_set_seek: begin at %li frames and %li samples, end at %li and %li; ignore from %li",
932  (long) fr->firstframe, (long) fr->firstoff,
933  (long) fr->lastframe, (long) fr->lastoff, (long) fr->ignoreframe);
934 #else
935  debug3("frame_set_seek: begin at %li frames, end at %li; ignore from %li",
936  (long) fr->firstframe, (long) fr->lastframe, (long) fr->ignoreframe);
937 #endif
938 }
939 
941 {
942  if(mh == NULL) return MPG123_ERR;
943  return mpg123_volume(mh, change + (double) mh->p.outscale);
944 }
945 
947 {
948  if(mh == NULL) return MPG123_ERR;
949 
950  if(vol >= 0) mh->p.outscale = vol;
951  else mh->p.outscale = 0.;
952 
953  do_rva(mh);
954  return MPG123_OK;
955 }
956 
957 static int get_rva(mpg123_handle *fr, double *peak, double *gain)
958 {
959  double p = -1;
960  double g = 0;
961  int ret = 0;
962  if(fr->p.rva)
963  {
964  int rt = 0;
965  /* Should one assume a zero RVA as no RVA? */
966  if(fr->p.rva == 2 && fr->rva.level[1] != -1) rt = 1;
967  if(fr->rva.level[rt] != -1)
968  {
969  p = fr->rva.peak[rt];
970  g = fr->rva.gain[rt];
971  ret = 1; /* Success. */
972  }
973  }
974  if(peak != NULL) *peak = p;
975  if(gain != NULL) *gain = g;
976  return ret;
977 }
978 
979 /* adjust the volume, taking both fr->outscale and rva values into account */
981 {
982  double peak = 0;
983  double gain = 0;
984  double newscale;
985  double rvafact = 1;
986  if(get_rva(fr, &peak, &gain))
987  {
988  if(NOQUIET && fr->p.verbose > 1) fprintf(stderr, "Note: doing RVA with gain %f\n", gain);
989  rvafact = pow(10,gain/20);
990  }
991 
992  newscale = fr->p.outscale*rvafact;
993 
994  /* if peak is unknown (== 0) this check won't hurt */
995  if((peak*newscale) > 1.0)
996  {
997  newscale = 1.0/peak;
998  warning2("limiting scale value to %f to prevent clipping with indicated peak factor of %f", newscale, peak);
999  }
1000  /* first rva setting is forced with fr->lastscale < 0 */
1001  if(newscale != fr->lastscale || fr->decoder_change)
1002  {
1003  debug3("changing scale value from %f to %f (peak estimated to %f)", fr->lastscale != -1 ? fr->lastscale : fr->p.outscale, newscale, (double) (newscale*peak));
1004  fr->lastscale = newscale;
1005  /* It may be too early, actually. */
1006  if(fr->make_decode_tables != NULL) fr->make_decode_tables(fr); /* the actual work */
1007  }
1008 }
1009 
1010 
1011 int attribute_align_arg mpg123_getvolume(mpg123_handle *mh, double *base, double *really, double *rva_db)
1012 {
1013  if(mh == NULL) return MPG123_ERR;
1014  if(base) *base = mh->p.outscale;
1015  if(really) *really = mh->lastscale;
1016  get_rva(mh, NULL, rva_db);
1017  return MPG123_OK;
1018 }
1019 
1021 {
1022  if(mh == NULL) return MPG123_ERR;
1023 
1024  return mh->input_offset;
1025 }
#define ntom_frame_outsamples
Definition: intsym.h:145
#define INDEX_SIZE
Definition: config.h:270
real equalizer[2][32]
Definition: frame.h:126
int frame_buffers(mpg123_handle *fr)
Definition: frame.c:263
long index_size
Definition: frame.h:81
void frame_gapless_init(mpg123_handle *fr, off_t framecount, off_t bskip, off_t eskip)
#define decclass
Definition: intsym.h:225
void frame_set_seek(mpg123_handle *fr, off_t sp)
Definition: frame.c:921
#define TRUE
Definition: types.h:120
#define exit_id3
Definition: intsym.h:202
int frame_outbuffer(mpg123_handle *fr)
Definition: frame.c:178
#define bc_cleanup
Definition: intsym.h:238
#define reset_id3
Definition: intsym.h:203
long preframes
Definition: frame.h:82
struct mpg123_pars_struct p
Definition: frame.h:287
real * layerscratch
Definition: frame.h:310
#define error(str)
Definition: mkdosfs.c:1605
long feedbuffer
Definition: frame.h:85
struct mpg123_handle_struct::@3303 cpu_opts
#define DOUBLE_TO_REAL(x)
#define set_pointer
Definition: intsym.h:232
#define fi_reset
Definition: intsym.h:212
off_t frame_expect_outsamples(mpg123_handle *fr)
Definition: frame.c:769
long freeformat_framesize
Definition: frame.h:223
#define error1(s, a)
Definition: debug.h:109
#define reset_icy
Definition: intsym.h:200
void * wrapperdata
Definition: frame.h:333
#define fi_exit
Definition: intsym.h:208
#define invalidate_format
Definition: intsym.h:167
#define free
Definition: debug_ros.c:5
unsigned char * bsbufold
Definition: frame.h:253
__kernel_off_t off_t
Definition: linux.h:201
#define SBLIMIT
#define defdec
Definition: intsym.h:224
static void frame_free_buffers(mpg123_handle *fr)
Definition: frame.c:566
#define fi_resize
Definition: intsym.h:209
double mean_framesize
Definition: frame.h:246
void frame_skip(mpg123_handle *fr)
Definition: frame.c:912
#define NTOM_MUL
Definition: frame.c:16
#define debug4(s, a, b, c, d)
Definition: debug.h:55
off_t frame_index_find(mpg123_handle *fr, off_t want_frame, off_t *get_frame)
Definition: frame.c:682
_Tp _STLP_CALL real(const complex< _Tp > &__z)
Definition: _complex.h:727
struct outbuffer buffer
Definition: frame.h:265
#define open_bad
Definition: intsym.h:247
void frame_init_par(mpg123_handle *fr, mpg123_pars *mp)
Definition: frame.c:74
long icy_interval
Definition: frame.h:77
static void frame_icy_reset(mpg123_handle *fr)
Definition: frame.c:452
#define debug2(s, a, b)
Definition: debug.h:53
off_t input_offset
Definition: frame.h:216
long doublespeed
Definition: frame.h:70
static off_t ignoreframe(mpg123_handle *fr)
Definition: frame.c:864
struct reader_data rdat
Definition: frame.h:286
int frame_fill_toc(mpg123_handle *fr, unsigned char *in)
Definition: frame.c:468
#define debug3(s, a, b, c)
Definition: debug.h:54
static void frame_free_toc(mpg123_handle *fr)
Definition: frame.c:462
void(* wrapperclean)(void *)
Definition: frame.h:335
#define ntom_frameoff
Definition: intsym.h:148
long halfspeed
Definition: frame.h:69
off_t attribute_align_arg mpg123_framepos(mpg123_handle *mh)
Definition: frame.c:1020
unsigned char * xing_toc
Definition: frame.h:221
#define dither_table_init
Definition: intsym.h:165
off_t track_frames
Definition: frame.h:244
int attribute_align_arg mpg123_framedata(mpg123_handle *mh, unsigned long *header, unsigned char **bodydata, size_t *bodybytes)
Definition: frame.c:614
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 void frame_default_pars(mpg123_pars *mp)
Definition: frame.c:36
GLuint base
Definition: 3dtext.c:35
float pow(float __x, int __y)
Definition: _cmath.h:458
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define init_id3
Definition: intsym.h:201
int attribute_align_arg mpg123_reset_eq(mpg123_handle *mh)
Definition: frame.c:167
unsigned int uintptr_t
Definition: crtdefs.h:300
void(* make_decode_tables)(mpg123_handle *fr)
Definition: frame.h:183
void frame_init(mpg123_handle *fr)
Definition: frame.c:69
static void frame_decode_buffers_reset(mpg123_handle *fr)
Definition: frame.c:257
struct icy_meta icy
Definition: frame.h:299
smooth NULL
Definition: ftsmooth.c:416
int frame_reset(mpg123_handle *fr)
Definition: frame.c:489
func_synth_mono synth_mono
Definition: frame.h:181
static int get_rva(mpg123_handle *fr, double *peak, double *gain)
Definition: frame.c:957
#define off_t
Definition: dosfsck.h:5
#define warning2(s, a, b)
Definition: debug.h:73
#define error2(s, a, b)
Definition: debug.h:110
#define ntom_ins2outs
Definition: intsym.h:147
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 GLint GLint j
Definition: glfuncs.h:250
__kernel_size_t size_t
Definition: linux.h:237
#define init_icy
Definition: intsym.h:198
GLboolean GLboolean g
Definition: glext.h:6204
off_t gapless_frames
Definition: frame.h:275
unsigned long size_p
Definition: compat.h:138
GLsizeiptr size
Definition: glext.h:5919
void frame_exit(mpg123_handle *fr)
Definition: frame.c:581
long force_rate
Definition: frame.h:65
GLuint GLuint num
Definition: glext.h:9618
void attribute_align_arg mpg123_delete_pars(mpg123_pars *mp)
Definition: frame.c:162
int frame_buffers_reset(mpg123_handle *fr)
Definition: frame.c:436
#define SSLIMIT
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define MAXFRAMESIZE
Definition: frame.h:30
#define NOQUIET
unsigned char bsspace[2][MAXFRAMESIZE+512]
Definition: frame.h:251
int ret
void do_rva(mpg123_handle *fr)
Definition: frame.c:980
int attribute_align_arg mpg123_replace_buffer(mpg123_handle *mh, unsigned char *data, size_t size)
Definition: frame.c:213
real hybrid_block[2][2][SBLIMIT *SSLIMIT]
Definition: frame.h:101
int frame_index_setup(mpg123_handle *fr)
struct mpg123_handle_struct::@3304 rva
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned long ntom_val[2]
Definition: frame.h:148
static off_t frame_fuzzy_find(mpg123_handle *fr, off_t want_frame, off_t *get_frame)
Definition: frame.c:634
#define aligned_pointer(p, type, alignment)
Definition: frame.c:18
void frame_set_frameseek(mpg123_handle *fr, off_t fe)
Definition: frame.c:879
void frame_gapless_realinit(mpg123_handle *fr)
long resync_limit
Definition: frame.h:80
func_synth synth
Definition: frame.h:179
unsigned long firsthead
Definition: frame.h:258
#define bc_prepare
Definition: intsym.h:237
struct audioformat af
Definition: frame.h:266
GLuint in
Definition: glext.h:9616
#define clear_icy
Definition: intsym.h:199
double lastscale
Definition: frame.h:235
off_t frame_outs(mpg123_handle *fr, off_t num)
Definition: frame.c:747
unsigned int bitreservoir
Definition: frame.h:250
int attribute_align_arg mpg123_getvolume(mpg123_handle *mh, double *base, double *really, double *rva_db)
Definition: frame.c:1011
#define SIZE_P
Definition: compat.h:137
struct frame_index index
Definition: frame.h:261
int attribute_align_arg mpg123_volume(mpg123_handle *mh, double vol)
Definition: frame.c:946
unsigned char * rawbuffs
Definition: frame.h:106
#define GAPLESS_DELAY
Definition: frame.h:381
double outscale
Definition: frame.h:79
MPG123_EXPORT int mpg123_fmt_all(mpg123_pars *mp)
Definition: format.c:379
long off_p
Definition: compat.h:130
int hybrid_blc[2]
Definition: frame.h:102
off_t frame_offset(mpg123_handle *fr, off_t outs)
Definition: frame.c:789
static void * align_the_pointer(void *base, unsigned int alignment)
Definition: frame.c:19
FILE * stderr
static void frame_fixed_reset(mpg123_handle *fr)
Definition: frame.c:502
off_t frame_ins2outs(mpg123_handle *fr, off_t ins)
Definition: frame.c:727
#define debug(msg)
Definition: key_call.c:71
static const WCHAR sp[]
Definition: suminfo.c:288
unsigned long ntom_step
Definition: frame.h:149
#define malloc
Definition: debug_ros.c:4
#define fi_init
Definition: intsym.h:207
#define debug5(s, a, b, c, d, e)
Definition: debug.h:56
int attribute_align_arg mpg123_volume_change(mpg123_handle *mh, double change)
Definition: frame.c:940
#define ntom_frmouts
Definition: intsym.h:146
void frame_gapless_update(mpg123_handle *mh, off_t total_samples)
#define attribute_align_arg
Definition: abi_align.h:30
unsigned char * conv16to8_buf
Definition: frame.h:133
GLfloat GLfloat p
Definition: glext.h:8902
off_t track_samples
Definition: frame.h:245
unsigned char ssave[34]
Definition: frame.h:129
#define frame_dither_init
Definition: intsym.h:166
#define memset(x, y, z)
Definition: compat.h:39
unsigned char * rawdecwin
Definition: frame.h:116
#define debug1(s, a)
Definition: debug.h:52
unsigned long oldhead
Definition: frame.h:256
#define OFF_P
Definition: compat.h:129
struct CFHEADER header
Definition: fdi.c:109
#define ntom_set_ntom
Definition: intsym.h:21
enum mpg123_vbr vbr
Definition: frame.h:214
#define DITHERSIZE
Definition: dither.h:12
unsigned char * bsbuf
Definition: frame.h:252
mpg123_pars attribute_align_arg * mpg123_new_pars(int *error)
Definition: frame.c:154
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31