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)
align_the_pointer(void * base,unsigned int 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
frame_default_pars(mpg123_pars * mp)36 static void frame_default_pars(mpg123_pars *mp)
37 {
38 mp->outscale = 1.0;
39 mp->flags = 0;
40 #ifdef GAPLESS
41 mp->flags |= MPG123_GAPLESS;
42 #endif
43 mp->flags |= MPG123_AUTO_RESAMPLE;
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
frame_init(mpg123_handle * fr)69 void frame_init(mpg123_handle *fr)
70 {
71 frame_init_par(fr, NULL);
72 }
73
frame_init_par(mpg123_handle * fr,mpg123_pars * mp)74 void frame_init_par(mpg123_handle *fr, mpg123_pars *mp)
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(?). */
frame_dither_init(mpg123_handle * fr)140 int frame_dither_init(mpg123_handle *fr)
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
mpg123_new_pars(int * error)154 mpg123_pars attribute_align_arg *mpg123_new_pars(int *error)
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
mpg123_delete_pars(mpg123_pars * mp)162 void attribute_align_arg mpg123_delete_pars(mpg123_pars* mp)
163 {
164 if(mp != NULL) free(mp);
165 }
166
mpg123_reset_eq(mpg123_handle * mh)167 int attribute_align_arg mpg123_reset_eq(mpg123_handle *mh)
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
frame_outbuffer(mpg123_handle * fr)178 int frame_outbuffer(mpg123_handle *fr)
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
mpg123_replace_buffer(mpg123_handle * mh,unsigned char * data,size_t size)213 int attribute_align_arg mpg123_replace_buffer(mpg123_handle *mh, unsigned char *data, size_t size)
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
frame_index_setup(mpg123_handle * fr)233 int frame_index_setup(mpg123_handle *fr)
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
frame_decode_buffers_reset(mpg123_handle * fr)257 static void frame_decode_buffers_reset(mpg123_handle *fr)
258 {
259 if(fr->rawbuffs) /* memset(NULL, 0, 0) not desired */
260 memset(fr->rawbuffs, 0, fr->rawbuffss);
261 }
262
frame_buffers(mpg123_handle * fr)263 int frame_buffers(mpg123_handle *fr)
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. */
430 frame_decode_buffers_reset(fr);
431
432 debug1("frame %p buffer done", (void*)fr);
433 return 0;
434 }
435
frame_buffers_reset(mpg123_handle * fr)436 int frame_buffers_reset(mpg123_handle *fr)
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;
444 frame_decode_buffers_reset(fr);
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
frame_icy_reset(mpg123_handle * fr)452 static void frame_icy_reset(mpg123_handle* fr)
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
frame_free_toc(mpg123_handle * fr)462 static void frame_free_toc(mpg123_handle *fr)
463 {
464 if(fr->xing_toc != NULL){ free(fr->xing_toc); fr->xing_toc = NULL; }
465 }
466
467 /* Just copy the Xing TOC over... */
frame_fill_toc(mpg123_handle * fr,unsigned char * in)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... */
frame_reset(mpg123_handle * fr)489 int frame_reset(mpg123_handle* fr)
490 {
491 frame_buffers_reset(fr);
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. */
frame_fixed_reset(mpg123_handle * fr)502 static void frame_fixed_reset(mpg123_handle *fr)
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;
513 fr->state_flags = FRAME_ACCURATE;
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
frame_free_buffers(mpg123_handle * fr)566 static void frame_free_buffers(mpg123_handle *fr)
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
frame_exit(mpg123_handle * fr)581 void frame_exit(mpg123_handle *fr)
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
mpg123_framedata(mpg123_handle * mh,unsigned long * header,unsigned char ** bodydata,size_t * bodybytes)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
frame_fuzzy_find(mpg123_handle * fr,off_t want_frame,off_t * get_frame)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
frame_index_find(mpg123_handle * fr,off_t want_frame,off_t * get_frame)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
frame_ins2outs(mpg123_handle * fr,off_t ins)727 off_t frame_ins2outs(mpg123_handle *fr, off_t ins)
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
frame_outs(mpg123_handle * fr,off_t num)747 off_t frame_outs(mpg123_handle *fr, off_t num)
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. */
frame_expect_outsamples(mpg123_handle * fr)769 off_t frame_expect_outsamples(mpg123_handle *fr)
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
frame_offset(mpg123_handle * fr,off_t outs)789 off_t frame_offset(mpg123_handle *fr, off_t outs)
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 */
frame_gapless_init(mpg123_handle * fr,off_t framecount,off_t bskip,off_t eskip)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
frame_gapless_realinit(mpg123_handle * fr)828 void frame_gapless_realinit(mpg123_handle *fr)
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... */
frame_gapless_update(mpg123_handle * fr,off_t total_samples)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);
855 frame_gapless_realinit(fr);
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. */
ignoreframe(mpg123_handle * fr)864 static off_t ignoreframe(mpg123_handle *fr)
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). */
frame_set_frameseek(mpg123_handle * fr,off_t fe)879 void frame_set_frameseek(mpg123_handle *fr, off_t fe)
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
frame_skip(mpg123_handle * fr)912 void frame_skip(mpg123_handle *fr)
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 */
frame_set_seek(mpg123_handle * fr,off_t sp)921 void frame_set_seek(mpg123_handle *fr, off_t sp)
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
mpg123_volume_change(mpg123_handle * mh,double change)940 int attribute_align_arg mpg123_volume_change(mpg123_handle *mh, double change)
941 {
942 if(mh == NULL) return MPG123_ERR;
943 return mpg123_volume(mh, change + (double) mh->p.outscale);
944 }
945
mpg123_volume(mpg123_handle * mh,double vol)946 int attribute_align_arg mpg123_volume(mpg123_handle *mh, double vol)
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
get_rva(mpg123_handle * fr,double * peak,double * gain)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 */
do_rva(mpg123_handle * fr)980 void do_rva(mpg123_handle *fr)
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
mpg123_getvolume(mpg123_handle * mh,double * base,double * really,double * rva_db)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
mpg123_framepos(mpg123_handle * mh)1020 off_t attribute_align_arg mpg123_framepos(mpg123_handle *mh)
1021 {
1022 if(mh == NULL) return MPG123_ERR;
1023
1024 return mh->input_offset;
1025 }
1026