devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity

Initial DSP implementation. DSP supports resampling audio stream from

Browse source 
codecs (currently works corrently only with mp3's, somebody should fix
that).


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@6877 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Miika Pekkarinen 2005-06-26 19:41:29 +00:00
parent 316eb6538e
commit d8cb703b1e
15 changed files with 805 additions and 328 deletions
Download patch file Download diff file Expand all files Collapse all files

1
apps/SOURCES
View file

@ -52,6 +52,7 @@ recorder/recording.c
playback.c playback.c
metadata.c metadata.c
codecs.c codecs.c
dsp.c
#ifndef SIMULATOR #ifndef SIMULATOR
pcm_recording.c pcm_recording.c
#endif #endif

1
apps/codecs.c
View file

@ -88,6 +88,7 @@ struct codec_api ci = {
NULL, NULL,
NULL, NULL,
NULL, NULL,
NULL,
splash, splash,

1
apps/codecs.h
View file

@ -143,6 +143,7 @@ struct codec_api {
/* Insert PCM data into audio buffer for playback. Playback will start /* Insert PCM data into audio buffer for playback. Playback will start
automatically. */ automatically. */
bool (*audiobuffer_insert)(char *data, size_t length); bool (*audiobuffer_insert)(char *data, size_t length);
bool (*audiobuffer_insert_split)(void *ch1, void *ch2, size_t length);
/* Set song position in WPS (value in ms). */ /* Set song position in WPS (value in ms). */
void (*set_elapsed)(unsigned int value); void (*set_elapsed)(unsigned int value);

15
apps/codecs/a52.c
View file

@ -24,6 +24,7 @@
#include <codecs/liba52/a52.h> #include <codecs/liba52/a52.h>
#include "playback.h" #include "playback.h"
#include "dsp.h"
#include "lib/codeclib.h" #include "lib/codeclib.h"
#define BUFFER_SIZE 4096 #define BUFFER_SIZE 4096
@ -173,12 +174,26 @@ enum codec_status codec_start(struct codec_api* api)
ci->configure(CODEC_SET_FILEBUF_LIMIT, (int *)(1024*1024*2)); ci->configure(CODEC_SET_FILEBUF_LIMIT, (int *)(1024*1024*2));
ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*128)); ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*128));
ci->configure(DSP_DITHER, (bool *)false);
ci->configure(DSP_SET_STEREO_MODE, (int *)STEREO_INTERLEAVED);
ci->configure(DSP_SET_SAMPLE_DEPTH, (int *)(16));
next_track: next_track:
if (codec_init(api)) { if (codec_init(api)) {
return CODEC_ERROR; return CODEC_ERROR;
} }
while (!rb->taginfo_ready)
rb->yield();
if (rb->id3->frequency != NATIVE_FREQUENCY) {
rb->configure(DSP_SET_FREQUENCY, (long *)(rb->id3->frequency));
rb->configure(CODEC_DSP_ENABLE, (bool *)true);
} else {
rb->configure(CODEC_DSP_ENABLE, (bool *)false);
}
/* Intialise the A52 decoder and check for success */ /* Intialise the A52 decoder and check for success */
state = a52_init (0); // Parameter is "accel" state = a52_init (0); // Parameter is "accel"

15
apps/codecs/flac.c
View file

@ -22,6 +22,7 @@
#include <codecs/libFLAC/include/FLAC/seekable_stream_decoder.h> #include <codecs/libFLAC/include/FLAC/seekable_stream_decoder.h>
#include "playback.h" #include "playback.h"
#include "lib/codeclib.h" #include "lib/codeclib.h"
#include "dsp.h"
#define FLAC_MAX_SUPPORTED_BLOCKSIZE 4608 #define FLAC_MAX_SUPPORTED_BLOCKSIZE 4608
#define FLAC_MAX_SUPPORTED_CHANNELS 2 #define FLAC_MAX_SUPPORTED_CHANNELS 2
@ -180,12 +181,26 @@ enum codec_status codec_start(struct codec_api* api)
ci->configure(CODEC_SET_FILEBUF_WATERMARK, (int *)(1024*512)); ci->configure(CODEC_SET_FILEBUF_WATERMARK, (int *)(1024*512));
ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*128)); ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*128));
ci->configure(DSP_DITHER, (bool *)false);
ci->configure(DSP_SET_STEREO_MODE, (int *)STEREO_INTERLEAVED);
ci->configure(DSP_SET_SAMPLE_DEPTH, (int *)(16));
next_track: next_track:
if (codec_init(api)) { if (codec_init(api)) {
return CODEC_ERROR; return CODEC_ERROR;
} }
while (!rb->taginfo_ready)
rb->yield();
if (rb->id3->frequency != NATIVE_FREQUENCY) {
rb->configure(DSP_SET_FREQUENCY, (long *)(rb->id3->frequency));
rb->configure(CODEC_DSP_ENABLE, (bool *)true);
} else {
rb->configure(CODEC_DSP_ENABLE, (bool *)false);
}
/* Create a decoder instance */ /* Create a decoder instance */
flacDecoder=FLAC__seekable_stream_decoder_new(); flacDecoder=FLAC__seekable_stream_decoder_new();

303
apps/codecs/mpa.c
View file

