|
562
|
1 /*
|
|
|
2 frame: Heap of routines dealing with the core mpg123 data structure.
|
|
|
3
|
|
|
4 copyright 2008 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 #define IGNORESHIFT 2
|
|
|
14
|
|
|
15 static void frame_fixed_reset(mpg123_handle *fr);
|
|
|
16
|
|
|
17 /* that's doubled in decode_ntom.c */
|
|
|
18 #define NTOM_MUL (32768)
|
|
|
19 #define aligned_pointer(p,type,alignment) \
|
|
|
20 (((char*)(p)-(char*)NULL) % (alignment)) \
|
|
|
21 ? (type*)((char*)(p) + (alignment) - (((char*)(p)-(char*)NULL) % (alignment))) \
|
|
|
22 : (type*)(p)
|
|
|
23 void frame_default_pars(mpg123_pars *mp)
|
|
|
24 {
|
|
|
25 mp->outscale = MAXOUTBURST;
|
|
|
26 #ifdef GAPLESS
|
|
|
27 mp->flags = MPG123_GAPLESS;
|
|
|
28 #else
|
|
|
29 mp->flags = 0;
|
|
|
30 #endif
|
|
|
31 mp->force_rate = 0;
|
|
|
32 mp->down_sample = 0;
|
|
|
33 mp->rva = 0;
|
|
|
34 mp->halfspeed = 0;
|
|
|
35 mp->doublespeed = 0;
|
|
|
36 mp->verbose = 0;
|
|
|
37 mp->icy_interval = 0;
|
|
|
38 #ifndef WIN32
|
|
|
39 mp->timeout = 0;
|
|
|
40 #endif
|
|
|
41 mp->resync_limit = 1024;
|
|
|
42 #ifdef FRAME_INDEX
|
|
|
43 mp->index_size = INDEX_SIZE;
|
|
|
44 #endif
|
|
|
45 mpg123_fmt_all(mp);
|
|
|
46 }
|
|
|
47
|
|
|
48 void frame_init(mpg123_handle *fr)
|
|
|
49 {
|
|
|
50 frame_init_par(fr, NULL);
|
|
|
51 }
|
|
|
52
|
|
|
53 void frame_init_par(mpg123_handle *fr, mpg123_pars *mp)
|
|
|
54 {
|
|
|
55 fr->own_buffer = FALSE;
|
|
|
56 fr->buffer.data = NULL;
|
|
|
57 fr->rawbuffs = NULL;
|
|
|
58 fr->rawdecwin = NULL;
|
|
|
59 fr->conv16to8_buf = NULL;
|
|
|
60 fr->xing_toc = NULL;
|
|
|
61 fr->cpu_opts.type = defopt;
|
|
|
62 fr->cpu_opts.class = (defopt == mmx || defopt == sse || defopt == dreidnowext) ? mmxsse : normal;
|
|
|
63 /* these two look unnecessary, check guarantee for synth_ntom_set_step (in control_generic, even)! */
|
|
|
64 fr->ntom_val[0] = NTOM_MUL>>1;
|
|
|
65 fr->ntom_val[1] = NTOM_MUL>>1;
|
|
|
66 fr->ntom_step = NTOM_MUL;
|
|
|
67 /* unnecessary: fr->buffer.size = fr->buffer.fill = 0; */
|
|
|
68 mpg123_reset_eq(fr);
|
|
|
69 init_icy(&fr->icy);
|
|
|
70 init_id3(fr);
|
|
|
71 /* frame_outbuffer is missing... */
|
|
|
72 /* frame_buffers is missing... that one needs cpu opt setting! */
|
|
|
73 /* after these... frame_reset is needed before starting full decode */
|
|
|
74 invalidate_format(&fr->af);
|
|
|
75 fr->rdat.r_read = NULL;
|
|
|
76 fr->rdat.r_lseek = NULL;
|
|
|
77 fr->decoder_change = 1;
|
|
|
78 fr->err = MPG123_OK;
|
|
|
79 if(mp == NULL) frame_default_pars(&fr->p);
|
|
|
80 else memcpy(&fr->p, mp, sizeof(struct mpg123_pars_struct));
|
|
|
81
|
|
|
82 fr->down_sample = 0; /* Initialize to silence harmless errors when debugging. */
|
|
|
83 frame_fixed_reset(fr); /* Reset only the fixed data, dynamic buffers are not there yet! */
|
|
|
84 #ifdef FRAME_INDEX
|
|
|
85 fi_init(&fr->index);
|
|
|
86 frame_index_setup(fr); /* Apply the size setting. */
|
|
|
87 #endif
|
|
|
88 }
|
|
|
89
|
|
|
90 mpg123_pars attribute_align_arg *mpg123_new_pars(int *error)
|
|
|
91 {
|
|
|
92 mpg123_pars *mp = malloc(sizeof(struct mpg123_pars_struct));
|
|
|
93 if(mp != NULL){ frame_default_pars(mp); if(error != NULL) *error = MPG123_OK; }
|
|
|
94 else if(error != NULL) *error = MPG123_OUT_OF_MEM;
|
|
|
95 return mp;
|
|
|
96 }
|
|
|
97
|
|
|
98 void attribute_align_arg mpg123_delete_pars(mpg123_pars* mp)
|
|
|
99 {
|
|
|
100 if(mp != NULL) free(mp);
|
|
|
101 }
|
|
|
102
|
|
|
103 int attribute_align_arg mpg123_reset_eq(mpg123_handle *mh)
|
|
|
104 {
|
|
|
105 int i;
|
|
|
106 mh->have_eq_settings = 0;
|
|
|
107 for(i=0; i < 32; ++i) mh->equalizer[0][i] = mh->equalizer[1][i] = DOUBLE_TO_REAL(1.0);
|
|
|
108
|
|
|
109 return MPG123_OK;
|
|
|
110 }
|
|
|
111
|
|
|
112 int frame_outbuffer(mpg123_handle *fr)
|
|
|
113 {
|
|
|
114 size_t size = mpg123_safe_buffer()*AUDIOBUFSIZE;
|
|
|
115 if(!fr->own_buffer) fr->buffer.data = NULL;
|
|
|
116 if(fr->buffer.data != NULL && fr->buffer.size != size)
|
|
|
117 {
|
|
|
118 free(fr->buffer.data);
|
|
|
119 fr->buffer.data = NULL;
|
|
|
120 }
|
|
|
121 fr->buffer.size = size;
|
|
|
122 if(fr->buffer.data == NULL) fr->buffer.data = (unsigned char*) malloc(fr->buffer.size);
|
|
|
123 if(fr->buffer.data == NULL)
|
|
|
124 {
|
|
|
125 fr->err = MPG123_OUT_OF_MEM;
|
|
|
126 return -1;
|
|
|
127 }
|
|
|
128 fr->own_buffer = TRUE;
|
|
|
129 fr->buffer.fill = 0;
|
|
|
130 return 0;
|
|
|
131 }
|
|
|
132
|
|
|
133 int attribute_align_arg mpg123_replace_buffer(mpg123_handle *mh, unsigned char *data, size_t size)
|
|
|
134 {
|
|
|
135 if(data == NULL || size < mpg123_safe_buffer())
|
|
|
136 {
|
|
|
137 mh->err = MPG123_BAD_BUFFER;
|
|
|
138 return MPG123_ERR;
|
|
|
139 }
|
|
|
140 if(mh->own_buffer && mh->buffer.data != NULL) free(mh->buffer.data);
|
|
|
141 mh->own_buffer = FALSE;
|
|
|
142 mh->buffer.data = data;
|
|
|
143 mh->buffer.size = size;
|
|
|
144 mh->buffer.fill = 0;
|
|
|
145 return MPG123_OK;
|
|
|
146 }
|
|
|
147
|
|
|
148 #ifdef FRAME_INDEX
|
|
|
149 int frame_index_setup(mpg123_handle *fr)
|
|
|
150 {
|
|
|
151 int ret = MPG123_ERR;
|
|
|
152 if(fr->p.index_size >= 0)
|
|
|
153 { /* Simple fixed index. */
|
|
|
154 fr->index.grow_size = 0;
|
|
|
155 debug1("resizing index to %li", fr->p.index_size);
|
|
|
156 ret = fi_resize(&fr->index, (size_t)fr->p.index_size);
|
|
|
157 debug2("index resized... %lu at %p", (unsigned long)fr->index.size, (void*)fr->index.data);
|
|
|
158 }
|
|
|
159 else
|
|
|
160 { /* A growing index. We give it a start, though. */
|
|
|
161 fr->index.grow_size = (size_t)(- fr->p.index_size);
|
|
|
162 if(fr->index.size < fr->index.grow_size)
|
|
|
163 ret = fi_resize(&fr->index, fr->index.grow_size);
|
|
|
164 else
|
|
|
165 ret = MPG123_OK; /* We have minimal size already... and since growing is OK... */
|
|
|
166 }
|
|
|
167 debug2("set up frame index of size %lu (ret=%i)", (unsigned long)fr->index.size, ret);
|
|
|
168
|
|
|
169 return ret;
|
|
|
170 }
|
|
|
171 #endif
|
|
|
172
|
|
|
173 int frame_buffers(mpg123_handle *fr)
|
|
|
174 {
|
|
|
175 int buffssize = 0;
|
|
|
176 debug1("frame %p buffer", (void*)fr);
|
|
|
177 /*
|
|
|
178 the used-to-be-static buffer of the synth functions, has some subtly different types/sizes
|
|
|
179
|
|
|
180 2to1, 4to1, ntom, generic, i386: real[2][2][0x110]
|
|
|
181 mmx, sse: short[2][2][0x110]
|
|
|
182 i586(_dither): 4352 bytes; int/long[2][2][0x110]
|
|
|
183 i486: int[2][2][17*FIR_BUFFER_SIZE]
|
|
|
184 altivec: static real __attribute__ ((aligned (16))) buffs[4][4][0x110]
|
|
|
185
|
|
|
186 Huh, altivec looks like fun. Well, let it be large... then, the 16 byte alignment seems to be implicit on MacOSX malloc anyway.
|
|
|
187 Let's make a reasonable attempt to allocate enough memory...
|
|
|
188 Keep in mind: biggest ones are i486 and altivec (mutually exclusive!), then follows i586 and normal real.
|
|
|
189 mmx/sse use short but also real for resampling.
|
|
|
190 Thus, minimum is 2*2*0x110*sizeof(real).
|
|
|
191 */
|
|
|
192 if(fr->cpu_opts.type == altivec) buffssize = 4*4*0x110*sizeof(real);
|
|
|
193 #ifdef OPT_I486
|
|
|
194 else if(fr->cpu_opts.type == ivier) buffssize = 2*2*17*FIR_BUFFER_SIZE*sizeof(int);
|
|
|
195 #endif
|
|
|
196 else if(fr->cpu_opts.type == ifuenf || fr->cpu_opts.type == ifuenf_dither || fr->cpu_opts.type == dreidnow)
|
|
|
197 buffssize = 2*2*0x110*4; /* don't rely on type real, we need 4352 bytes */
|
|
|
198
|
|
|
199 if(2*2*0x110*sizeof(real) > buffssize)
|
|
|
200 buffssize = 2*2*0x110*sizeof(real);
|
|
|
201 buffssize += 15; /* For 16-byte alignment (SSE likes that). */
|
|
|
202
|
|
|
203 if(fr->rawbuffs != NULL && fr->rawbuffss != buffssize)
|
|
|
204 {
|
|
|
205 free(fr->rawbuffs);
|
|
|
206 fr->rawbuffs = NULL;
|
|
|
207 }
|
|
|
208
|
|
|
209 if(fr->rawbuffs == NULL) fr->rawbuffs = (unsigned char*) malloc(buffssize);
|
|
|
210 if(fr->rawbuffs == NULL) return -1;
|
|
|
211 fr->rawbuffss = buffssize;
|
|
|
212 fr->short_buffs[0][0] = aligned_pointer(fr->rawbuffs,short,16);
|
|
|
213 fr->short_buffs[0][1] = fr->short_buffs[0][0] + 0x110;
|
|
|
214 fr->short_buffs[1][0] = fr->short_buffs[0][1] + 0x110;
|
|
|
215 fr->short_buffs[1][1] = fr->short_buffs[1][0] + 0x110;
|
|
|
216 fr->real_buffs[0][0] = aligned_pointer(fr->rawbuffs,real,16);
|
|
|
217 fr->real_buffs[0][1] = fr->real_buffs[0][0] + 0x110;
|
|
|
218 fr->real_buffs[1][0] = fr->real_buffs[0][1] + 0x110;
|
|
|
219 fr->real_buffs[1][1] = fr->real_buffs[1][0] + 0x110;
|
|
|
220 #ifdef OPT_I486
|
|
|
221 if(fr->cpu_opts.type == ivier)
|
|
|
222 {
|
|
|
223 fr->int_buffs[0][0] = (int*) fr->rawbuffs;
|
|
|
224 fr->int_buffs[0][1] = fr->int_buffs[0][0] + 17*FIR_BUFFER_SIZE;
|
|
|
225 fr->int_buffs[1][0] = fr->int_buffs[0][1] + 17*FIR_BUFFER_SIZE;
|
|
|
226 fr->int_buffs[1][1] = fr->int_buffs[1][0] + 17*FIR_BUFFER_SIZE;
|
|
|
227 }
|
|
|
228 #endif
|
|
|
229 #ifdef OPT_ALTIVEC
|
|
|
230 if(fr->cpu_opts.type == altivec)
|
|
|
231 {
|
|
|
232 int i,j;
|
|
|
233 fr->areal_buffs[0][0] = (real*) fr->rawbuffs;
|
|
|
234 for(i=0; i<4; ++i) for(j=0; j<4; ++j)
|
|
|
235 fr->areal_buffs[i][j] = fr->areal_buffs[0][0] + (i*4+j)*0x110;
|
|
|
236 }
|
|
|
237 #endif
|
|
|
238 /* now the different decwins... all of the same size, actually */
|
|
|
239 /* The MMX ones want 32byte alignment, which I'll try to ensure manually */
|
|
|
240 {
|
|
|
241 int decwin_size = (512+32)*sizeof(real);
|
|
|
242 if(fr->rawdecwin != NULL) free(fr->rawdecwin);
|
|
|
243 #ifdef OPT_MMXORSSE
|
|
|
244 #ifdef OPT_MULTI
|
|
|
245 if(fr->cpu_opts.class == mmxsse)
|
|
|
246 {
|
|
|
247 #endif
|
|
|
248 /* decwin_mmx will share, decwins will be appended ... sizeof(float)==4 */
|
|
|
249 if(decwin_size < (512+32)*4) decwin_size = (512+32)*4;
|
|
|
250 decwin_size += (512+32)*4 + 31; /* the second window + alignment zone */
|
|
|
251 /* (512+32)*4/32 == 2176/32 == 68, so one decwin block retains alignment */
|
|
|
252 #ifdef OPT_MULTI
|
|
|
253 }
|
|
|
254 #endif
|
|
|
255 #endif
|
|
|
256 fr->rawdecwin = (unsigned char*) malloc(decwin_size);
|
|
|
257 if(fr->rawdecwin == NULL) return -1;
|
|
|
258 fr->decwin = (real*) fr->rawdecwin;
|
|
|
259 #ifdef OPT_MMXORSSE
|
|
|
260 #ifdef OPT_MULTI
|
|
|
261 if(fr->cpu_opts.class == mmxsse)
|
|
|
262 {
|
|
|
263 #endif
|
|
|
264 /* align decwin, assign that to decwin_mmx, append decwins */
|
|
|
265 /* I need to add to decwin what is missing to the next full 32 byte -- also I want to make gcc -pedantic happy... */
|
|
|
266 fr->decwin = aligned_pointer(fr->rawdecwin,real,32);
|
|
|
267 debug1("aligned decwin: %p", (void*)fr->decwin);
|
|
|
268 fr->decwin_mmx = (float*)fr->decwin;
|
|
|
269 fr->decwins = fr->decwin_mmx+512+32;
|
|
|
270 #ifdef OPT_MULTI
|
|
|
271 }
|
|
|
272 else debug("no decwins/decwin_mmx for that class");
|
|
|
273 #endif
|
|
|
274 #endif
|
|
|
275 }
|
|
|
276 frame_buffers_reset(fr);
|
|
|
277 debug1("frame %p buffer done", (void*)fr);
|
|
|
278 return 0;
|
|
|
279 }
|
|
|
280
|
|
|
281 int frame_buffers_reset(mpg123_handle *fr)
|
|
|
282 {
|
|
|
283 fr->buffer.fill = 0; /* hm, reset buffer fill... did we do a flush? */
|
|
|
284 fr->bsnum = 0;
|
|
|
285 /* Wondering: could it be actually _wanted_ to retain buffer contents over different files? (special gapless / cut stuff) */
|
|
|
286 fr->bsbuf = fr->bsspace[1];
|
|
|
287 fr->bsbufold = fr->bsbuf;
|
|
|
288 fr->bitreservoir = 0; /* Not entirely sure if this is the right place for that counter. */
|
|
|
289 memset(fr->bsspace, 0, 2*(MAXFRAMESIZE+512));
|
|
|
290 memset(fr->ssave, 0, 34);
|
|
|
291 memset(fr->rawbuffs, 0, fr->rawbuffss);
|
|
|
292 fr->hybrid_blc[0] = fr->hybrid_blc[1] = 0;
|
|
|
293 memset(fr->hybrid_block, 0, sizeof(real)*2*2*SBLIMIT*SSLIMIT);
|
|
|
294 /* Not totally, but quite, sure that decwin(s) doesn't need cleaning. */
|
|
|
295 return 0;
|
|
|
296 }
|
|
|
297
|
|
|
298 void frame_icy_reset(mpg123_handle* fr)
|
|
|
299 {
|
|
|
300 if(fr->icy.data != NULL) free(fr->icy.data);
|
|
|
301 fr->icy.data = NULL;
|
|
|
302 fr->icy.interval = 0;
|
|
|
303 fr->icy.next = 0;
|
|
|
304 }
|
|
|
305
|
|
|
306 void frame_free_toc(mpg123_handle *fr)
|
|
|
307 {
|
|
|
308 if(fr->xing_toc != NULL){ free(fr->xing_toc); fr->xing_toc = NULL; }
|
|
|
309 }
|
|
|
310
|
|
|
311 /* Just copy the Xing TOC over... */
|
|
|
312 int frame_fill_toc(mpg123_handle *fr, unsigned char* in)
|
|
|
313 {
|
|
|
314 if(fr->xing_toc == NULL) fr->xing_toc = malloc(100);
|
|
|
315 if(fr->xing_toc != NULL)
|
|
|
316 {
|
|
|
317 memcpy(fr->xing_toc, in, 100);
|
|
|
318 #ifdef DEBUG
|
|
|
319 debug("Got a TOC! Showing the values...");
|
|
|
320 {
|
|
|
321 int i;
|
|
|
322 for(i=0; i<100; ++i)
|
|
|
323 debug2("entry %i = %i", i, fr->xing_toc[i]);
|
|
|
324 }
|
|
|
325 #endif
|
|
|
326 return TRUE;
|
|
|
327 }
|
|
|
328 return FALSE;
|
|
|
329 }
|
|
|
330
|
|
|
331 /* Prepare the handle for a new track.
|
|
|
332 Reset variables, buffers... */
|
|
|
333 int frame_reset(mpg123_handle* fr)
|
|
|
334 {
|
|
|
335 frame_buffers_reset(fr);
|
|
|
336 frame_fixed_reset(fr);
|
|
|
337 frame_free_toc(fr);
|
|
|
338 #ifdef FRAME_INDEX
|
|
|
339 fi_reset(&fr->index);
|
|
|
340 #endif
|
|
|
341
|
|
|
342 return 0;
|
|
|
343 }
|
|
|
344
|
|
|
345 /* Reset everythign except dynamic memory. */
|
|
|
346 static void frame_fixed_reset(mpg123_handle *fr)
|
|
|
347 {
|
|
|
348 frame_icy_reset(fr);
|
|
|
349 open_bad(fr);
|
|
|
350 fr->to_decode = FALSE;
|
|
|
351 fr->to_ignore = FALSE;
|
|
|
352 fr->metaflags = 0;
|
|
|
353 fr->outblock = mpg123_safe_buffer();
|
|
|
354 fr->num = -1;
|
|
|
355 fr->accurate = TRUE;
|
|
|
356 fr->silent_resync = 0;
|
|
|
357 fr->audio_start = 0;
|
|
|
358 fr->clip = 0;
|
|
|
359 fr->oldhead = 0;
|
|
|
360 fr->firsthead = 0;
|
|
|
361 fr->vbr = MPG123_CBR;
|
|
|
362 fr->abr_rate = 0;
|
|
|
363 fr->track_frames = 0;
|
|
|
364 fr->track_samples = -1;
|
|
|
365 fr->framesize=0;
|
|
|
366 fr->mean_frames = 0;
|
|
|
367 fr->mean_framesize = 0;
|
|
|
368 fr->freesize = 0;
|
|
|
369 fr->lastscale = -1;
|
|
|
370 fr->rva.level[0] = -1;
|
|
|
371 fr->rva.level[1] = -1;
|
|
|
372 fr->rva.gain[0] = 0;
|
|
|
373 fr->rva.gain[1] = 0;
|
|
|
374 fr->rva.peak[0] = 0;
|
|
|
375 fr->rva.peak[1] = 0;
|
|
|
376 fr->fsizeold = 0;
|
|
|
377 fr->firstframe = 0;
|
|
|
378 fr->ignoreframe = fr->firstframe-IGNORESHIFT;
|
|
|
379 fr->lastframe = -1;
|
|
|
380 fr->fresh = 1;
|
|
|
381 fr->new_format = 0;
|
|
|
382 #ifdef GAPLESS
|
|
|
383 frame_gapless_init(fr,0,0);
|
|
|
384 fr->lastoff = 0;
|
|
|
385 fr->firstoff = 0;
|
|
|
386 #endif
|
|
|
387 fr->bo[0] = 1; /* the usual bo */
|
|
|
388 fr->bo[1] = 0; /* ditherindex */
|
|
|
389 #ifdef OPT_I486
|
|
|
390 fr->bo[0] = fr->bo[1] = FIR_SIZE-1;
|
|
|
391 #endif
|
|
|
392 reset_id3(fr);
|
|
|
393 reset_icy(&fr->icy);
|
|
|
394 /* ICY stuff should go into icy.c, eh? */
|
|
|
395 fr->icy.interval = 0;
|
|
|
396 fr->icy.next = 0;
|
|
|
397 fr->halfphase = 0; /* here or indeed only on first-time init? */
|
|
|
398 }
|
|
|
399
|
|
|
400 void frame_free_buffers(mpg123_handle *fr)
|
|
|
401 {
|
|
|
402 if(fr->rawbuffs != NULL) free(fr->rawbuffs);
|
|
|
403 fr->rawbuffs = NULL;
|
|
|
404 if(fr->rawdecwin != NULL) free(fr->rawdecwin);
|
|
|
405 fr->rawdecwin = NULL;
|
|
|
406 if(fr->conv16to8_buf != NULL) free(fr->conv16to8_buf);
|
|
|
407 fr->conv16to8_buf = NULL;
|
|
|
408 }
|
|
|
409
|
|
|
410 void frame_exit(mpg123_handle *fr)
|
|
|
411 {
|
|
|
412 if(fr->own_buffer && fr->buffer.data != NULL)
|
|
|
413 {
|
|
|
414 debug1("freeing buffer at %p", (void*)fr->buffer.data);
|
|
|
415 free(fr->buffer.data);
|
|
|
416 }
|
|
|
417 fr->buffer.data = NULL;
|
|
|
418 frame_free_buffers(fr);
|
|
|
419 frame_free_toc(fr);
|
|
|
420 #ifdef FRAME_INDEX
|
|
|
421 fi_exit(&fr->index);
|
|
|
422 #endif
|
|
|
423 exit_id3(fr);
|
|
|
424 clear_icy(&fr->icy);
|
|
|
425 }
|
|
|
426
|
|
|
427 int attribute_align_arg mpg123_info(mpg123_handle *mh, struct mpg123_frameinfo *mi)
|
|
|
428 {
|
|
|
429 if(mh == NULL) return MPG123_ERR;
|
|
|
430 if(mi == NULL)
|
|
|
431 {
|
|
|
432 mh->err = MPG123_ERR_NULL;
|
|
|
433 return MPG123_ERR;
|
|
|
434 }
|
|
|
435 mi->version = mh->mpeg25 ? MPG123_2_5 : (mh->lsf ? MPG123_2_0 : MPG123_1_0);
|
|
|
436 mi->layer = mh->lay;
|
|
|
437 mi->rate = frame_freq(mh);
|
|
|
438 switch(mh->mode)
|
|
|
439 {
|
|
|
440 case 0: mi->mode = MPG123_M_STEREO; break;
|
|
|
441 case 1: mi->mode = MPG123_M_JOINT; break;
|
|
|
442 case 2: mi->mode = MPG123_M_DUAL; break;
|
|
|
443 case 3: mi->mode = MPG123_M_MONO; break;
|
|
|
444 default: error("That mode cannot be!");
|
|
|
445 }
|
|
|
446 mi->mode_ext = mh->mode_ext;
|
|
|
447 mi->framesize = mh->framesize+4; /* Include header. */
|
|
|
448 mi->flags = 0;
|
|
|
449 if(mh->error_protection) mi->flags |= MPG123_CRC;
|
|
|
450 if(mh->copyright) mi->flags |= MPG123_COPYRIGHT;
|
|
|
451 if(mh->extension) mi->flags |= MPG123_PRIVATE;
|
|
|
452 if(mh->original) mi->flags |= MPG123_ORIGINAL;
|
|
|
453 mi->emphasis = mh->emphasis;
|
|
|
454 mi->bitrate = frame_bitrate(mh);
|
|
|
455 mi->abr_rate = mh->abr_rate;
|
|
|
456 mi->vbr = mh->vbr;
|
|
|
457 return MPG123_OK;
|
|
|
458 }
|
|
|
459
|
|
|
460
|
|
|
461 /*
|
|
|
462 Fuzzy frame offset searching (guessing).
|
|
|
463 When we don't have an accurate position, we may use an inaccurate one.
|
|
|
464 Possibilities:
|
|
|
465 - use approximate positions from Xing TOC (not yet parsed)
|
|
|
466 - guess wildly from mean framesize and offset of first frame / beginning of file.
|
|
|
467 */
|
|
|
468
|
|
|
469 off_t frame_fuzzy_find(mpg123_handle *fr, off_t want_frame, off_t* get_frame)
|
|
|
470 {
|
|
|
471 /* Default is to go to the beginning. */
|
|
|
472 off_t ret = fr->audio_start;
|
|
|
473 *get_frame = 0;
|
|
|
474
|
|
|
475 /* But we try to find something better. */
|
|
|
476 /* Xing VBR TOC works with relative positions, both in terms of audio frames and stream bytes.
|
|
|
477 Thus, it only works when whe know the length of things.
|
|
|
478 Oh... I assume the offsets are relative to the _total_ file length. */
|
|
|
479 if(fr->xing_toc != NULL && fr->track_frames > 0 && fr->rdat.filelen > 0)
|
|
|
480 {
|
|
|
481 /* One could round... */
|
|
|
482 int toc_entry = (int) ((double)want_frame*100./fr->track_frames);
|
|
|
483 /* It is an index in the 100-entry table. */
|
|
|
484 if(toc_entry < 0) toc_entry = 0;
|
|
|
485 if(toc_entry > 99) toc_entry = 99;
|
|
|
486
|
|
|
487 /* Now estimate back what frame we get. */
|
|
|
488 *get_frame = (off_t) ((double)toc_entry/100. * fr->track_frames);
|
|
|
489 fr->accurate = FALSE;
|
|
|
490 fr->silent_resync = 1;
|
|
|
491 /* Question: Is the TOC for whole file size (with/without ID3) or the "real" audio data only?
|
|
|
492 ID3v1 info could also matter. */
|
|
|
493 ret = (off_t) ((double)fr->xing_toc[toc_entry]/256.* fr->rdat.filelen);
|
|
|
494 }
|
|
|
495 else if(fr->mean_framesize > 0)
|
|
|
496 { /* Just guess with mean framesize (may be exact with CBR files). */
|
|
|
497 /* Query filelen here or not? */
|
|
|
498 fr->accurate = FALSE; /* Fuzzy! */
|
|
|
499 fr->silent_resync = 1;
|
|
|
500 *get_frame = want_frame;
|
|
|
501 ret = fr->audio_start+fr->mean_framesize*want_frame;
|
|
|
502 }
|
|
|
503 debug5("fuzzy: want %li of %li, get %li at %li B of %li B",
|
|
|
504 (long)want_frame, (long)fr->track_frames, (long)*get_frame, (long)ret, (long)(fr->rdat.filelen-fr->audio_start));
|
|
|
505 return ret;
|
|
|
506 }
|
|
|
507
|
|
|
508 /*
|
|
|
509 find the best frame in index just before the wanted one, seek to there
|
|
|
510 then step to just before wanted one with read_frame
|
|
|
511 do not care tabout the stuff that was in buffer but not played back
|
|
|
512 everything that left the decoder is counted as played
|
|
|
513
|
|
|
514 Decide if you want low latency reaction and accurate timing info or stable long-time playback with buffer!
|
|
|
515 */
|
|
|
516
|
|
|
517 off_t frame_index_find(mpg123_handle *fr, off_t want_frame, off_t* get_frame)
|
|
|
518 {
|
|
|
519 /* default is file start if no index position */
|
|
|
520 off_t gopos = 0;
|
|
|
521 *get_frame = 0;
|
|
|
522 #ifdef FRAME_INDEX
|
|
|
523 /* Possibly use VBRI index, too? I'd need an example for this... */
|
|
|
524 if(fr->index.fill)
|
|
|
525 {
|
|
|
526 /* find in index */
|
|
|
527 size_t fi;
|
|
|
528 /* at index fi there is frame step*fi... */
|
|
|
529 fi = want_frame/fr->index.step;
|
|
|
530 if(fi >= fr->index.fill) /* If we are beyond the end of frame index...*/
|
|
|
531 {
|
|
|
532 /* When fuzzy seek is allowed, we have some limited tolerance for the frames we want to read rather then jump over. */
|
|
|
533 if(fr->p.flags & MPG123_FUZZY && want_frame - (fr->index.fill-1)*fr->index.step > 10)
|
|
|
534 {
|
|
|
535 gopos = frame_fuzzy_find(fr, want_frame, get_frame);
|
|
|
536 if(gopos > fr->audio_start) return gopos; /* Only in that case, we have a useful guess. */
|
|
|
537 /* Else... just continue, fuzzyness didn't help. */
|
|
|
538 }
|
|
|
539 /* Use the last available position, slowly advancing from that one. */
|
|
|
540 fi = fr->index.fill - 1;
|
|
|
541 }
|
|
|
542 /* We have index position, that yields frame and byte offsets. */
|
|
|
543 *get_frame = fi*fr->index.step;
|
|
|
544 gopos = fr->index.data[fi];
|
|
|
545 fr->accurate = TRUE; /* When using the frame index, we are accurate. */
|
|
|
546 }
|
|
|
547 else
|
|
|
548 {
|
|
|
549 #endif
|
|
|
550 if(fr->p.flags & MPG123_FUZZY)
|
|
|
551 return frame_fuzzy_find(fr, want_frame, get_frame);
|
|
|
552 /* A bit hackish here... but we need to be fresh when looking for the first header again. */
|
|
|
553 fr->firsthead = 0;
|
|
|
554 fr->oldhead = 0;
|
|
|
555 #ifdef FRAME_INDEX
|
|
|
556 }
|
|
|
557 #endif
|
|
|
558 debug2("index: 0x%lx for frame %li", (unsigned long)gopos, (long) *get_frame);
|
|
|
559 return gopos;
|
|
|
560 }
|
|
|
561
|
|
|
562 off_t frame_ins2outs(mpg123_handle *fr, off_t ins)
|
|
|
563 {
|
|
|
564 off_t outs = 0;
|
|
|
565 switch(fr->down_sample)
|
|
|
566 {
|
|
|
567 case 0:
|
|
|
568 case 1:
|
|
|
569 case 2: outs = ins>>fr->down_sample; break;
|
|
|
570 case 3: outs = ntom_ins2outs(fr, ins); break;
|
|
|
571 default: error1("Bad down_sample (%i) ... should not be possible!!", fr->down_sample);
|
|
|
572 }
|
|
|
573 return outs;
|
|
|
574 }
|
|
|
575
|
|
|
576 off_t frame_outs(mpg123_handle *fr, off_t num)
|
|
|
577 {
|
|
|
578 off_t outs = 0;
|
|
|
579 switch(fr->down_sample)
|
|
|
580 {
|
|
|
581 case 0:
|
|
|
582 case 1:
|
|
|
583 case 2: outs = (spf(fr)>>fr->down_sample)*num; break;
|
|
|
584 case 3: outs = ntom_frmouts(fr, num); break;
|
|
|
585 default: error1("Bad down_sample (%i) ... should not be possible!!", fr->down_sample);
|
|
|
586 }
|
|
|
587 return outs;
|
|
|
588 }
|
|
|
589
|
|
|
590 off_t frame_offset(mpg123_handle *fr, off_t outs)
|
|
|
591 {
|
|
|
592 off_t num = 0;
|
|
|
593 switch(fr->down_sample)
|
|
|
594 {
|
|
|
595 case 0:
|
|
|
596 case 1:
|
|
|
597 case 2: num = outs/(spf(fr)>>fr->down_sample); break;
|
|
|
598 case 3: num = ntom_frameoff(fr, outs); break;
|
|
|
599 default: error("Bad down_sample ... should not be possible!!");
|
|
|
600 }
|
|
|
601 return num;
|
|
|
602 }
|
|
|
603
|
|
|
604 #ifdef GAPLESS
|
|
|
605 /* input in _input_ samples */
|
|
|
606 void frame_gapless_init(mpg123_handle *fr, off_t b, off_t e)
|
|
|
607 {
|
|
|
608 fr->begin_s = b;
|
|
|
609 fr->end_s = e;
|
|
|
610 /* These will get proper values later, from above plus resampling info. */
|
|
|
611 fr->begin_os = 0;
|
|
|
612 fr->end_os = 0;
|
|
|
613 debug2("frame_gapless_init: from %lu to %lu samples", (long unsigned)fr->begin_s, (long unsigned)fr->end_s);
|
|
|
614 }
|
|
|
615
|
|
|
616 void frame_gapless_realinit(mpg123_handle *fr)
|
|
|
617 {
|
|
|
618 fr->begin_os = frame_ins2outs(fr, fr->begin_s);
|
|
|
619 fr->end_os = frame_ins2outs(fr, fr->end_s);
|
|
|
620 debug2("frame_gapless_realinit: from %lu to %lu samples", (long unsigned)fr->begin_os, (long unsigned)fr->end_os);
|
|
|
621 }
|
|
|
622 #endif
|
|
|
623
|
|
|
624 /* The frame seek... This is not simply the seek to fe*spf(fr) samples in output because we think of _input_ frames here.
|
|
|
625 Seek to frame offset 1 may be just seek to 200 samples offset in output since the beginning of first frame is delay/padding.
|
|
|
626 Hm, is that right? OK for the padding stuff, but actually, should the decoder delay be better totally hidden or not?
|
|
|
627 With gapless, even the whole frame position could be advanced further than requested (since Homey don't play dat). */
|
|
|
628 void frame_set_frameseek(mpg123_handle *fr, off_t fe)
|
|
|
629 {
|
|
|
630 fr->firstframe = fe;
|
|
|
631 #ifdef GAPLESS
|
|
|
632 if(fr->p.flags & MPG123_GAPLESS)
|
|
|
633 {
|
|
|
634 /* Take care of the beginning... */
|
|
|
635 off_t beg_f = frame_offset(fr, fr->begin_os);
|
|
|
636 if(fe <= beg_f)
|
|
|
637 {
|
|
|
638 fr->firstframe = beg_f;
|
|
|
639 fr->firstoff = fr->begin_os - frame_outs(fr, beg_f);
|
|
|
640 }
|
|
|
641 else fr->firstoff = 0;
|
|
|
642 /* The end is set once for a track at least, on the frame_set_frameseek called in get_next_frame() */
|
|
|
643 if(fr->end_os > 0)
|
|
|
644 {
|
|
|
645 fr->lastframe = frame_offset(fr,fr->end_os);
|
|
|
646 fr->lastoff = fr->end_os - frame_outs(fr, fr->lastframe);
|
|
|
647 } else fr->lastoff = 0;
|
|
|
648 } else { fr->firstoff = fr->lastoff = 0; fr->lastframe = -1; }
|
|
|
649 #endif
|
|
|
650 fr->ignoreframe = fr->lay == 3 ? fr->firstframe-IGNORESHIFT : fr->firstframe;
|
|
|
651 #ifdef GAPLESS
|
|
|
652 debug5("frame_set_frameseek: begin at %li frames and %li samples, end at %li and %li; ignore from %li",
|
|
|
653 (long) fr->firstframe, (long) fr->firstoff,
|
|
|
654 (long) fr->lastframe, (long) fr->lastoff, (long) fr->ignoreframe);
|
|
|
655 #else
|
|
|
656 debug3("frame_set_frameseek: begin at %li frames, end at %li; ignore from %li",
|
|
|
657 (long) fr->firstframe, (long) fr->lastframe, (long) fr->ignoreframe);
|
|
|
658 #endif
|
|
|
659 }
|
|
|
660
|
|
|
661 /* Sample accurate seek prepare for decoder. */
|
|
|
662 /* This gets unadjusted output samples and takes resampling into account */
|
|
|
663 void frame_set_seek(mpg123_handle *fr, off_t sp)
|
|
|
664 {
|
|
|
665 fr->firstframe = frame_offset(fr, sp);
|
|
|
666 fr->ignoreframe = fr->lay == 3 ? fr->firstframe-IGNORESHIFT : fr->firstframe;
|
|
|
667 #ifdef GAPLESS /* The sample offset is used for non-gapless mode, too! */
|
|
|
668 fr->firstoff = sp - frame_outs(fr, fr->firstframe);
|
|
|
669 debug5("frame_set_seek: begin at %li frames and %li samples, end at %li and %li; ignore from %li",
|
|
|
670 (long) fr->firstframe, (long) fr->firstoff,
|
|
|
671 (long) fr->lastframe, (long) fr->lastoff, (long) fr->ignoreframe);
|
|
|
672 #else
|
|
|
673 debug3("frame_set_seek: begin at %li frames, end at %li; ignore from %li",
|
|
|
674 (long) fr->firstframe, (long) fr->lastframe, (long) fr->ignoreframe);
|
|
|
675 #endif
|
|
|
676 }
|
|
|
677
|
|
|
678 /* to vanish */
|
|
|
679 void frame_outformat(mpg123_handle *fr, int format, int channels, long rate)
|
|
|
680 {
|
|
|
681 fr->af.encoding = format;
|
|
|
682 fr->af.rate = rate;
|
|
|
683 fr->af.channels = channels;
|
|
|
684 }
|
|
|
685
|
|
|
686 /* set synth functions for current frame, optimizations handled by opt_* macros */
|
|
|
687 int set_synth_functions(mpg123_handle *fr)
|
|
|
688 {
|
|
|
689 int ds = fr->down_sample;
|
|
|
690 int p8=0;
|
|
|
691 static func_synth funcs[2][4] = {
|
|
|
692 { NULL,
|
|
|
693 synth_2to1,
|
|
|
694 synth_4to1,
|
|
|
695 synth_ntom } ,
|
|
|
696 { NULL,
|
|
|
697 synth_2to1_8bit,
|
|
|
698 synth_4to1_8bit,
|
|
|
699 synth_ntom_8bit }
|
|
|
700 };
|
|
|
701 static func_synth_mono funcs_mono[2][2][4] = {
|
|
|
702 { { NULL ,
|
|
|
703 synth_2to1_mono2stereo ,
|
|
|
704 synth_4to1_mono2stereo ,
|
|
|
705 synth_ntom_mono2stereo } ,
|
|
|
706 { NULL ,
|
|
|
707 synth_2to1_8bit_mono2stereo ,
|
|
|
708 synth_4to1_8bit_mono2stereo ,
|
|
|
709 synth_ntom_8bit_mono2stereo } } ,
|
|
|
710 { { NULL ,
|
|
|
711 synth_2to1_mono ,
|
|
|
712 synth_4to1_mono ,
|
|
|
713 synth_ntom_mono } ,
|
|
|
714 { NULL ,
|
|
|
715 synth_2to1_8bit_mono ,
|
|
|
716 synth_4to1_8bit_mono ,
|
|
|
717 synth_ntom_8bit_mono } }
|
|
|
718 };
|
|
|
719
|
|
|
720 /* possibly non-constand entries filled here */
|
|
|
721 funcs[0][0] = (func_synth) opt_synth_1to1(fr);
|
|
|
722 funcs[1][0] = (func_synth) opt_synth_1to1_8bit(fr);
|
|
|
723 funcs_mono[0][0][0] = (func_synth_mono) opt_synth_1to1_mono2stereo(fr);
|
|
|
724 funcs_mono[0][1][0] = (func_synth_mono) opt_synth_1to1_8bit_mono2stereo(fr);
|
|
|
725 funcs_mono[1][0][0] = (func_synth_mono) opt_synth_1to1_mono(fr);
|
|
|
726 funcs_mono[1][1][0] = (func_synth_mono) opt_synth_1to1_8bit_mono(fr);
|
|
|
727
|
|
|
728 if(fr->af.encoding & MPG123_ENC_8) p8 = 1;
|
|
|
729 fr->synth = funcs[p8][ds];
|
|
|
730 fr->synth_mono = funcs_mono[fr->af.channels==2 ? 0 : 1][p8][ds];
|
|
|
731
|
|
|
732 if(p8)
|
|
|
733 {
|
|
|
734 if(make_conv16to8_table(fr) != 0)
|
|
|
735 {
|
|
|
736 /* it's a bit more work to get proper error propagation up */
|
|
|
737 return -1;
|
|
|
738 }
|
|
|
739 }
|
|
|
740 return 0;
|
|
|
741 }
|
|
|
742
|
|
|
743 int attribute_align_arg mpg123_volume_change(mpg123_handle *mh, double change)
|
|
|
744 {
|
|
|
745 if(mh == NULL) return MPG123_ERR;
|
|
|
746 return mpg123_volume(mh, change + (double) mh->p.outscale / MAXOUTBURST);
|
|
|
747 }
|
|
|
748
|
|
|
749 int attribute_align_arg mpg123_volume(mpg123_handle *mh, double vol)
|
|
|
750 {
|
|
|
751 if(mh == NULL) return MPG123_ERR;
|
|
|
752 if(vol >= 0) mh->p.outscale = (double) MAXOUTBURST * vol;
|
|
|
753 do_rva(mh);
|
|
|
754 return MPG123_OK;
|
|
|
755 }
|
|
|
756
|
|
|
757 static int get_rva(mpg123_handle *fr, double *peak, double *gain)
|
|
|
758 {
|
|
|
759 double p = -1;
|
|
|
760 double g = 0;
|
|
|
761 int ret = 0;
|
|
|
762 if(fr->p.rva)
|
|
|
763 {
|
|
|
764 int rt = 0;
|
|
|
765 /* Should one assume a zero RVA as no RVA? */
|
|
|
766 if(fr->p.rva == 2 && fr->rva.level[1] != -1) rt = 1;
|
|
|
767 if(fr->rva.level[rt] != -1)
|
|
|
768 {
|
|
|
769 p = fr->rva.peak[rt];
|
|
|
770 g = fr->rva.gain[rt];
|
|
|
771 ret = 1; /* Success. */
|
|
|
772 }
|
|
|
773 }
|
|
|
774 if(peak != NULL) *peak = p;
|
|
|
775 if(gain != NULL) *gain = g;
|
|
|
776 return ret;
|
|
|
777 }
|
|
|
778
|
|
|
779 /* adjust the volume, taking both fr->outscale and rva values into account */
|
|
|
780 void do_rva(mpg123_handle *fr)
|
|
|
781 {
|
|
|
782 double peak = 0;
|
|
|
783 double gain = 0;
|
|
|
784 scale_t newscale;
|
|
|
785 double rvafact = 1;
|
|
|
786 if(get_rva(fr, &peak, &gain))
|
|
|
787 {
|
|
|
788 if(NOQUIET && fr->p.verbose > 1) fprintf(stderr, "Note: doing RVA with gain %f\n", gain);
|
|
|
789 rvafact = pow(10,gain/20);
|
|
|
790 }
|
|
|
791
|
|
|
792 newscale = fr->p.outscale*rvafact;
|
|
|
793
|
|
|
794 /* if peak is unknown (== 0) this check won't hurt */
|
|
|
795 if((peak*newscale) > MAXOUTBURST)
|
|
|
796 {
|
|
|
797 newscale = (scale_t) ((double) MAXOUTBURST/peak);
|
|
|
798 #ifdef FLOATOUT
|
|
|
799 warning2("limiting scale value to %f to prevent clipping with indicated peak factor of %f", newscale, peak);
|
|
|
800 #else
|
|
|
801 warning2("limiting scale value to %li to prevent clipping with indicated peak factor of %f", newscale, peak);
|
|
|
802 #endif
|
|
|
803 }
|
|
|
804 /* first rva setting is forced with fr->lastscale < 0 */
|
|
|
805 if(newscale != fr->lastscale)
|
|
|
806 {
|
|
|
807 #ifdef FLOATOUT
|
|
|
808 debug3("changing scale value from %f to %f (peak estimated to %f)", fr->lastscale != -1 ? fr->lastscale : fr->p.outscale, newscale, (double) (newscale*peak));
|
|
|
809 #else
|
|
|
810 debug3("changing scale value from %li to %li (peak estimated to %li)", fr->lastscale != -1 ? fr->lastscale : fr->p.outscale, newscale, (long) (newscale*peak));
|
|
|
811 #endif
|
|
|
812 fr->lastscale = newscale;
|
|
|
813 opt_make_decode_tables(fr); /* the actual work */
|
|
|
814 }
|
|
|
815 }
|
|
|
816
|
|
|
817 int attribute_align_arg mpg123_getvolume(mpg123_handle *mh, double *base, double *really, double *rva_db)
|
|
|
818 {
|
|
|
819 if(mh == NULL) return MPG123_ERR;
|
|
|
820 if(base) *base = (double)mh->p.outscale/MAXOUTBURST;
|
|
|
821 if(really) *really = (double)mh->lastscale/MAXOUTBURST;
|
|
|
822 get_rva(mh, NULL, rva_db);
|
|
|
823 return MPG123_OK;
|
|
|
824 }
|
|
|
825
|
|
|
826 int frame_cpu_opt(mpg123_handle *fr, const char* cpu)
|
|
|
827 {
|
|
|
828 char* chosen = ""; /* the chosed decoder opt as string */
|
|
|
829 int auto_choose = 0;
|
|
|
830 int done = 0;
|
|
|
831 if( (cpu == NULL)
|
|
|
832 || (cpu[0] == 0)
|
|
|
833 || !strcasecmp(cpu, "auto") )
|
|
|
834 auto_choose = 1;
|
|
|
835 #ifndef OPT_MULTI
|
|
|
836 {
|
|
|
837 char **sd = mpg123_decoders(); /* this contains _one_ decoder */
|
|
|
838 if(!auto_choose && strcasecmp(cpu, sd[0])) done = 0;
|
|
|
839 else
|
|
|
840 {
|
|
|
841 chosen = sd[0];
|
|
|
842 done = 1;
|
|
|
843 }
|
|
|
844 }
|
|
|
845 #else
|
|
|
846 fr->cpu_opts.type = nodec;
|
|
|
847 /* covers any i386+ cpu; they actually differ only in the synth_1to1 function... */
|
|
|
848 #ifdef OPT_X86
|
|
|
849
|
|
|
850 #ifdef OPT_MMXORSSE
|
|
|
851 fr->cpu_opts.make_decode_tables = make_decode_tables;
|
|
|
852 fr->cpu_opts.init_layer3_gainpow2 = init_layer3_gainpow2;
|
|
|
853 fr->cpu_opts.init_layer2_table = init_layer2_table;
|
|
|
854 #endif
|
|
|
855 #ifdef OPT_3DNOW
|
|
|
856 fr->cpu_opts.dct36 = dct36;
|
|
|
857 #endif
|
|
|
858 #ifdef OPT_3DNOWEXT
|
|
|
859 fr->cpu_opts.dct36 = dct36;
|
|
|
860 #endif
|
|
|
861
|
|
|
862 if(cpu_i586(cpu_flags))
|
|
|
863 {
|
|
|
864 debug2("standard flags: 0x%08x\textended flags: 0x%08x", cpu_flags.std, cpu_flags.ext);
|
|
|
865 #ifdef OPT_3DNOWEXT
|
|
|
866 if( !done && (auto_choose || !strcasecmp(cpu, "3dnowext"))
|
|
|
867 && cpu_3dnow(cpu_flags)
|
|
|
868 && cpu_3dnowext(cpu_flags)
|
|
|
869 && cpu_mmx(cpu_flags) )
|
|
|
870 {
|
|
|
871 int go = 1;
|
|
|
872 if(fr->p.force_rate)
|
|
|
873 {
|
|
|
874 #if defined(K6_FALLBACK) || defined(PENTIUM_FALLBACK)
|
|
|
875 if(!auto_choose){ if(NOQUIET) error("I refuse to choose 3DNowExt as this will screw up with forced rate!"); }
|
|
|
876 else if(VERBOSE) fprintf(stderr, "Note: Not choosing 3DNowExt because flexible rate not supported.\n");
|
|
|
877
|
|
|
878 go = 0;
|
|
|
879 #else
|
|
|
880 if(NOQUIET) error("You will hear some awful sound because of flexible rate being chosen with 3DNowExt decoder!");
|
|
|
881 #endif
|
|
|
882 }
|
|
|
883 if(go){ /* temporary hack for flexible rate bug, not going indent this - fix it instead! */
|
|
|
884 chosen = "3DNowExt";
|
|
|
885 fr->cpu_opts.type = dreidnowext;
|
|
|
886 fr->cpu_opts.class = mmxsse;
|
|
|
887 fr->cpu_opts.dct36 = dct36_3dnowext;
|
|
|
888 fr->cpu_opts.synth_1to1 = synth_1to1_3dnowext;
|
|
|
889 fr->cpu_opts.dct64 = dct64_mmx; /* only use the 3dnow version in the synth_1to1_sse */
|
|
|
890 fr->cpu_opts.make_decode_tables = make_decode_tables_mmx;
|
|
|
891 fr->cpu_opts.init_layer3_gainpow2 = init_layer3_gainpow2_mmx;
|
|
|
892 fr->cpu_opts.init_layer2_table = init_layer2_table_mmx;
|
|
|
893 fr->cpu_opts.mpl_dct64 = dct64_3dnowext;
|
|
|
894 done = 1;
|
|
|
895 }
|
|
|
896 }
|
|
|
897 #endif
|
|
|
898 #ifdef OPT_SSE
|
|
|
899 if( !done && (auto_choose || !strcasecmp(cpu, "sse"))
|
|
|
900 && cpu_sse(cpu_flags) && cpu_mmx(cpu_flags) )
|
|
|
901 {
|
|
|
902 int go = 1;
|
|
|
903 if(fr->p.force_rate)
|
|
|
904 {
|
|
|
905 #ifdef PENTIUM_FALLBACK
|
|
|
906 if(!auto_choose){ if(NOQUIET) error("I refuse to choose SSE as this will screw up with forced rate!"); }
|
|
|
907 else if(VERBOSE) fprintf(stderr, "Note: Not choosing SSE because flexible rate not supported.\n");
|
|
|
908
|
|
|
909 go = 0;
|
|
|
910 #else
|
|
|
911 if(NOQUIET) error("You will hear some awful sound because of flexible rate being chosen with SSE decoder!");
|
|
|
912 #endif
|
|
|
913 }
|
|
|
914 if(go){ /* temporary hack for flexible rate bug, not going indent this - fix it instead! */
|
|
|
915 chosen = "SSE";
|
|
|
916 fr->cpu_opts.type = sse;
|
|
|
917 fr->cpu_opts.class = mmxsse;
|
|
|
918 fr->cpu_opts.synth_1to1 = synth_1to1_sse;
|
|
|
919 fr->cpu_opts.dct64 = dct64_mmx; /* only use the sse version in the synth_1to1_sse */
|
|
|
920 fr->cpu_opts.make_decode_tables = make_decode_tables_mmx;
|
|
|
921 fr->cpu_opts.init_layer3_gainpow2 = init_layer3_gainpow2_mmx;
|
|
|
922 fr->cpu_opts.init_layer2_table = init_layer2_table_mmx;
|
|
|
923 fr->cpu_opts.mpl_dct64 = dct64_sse;
|
|
|
924 done = 1;
|
|
|
925 }
|
|
|
926 }
|
|
|
927 #endif
|
|
|
928 #ifdef OPT_3DNOW
|
|
|
929 fr->cpu_opts.dct36 = dct36;
|
|
|
930 /* TODO: make autodetection for _all_ x86 optimizations (maybe just for i586+ and keep separate 486 build?) */
|
|
|
931 /* check cpuflags bit 31 (3DNow!) and 23 (MMX) */
|
|
|
932 if( !done && (auto_choose || !strcasecmp(cpu, "3dnow"))
|
|
|
933 && cpu_3dnow(cpu_flags) && cpu_mmx(cpu_flags) )
|
|
|
934 {
|
|
|
935 chosen = "3DNow";
|
|
|
936 fr->cpu_opts.type = dreidnow;
|
|
|
937 fr->cpu_opts.dct36 = dct36_3dnow; /* 3DNow! optimized dct36() */
|
|
|
938 fr->cpu_opts.synth_1to1 = synth_1to1_3dnow;
|
|
|
939 fr->cpu_opts.dct64 = dct64_i386; /* use the 3dnow one? */
|
|
|
940 done = 1;
|
|
|
941 }
|
|
|
942 #endif
|
|
|
943 #ifdef OPT_MMX
|
|
|
944 if( !done && (auto_choose || !strcasecmp(cpu, "mmx"))
|
|
|
945 && cpu_mmx(cpu_flags) )
|
|
|
946 {
|
|
|
947 int go = 1;
|
|
|
948 if(fr->p.force_rate)
|
|
|
949 {
|
|
|
950 #ifdef PENTIUM_FALLBACK
|
|
|
951 if(!auto_choose){ if(NOQUIET) error("I refuse to choose MMX as this will screw up with forced rate!"); }
|
|
|
952 else if(VERBOSE) fprintf(stderr, "Note: Not choosing MMX because flexible rate not supported.\n");
|
|
|
953
|
|
|
954 go = 0;
|
|
|
955 #else
|
|
|
956 error("You will hear some awful sound because of flexible rate being chosen with MMX decoder!");
|
|
|
957 #endif
|
|
|
958 }
|
|
|
959 if(go){ /* temporary hack for flexible rate bug, not going indent this - fix it instead! */
|
|
|
960 chosen = "MMX";
|
|
|
961 fr->cpu_opts.type = mmx;
|
|
|
962 fr->cpu_opts.class = mmxsse;
|
|
|
963 fr->cpu_opts.synth_1to1 = synth_1to1_mmx;
|
|
|
964 fr->cpu_opts.dct64 = dct64_mmx;
|
|
|
965 fr->cpu_opts.make_decode_tables = make_decode_tables_mmx;
|
|
|
966 fr->cpu_opts.init_layer3_gainpow2 = init_layer3_gainpow2_mmx;
|
|
|
967 fr->cpu_opts.init_layer2_table = init_layer2_table_mmx;
|
|
|
968 done = 1;
|
|
|
969 }
|
|
|
970 }
|
|
|
971 #endif
|
|
|
972 #ifdef OPT_I586
|
|
|
973 if(!done && (auto_choose || !strcasecmp(cpu, "i586")))
|
|
|
974 {
|
|
|
975 chosen = "i586/pentium";
|
|
|
976 fr->cpu_opts.type = ifuenf;
|
|
|
977 fr->cpu_opts.synth_1to1 = synth_1to1_i586;
|
|
|
978 fr->cpu_opts.synth_1to1_i586_asm = synth_1to1_i586_asm;
|
|
|
979 fr->cpu_opts.dct64 = dct64_i386;
|
|
|
980 done = 1;
|
|
|
981 }
|
|
|
982 #endif
|
|
|
983 #ifdef OPT_I586_DITHER
|
|
|
984 if(!done && (auto_choose || !strcasecmp(cpu, "i586_dither")))
|
|
|
985 {
|
|
|
986 chosen = "dithered i586/pentium";
|
|
|
987 fr->cpu_opts.type = ifuenf_dither;
|
|
|
988 fr->cpu_opts.synth_1to1 = synth_1to1_i586;
|
|
|
989 fr->cpu_opts.dct64 = dct64_i386;
|
|
|
990 fr->cpu_opts.synth_1to1_i586_asm = synth_1to1_i586_asm_dither;
|
|
|
991 done = 1;
|
|
|
992 }
|
|
|
993 #endif
|
|
|
994 }
|
|
|
995 #ifdef OPT_I486 /* that won't cooperate nicely in multi opt mode - forcing i486 in layer3.c */
|
|
|
996 if(!done && (auto_choose || !strcasecmp(cpu, "i486")))
|
|
|
997 {
|
|
|
998 chosen = "i486";
|
|
|
999 fr->cpu_opts.type = ivier;
|
|
|
1000 fr->cpu_opts.synth_1to1 = synth_1to1_i386; /* i486 function is special */
|
|
|
1001 fr->cpu_opts.dct64 = dct64_i386;
|
|
|
1002 done = 1;
|
|
|
1003 }
|
|
|
1004 #endif
|
|
|
1005 #ifdef OPT_I386
|
|
|
1006 if(!done && (auto_choose || !strcasecmp(cpu, "i386")))
|
|
|
1007 {
|
|
|
1008 chosen = "i386";
|
|
|
1009 fr->cpu_opts.type = idrei;
|
|
|
1010 fr->cpu_opts.synth_1to1 = synth_1to1_i386;
|
|
|
1011 fr->cpu_opts.dct64 = dct64_i386;
|
|
|
1012 done = 1;
|
|
|
1013 }
|
|
|
1014 #endif
|
|
|
1015
|
|
|
1016 if(done) /* set common x86 functions */
|
|
|
1017 {
|
|
|
1018 fr->cpu_opts.synth_1to1_mono = synth_1to1_mono_i386;
|
|
|
1019 fr->cpu_opts.synth_1to1_mono2stereo = synth_1to1_mono2stereo_i386;
|
|
|
1020 fr->cpu_opts.synth_1to1_8bit = synth_1to1_8bit_i386;
|
|
|
1021 fr->cpu_opts.synth_1to1_8bit_mono = synth_1to1_8bit_mono_i386;
|
|
|
1022 fr->cpu_opts.synth_1to1_8bit_mono2stereo = synth_1to1_8bit_mono2stereo_i386;
|
|
|
1023 }
|
|
|
1024 #endif /* OPT_X86 */
|
|
|
1025
|
|
|
1026 #ifdef OPT_ALTIVEC
|
|
|
1027 if(!done && (auto_choose || !strcasecmp(cpu, "altivec")))
|
|
|
1028 {
|
|
|
1029 chosen = "AltiVec";
|
|
|
1030 fr->cpu_opts.type = altivec;
|
|
|
1031 fr->cpu_opts.dct64 = dct64_altivec;
|
|
|
1032 fr->cpu_opts.synth_1to1 = synth_1to1_altivec;
|
|
|
1033 fr->cpu_opts.synth_1to1_mono = synth_1to1_mono_altivec;
|
|
|
1034 fr->cpu_opts.synth_1to1_mono2stereo = synth_1to1_mono2stereo_altivec;
|
|
|
1035 fr->cpu_opts.synth_1to1_8bit = synth_1to1_8bit_altivec;
|
|
|
1036 fr->cpu_opts.synth_1to1_8bit_mono = synth_1to1_8bit_mono_altivec;
|
|
|
1037 fr->cpu_opts.synth_1to1_8bit_mono2stereo = synth_1to1_8bit_mono2stereo_altivec;
|
|
|
1038 done = 1;
|
|
|
1039 }
|
|
|
1040 #endif
|
|
|
1041
|
|
|
1042 #ifdef OPT_GENERIC
|
|
|
1043 if(!done && (auto_choose || !strcasecmp(cpu, "generic")))
|
|
|
1044 {
|
|
|
1045 chosen = "generic";
|
|
|
1046 fr->cpu_opts.type = generic;
|
|
|
1047 fr->cpu_opts.dct64 = dct64;
|
|
|
1048 fr->cpu_opts.synth_1to1 = synth_1to1;
|
|
|
1049 fr->cpu_opts.synth_1to1_mono = synth_1to1_mono;
|
|
|
1050 fr->cpu_opts.synth_1to1_mono2stereo = synth_1to1_mono2stereo;
|
|
|
1051 fr->cpu_opts.synth_1to1_8bit = synth_1to1_8bit;
|
|
|
1052 fr->cpu_opts.synth_1to1_8bit_mono = synth_1to1_8bit_mono;
|
|
|
1053 fr->cpu_opts.synth_1to1_8bit_mono2stereo = synth_1to1_8bit_mono2stereo;
|
|
|
1054 done = 1;
|
|
|
1055 }
|
|
|
1056 #endif
|
|
|
1057 #endif
|
|
|
1058 if(done)
|
|
|
1059 {
|
|
|
1060 if(VERBOSE) fprintf(stderr, "Decoder: %s\n", chosen);
|
|
|
1061 return 1;
|
|
|
1062 }
|
|
|
1063 else
|
|
|
1064 {
|
|
|
1065 if(NOQUIET) error("Could not set optimization!");
|
|
|
1066 return 0;
|
|
|
1067 }
|
|
|
1068 }
|
|
|
1069
|
|
|
1070 enum optdec dectype(const char* decoder)
|
|
|
1071 {
|
|
|
1072 if(decoder == NULL) return autodec;
|
|
|
1073 if(!strcasecmp(decoder, "3dnowext")) return dreidnowext;
|
|
|
1074 if(!strcasecmp(decoder, "3dnow")) return dreidnow;
|
|
|
1075 if(!strcasecmp(decoder, "sse")) return sse;
|
|
|
1076 if(!strcasecmp(decoder, "mmx")) return mmx;
|
|
|
1077 if(!strcasecmp(decoder, "generic")) return generic;
|
|
|
1078 if(!strcasecmp(decoder, "altivec")) return altivec;
|
|
|
1079 if(!strcasecmp(decoder, "i386")) return idrei;
|
|
|
1080 if(!strcasecmp(decoder, "i486")) return ivier;
|
|
|
1081 if(!strcasecmp(decoder, "i586")) return ifuenf;
|
|
|
1082 if(!strcasecmp(decoder, "i586_dither")) return ifuenf_dither;
|
|
|
1083 return nodec;
|
|
|
1084 }
|
|
|
1085
|
