1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
9 * Copyright (C) 2006-2008 Adam Gashlin (hcs)
10 * Copyright (C) 2006 Jens Arnold
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
27 /* Maximum number of bytes to process in one iteration */
28 #define WAV_CHUNK_SIZE (1024*2)
30 /* Number of times to loop looped tracks when repeat is disabled */
33 /* Length of fade-out for looped tracks (milliseconds) */
34 #define FADE_LENGTH 10000L
36 /* Default high pass filter cutoff frequency is 500 Hz.
37 * Others can be set, but the default is nearly always used,
38 * and there is no way to determine if another was used, anyway.
40 const long cutoff
= 500;
42 static int16_t samples
[WAV_CHUNK_SIZE
] IBSS_ATTR
;
44 /* fixed point stuff from apps/plugins/lib/fixedpoint.c */
46 /* Inverse gain of circular cordic rotation in s0.31 format. */
47 static const long cordic_circular_gain
= 0xb2458939; /* 0.607252929 */
49 /* Table of values of atan(2^-i) in 0.32 format fractions of pi where pi = 0xffffffff / 2 */
50 static const unsigned long atan_table
[] = {
51 0x1fffffff, /* +0.785398163 (or pi/4) */
52 0x12e4051d, /* +0.463647609 */
53 0x09fb385b, /* +0.244978663 */
54 0x051111d4, /* +0.124354995 */
55 0x028b0d43, /* +0.062418810 */
56 0x0145d7e1, /* +0.031239833 */
57 0x00a2f61e, /* +0.015623729 */
58 0x00517c55, /* +0.007812341 */
59 0x0028be53, /* +0.003906230 */
60 0x00145f2e, /* +0.001953123 */
61 0x000a2f98, /* +0.000976562 */
62 0x000517cc, /* +0.000488281 */
63 0x00028be6, /* +0.000244141 */
64 0x000145f3, /* +0.000122070 */
65 0x0000a2f9, /* +0.000061035 */
66 0x0000517c, /* +0.000030518 */
67 0x000028be, /* +0.000015259 */
68 0x0000145f, /* +0.000007629 */
69 0x00000a2f, /* +0.000003815 */
70 0x00000517, /* +0.000001907 */
71 0x0000028b, /* +0.000000954 */
72 0x00000145, /* +0.000000477 */
73 0x000000a2, /* +0.000000238 */
74 0x00000051, /* +0.000000119 */
75 0x00000028, /* +0.000000060 */
76 0x00000014, /* +0.000000030 */
77 0x0000000a, /* +0.000000015 */
78 0x00000005, /* +0.000000007 */
79 0x00000002, /* +0.000000004 */
80 0x00000001, /* +0.000000002 */
81 0x00000000, /* +0.000000001 */
82 0x00000000, /* +0.000000000 */
86 * Implements sin and cos using CORDIC rotation.
88 * @param phase has range from 0 to 0xffffffff, representing 0 and
90 * @param cos return address for cos
91 * @return sin of phase, value is a signed value from LONG_MIN to LONG_MAX,
92 * representing -1 and 1 respectively.
94 static long fsincos(unsigned long phase
, long *cos
)
100 /* Setup initial vector */
101 x
= cordic_circular_gain
;
105 /* The phase has to be somewhere between 0..pi for this to work right */
106 if (z
< 0xffffffff / 4) {
107 /* z in first quadrant, z += pi/2 to correct */
110 } else if (z
< 3 * (0xffffffff / 4)) {
111 /* z in third quadrant, z -= pi/2 to correct */
114 /* z in fourth quadrant, z -= 3pi/2 to correct */
116 z
-= 3 * (0xffffffff / 4);
119 /* Each iteration adds roughly 1-bit of extra precision */
120 for (i
= 0; i
< 31; i
++) {
125 /* Decided which direction to rotate vector. Pivot point is pi/2 */
126 if (z
>= 0xffffffff / 4) {
144 * Fixed point square root via Newton-Raphson.
145 * @param a square root argument.
146 * @param fracbits specifies number of fractional bits in argument.
147 * @return Square root of argument in same fixed point format as input.
149 static long fsqrt(long a
, unsigned int fracbits
)
151 long b
= a
/2 + (1 << fracbits
); /* initial approximation */
153 const unsigned iterations
= 8; /* bumped up from 4 as it wasn't
154 nearly enough for 28 fractional bits */
156 for (n
= 0; n
< iterations
; ++n
)
157 b
= (b
+ (long)(((long long)(a
) << fracbits
)/b
))/2;
162 /* this is the codec entry point */
163 enum codec_status
codec_main(void)
166 int sampleswritten
, i
;
168 int32_t ch1_1
, ch1_2
, ch2_1
, ch2_2
; /* ADPCM history */
170 int endofstream
; /* end of stream flag */
171 uint32_t avgbytespersec
;
172 int looping
; /* looping flag */
173 int loop_count
; /* number of loops done so far */
174 int fade_count
; /* countdown for fadeout */
175 int fade_frames
; /* length of fade in frames */
176 off_t start_adr
, end_adr
; /* loop points */
177 off_t chanstart
, bufoff
;
178 /*long coef1=0x7298L,coef2=-0x3350L;*/
181 /* Generic codec initialisation */
182 /* we only render 16 bits */
183 ci
->configure(DSP_SET_SAMPLE_DEPTH
, 16);
186 DEBUGF("ADX: next_track\n");
190 DEBUGF("ADX: after init\n");
193 ch1_1
=ch1_2
=ch2_1
=ch2_2
=0;
195 /* wait for track info to load */
196 while (!*ci
->taginfo_ready
&& !ci
->stop_codec
)
199 codec_set_replaygain(ci
->id3
);
202 DEBUGF("ADX: request initial buffer\n");
204 buf
= ci
->request_buffer(&n
, 0x38);
205 if (!buf
|| n
< 0x38) {
209 DEBUGF("ADX: read size = %lx\n",(unsigned long)n
);
211 /* Get file header for starting offset, channel count */
213 chanstart
= ((buf
[2] << 8) | buf
[3]) + 4;
216 /* useful for seeking and reporting current playback position */
217 avgbytespersec
= ci
->id3
->frequency
* 18 * channels
/ 32;
218 DEBUGF("avgbytespersec=%ld\n",(unsigned long)avgbytespersec
);
220 /* calculate filter coefficients */
223 * A simple table of these coefficients would be nice, but
224 * some very odd frequencies are used and if I'm going to
225 * interpolate I might as well just go all the way and
226 * calclate them precisely.
227 * Speed is not an issue as this only needs to be done once per file.
230 const int64_t big28
= 0x10000000LL
;
231 const int64_t big32
= 0x100000000LL
;
232 int64_t frequency
= ci
->id3
->frequency
;
233 int64_t phasemultiple
= cutoff
*big32
/frequency
;
237 const int64_t b
= (M_SQRT2
*big28
)-big28
;
241 fsincos((unsigned long)phasemultiple
,&z
);
243 a
= (M_SQRT2
*big28
)-(z
*big28
/LONG_MAX
);
246 * In the long passed to fsqrt there are only 4 nonfractional bits,
247 * which is sufficient here, but this is the only reason why I don't
248 * use 32 fractional bits everywhere.
250 d
= fsqrt((a
+b
)*(a
-b
)/big28
,28);
253 coef1
= (c
*8192) >> 28;
254 coef2
= (c
*c
/big28
*-4096) >> 28;
255 DEBUGF("ADX: samprate=%ld ",(long)frequency
);
256 DEBUGF("coef1 %04x ",(unsigned int)(coef1
*4));
257 DEBUGF("coef2 %04x\n",(unsigned int)(coef2
*-4));
262 looping
= 0; start_adr
= 0; end_adr
= 0;
263 if (!memcmp(buf
+0x10,"\x01\xF4\x03\x00",4)) {
264 /* Soul Calibur 2 style (type 03) */
265 DEBUGF("ADX: type 03 found\n");
266 /* check if header is too small for loop data */
267 if (chanstart
-6 < 0x2c) looping
=0;
269 looping
= (buf
[0x18]) ||
273 end_adr
= (buf
[0x28]<<24) |
283 )/32*channels
*18+chanstart
;
285 } else if (!memcmp(buf
+0x10,"\x01\xF4\x04\x00",4)) {
286 /* Standard (type 04) */
287 DEBUGF("ADX: type 04 found\n");
288 /* check if header is too small for loop data */
289 if (chanstart
-6 < 0x38) looping
=0;
291 looping
= (buf
[0x24]) ||
295 end_adr
= (buf
[0x34]<<24) |
304 )/32*channels
*18+chanstart
;
307 DEBUGF("ADX: error, couldn't determine ADX type\n");
312 DEBUGF("ADX: looped, start: %lx end: %lx\n",start_adr
,end_adr
);
314 DEBUGF("ADX: not looped\n");
317 /* advance to first frame */
318 DEBUGF("ADX: first frame at %lx\n",chanstart
);
321 /* get in position */
322 ci
->seek_buffer(bufoff
);
325 /* setup pcm buffer format */
326 ci
->configure(DSP_SWITCH_FREQUENCY
, ci
->id3
->frequency
);
328 ci
->configure(DSP_SET_STEREO_MODE
, STEREO_INTERLEAVED
);
329 } else if (channels
== 1) {
330 ci
->configure(DSP_SET_STEREO_MODE
, STEREO_MONO
);
332 DEBUGF("ADX CODEC_ERROR: more than 2 channels\n");
338 fade_count
= -1; /* disable fade */
341 /* The main decoder loop */
343 while (!endofstream
) {
345 if (ci
->stop_codec
|| ci
->new_track
) {
349 /* do we need to loop? */
350 if (bufoff
> end_adr
-18*channels
&& looping
) {
351 DEBUGF("ADX: loop!\n");
352 /* check for endless looping */
353 if (ci
->global_settings
->repeat_mode
==REPEAT_ONE
) {
355 fade_count
= -1; /* disable fade */
357 /* otherwise start fade after LOOP_TIMES loops */
359 if (loop_count
>= LOOP_TIMES
&& fade_count
< 0) {
360 /* frames to fade over */
361 fade_frames
= FADE_LENGTH
*ci
->id3
->frequency
/32/1000;
362 /* volume relative to fade_frames */
363 fade_count
= fade_frames
;
364 DEBUGF("ADX: fade_frames = %d\n",fade_frames
);
368 ci
->seek_buffer(bufoff
);
371 /* do we need to seek? */
375 DEBUGF("ADX: seek to %ldms\n",ci
->seek_time
);
379 fade_count
= -1; /* disable fade */
382 newpos
= (((uint64_t)avgbytespersec
*(ci
->seek_time
- 1))
383 / (1000LL*18*channels
))*(18*channels
);
384 bufoff
= chanstart
+ newpos
;
385 while (bufoff
> end_adr
-18*channels
) {
386 bufoff
-=end_adr
-start_adr
;
389 ci
->seek_buffer(bufoff
);
393 if (bufoff
>ci
->filesize
-channels
*18) break; /* End of stream */
398 /* Is there data left in the file? */
399 (bufoff
<= ci
->filesize
-(18*channels
)) &&
400 /* Is there space in the output buffer? */
401 (sampleswritten
<= WAV_CHUNK_SIZE
-(32*channels
)) &&
402 /* Should we be looping? */
403 ((!looping
) || bufoff
<= end_adr
-18*channels
))
405 /* decode first/only channel */
410 buf
= ci
->request_buffer(&n
, 18);
413 DEBUGF("ADX: couldn't get buffer at %lx\n",
418 scale
= ((buf
[0] << 8) | (buf
[1])) +1;
420 for (i
= 2; i
< 18; i
++)
422 d
= (buf
[i
] >> 4) & 15;
424 ch1_0
= d
*scale
+ ((coef1
*ch1_1
+ coef2
*ch1_2
) >> 12);
425 if (ch1_0
> 32767) ch1_0
= 32767;
426 else if (ch1_0
< -32768) ch1_0
= -32768;
427 samples
[sampleswritten
] = ch1_0
;
428 sampleswritten
+=channels
;
429 ch1_2
= ch1_1
; ch1_1
= ch1_0
;
433 ch1_0
= d
*scale
+ ((coef1
*ch1_1
+ coef2
*ch1_2
) >> 12);
434 if (ch1_0
> 32767) ch1_0
= 32767;
435 else if (ch1_0
< -32768) ch1_0
= -32768;
436 samples
[sampleswritten
] = ch1_0
;
437 sampleswritten
+=channels
;
438 ch1_2
= ch1_1
; ch1_1
= ch1_0
;
441 ci
->advance_buffer(18);
444 /* decode second channel */
448 buf
= ci
->request_buffer(&n
, 18);
451 DEBUGF("ADX: couldn't get buffer at %lx\n",
456 scale
= ((buf
[0] << 8)|(buf
[1]))+1;
460 for (i
= 2; i
< 18; i
++)
462 d
= (buf
[i
] >> 4) & 15;
464 ch2_0
= d
*scale
+ ((coef1
*ch2_1
+ coef2
*ch2_2
) >> 12);
465 if (ch2_0
> 32767) ch2_0
= 32767;
466 else if (ch2_0
< -32768) ch2_0
= -32768;
467 samples
[sampleswritten
] = ch2_0
;
469 ch2_2
= ch2_1
; ch2_1
= ch2_0
;
473 ch2_0
= d
*scale
+ ((coef1
*ch2_1
+ coef2
*ch2_2
) >> 12);
474 if (ch2_0
> 32767) ch2_0
= 32767;
475 else if (ch2_0
< -32768) ch2_0
= -32768;
476 samples
[sampleswritten
] = ch2_0
;
478 ch2_2
= ch2_1
; ch2_1
= ch2_0
;
481 ci
->advance_buffer(18);
482 sampleswritten
--; /* go back to first channel's next sample */
487 for (i
=0;i
<(channels
==1?32:64);i
++) samples
[sampleswritten
-i
-1]=
488 ((int32_t)samples
[sampleswritten
-i
-1])*fade_count
/fade_frames
;
489 if (fade_count
==0) {endofstream
=1; break;}
494 sampleswritten
>>= 1; /* make samples/channel */
496 ci
->pcmbuf_insert(samples
, NULL
, sampleswritten
);
499 ((end_adr
-start_adr
)*loop_count
+ bufoff
-chanstart
)*
500 1000LL/avgbytespersec
);
503 if (ci
->request_next_track())