@ -22,6 +22,7 @@
#include <codecs/libmad/mad.h> #include <codecs/libmad/mad.h>
#include "playback.h" #include "playback.h"
#include "dsp.h"
#include "mp3data.h" #include "mp3data.h"
#include "lib/codeclib.h" #include "lib/codeclib.h"
@ -29,7 +30,6 @@ struct mad_stream Stream IDATA_ATTR;
struct mad_frame Frame IDATA_ATTR; struct mad_frame Frame IDATA_ATTR;
struct mad_synth Synth IDATA_ATTR; struct mad_synth Synth IDATA_ATTR;
mad_timer_t Timer; mad_timer_t Timer;
struct dither d0, d1;
/* The following function is used inside libmad - let's hope it's never /* The following function is used inside libmad - let's hope it's never
called. called.
@ -38,122 +38,6 @@ struct dither d0, d1;
void abort(void) { void abort(void) {
} }
/* The "dither" code to convert the 24-bit samples produced by libmad was
taken from the coolplayer project - coolplayer.sourceforge.net */
struct dither {
mad_fixed_t error[3];
mad_fixed_t random;
};
# define SAMPLE_DEPTH 16
# define scale(x, y) dither((x), (y))
/*
* NAME: prng()
* DESCRIPTION: 32-bit pseudo-random number generator
*/
static __inline
unsigned long prng(unsigned long state)
{
return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
}
/*
* NAME: dither()
* DESCRIPTION: dither and scale sample
*/
inline int dither(mad_fixed_t sample, struct dither *dither)
{
unsigned int scalebits;
mad_fixed_t output, mask, random;
enum {
MIN = -MAD_F_ONE,
MAX = MAD_F_ONE - 1
};
/* noise shape */
sample += dither->error[0] - dither->error[1] + dither->error[2];
dither->error[2] = dither->error[1];
dither->error[1] = dither->error[0]/2;
/* bias */
output = sample + (1L << (MAD_F_FRACBITS + 1 - SAMPLE_DEPTH - 1));
scalebits = MAD_F_FRACBITS + 1 - SAMPLE_DEPTH;
mask = (1L << scalebits) - 1;
/* dither */
random = prng(dither->random);
output += (random & mask) - (dither->random & mask);
//dither->random = random;
/* clip */
if (output > MAX) {
output = MAX;
if (sample > MAX)
sample = MAX;
} else if (output < MIN) {
output = MIN;
if (sample < MIN)
sample = MIN;
}
/* quantize */
output &= ~mask;
/* error feedback */
dither->error[0] = sample - output;
/* scale */
return output >> scalebits;
}
inline int detect_silence(mad_fixed_t sample)
{
unsigned int scalebits;
mad_fixed_t output, mask;
enum {
MIN = -MAD_F_ONE,
MAX = MAD_F_ONE - 1
};
/* bias */
output = sample + (1L << (MAD_F_FRACBITS + 1 - SAMPLE_DEPTH - 1));
scalebits = MAD_F_FRACBITS + 1 - SAMPLE_DEPTH;
mask = (1L << scalebits) - 1;
/* clip */
if (output > MAX) {
output = MAX;
if (sample > MAX)
sample = MAX;
} else if (output < MIN) {
output = MIN;
if (sample < MIN)
sample = MIN;
}
/* quantize */
output &= ~mask;
/* scale */
output >>= scalebits + 4;
if (output == 0x00 || output == 0xff)
return 1;
return 0;
}
#define INPUT_CHUNK_SIZE 8192 #define INPUT_CHUNK_SIZE 8192
#define OUTPUT_BUFFER_SIZE 65536 /* Must be an integer multiple of 4. */ #define OUTPUT_BUFFER_SIZE 65536 /* Must be an integer multiple of 4. */
@ -162,7 +46,6 @@ unsigned char OutputBuffer[OUTPUT_BUFFER_SIZE];
unsigned char *OutputPtr; unsigned char *OutputPtr;
unsigned char *GuardPtr = NULL; unsigned char *GuardPtr = NULL;
const unsigned char *OutputBufferEnd = OutputBuffer + OUTPUT_BUFFER_SIZE; const unsigned char *OutputBufferEnd = OutputBuffer + OUTPUT_BUFFER_SIZE;
long resampled_data[2][5000]; /* enough to cope with 11khz upsampling */
mad_fixed_t mad_frame_overlap[2][32][18] IDATA_ATTR; mad_fixed_t mad_frame_overlap[2][32][18] IDATA_ATTR;
unsigned char mad_main_data[MAD_BUFFER_MDLEN] IDATA_ATTR; unsigned char mad_main_data[MAD_BUFFER_MDLEN] IDATA_ATTR;
@ -174,73 +57,7 @@ extern char iramstart[];
extern char iramend[]; extern char iramend[];
#endif #endif
#undef DEBUG_GAPLESS /*
struct resampler {
long last_sample, phase, delta;
};
#if CONFIG_CPU==MCF5249 && !defined(SIMULATOR)
#define INIT() asm volatile ("move.l #0xb0, %macsr") /* frac, round, clip */
#define FRACMUL(x, y) \
({ \
long t; \
asm volatile ("mac.l %[a], %[b], %%acc0\n\t" \
"movclr.l %%acc0, %[t]\n\t" \
: [t] "=r" (t) : [a] "r" (x), [b] "r" (y)); \
t; \
})
#else
#define INIT()
#define FRACMUL(x, y) (long)(((long long)(x)*(long long)(y)) << 1)
#endif
/* linear resampling, introduces one sample delay, because of our inability to
look into the future at the end of a frame */
long downsample(long *in, long *out, int num, struct resampler *s)
{
long i = 1, pos;
long last = s->last_sample;
INIT();
pos = s->phase >> 16;
/* check if we need last sample of previous frame for interpolation */
if (pos > 0)
last = in[pos - 1];
out[0] = last + FRACMUL((s->phase & 0xffff) << 15, in[pos] - last);
s->phase += s->delta;
while ((pos = s->phase >> 16) < num) {
out[i++] = in[pos - 1] + FRACMUL((s->phase & 0xffff) << 15, in[pos] - in[pos - 1]);
s->phase += s->delta;
}
/* wrap phase accumulator back to start of next frame */
s->phase -= num << 16;
s->last_sample = in[num - 1];
return i;
}
long upsample(long *in, long *out, int num, struct resampler *s)
{
long i = 0, pos;
INIT();
while ((pos = s->phase >> 16) == 0) {
out[i++] = s->last_sample + FRACMUL((s->phase & 0xffff) << 15, in[pos] - s->last_sample);
s->phase += s->delta;
}
while ((pos = s->phase >> 16) < num) {
out[i++] = in[pos - 1] + FRACMUL((s->phase & 0xffff) << 15, in[pos] - in[pos - 1]);
s->phase += s->delta;
}
/* wrap phase accumulator back to start of next frame */
s->phase -= num << 16;
s->last_sample = in[num - 1];
return i;
}
long resample(long *in, long *out, int num, struct resampler *s) long resample(long *in, long *out, int num, struct resampler *s)
{ {
if (s->delta >= (1 << 16)) if (s->delta >= (1 << 16))
@ -248,7 +65,7 @@ long resample(long *in, long *out, int num, struct resampler *s)
else else
return upsample(in, out, num, s); return upsample(in, out, num, s);
} }
*/
/* this is the codec entry point */ /* this is the codec entry point */
enum codec_status codec_start(struct codec_api* api) enum codec_status codec_start(struct codec_api* api)
{ {
@ -257,20 +74,12 @@ enum codec_status codec_start(struct codec_api* api)
int Status = 0; int Status = 0;
size_t size; size_t size;
int file_end; int file_end;
unsigned short Sample;
char *InputBuffer; char *InputBuffer;
unsigned int samplecount; unsigned int samplecount;
unsigned int samplesdone; unsigned int samplesdone;
bool first_frame; bool first_frame;
#ifdef DEBUG_GAPLESS
bool first = true;
int fd;
#endif
int i;
int yieldcounter = 0;
int stop_skip, start_skip; int stop_skip, start_skip;
struct resampler lr = { 0, 0, 0 }, rr = { 0, 0, 0 }; // struct resampler lr = { 0, 0, 0 }, rr = { 0, 0, 0 };
long length;
/* Generic codec inititialisation */ /* Generic codec inititialisation */
TEST_CODEC_API(api); TEST_CODEC_API(api);
@ -289,7 +98,13 @@ enum codec_status codec_start(struct codec_api* api)
ci->configure(CODEC_SET_FILEBUF_LIMIT, (int *)(1024*1024*2)); ci->configure(CODEC_SET_FILEBUF_LIMIT, (int *)(1024*1024*2));
ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*16)); ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*16));
ci->configure(DSP_SET_CLIP_MIN, (int *)-MAD_F_ONE);
ci->configure(DSP_SET_CLIP_MAX, (int *)(MAD_F_ONE - 1));
ci->configure(DSP_SET_SAMPLE_DEPTH, (int *)(MAD_F_FRACBITS));
ci->configure(DSP_DITHER, (bool *)true);
ci->configure(DSP_SET_STEREO_MODE, (int *)STEREO_NONINTERLEAVED);
ci->configure(CODEC_DSP_ENABLE, (bool *)true);
ci->memset(&Stream, 0, sizeof(struct mad_stream)); ci->memset(&Stream, 0, sizeof(struct mad_stream));
ci->memset(&Frame, 0, sizeof(struct mad_frame)); ci->memset(&Frame, 0, sizeof(struct mad_frame));
ci->memset(&Synth, 0, sizeof(struct mad_synth)); ci->memset(&Synth, 0, sizeof(struct mad_synth));
@ -309,14 +124,6 @@ enum codec_status codec_start(struct codec_api* api)
for gapless playback */ for gapless playback */
next_track: next_track:
#ifdef DEBUG_GAPLESS
if (first)
fd = ci->open("/first.pcm", O_WRONLY | O_CREAT);
else
fd = ci->open("/second.pcm", O_WRONLY | O_CREAT);
first = false;
#endif
info = ci->mp3data; info = ci->mp3data;
first_frame = false; first_frame = false;
file_end = 0; file_end = 0;
@ -325,6 +132,8 @@ enum codec_status codec_start(struct codec_api* api)
while (!*ci->taginfo_ready) while (!*ci->taginfo_ready)
ci->yield(); ci->yield();
ci->configure(DSP_SET_FREQUENCY, (int *)ci->id3->frequency);
ci->request_buffer(&size, ci->id3->first_frame_offset); ci->request_buffer(&size, ci->id3->first_frame_offset);
ci->advance_buffer(size); ci->advance_buffer(size);
@ -350,13 +159,7 @@ enum codec_status codec_start(struct codec_api* api)
samplecount = ci->id3->length * (ci->id3->frequency / 100) / 10; samplecount = ci->id3->length * (ci->id3->frequency / 100) / 10;
samplesdone = ci->id3->elapsed * (ci->id3->frequency / 100) / 10; samplesdone = ci->id3->elapsed * (ci->id3->frequency / 100) / 10;
} }
/* rb->snprintf(buf2, sizeof(buf2), "sc: %d", samplecount);
rb->splash(0, true, buf2);
rb->snprintf(buf2, sizeof(buf2), "length: %d", ci->id3->length);
rb->splash(HZ*5, true, buf2);
rb->snprintf(buf2, sizeof(buf2), "frequency: %d", ci->id3->frequency);
rb->splash(HZ*5, true, buf2); */
lr.delta = rr.delta = ci->id3->frequency*65536/44100;
/* This is the decoding loop. */ /* This is the decoding loop. */
while (1) { while (1) {
ci->yield(); ci->yield();
@ -387,9 +190,6 @@ enum codec_status codec_start(struct codec_api* api)
mad_stream_buffer(&Stream, InputBuffer, size); mad_stream_buffer(&Stream, InputBuffer, size);
} }
//if ((int)ci->curpos >= ci->id3->first_frame_offset)
//first_frame = true;
if(mad_frame_decode(&Frame,&Stream)) if(mad_frame_decode(&Frame,&Stream))
{ {
if (Stream.error == MAD_FLAG_INCOMPLETE || Stream.error == MAD_ERROR_BUFLEN) { if (Stream.error == MAD_FLAG_INCOMPLETE || Stream.error == MAD_ERROR_BUFLEN) {
@ -428,78 +228,23 @@ enum codec_status codec_start(struct codec_api* api)
mad_synth_frame(&Synth,&Frame); mad_synth_frame(&Synth,&Frame);
//if (!first_frame) {
//samplecount -= Synth.pcm.length;
//continue ;
//}
/* Convert MAD's numbers to an array of 16-bit LE signed integers */ /* Convert MAD's numbers to an array of 16-bit LE signed integers */
/* We skip start_skip number of samples here, this should only happen for /* We skip start_skip number of samples here, this should only happen for
very first frame in the stream. */ very first frame in the stream. */
/* TODO: possible for start_skip to exceed one frames worth of samples? */ /* TODO: possible for start_skip to exceed one frames worth of samples? */
length = resample((long *)&Synth.pcm.samples[0][start_skip], resampled_data[0], Synth.pcm.length, &lr); //length = resample((long *)&Synth.pcm.samples[0][start_skip], resampled_data[0], Synth.pcm.length, &lr);
if (MAD_NCHANNELS(&Frame.header) == 2) //if (MAD_NCHANNELS(&Frame.header) == 2)
resample((long *)&Synth.pcm.samples[1][start_skip], resampled_data[1], Synth.pcm.length, &rr); // resample((long *)&Synth.pcm.samples[1][start_skip], resampled_data[1], Synth.pcm.length, &rr);
for (i = 0; i < length; i++) ci->audiobuffer_insert_split(&Synth.pcm.samples[0][start_skip],
{ &Synth.pcm.samples[1][start_skip],
start_skip = 0; /* not very elegant, and might want to keep this value */ (Synth.pcm.length - start_skip) * 4);
samplesdone++; start_skip = 0; /* not very elegant, and might want to keep this value */
//if (ci->mp3data->padding > 0) {
// ci->mp3data->padding--; samplesdone += Synth.pcm.length;
// continue ; samplecount -= Synth.pcm.length;
//}
/*if (!first_frame) {
if (detect_silence(Synth.pcm.samples[0][i]))
continue ;
first_frame = true;
}*/
/* Left channel */
Sample = scale(resampled_data[0][i], &d0);
*(OutputPtr++) = Sample >> 8;
*(OutputPtr++) = Sample & 0xff;
/* Right channel. If the decoded stream is monophonic then
* the right output channel is the same as the left one.
*/
if (MAD_NCHANNELS(&Frame.header) == 2)
Sample = scale(resampled_data[1][i], &d1);
*(OutputPtr++) = Sample >> 8;
*(OutputPtr++) = Sample & 0xff;
samplecount--;
if (samplecount == 0) {
#ifdef DEBUG_GAPLESS
ci->write(fd, OutputBuffer, (int)OutputPtr - (int)OutputBuffer);
#endif
while (!ci->audiobuffer_insert(OutputBuffer, (int)OutputPtr - (int)OutputBuffer))
ci->yield();
goto song_end;
}
if (yieldcounter++ == 200) {
ci->yield();
yieldcounter = 0;
}
/* Flush the buffer if it is full. */
if (OutputPtr == OutputBufferEnd)
{
#ifdef DEBUG_GAPLESS
ci->write(fd, OutputBuffer, OUTPUT_BUFFER_SIZE);
#endif
while (!ci->audiobuffer_insert(OutputBuffer, OUTPUT_BUFFER_SIZE))
ci->yield();
OutputPtr = OutputBuffer;
}
}
ci->set_elapsed(samplesdone / (ci->id3->frequency/1000)); ci->set_elapsed(samplesdone / (ci->id3->frequency/1000));
} }
song_end:
#ifdef DEBUG_GAPLESS
ci->close(fd);
#endif
Stream.error = 0; Stream.error = 0;
if (ci->request_next_track()) if (ci->request_next_track())

30
apps/codecs/vorbis.c
View file

@ -21,6 +21,7 @@
#include "Tremor/ivorbisfile.h" #include "Tremor/ivorbisfile.h"
#include "playback.h" #include "playback.h"
#include "dsp.h"
#include "lib/codeclib.h" #include "lib/codeclib.h"
static struct codec_api* rb; static struct codec_api* rb;
@ -92,10 +93,6 @@ enum codec_status codec_start(struct codec_api* api)
long n; long n;
int current_section; int current_section;
int eof; int eof;
#if BYTE_ORDER == BIG_ENDIAN
int i;
char x;
#endif
TEST_CODEC_API(api); TEST_CODEC_API(api);
@ -110,15 +107,27 @@ enum codec_status codec_start(struct codec_api* api)
rb->configure(CODEC_SET_FILEBUF_LIMIT, (int *)(1024*1024*2)); rb->configure(CODEC_SET_FILEBUF_LIMIT, (int *)(1024*1024*2));
rb->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*64)); rb->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*64));
/* We need to flush reserver memory every track load. */ rb->configure(DSP_DITHER, (bool *)false);
rb->configure(DSP_SET_STEREO_MODE, (int *)STEREO_INTERLEAVED);
rb->configure(DSP_SET_SAMPLE_DEPTH, (int *)(16));
/* We need to flush reserver memory every track load. */
next_track: next_track:
if (codec_init(rb)) { if (codec_init(rb)) {
return CODEC_ERROR; return CODEC_ERROR;
} }
while (!rb->taginfo_ready)
rb->yield();
if (rb->id3->frequency != NATIVE_FREQUENCY) {
rb->configure(DSP_SET_FREQUENCY, (long *)(rb->id3->frequency));
rb->configure(CODEC_DSP_ENABLE, (bool *)true);
} else {
rb->configure(CODEC_DSP_ENABLE, (bool *)false);
}
/* Create a decoder instance */ /* Create a decoder instance */
callbacks.read_func=read_handler; callbacks.read_func=read_handler;
callbacks.seek_func=seek_handler; callbacks.seek_func=seek_handler;
callbacks.tell_func=tell_handler; callbacks.tell_func=tell_handler;
@ -148,17 +157,10 @@ enum codec_status codec_start(struct codec_api* api)
if (rb->stop_codec || rb->reload_codec) if (rb->stop_codec || rb->reload_codec)
break ; break ;
rb->yield();
while (!rb->audiobuffer_insert(pcmbuf, n)) while (!rb->audiobuffer_insert(pcmbuf, n))
rb->yield(); rb->yield();
rb->set_elapsed(ov_time_tell(&vf)); rb->set_elapsed(ov_time_tell(&vf));
#if BYTE_ORDER == BIG_ENDIAN
for (i=0;i<n;i+=2) {
x=pcmbuf[i]; pcmbuf[i]=pcmbuf[i+1]; pcmbuf[i+1]=x;
}
#endif
} }
} }

17
apps/codecs/wav.c
View file

@ -20,6 +20,7 @@
#include "codec.h" #include "codec.h"
#include "playback.h" #include "playback.h"
#include "lib/codeclib.h" #include "lib/codeclib.h"
#include "dsp.h"
#define BYTESWAP(x) (((x>>8) & 0xff) | ((x<<8) & 0xff00)) #define BYTESWAP(x) (((x>>8) & 0xff) | ((x<<8) & 0xff00))
@ -60,12 +61,26 @@ enum codec_status codec_start(struct codec_api* api)
ci->configure(CODEC_SET_FILEBUF_WATERMARK, (int *)(1024*512)); ci->configure(CODEC_SET_FILEBUF_WATERMARK, (int *)(1024*512));
ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*256)); ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*256));
ci->configure(DSP_DITHER, (bool *)false);
ci->configure(DSP_SET_STEREO_MODE, (int *)STEREO_INTERLEAVED);
ci->configure(DSP_SET_SAMPLE_DEPTH, (int *)(16));
next_track: next_track:
if (codec_init(api)) { if (codec_init(api)) {
return CODEC_ERROR; return CODEC_ERROR;
} }
while (!rb->taginfo_ready)
rb->yield();
if (rb->id3->frequency != NATIVE_FREQUENCY) {
rb->configure(DSP_SET_FREQUENCY, (long *)(rb->id3->frequency));
rb->configure(CODEC_DSP_ENABLE, (bool *)true);
} else {
rb->configure(CODEC_DSP_ENABLE, (bool *)false);
}
/* FIX: Correctly parse WAV header - we assume canonical 44-byte header */ /* FIX: Correctly parse WAV header - we assume canonical 44-byte header */
header=ci->request_buffer(&n,44); header=ci->request_buffer(&n,44);
@ -116,7 +131,7 @@ enum codec_status codec_start(struct codec_api* api)
/* Byte-swap data */ /* Byte-swap data */
for (i=0;i<n/2;i++) { for (i=0;i<n/2;i++) {
wavbuf[i]=BYTESWAP(wavbuf[i]); wavbuf[i]=SWAB16(wavbuf[i]);
} }
samplesdone+=nsamples; samplesdone+=nsamples;

16
apps/codecs/wavpack.c
View file

@ -22,6 +22,7 @@
#include <codecs/libwavpack/wavpack.h> #include <codecs/libwavpack/wavpack.h>
#include "playback.h" #include "playback.h"
#include "lib/codeclib.h" #include "lib/codeclib.h"
#include "dsp.h"
static struct codec_api *rb; static struct codec_api *rb;
static struct codec_api *ci; static struct codec_api *ci;
@ -61,14 +62,27 @@ enum codec_status codec_start(struct codec_api* api)
ci->configure(CODEC_SET_FILEBUF_LIMIT, (int *)(1024*1024*10)); ci->configure(CODEC_SET_FILEBUF_LIMIT, (int *)(1024*1024*10));
ci->configure(CODEC_SET_FILEBUF_WATERMARK, (int *)(1024*512)); ci->configure(CODEC_SET_FILEBUF_WATERMARK, (int *)(1024*512));
ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*128)); ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*128));
ci->configure(DSP_DITHER, (bool *)false);
ci->configure(DSP_SET_STEREO_MODE, (int *)STEREO_INTERLEAVED);
ci->configure(DSP_SET_SAMPLE_DEPTH, (int *)(16));
next_track: next_track:
if (codec_init(api)) if (codec_init(api))
return CODEC_ERROR; return CODEC_ERROR;
while (!rb->taginfo_ready)
ci->yield();
if (ci->id3->frequency != NATIVE_FREQUENCY) {
ci->configure(DSP_SET_FREQUENCY, (long *)(ci->id3->frequency));
ci->configure(CODEC_DSP_ENABLE, (bool *)true);
} else {
ci->configure(CODEC_DSP_ENABLE, (bool *)false);
}
/* Create a decoder instance */ /* Create a decoder instance */
wpc = WavpackOpenFileInput (read_callback, error); wpc = WavpackOpenFileInput (read_callback, error);
if (!wpc) if (!wpc)

397
apps/dsp.c Normal file
View file

@ -0,0 +1,397 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2005 Miika Pekkarinen
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "kernel.h"
#include "logf.h"
#include "dsp.h"
#include "playback.h"
#include "system.h"
/* The "dither" code to convert the 24-bit samples produced by libmad was
taken from the coolplayer project - coolplayer.sourceforge.net */
struct s_dither {
int error[3];
int random;
};
static struct s_dither dither[2];
struct dsp_configuration dsp_config;
static int channel;
static int fracbits;
#define SAMPLE_DEPTH 16
/*
* NAME: prng()
* DESCRIPTION: 32-bit pseudo-random number generator
*/
static __inline
unsigned long prng(unsigned long state)
{
return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
}
inline long dsp_noiseshape(long sample)
{
sample += dither[channel].error[0] - dither[channel].error[1]
+ dither[channel].error[2];
dither[channel].error[2] = dither[channel].error[1];
dither[channel].error[1] = dither[channel].error[0]/2;
return sample;
}
inline long dsp_bias(long sample)
{
sample = sample + (1L << (fracbits - SAMPLE_DEPTH));
return sample;
}
inline long dsp_dither(long *mask)
{
long random, output;
random = prng(dither[channel].random);
output = (random & *mask) - (dither[channel].random & *mask);
dither[channel].random = random;
return output;
}
inline void dsp_clip(long *sample, long *output)
{
if (*output > dsp_config.clip_max) {
*output = dsp_config.clip_max;
if (*sample > dsp_config.clip_max)
*sample = dsp_config.clip_max;
} else if (*output < dsp_config.clip_min) {
*output = dsp_config.clip_min;
if (*sample < dsp_config.clip_min)
*sample = dsp_config.clip_min;
}
}
/*
* NAME: dither()
* DESCRIPTION: dither and scale sample
*/
inline int scale_dither_clip(long sample)
{
unsigned int scalebits;
long output, mask;
/* noise shape */
sample = dsp_noiseshape(sample);
/* bias */
output = dsp_bias(sample);
scalebits = fracbits + 1 - SAMPLE_DEPTH;
mask = (1L << scalebits) - 1;
/* dither */
output += dsp_dither(&mask);
/* clip */
dsp_clip(&sample, &output);
/* quantize */
output &= ~mask;
/* error feedback */
dither->error[0] = sample - output;
/* scale */
return output >> scalebits;
}
inline int scale_clip(long sample)
{
unsigned int scalebits;
long output, mask;
output = sample;
scalebits = fracbits + 1 - SAMPLE_DEPTH;
mask = (1L << scalebits) - 1;
dsp_clip(&sample, &output);
output &= ~mask;
return output >> scalebits;
}
void dsp_scale_dither_clip(short *dest, long *src, int samplecount)
{
dest += channel;
while (samplecount-- > 0) {
*dest = scale_dither_clip(*src);
src++;
dest += 2;
}
}
void dsp_scale_clip(short *dest, long *src, int samplecount)
{
dest += channel;
while (samplecount-- > 0) {
*dest = scale_clip(*src);
src++;
dest += 2;
}
}
struct resampler {
long last_sample, phase, delta;
};
static struct resampler resample[2];
#if CONFIG_CPU==MCF5249 && !defined(SIMULATOR)
#define INIT() asm volatile ("move.l #0xb0, %macsr") /* frac, round, clip */
#define FRACMUL(x, y) \
({ \
long t; \
asm volatile ("mac.l %[a], %[b], %%acc0\n\t" \
"movclr.l %%acc0, %[t]\n\t" \
: [t] "=r" (t) : [a] "r" (x), [b] "r" (y)); \
t; \
})
#else
#define INIT()
#define FRACMUL(x, y) (long)(((long long)(x)*(long long)(y)) << 1)
#endif
/* linear resampling, introduces one sample delay, because of our inability to
look into the future at the end of a frame */
long downsample(long *out, long *in, int num, struct resampler *s)
{
long i = 1, pos;
long last = s->last_sample;
INIT();
pos = s->phase >> 16;
/* check if we need last sample of previous frame for interpolation */
if (pos > 0)
last = in[pos - 1];
out[0] = last + FRACMUL((s->phase & 0xffff) << 15, in[pos] - last);
s->phase += s->delta;
while ((pos = s->phase >> 16) < num) {
out[i++] = in[pos - 1] + FRACMUL((s->phase & 0xffff) << 15, in[pos] - in[pos - 1]);
s->phase += s->delta;
}
/* wrap phase accumulator back to start of next frame */
s->phase -= num << 16;
s->last_sample = in[num - 1];
return i;
}
long upsample(long *out, long *in, int num, struct resampler *s)
{
long i = 0, pos;
INIT();
while ((pos = s->phase >> 16) == 0) {
out[i++] = s->last_sample + FRACMUL((s->phase & 0xffff) << 15, in[pos] - s->last_sample);
s->phase += s->delta;
}
while ((pos = s->phase >> 16) < num) {
out[i++] = in[pos - 1] + FRACMUL((s->phase & 0xffff) << 15, in[pos] - in[pos - 1]);
s->phase += s->delta;
}
/* wrap phase accumulator back to start of next frame */
s->phase -= num << 16;
s->last_sample = in[num - 1];
return i;
}
#define MAX_CHUNK_SIZE 1024
static char samplebuf[MAX_CHUNK_SIZE*4];
/* enough to cope with 11khz upsampling */
long resampled[MAX_CHUNK_SIZE * 4];
int process(short *dest, long *src, int samplecount)
{
long *p;
int length = samplecount;
p = resampled;
/* Resample as necessary */
if (dsp_config.frequency > NATIVE_FREQUENCY)
length = upsample(resampled, src, samplecount, &resample[channel]);
else if (dsp_config.frequency < NATIVE_FREQUENCY)
length = downsample(resampled, src, samplecount, &resample[channel]);
else
p = src;
/* Scale & dither */
if (dsp_config.dither_enabled) {
dsp_scale_dither_clip(dest, p, length);
} else {
dsp_scale_clip(dest, p, length);
}
return length;
}
void convert_stereo_mode(long *dest, long *src, int samplecount)
{
int i;
samplecount /= 2;
for (i = 0; i < samplecount; i++) {
dest[i] = src[i*2 + 0];
dest[i+samplecount] = src[i*2 + 1];
}
}
/* Not yet functional. */
void scale_up(long *dest, short *src, int samplecount)
{
int i;
for (i = 0; i < samplecount; i++)
dest[i] = (long)(src[i] << 8);
}
void scale_up_convert_stereo_mode(long *dest, short *src, int samplecount)
{
int i;
samplecount /= 2;
for (i = 0; i < samplecount; i++) {
dest[i] = (long)(src[i*2+0] << SAMPLE_DEPTH);
dest[i+samplecount] = (long)(src[i*2+1] << SAMPLE_DEPTH);
//dest[i] = (long)(((src[i*2 + 0] << 8)&0x7fff) | ((1L << 31) & src[i*2+0]<<15));
//dest[i+samplecount] = (long)(((src[i*2 + 1] << 8)&0x7fff) | ((1L << 31) & src[i*2+1]<<15));
}
}
int dsp_process(char *dest, char *src, int samplecount)
{
int copy_n, rc;
char *p;
int processed_bytes = 0;
fracbits = dsp_config.sample_depth;
while (samplecount > 0) {
yield();
copy_n = MIN(MAX_CHUNK_SIZE / 4, samplecount);
p = src;
/* Scale up to 32-bit samples. */
if (dsp_config.sample_depth <= SAMPLE_DEPTH) {
if (dsp_config.stereo_mode == STEREO_INTERLEAVED)
scale_up_convert_stereo_mode((long *)samplebuf,
(short *)p, copy_n);
else
scale_up((long *)samplebuf, (short *)p, copy_n);
p = samplebuf;
fracbits = 31;
}
/* Convert to non-interleaved stereo. */
else if (dsp_config.stereo_mode == STEREO_INTERLEAVED) {
convert_stereo_mode((long *)samplebuf, (long *)p, copy_n);
p = samplebuf;
}
/* Apply DSP functions. */
if (dsp_config.stereo_mode == STEREO_INTERLEAVED) {
channel = 0;
rc = process((short *)dest, (long *)p, copy_n / 2) * 4;
p += copy_n * 2;
channel = 1;
process((short *)dest, (long *)p, copy_n / 2);
dest += rc;
} else {
rc = process((short *)dest, (long *)p, copy_n) * 2;
dest += rc * 2;
}
samplecount -= copy_n;
if (dsp_config.sample_depth <= SAMPLE_DEPTH)
src += copy_n * 2;
else
src += copy_n * 4;
processed_bytes += rc;
}
/* Set stereo channel */
channel = channel ? 0 : 1;
return processed_bytes;
}
bool dsp_configure(int setting, void *value)
{
switch (setting) {
case DSP_SET_FREQUENCY:
dsp_config.frequency = (int)value;
resample[0].delta = resample[1].delta =
(unsigned long)value*65536/NATIVE_FREQUENCY;
break ;
case DSP_SET_CLIP_MIN:
dsp_config.clip_min = (long)value;
break ;
case DSP_SET_CLIP_MAX:
dsp_config.clip_max = (long)value;
break ;
case DSP_SET_SAMPLE_DEPTH:
dsp_config.sample_depth = (long)value;
break ;
case DSP_SET_STEREO_MODE:
dsp_config.stereo_mode = (long)value;
channel = 0;
break ;
case DSP_RESET:
dsp_config.dither_enabled = false;
dsp_config.clip_max = 0x7fffffff;
dsp_config.clip_min = 0x80000000;
dsp_config.frequency = NATIVE_FREQUENCY;
channel = 0;
break ;
case DSP_DITHER:
dsp_config.dither_enabled = (bool)value;
break ;
default:
return 0;
}
return 1;
}

48
apps/dsp.h Normal file
View file

@ -0,0 +1,48 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2005 Miika Pekkarinen
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#ifndef _DSP_H
#define _DSP_H
#include <stdlib.h>
#include <ctype.h>
#include <stdbool.h>
#define NATIVE_FREQUENCY 44100
#define STEREO_INTERLEAVED 0
#define STEREO_NONINTERLEAVED 1
/* Not supported yet. */
#define STEREO_MONO 2
struct dsp_configuration {
long frequency;
long clip_min, clip_max;
int sample_depth;
bool dither_enabled;
int stereo_mode;
};
extern struct dsp_configuration dsp_config;
int dsp_process(char *dest, char *src, int samplecount);
bool dsp_configure(int setting, void *value);
#endif

131
apps/playback.c
View file

@ -49,6 +49,7 @@
#include "playback.h" #include "playback.h"
#include "pcm_playback.h" #include "pcm_playback.h"
#include "buffer.h" #include "buffer.h"
#include "dsp.h"
#ifdef HAVE_LCD_BITMAP #ifdef HAVE_LCD_BITMAP
#include "icons.h" #include "icons.h"
#include "peakmeter.h" #include "peakmeter.h"
@ -171,7 +172,7 @@ int mp3_get_file_pos(void);
/* Simulator stubs. */ /* Simulator stubs. */
#ifdef SIMULATOR #ifdef SIMULATOR
bool audiobuffer_insert(char *buf, size_t length) bool pcm_insert_buffer(char *buf, size_t length)
{ {
(void)buf; (void)buf;
(void)length; (void)length;
@ -179,6 +180,20 @@ bool audiobuffer_insert(char *buf, size_t length)
return true; return true;
} }
void pcm_flush_buffer(size_t length)
{
(void)length;
}
void* pcm_request_buffer(size_t length, size_t *realsize)
{
(void)length;
(void)realsize;
return NULL;
}
void audiobuffer_add_event(void (*event_handler)(void)) void audiobuffer_add_event(void (*event_handler)(void))
{ {
(void)event_handler; (void)event_handler;
@ -229,6 +244,92 @@ int ata_sleep(void)
} }
#endif #endif
bool codec_audiobuffer_insert_callback(char *buf, size_t length)
{
char *dest;
size_t realsize;
int factor;
int next_channel = 0;
int processed_length;
/* If non-interleaved stereo mode. */
if (dsp_config.stereo_mode == STEREO_NONINTERLEAVED) {
next_channel = length / 2;
}
if (dsp_config.sample_depth > 16) {
length /= 2;
factor = 1;
} else {
factor = 0;
}
while (length > 0) {
/* Request a few extra bytes for resampling. */
/* FIXME: Required extra bytes SHOULD be calculated. */
while ((dest = pcm_request_buffer(length+16384, &realsize)) == NULL)
yield();
if (realsize < 16384) {
pcm_flush_buffer(0);
continue ;
}
realsize -= 16384;
if (next_channel) {
processed_length = dsp_process(dest, buf, realsize / 4) * 2;
dsp_process(dest, buf + next_channel, realsize / 4);
} else {
processed_length = dsp_process(dest, buf, realsize / 2);
}
pcm_flush_buffer(processed_length);
length -= realsize;
buf += realsize << factor;
}
return true;
}
bool codec_audiobuffer_insert_split_callback(void *ch1, void *ch2,
size_t length)
{
char *dest;
size_t realsize;
int factor;
int processed_length;
/* non-interleaved stereo mode. */
if (dsp_config.sample_depth > 16) {
factor = 0;
} else {
length /= 2;
factor = 1;
}
while (length > 0) {
/* Request a few extra bytes for resampling. */
while ((dest = pcm_request_buffer(length+4096, &realsize)) == NULL)
yield();
if (realsize < 4096) {
pcm_flush_buffer(0);
continue ;
}
realsize -= 4096;
processed_length = dsp_process(dest, ch1, realsize / 4) * 2;
dsp_process(dest, ch2, realsize / 4);
pcm_flush_buffer(processed_length);
length -= realsize;
ch1 += realsize >> factor;
ch2 += realsize >> factor;
}
return true;
}
void* get_codec_memory_callback(size_t *size) void* get_codec_memory_callback(size_t *size)
{ {
*size = MALLOC_BUFSIZE; *size = MALLOC_BUFSIZE;
@ -260,7 +361,7 @@ size_t codec_filebuf_callback(void *ptr, size_t size)
if (ci.stop_codec || !playing) if (ci.stop_codec || !playing)
return 0; return 0;
copy_n = MIN((off_t)size, (off_t)cur_ti->available + cur_ti->filerem); copy_n = MIN((off_t)size, (off_t)cur_ti->available + cur_ti->filerem);
while (copy_n > cur_ti->available) { while (copy_n > cur_ti->available) {
@ -283,7 +384,7 @@ size_t codec_filebuf_callback(void *ptr, size_t size)
buf_ridx -= codecbuflen; buf_ridx -= codecbuflen;
ci.curpos += copy_n; ci.curpos += copy_n;
cur_ti->available -= copy_n; cur_ti->available -= copy_n;
codecbufused -= copy_n; codecbufused -= copy_n;
return copy_n; return copy_n;
} }
@ -427,8 +528,18 @@ void codec_configure_callback(int setting, void *value)
conf_bufferlimit = (unsigned int)value; conf_bufferlimit = (unsigned int)value;
break; break;
case CODEC_DSP_ENABLE:
if ((bool)value)
ci.audiobuffer_insert = codec_audiobuffer_insert_callback;
else
ci.audiobuffer_insert = pcm_insert_buffer;
break ;
#ifndef SIMULATOR
default: default:
logf("Illegal key: %d", setting); if (!dsp_configure(setting, value))
logf("Illegal key: %d", setting);
#endif
} }
} }
@ -647,6 +758,8 @@ bool audio_load_track(int offset, bool start_play, int peek_offset)
conf_bufferlimit = 0; conf_bufferlimit = 0;
conf_watermark = AUDIO_DEFAULT_WATERMARK; conf_watermark = AUDIO_DEFAULT_WATERMARK;
conf_filechunk = AUDIO_DEFAULT_FILECHUNK; conf_filechunk = AUDIO_DEFAULT_FILECHUNK;
dsp_configure(DSP_RESET, 0);
ci.configure(CODEC_DSP_ENABLE, false);
} }
tracks[track_widx].codecbuf = &codecbuf[buf_widx]; tracks[track_widx].codecbuf = &codecbuf[buf_widx];
@ -697,7 +810,7 @@ bool audio_load_track(int offset, bool start_play, int peek_offset)
copy_n = MIN(size - i, copy_n); copy_n = MIN(size - i, copy_n);
copy_n = MIN((int)fill_bytesleft, copy_n); copy_n = MIN((int)fill_bytesleft, copy_n);
rc = read(fd, &codecbuf[buf_widx], copy_n); rc = read(fd, &codecbuf[buf_widx], copy_n);
if (rc < 0) { if (rc <= 0) {
logf("File error!"); logf("File error!");
close(fd); close(fd);
return false; return false;
@ -1152,7 +1265,7 @@ struct mp3entry* audio_next_track(void)
bool audio_has_changed_track(void) bool audio_has_changed_track(void)
{ {
if (track_changed && track_count > 0) { if (track_changed && track_count > 0 && playing) {
if (!cur_ti->taginfo_ready) if (!cur_ti->taginfo_ready)
return false; return false;
track_changed = false; track_changed = false;
@ -1384,6 +1497,7 @@ int mp3_get_file_pos(void)
void audio_set_buffer_margin(int seconds) void audio_set_buffer_margin(int seconds)
{ {
(void)seconds; (void)seconds;
logf("bufmargin: %d", seconds);
} }
#endif #endif
@ -1395,7 +1509,7 @@ void mpeg_id3_options(bool _v1first)
void audio_init(void) void audio_init(void)
{ {
logf("audio api init"); logf("audio api init");
codecbuflen = audiobufend - audiobuf - PCMBUF_SIZE codecbuflen = audiobufend - audiobuf - PCMBUF_SIZE - PCMBUF_GUARD
- MALLOC_BUFSIZE - GUARD_BUFSIZE; - MALLOC_BUFSIZE - GUARD_BUFSIZE;
//codecbuflen = 2*512*1024; //codecbuflen = 2*512*1024;
codecbufused = 0; codecbufused = 0;
@ -1412,7 +1526,8 @@ void audio_init(void)
/* Initialize codec api. */ /* Initialize codec api. */
ci.read_filebuf = codec_filebuf_callback; ci.read_filebuf = codec_filebuf_callback;
ci.audiobuffer_insert = audiobuffer_insert; ci.audiobuffer_insert = pcm_insert_buffer;
ci.audiobuffer_insert_split = codec_audiobuffer_insert_split_callback;
ci.get_codec_memory = get_codec_memory_callback; ci.get_codec_memory = get_codec_memory_callback;
ci.request_buffer = codec_request_buffer_callback; ci.request_buffer = codec_request_buffer_callback;
ci.advance_buffer = codec_advance_buffer_callback; ci.advance_buffer = codec_advance_buffer_callback;

17
apps/playback.h
View file

@ -27,10 +27,19 @@
#include "id3.h" #include "id3.h"
#include "mp3data.h" #include "mp3data.h"
/* File buffer configuration keys. */ enum {
#define CODEC_SET_FILEBUF_WATERMARK 1 CODEC_SET_FILEBUF_WATERMARK = 1,
#define CODEC_SET_FILEBUF_CHUNKSIZE 2 CODEC_SET_FILEBUF_CHUNKSIZE,
#define CODEC_SET_FILEBUF_LIMIT 3 CODEC_SET_FILEBUF_LIMIT,
CODEC_DSP_ENABLE,
DSP_SET_FREQUENCY,
DSP_SET_CLIP_MIN,
DSP_SET_CLIP_MAX,
DSP_SET_SAMPLE_DEPTH,
DSP_SET_STEREO_MODE,
DSP_RESET,
DSP_DITHER
};
/* Not yet implemented. */ /* Not yet implemented. */
#define CODEC_SET_AUDIOBUF_WATERMARK 4 #define CODEC_SET_AUDIOBUF_WATERMARK 4

8
firmware/export/pcm_playback.h
View file

@ -19,6 +19,10 @@
#ifndef PCM_PLAYBACK_H #ifndef PCM_PLAYBACK_H
#define PCM_PLAYBACK_H #define PCM_PLAYBACK_H
/* Guard buffer for crossfader when dsp is enabled. */
#define PCMBUF_GUARD 32768
/* PCM audio buffer. */
#define PCMBUF_SIZE (1*1024*1024) #define PCMBUF_SIZE (1*1024*1024)
void pcm_init(void); void pcm_init(void);
@ -44,7 +48,9 @@ bool pcm_is_lowdata(void);
bool pcm_crossfade_init(void); bool pcm_crossfade_init(void);
void audiobuffer_add_event(void (*event_handler)(void)); void audiobuffer_add_event(void (*event_handler)(void));
unsigned int audiobuffer_get_latency(void); unsigned int audiobuffer_get_latency(void);
bool audiobuffer_insert(char *buf, size_t length); bool pcm_insert_buffer(char *buf, size_t length);
void pcm_flush_buffer(size_t length);
void* pcm_request_buffer(size_t length, size_t *realsize);
bool pcm_is_crossfade_enabled(void); bool pcm_is_crossfade_enabled(void);
void pcm_crossfade_enable(bool on_off); void pcm_crossfade_enable(bool on_off);

133
firmware/pcm_playback.c
View file

@ -67,6 +67,7 @@ static int crossfade_pos;
static int crossfade_amount; static int crossfade_amount;
static int crossfade_rem; static int crossfade_rem;
static char *guardbuf;
static void (*pcm_event_handler)(void); static void (*pcm_event_handler)(void);
static unsigned char *next_start; static unsigned char *next_start;
@ -258,7 +259,6 @@ void pcm_play_pause(bool play)
IIS2CONFIG = 0x800; IIS2CONFIG = 0x800;
} }
pcm_paused = !play; pcm_paused = !play;
pcm_boost(false);
} }
bool pcm_is_playing(void) bool pcm_is_playing(void)
@ -401,15 +401,8 @@ bool pcm_crossfade_init(void)
} }
static void crossfade_start(void) void pcm_flush_fillpos(void)
{ {
if (!crossfade_init)
return ;
crossfade_init = 0;
if (PCMBUF_SIZE - audiobuffer_free < CHUNK_SIZE * 6)
return ;
if (audiobuffer_fillpos) { if (audiobuffer_fillpos) {
while (!pcm_play_add_chunk(&audiobuffer[audiobuffer_pos], while (!pcm_play_add_chunk(&audiobuffer[audiobuffer_pos],
audiobuffer_fillpos, pcm_event_handler)) { audiobuffer_fillpos, pcm_event_handler)) {
@ -419,13 +412,26 @@ static void crossfade_start(void)
audiobuffer_pos += audiobuffer_fillpos; audiobuffer_pos += audiobuffer_fillpos;
if (audiobuffer_pos >= PCMBUF_SIZE) if (audiobuffer_pos >= PCMBUF_SIZE)
audiobuffer_pos -= PCMBUF_SIZE; audiobuffer_pos -= PCMBUF_SIZE;
audiobuffer_free -= audiobuffer_fillpos;
audiobuffer_fillpos = 0;
} }
}
static void crossfade_start(void)
{
if (!crossfade_init)
return ;
crossfade_init = 0;
if (PCMBUF_SIZE - audiobuffer_free < CHUNK_SIZE * 6)
return ;
pcm_flush_fillpos();
pcm_boost(true); pcm_boost(true);
crossfade_active = true; crossfade_active = true;
crossfade_pos = audiobuffer_pos; crossfade_pos = audiobuffer_pos;
crossfade_amount = (PCMBUF_SIZE - audiobuffer_free - (CHUNK_SIZE * 2))/2; crossfade_amount = (PCMBUF_SIZE - audiobuffer_free - (CHUNK_SIZE * 2))/2;
crossfade_rem = crossfade_amount; crossfade_rem = crossfade_amount;
audiobuffer_fillpos = 0;
crossfade_pos -= crossfade_amount*2; crossfade_pos -= crossfade_amount*2;
if (crossfade_pos < 0) if (crossfade_pos < 0)
@ -451,12 +457,11 @@ int crossfade(short *buf, const short *buf2, int length)
return size; return size;
} }
bool audiobuffer_insert(char *buf, size_t length) inline static bool prepare_insert(size_t length)
{ {
size_t copy_n = 0;
crossfade_start(); crossfade_start();
if (audiobuffer_free < length + CHUNK_SIZE && !crossfade_active) { if (audiobuffer_free < length + audiobuffer_fillpos
+ CHUNK_SIZE && !crossfade_active) {
pcm_boost(false); pcm_boost(false);
return false; return false;
} }
@ -467,7 +472,94 @@ bool audiobuffer_insert(char *buf, size_t length)
if (audiobuffer_free < PCMBUF_SIZE - CHUNK_SIZE*4) if (audiobuffer_free < PCMBUF_SIZE - CHUNK_SIZE*4)
pcm_play_start(); pcm_play_start();
} }
return true;
}
void* pcm_request_buffer(size_t length, size_t *realsize)
{
void *ptr = NULL;
if (!prepare_insert(length)) {
*realsize = 0;
return NULL;
}
if (crossfade_active) {
*realsize = MIN(length, PCMBUF_GUARD);
ptr = &guardbuf[0];
} else {
*realsize = MIN(length, PCMBUF_SIZE - audiobuffer_pos
- audiobuffer_fillpos);
if (*realsize < length) {
*realsize += MIN((long)(length - *realsize), PCMBUF_GUARD);
//logf("gbr:%d/%d", *realsize, length);
}
ptr = &audiobuffer[audiobuffer_pos + audiobuffer_fillpos];
}
return ptr;
}
void pcm_flush_buffer(size_t length)
{
int copy_n;
char *buf;
if (crossfade_active) {
buf = &guardbuf[0];
length = MIN(length, PCMBUF_GUARD);
while (length > 0 && crossfade_active) {
copy_n = MIN(length, PCMBUF_SIZE - (unsigned int)crossfade_pos);
copy_n = 2 * crossfade((short *)&audiobuffer[crossfade_pos],
(const short *)buf, copy_n/2);
buf += copy_n;
length -= copy_n;
crossfade_pos += copy_n;
if (crossfade_pos >= PCMBUF_SIZE)
crossfade_pos -= PCMBUF_SIZE;
}
if (length > 0) {
memcpy(&audiobuffer[audiobuffer_pos], buf, length);
audiobuffer_fillpos = length;
goto try_flush;
}
} else {
/* if (length == 0) {
pcm_flush_fillpos();
audiobuffer_pos = 0;
return ;
} */
audiobuffer_fillpos += length;
try_flush:
if (audiobuffer_fillpos < CHUNK_SIZE && PCMBUF_SIZE
- audiobuffer_pos - audiobuffer_fillpos > 0)
return ;
copy_n = MIN((long)(audiobuffer_fillpos - (PCMBUF_SIZE
- audiobuffer_pos)), PCMBUF_GUARD);
if (copy_n > 0) {
//logf("guard buf used:%d", copy_n);
audiobuffer_fillpos -= copy_n;
pcm_flush_fillpos();
memcpy(&audiobuffer[0], &guardbuf[0], copy_n);
audiobuffer_fillpos = copy_n;
goto try_flush;
}
pcm_flush_fillpos();
}
}
bool pcm_insert_buffer(char *buf, size_t length)
{
size_t copy_n = 0;
if (!prepare_insert(length))
return false;
while (length > 0) { while (length > 0) {
if (crossfade_active) { if (crossfade_active) {
copy_n = MIN(length, PCMBUF_SIZE - (unsigned int)crossfade_pos); copy_n = MIN(length, PCMBUF_SIZE - (unsigned int)crossfade_pos);
@ -521,7 +613,8 @@ bool audiobuffer_insert(char *buf, size_t length)
void pcm_play_init(void) void pcm_play_init(void)
{ {
audiobuffer = &audiobuf[(audiobufend - audiobuf) - audiobuffer = &audiobuf[(audiobufend - audiobuf) -
PCMBUF_SIZE]; PCMBUF_SIZE - PCMBUF_GUARD];
guardbuf = &audiobuffer[PCMBUF_SIZE];
audiobuffer_free = PCMBUF_SIZE; audiobuffer_free = PCMBUF_SIZE;
audiobuffer_pos = 0; audiobuffer_pos = 0;
audiobuffer_fillpos = 0; audiobuffer_fillpos = 0;
@ -532,11 +625,6 @@ void pcm_play_init(void)
crossfade_active = false; crossfade_active = false;
crossfade_init = false; crossfade_init = false;
pcm_event_handler = NULL; pcm_event_handler = NULL;
if (crossfade_enabled) {
pcm_play_set_watermark(PCM_CF_WATERMARK, pcm_watermark_callback);
} else {
pcm_play_set_watermark(PCM_WATERMARK, pcm_watermark_callback);
}
} }
void pcm_crossfade_enable(bool on_off) void pcm_crossfade_enable(bool on_off)
@ -555,6 +643,11 @@ void pcm_play_start(void)
int size; int size;
char *start; char *start;
if (crossfade_enabled) {
pcm_play_set_watermark(PCM_CF_WATERMARK, pcm_watermark_callback);
} else {
pcm_play_set_watermark(PCM_WATERMARK, pcm_watermark_callback);
}
crossfade_active = false; crossfade_active = false;
if(!pcm_is_playing()) if(!pcm_is_playing())
{ {