len0rd/rockbox
1
0
Fork 1
mirror of https://github.com/Rockbox/rockbox.git synced 2025-10-14 10:37:38 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

mp3buf renamed to audiobuf

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@6252 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Linus Nielsen Feltzing 2005-04-05 11:33:58 +00:00
parent 6cf9d51b33
commit d34865a530
22 changed files with 239 additions and 238 deletions
Download patch file Download diff file Expand all files Collapse all files

12
apps/debug_menu.c
View file

@ -126,7 +126,7 @@ int load_wave(char *filename)
if (audio_size > 8*1024*1024) if (audio_size > 8*1024*1024)
audio_size = 8*1024*1024; audio_size = 8*1024*1024;
audio_buffer = mp3buf; audio_buffer = audiobuf;
puts("Reading %d bytes..", audio_size); puts("Reading %d bytes..", audio_size);
@ -356,11 +356,11 @@ bool dbg_audio_thread(void)
lcd_clear_display(); lcd_clear_display();
snprintf(buf, sizeof(buf), "read: %x", d.mp3buf_read); snprintf(buf, sizeof(buf), "read: %x", d.audiobuf_read);
lcd_puts(0, 0, buf); lcd_puts(0, 0, buf);
snprintf(buf, sizeof(buf), "write: %x", d.mp3buf_write); snprintf(buf, sizeof(buf), "write: %x", d.audiobuf_write);
lcd_puts(0, 1, buf); lcd_puts(0, 1, buf);
snprintf(buf, sizeof(buf), "swap: %x", d.mp3buf_swapwrite); snprintf(buf, sizeof(buf), "swap: %x", d.audiobuf_swapwrite);
lcd_puts(0, 2, buf); lcd_puts(0, 2, buf);
snprintf(buf, sizeof(buf), "playing: %d", d.playing); snprintf(buf, sizeof(buf), "playing: %d", d.playing);
lcd_puts(0, 3, buf); lcd_puts(0, 3, buf);
@ -370,11 +370,11 @@ bool dbg_audio_thread(void)
lcd_puts(0, 5, buf); lcd_puts(0, 5, buf);
/* Playable space left */ /* Playable space left */
scrollbar(0, 6*8, 112, 4, d.mp3buflen, 0, scrollbar(0, 6*8, 112, 4, d.audiobuflen, 0,
d.playable_space, HORIZONTAL); d.playable_space, HORIZONTAL);
/* Show the watermark limit */ /* Show the watermark limit */
scrollbar(0, 6*8+4, 112, 4, d.mp3buflen, 0, scrollbar(0, 6*8+4, 112, 4, d.audiobuflen, 0,
d.low_watermark_level, HORIZONTAL); d.low_watermark_level, HORIZONTAL);
snprintf(buf, sizeof(buf), "wm: %x - %x", snprintf(buf, sizeof(buf), "wm: %x - %x",

2
apps/main_menu.c
View file

@ -138,7 +138,7 @@ extern bool simulate_usb(void);
bool show_info(void) bool show_info(void)
{ {
char s[32], s2[32]; char s[32], s2[32];
long buflen = ((mp3end - mp3buf) * 2) / 2097; /* avoid overflow */ long buflen = ((audiobufend - audiobuf) * 2) / 2097; /* avoid overflow */
int integer, decimal; int integer, decimal;
bool done = false; bool done = false;
int key; int key;

10
apps/playlist.c
View file

@ -351,8 +351,8 @@ static int add_indices_to_playlist(struct playlist_info* playlist,
audio_stop(); audio_stop();
talk_buffer_steal(); /* we use the mp3 buffer, need to tell */ talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
buffer = mp3buf; buffer = audiobuf;
buflen = (mp3end - mp3buf); buflen = (audiobufend - audiobuf);
} }
store_index = true; store_index = true;
@ -1211,8 +1211,8 @@ int playlist_resume(void)
/* use mp3 buffer for maximum load speed */ /* use mp3 buffer for maximum load speed */
talk_buffer_steal(); /* we use the mp3 buffer, need to tell */ talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
buflen = (mp3end - mp3buf); buflen = (audiobufend - audiobuf);
buffer = mp3buf; buffer = audiobuf;
empty_playlist(playlist, true); empty_playlist(playlist, true);
@ -1294,7 +1294,7 @@ int playlist_resume(void)
if (str3[0] != '\0') if (str3[0] != '\0')
{ {
/* NOTE: add_indices_to_playlist() overwrites the /* NOTE: add_indices_to_playlist() overwrites the
mp3buf so we need to reload control file audiobuf so we need to reload control file
data */ data */
add_indices_to_playlist(playlist, NULL, 0); add_indices_to_playlist(playlist, NULL, 0);
} }

8
apps/plugin.c
View file

@ -238,7 +238,7 @@ static const struct plugin_api rockbox_api = {
get_time, get_time,
set_time, set_time,
plugin_get_buffer, plugin_get_buffer,
plugin_get_mp3_buffer, plugin_get_audio_buffer,
#ifndef SIMULATOR #ifndef SIMULATOR
plugin_register_timer, plugin_register_timer,
plugin_unregister_timer, plugin_unregister_timer,
@ -407,12 +407,12 @@ void* plugin_get_buffer(int* buffer_size)
/* Returns a pointer to the mp3 buffer. /* Returns a pointer to the mp3 buffer.
Playback gets stopped, to avoid conflicts. */ Playback gets stopped, to avoid conflicts. */
void* plugin_get_mp3_buffer(int* buffer_size) void* plugin_get_audio_buffer(int* buffer_size)
{ {
audio_stop(); audio_stop();
talk_buffer_steal(); /* we use the mp3 buffer, need to tell */ talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
*buffer_size = mp3end - mp3buf; *buffer_size = audiobufend - audiobuf;
return mp3buf; return audiobuf;
} }
#ifndef SIMULATOR #ifndef SIMULATOR

4
apps/plugin.h
View file

@ -280,7 +280,7 @@ struct plugin_api {
struct tm* (*get_time)(void); struct tm* (*get_time)(void);
int (*set_time)(const struct tm *tm); int (*set_time)(const struct tm *tm);
void* (*plugin_get_buffer)(int* buffer_size); void* (*plugin_get_buffer)(int* buffer_size);
void* (*plugin_get_mp3_buffer)(int* buffer_size); void* (*plugin_get_audio_buffer)(int* buffer_size);
#ifndef SIMULATOR #ifndef SIMULATOR
int (*plugin_register_timer)(int cycles, int prio, void (*timer_callback)(void)); int (*plugin_register_timer)(int cycles, int prio, void (*timer_callback)(void));
void (*plugin_unregister_timer)(void); void (*plugin_unregister_timer)(void);
@ -334,7 +334,7 @@ struct plugin_api {
/* defined by the plugin loader (plugin.c) */ /* defined by the plugin loader (plugin.c) */
int plugin_load(const char* plugin, void* parameter); int plugin_load(const char* plugin, void* parameter);
void* plugin_get_buffer(int *buffer_size); void* plugin_get_buffer(int *buffer_size);
void* plugin_get_mp3_buffer(int *buffer_size); void* plugin_get_audio_buffer(int *buffer_size);
int plugin_register_timer(int cycles, int prio, void (*timer_callback)(void)); int plugin_register_timer(int cycles, int prio, void (*timer_callback)(void));
void plugin_unregister_timer(void); void plugin_unregister_timer(void);
void plugin_tsr(void (*exit_callback)(void)); void plugin_tsr(void (*exit_callback)(void));

2
apps/plugins/battery_test.c
View file

@ -48,7 +48,7 @@ int buffersize;
int init(void) int init(void)
{ {
int f; int f;
buffer = rb->plugin_get_mp3_buffer(&buffersize); buffer = rb->plugin_get_audio_buffer(&buffersize);
#ifdef HAVE_MMC #ifdef HAVE_MMC
/* present info what's going on. MMC is slow. */ /* present info what's going on. MMC is slow. */

2
apps/plugins/jpeg.c
View file

@ -1824,7 +1824,7 @@ int main(char* filename)
rb->memset(&disp, 0, sizeof(disp)); rb->memset(&disp, 0, sizeof(disp));
buf = rb->plugin_get_mp3_buffer(&buf_size); /* start munching memory */ buf = rb->plugin_get_audio_buffer(&buf_size); /* start munching memory */
/* initialize the grayscale buffer: /* initialize the grayscale buffer:

14
apps/plugins/lib/xxx2wav.c
View file

@ -29,9 +29,9 @@ static struct plugin_api* local_rb;
int mem_ptr; int mem_ptr;
int bufsize; int bufsize;
unsigned char* mp3buf; // The actual MP3 buffer from Rockbox unsigned char* audiobuf; // The actual audio buffer from Rockbox
unsigned char* mallocbuf; // 512K from the start of MP3 buffer unsigned char* mallocbuf; // 512K from the start of audio buffer
unsigned char* filebuf; // The rest of the MP3 buffer unsigned char* filebuf; // The rest of the audio buffer
void* codec_malloc(size_t size) { void* codec_malloc(size_t size) {
void* x; void* x;
@ -169,11 +169,11 @@ int local_init(char* infilename, char* outfilename, file_info_struct* file_info,
local_rb=rb; local_rb=rb;
mem_ptr=0; mem_ptr=0;
mp3buf=local_rb->plugin_get_mp3_buffer(&bufsize); audiobuf=local_rb->plugin_get_audio_buffer(&bufsize);
mallocbuf=mp3buf; mallocbuf=audiobuf;
filebuf=&mp3buf[MALLOC_BUFSIZE]; filebuf=&audiobuf[MALLOC_BUFSIZE];
local_rb->snprintf(s,32,"mp3 bufsize: %d",bufsize); local_rb->snprintf(s,32,"audio bufsize: %d",bufsize);
local_rb->lcd_putsxy(0,100,s); local_rb->lcd_putsxy(0,100,s);
local_rb->lcd_update(); local_rb->lcd_update();

9
apps/plugins/rockboy.c
View file

@ -26,8 +26,8 @@
#define OVL_DISPLAYNAME "RockBoy" #define OVL_DISPLAYNAME "RockBoy"
struct plugin_api* rb; struct plugin_api* rb;
unsigned char *mp3buf; unsigned char *audiobuf;
int mp3buf_size; int audiobuf_size;
/* this is the plugin entry point */ /* this is the plugin entry point */
enum plugin_status plugin_start(struct plugin_api* api, void* parameter) enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
@ -60,8 +60,9 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
return PLUGIN_ERROR; return PLUGIN_ERROR;
} }
mp3buf = rb->plugin_get_mp3_buffer(&mp3buf_size); audiobuf = rb->plugin_get_audio_buffer(&audiobuf_size);
if (header.start_addr < mp3buf || header.end_addr > mp3buf + mp3buf_size) if (header.start_addr < audiobuf ||
header.end_addr > audiobuf + audiobuf_size)
{ {
rb->close(fh); rb->close(fh);
rb->splash(2*HZ, true, OVL_DISPLAYNAME rb->splash(2*HZ, true, OVL_DISPLAYNAME

34
apps/plugins/rockboy/rockboy.c
View file

@ -59,37 +59,37 @@ void die(char *message, ...)
errormsg=message; errormsg=message;
} }
void *mp3_bufferbase; void *audio_bufferbase;
void *mp3_bufferpointer; void *audio_bufferpointer;
unsigned int mp3_buffer_free; unsigned int audio_buffer_free;
void *my_malloc(size_t size) void *my_malloc(size_t size)
{ {
void *alloc; void *alloc;
if (!mp3_bufferbase) if (!audio_bufferbase)
{ {
mp3_bufferbase = mp3_bufferpointer audio_bufferbase = audio_bufferpointer
= rb->plugin_get_mp3_buffer(&mp3_buffer_free); = rb->plugin_get_audio_buffer(&audio_buffer_free);
#if MEM <= 8 && !defined(SIMULATOR) #if MEM <= 8 && !defined(SIMULATOR)
/* loaded as an overlay, protect from overwriting ourselves */ /* loaded as an overlay, protect from overwriting ourselves */
if ((unsigned)(ovl_start_addr - (unsigned char *)mp3_bufferbase) if ((unsigned)(ovl_start_addr - (unsigned char *)audio_bufferbase)
< mp3_buffer_free) < audio_buffer_free)
mp3_buffer_free = ovl_start_addr - (unsigned char *)mp3_bufferbase; audio_buffer_free = ovl_start_addr - (unsigned char *)audio_bufferbase;
#endif #endif
} }
if (size + 4 > mp3_buffer_free) if (size + 4 > audio_buffer_free)
return 0; return 0;
alloc = mp3_bufferpointer; alloc = audio_bufferpointer;
mp3_bufferpointer += size + 4; audio_bufferpointer += size + 4;
mp3_buffer_free -= size + 4; audio_buffer_free -= size + 4;
return alloc; return alloc;
} }
void setmallocpos(void *pointer) void setmallocpos(void *pointer)
{ {
mp3_bufferpointer = pointer; audio_bufferpointer = pointer;
mp3_buffer_free = mp3_bufferpointer - mp3_bufferbase; audio_buffer_free = audio_bufferpointer - audio_bufferbase;
} }
/* this is the plugin entry point */ /* this is the plugin entry point */
@ -113,8 +113,8 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
#endif #endif
shut=0; shut=0;
cleanshut=0; cleanshut=0;
mp3_bufferbase=mp3_bufferpointer=0; audio_bufferbase=audio_bufferpointer=0;
mp3_buffer_free=0; audio_buffer_free=0;
/* now go ahead and have fun! */ /* now go ahead and have fun! */
/* rb->splash(HZ*2, true, "Rockboy v0.3"); */ /* rb->splash(HZ*2, true, "Rockboy v0.3"); */

2
apps/plugins/sort.c
View file

@ -184,7 +184,7 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
rb = api; rb = api;
buf = rb->plugin_get_mp3_buffer(&buf_size); /* start munching memory */ buf = rb->plugin_get_audio_buffer(&buf_size); /* start munching memory */
stringbuffer = buf; stringbuffer = buf;
pointers = (char **)(buf + buf_size - sizeof(int)); pointers = (char **)(buf + buf_size - sizeof(int));

26
apps/plugins/vbrfix.c
View file

@ -20,8 +20,8 @@
static struct plugin_api* rb; static struct plugin_api* rb;
static char *mp3buf; static char *audiobuf;
static int mp3buflen; static int audiobuflen;
static void xingupdate(int percent) static void xingupdate(int percent)
{ {
@ -56,14 +56,14 @@ static int insert_data_in_file(char *fname, int fpos, char *buf, int num_bytes)
/* First, copy the initial portion (the ID3 tag) */ /* First, copy the initial portion (the ID3 tag) */
if(fpos) { if(fpos) {
readlen = rb->read(orig_fd, mp3buf, fpos); readlen = rb->read(orig_fd, audiobuf, fpos);
if(readlen < 0) { if(readlen < 0) {
rb->close(fd); rb->close(fd);
rb->close(orig_fd); rb->close(orig_fd);
return 10*readlen - 3; return 10*readlen - 3;
} }
rc = rb->write(fd, mp3buf, readlen); rc = rb->write(fd, audiobuf, readlen);
if(rc < 0) { if(rc < 0) {
rb->close(fd); rb->close(fd);
rb->close(orig_fd); rb->close(orig_fd);
@ -81,14 +81,14 @@ static int insert_data_in_file(char *fname, int fpos, char *buf, int num_bytes)
/* Copy the file */ /* Copy the file */
do { do {
readlen = rb->read(orig_fd, mp3buf, mp3buflen); readlen = rb->read(orig_fd, audiobuf, audiobuflen);
if(readlen < 0) { if(readlen < 0) {
rb->close(fd); rb->close(fd);
rb->close(orig_fd); rb->close(orig_fd);
return 10*readlen - 7; return 10*readlen - 7;
} }
rc = rb->write(fd, mp3buf, readlen); rc = rb->write(fd, audiobuf, readlen);
if(rc < 0) { if(rc < 0) {
rb->close(fd); rb->close(fd);
rb->close(orig_fd); rb->close(orig_fd);
@ -193,8 +193,8 @@ static bool vbr_fix(char *selected_file)
and write it to the file */ and write it to the file */
if(unused_space) if(unused_space)
{ {
rb->memset(mp3buf, 0, unused_space); rb->memset(audiobuf, 0, unused_space);
rc = rb->write(fd, mp3buf, unused_space); rc = rb->write(fd, audiobuf, unused_space);
if(rc < 0) { if(rc < 0) {
rb->close(fd); rb->close(fd);
fileerror(rc); fileerror(rc);
@ -230,20 +230,20 @@ static bool vbr_fix(char *selected_file)
DEBUGF("Inserting 4096+%d bytes\n", framelen); DEBUGF("Inserting 4096+%d bytes\n", framelen);
numbytes = 4096 + framelen; numbytes = 4096 + framelen;
rb->memset(mp3buf + 0x100000, 0, numbytes); rb->memset(audiobuf + 0x100000, 0, numbytes);
/* Insert the ID3 header */ /* Insert the ID3 header */
rb->memcpy(mp3buf + 0x100000, empty_id3_header, rb->memcpy(audiobuf + 0x100000, empty_id3_header,
sizeof(empty_id3_header)); sizeof(empty_id3_header));
} }
/* Copy the Xing header */ /* Copy the Xing header */
rb->memcpy(mp3buf + 0x100000 + numbytes - framelen, rb->memcpy(audiobuf + 0x100000 + numbytes - framelen,
xingbuf, framelen); xingbuf, framelen);
rc = insert_data_in_file(selected_file, rc = insert_data_in_file(selected_file,
entry.first_frame_offset, entry.first_frame_offset,
mp3buf + 0x100000, numbytes); audiobuf + 0x100000, numbytes);
if(rc < 0) { if(rc < 0) {
fileerror(rc); fileerror(rc);
@ -272,7 +272,7 @@ enum plugin_status plugin_start(struct plugin_api* api, void *parameter)
if (!parameter) if (!parameter)
return PLUGIN_ERROR; return PLUGIN_ERROR;
mp3buf = rb->plugin_get_mp3_buffer(&mp3buflen); audiobuf = rb->plugin_get_audio_buffer(&audiobuflen);
vbr_fix(parameter); vbr_fix(parameter);

2
apps/plugins/video.c
View file

@ -864,7 +864,7 @@ int main(char* filename)
// init buffer // init buffer
rb->memset(&gBuf, 0, sizeof(gBuf)); rb->memset(&gBuf, 0, sizeof(gBuf));
gBuf.pOSD = rb->lcd_framebuffer + LCD_WIDTH*7; // last screen line gBuf.pOSD = rb->lcd_framebuffer + LCD_WIDTH*7; // last screen line
gBuf.pBufStart = rb->plugin_get_mp3_buffer(&gBuf.bufsize); gBuf.pBufStart = rb->plugin_get_audio_buffer(&gBuf.bufsize);
//gBuf.bufsize = 1700*1024; // test, like 2MB version!!!! //gBuf.bufsize = 1700*1024; // test, like 2MB version!!!!
gBuf.pBufFill = gBuf.pBufStart; // all empty gBuf.pBufFill = gBuf.pBufStart; // all empty

20
apps/talk.c
View file

@ -131,7 +131,7 @@ static void load_voicefile(void)
goto load_err; goto load_err;
file_size = filesize(filehandle); file_size = filesize(filehandle);
if (file_size > mp3end - mp3buf) /* won't fit? */ if (file_size > audiobufend - audiobuf) /* won't fit? */
goto load_err; goto load_err;
#ifdef HAVE_MMC /* load only the header for now */ #ifdef HAVE_MMC /* load only the header for now */
@ -140,17 +140,17 @@ static void load_voicefile(void)
load_size = file_size; load_size = file_size;
#endif #endif
got_size = read(filehandle, mp3buf, load_size); got_size = read(filehandle, audiobuf, load_size);
if (got_size == load_size /* success */ if (got_size == load_size /* success */
&& ((struct voicefile*)mp3buf)->table /* format check */ && ((struct voicefile*)audiobuf)->table /* format check */
== offsetof(struct voicefile, index)) == offsetof(struct voicefile, index))
{ {
p_voicefile = (struct voicefile*)mp3buf; p_voicefile = (struct voicefile*)audiobuf;
/* thumbnail buffer is the remaining space behind */ /* thumbnail buffer is the remaining space behind */
p_thumbnail = mp3buf + file_size; p_thumbnail = audiobuf + file_size;
p_thumbnail += (long)p_thumbnail % 2; /* 16-bit align */ p_thumbnail += (long)p_thumbnail % 2; /* 16-bit align */
size_for_thumbnail = mp3end - p_thumbnail; size_for_thumbnail = audiobufend - p_thumbnail;
} }
else else
goto load_err; goto load_err;
@ -160,7 +160,7 @@ static void load_voicefile(void)
load_size = (p_voicefile->id1_max + p_voicefile->id2_max) load_size = (p_voicefile->id1_max + p_voicefile->id2_max)
* sizeof(struct clip_entry); * sizeof(struct clip_entry);
got_size = read(filehandle, got_size = read(filehandle,
mp3buf + offsetof(struct voicefile, index), load_size); audiobuf + offsetof(struct voicefile, index), load_size);
if (got_size != load_size) /* read error */ if (got_size != load_size) /* read error */
goto load_err; goto load_err;
#else #else
@ -356,7 +356,7 @@ static unsigned char* get_clip(long id, long* p_size)
clipsize = p_voicefile->index[id].size; clipsize = p_voicefile->index[id].size;
if (clipsize == 0) /* clip not included in voicefile */ if (clipsize == 0) /* clip not included in voicefile */
return NULL; return NULL;
clipbuf = mp3buf + p_voicefile->index[id].offset; clipbuf = audiobuf + p_voicefile->index[id].offset;
#ifdef HAVE_MMC /* dynamic loading, on demand */ #ifdef HAVE_MMC /* dynamic loading, on demand */
if (!(clipsize & LOADED_MASK)) if (!(clipsize & LOADED_MASK))
@ -383,8 +383,8 @@ static void reset_state(void)
{ {
queue_write = queue_read = 0; /* reset the queue */ queue_write = queue_read = 0; /* reset the queue */
p_voicefile = NULL; /* indicate no voicefile (trashed) */ p_voicefile = NULL; /* indicate no voicefile (trashed) */
p_thumbnail = mp3buf; /* whole space for thumbnail */ p_thumbnail = audiobuf; /* whole space for thumbnail */
size_for_thumbnail = mp3end - mp3buf; size_for_thumbnail = audiobufend - audiobuf;
p_silence = NULL; /* pause clip not accessible */ p_silence = NULL; /* pause clip not accessible */
} }

18
firmware/app.lds
View file

@ -88,10 +88,10 @@ _stackend = ADDR(.stack) + SIZEOF(.stack);
_idatastart = ADDR(.idata); _idatastart = ADDR(.idata);
/* FIXME: Where to put mp3 buffer? */ /* FIXME: Where to put audio buffer? */
_mp3buffer = 0; _audiobuffer = 0;
_mp3end = 0; _audioend = 0;
/* Plugins are not supported on the Gmini*/ /* Plugins are not supported on the Gmini*/
@ -217,16 +217,16 @@ SECTIONS
_end = .; _end = .;
} > DRAM } > DRAM
.mp3buf ALIGN(4) : .audiobuf ALIGN(4) :
{ {
_mp3buffer = .; _audiobuffer = .;
mp3buffer = .; audiobuffer = .;
} > DRAM } > DRAM
.mp3end ENDADDR: .audiobufend ENDADDR:
{ {
mp3end = .; audiobufend = .;
_mp3end = .; _audiobufend = .;
} > DRAM } > DRAM
.plugin ENDADDR: .plugin ENDADDR:

14
firmware/buffer.c
View file

@ -20,24 +20,24 @@
#include "buffer.h" #include "buffer.h"
#ifdef SIMULATOR #ifdef SIMULATOR
unsigned char mp3buffer[(MEM*1024-256)*1024]; unsigned char audiobuffer[(MEM*1024-256)*1024];
unsigned char *mp3end = mp3buffer + sizeof(mp3buffer); unsigned char *audiobufend = audiobuffer + sizeof(audiobuffer);
#else #else
/* defined in linker script */ /* defined in linker script */
extern unsigned char mp3buffer[]; extern unsigned char audiobuffer[];
#endif #endif
unsigned char *mp3buf; unsigned char *audiobuf;
void buffer_init(void) void buffer_init(void)
{ {
mp3buf = mp3buffer; audiobuf = audiobuffer;
} }
void *buffer_alloc(size_t size) void *buffer_alloc(size_t size)
{ {
void *retval = mp3buf; void *retval = audiobuf;
mp3buf += size; audiobuf += size;
return retval; return retval;
} }

8
firmware/export/audio.h
View file

@ -35,10 +35,10 @@
struct audio_debug struct audio_debug
{ {
int mp3buflen; int audiobuflen;
int mp3buf_write; int audiobuf_write;
int mp3buf_swapwrite; int audiobuf_swapwrite;
int mp3buf_read; int audiobuf_read;
int last_dma_chunk_size; int last_dma_chunk_size;

6
firmware/export/buffer.h
View file

@ -21,12 +21,12 @@
/* defined in linker script */ /* defined in linker script */
#ifdef SIMULATOR #ifdef SIMULATOR
extern unsigned char *mp3end; extern unsigned char *audiobufend;
#else #else
extern unsigned char mp3end[]; extern unsigned char audiobufend[];
#endif #endif
extern unsigned char *mp3buf; extern unsigned char *audiobuf;
void buffer_init(void); void buffer_init(void);
void *buffer_alloc(size_t size); void *buffer_alloc(size_t size);

16
firmware/mp3data.c
View file

@ -273,12 +273,12 @@ static int buf_getbyte(int fd, unsigned char *c)
{ {
if(fnf_read_index < fnf_buf_len) if(fnf_read_index < fnf_buf_len)
{ {
*c = mp3buf[fnf_read_index++]; *c = audiobuf[fnf_read_index++];
return 1; return 1;
} }
else else
{ {
fnf_buf_len = read(fd, mp3buf, mp3end - mp3buf); fnf_buf_len = read(fd, audiobuf, audiobufend - audiobuf);
if(fnf_buf_len < 0) if(fnf_buf_len < 0)
return -1; return -1;
@ -286,7 +286,7 @@ static int buf_getbyte(int fd, unsigned char *c)
if(fnf_buf_len > 0) if(fnf_buf_len > 0)
{ {
*c = mp3buf[fnf_read_index++]; *c = audiobuf[fnf_read_index++];
return 1; return 1;
} }
else else
@ -302,7 +302,7 @@ static int buf_seek(int fd, int len)
{ {
len = fnf_read_index - fnf_buf_len; len = fnf_read_index - fnf_buf_len;
fnf_buf_len = read(fd, mp3buf, mp3end - mp3buf); fnf_buf_len = read(fd, audiobuf, audiobufend - audiobuf);
if(fnf_buf_len < 0) if(fnf_buf_len < 0)
return -1; return -1;
@ -330,7 +330,7 @@ unsigned long buf_find_next_frame(int fd, long *offset, long max_offset,
return __find_next_frame(fd, offset, max_offset, last_header, buf_getbyte); return __find_next_frame(fd, offset, max_offset, last_header, buf_getbyte);
} }
static int mp3buflen; static int audiobuflen;
static int mem_pos; static int mem_pos;
static int mem_cnt; static int mem_cnt;
static int mem_maxlen; static int mem_maxlen;
@ -339,8 +339,8 @@ static int mem_getbyte(int dummy, unsigned char *c)
{ {
dummy = dummy; dummy = dummy;
*c = mp3buf[mem_pos++]; *c = audiobuf[mem_pos++];
if(mem_pos >= mp3buflen) if(mem_pos >= audiobuflen)
mem_pos = 0; mem_pos = 0;
if(mem_cnt++ >= mem_maxlen) if(mem_cnt++ >= mem_maxlen)
@ -352,7 +352,7 @@ static int mem_getbyte(int dummy, unsigned char *c)
unsigned long mem_find_next_frame(int startpos, long *offset, long max_offset, unsigned long mem_find_next_frame(int startpos, long *offset, long max_offset,
unsigned long last_header) unsigned long last_header)
{ {
mp3buflen = mp3end - mp3buf; audiobuflen = audiobufend - audiobuf;
mem_pos = startpos; mem_pos = startpos;
mem_cnt = 0; mem_cnt = 0;
mem_maxlen = max_offset; mem_maxlen = max_offset;

248
firmware/mpeg.c
View file

@ -313,10 +313,10 @@ static struct event_queue mpeg_queue;
static long mpeg_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)]; static long mpeg_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)];
static const char mpeg_thread_name[] = "mpeg"; static const char mpeg_thread_name[] = "mpeg";
static int mp3buflen; static int audiobuflen;
static int mp3buf_write; static int audiobuf_write;
static int mp3buf_swapwrite; static int audiobuf_swapwrite;
static int mp3buf_read; static int audiobuf_read;
static int last_dma_chunk_size; static int last_dma_chunk_size;
@ -410,10 +410,10 @@ void audio_set_buffer_margin(int seconds)
void audio_get_debugdata(struct audio_debug *dbgdata) void audio_get_debugdata(struct audio_debug *dbgdata)
{ {
dbgdata->mp3buflen = mp3buflen; dbgdata->audiobuflen = audiobuflen;
dbgdata->mp3buf_write = mp3buf_write; dbgdata->audiobuf_write = audiobuf_write;
dbgdata->mp3buf_swapwrite = mp3buf_swapwrite; dbgdata->audiobuf_swapwrite = audiobuf_swapwrite;
dbgdata->mp3buf_read = mp3buf_read; dbgdata->audiobuf_read = audiobuf_read;
dbgdata->last_dma_chunk_size = last_dma_chunk_size; dbgdata->last_dma_chunk_size = last_dma_chunk_size;
@ -457,17 +457,17 @@ static int dbg_cnt2us(unsigned int cnt)
static int get_unplayed_space(void) static int get_unplayed_space(void)
{ {
int space = mp3buf_write - mp3buf_read; int space = audiobuf_write - audiobuf_read;
if (space < 0) if (space < 0)
space += mp3buflen; space += audiobuflen;
return space; return space;
} }
static int get_playable_space(void) static int get_playable_space(void)
{ {
int space = mp3buf_swapwrite - mp3buf_read; int space = audiobuf_swapwrite - audiobuf_read;
if (space < 0) if (space < 0)
space += mp3buflen; space += audiobuflen;
return space; return space;
} }
@ -479,33 +479,33 @@ static int get_unplayed_space_current_song(void)
{ {
int track_offset = (tag_read_idx+1) & MAX_ID3_TAGS_MASK; int track_offset = (tag_read_idx+1) & MAX_ID3_TAGS_MASK;
space = id3tags[track_offset].mempos - mp3buf_read; space = id3tags[track_offset].mempos - audiobuf_read;
} }
else else
{ {
space = mp3buf_write - mp3buf_read; space = audiobuf_write - audiobuf_read;
} }
if (space < 0) if (space < 0)
space += mp3buflen; space += audiobuflen;
return space; return space;
} }
static int get_unswapped_space(void) static int get_unswapped_space(void)
{ {
int space = mp3buf_write - mp3buf_swapwrite; int space = audiobuf_write - audiobuf_swapwrite;
if (space < 0) if (space < 0)
space += mp3buflen; space += audiobuflen;
return space; return space;
} }
#if CONFIG_HWCODEC == MAS3587F #if CONFIG_HWCODEC == MAS3587F
static int get_unsaved_space(void) static int get_unsaved_space(void)
{ {
int space = mp3buf_write - mp3buf_read; int space = audiobuf_write - audiobuf_read;
if (space < 0) if (space < 0)
space += mp3buflen; space += audiobuflen;
return space; return space;
} }
#endif /* #if CONFIG_HWCODEC == MAS3587F */ #endif /* #if CONFIG_HWCODEC == MAS3587F */
@ -570,8 +570,8 @@ void rec_tick(void)
"mov #30,r3 \n" /* i_max = 30 */ "mov #30,r3 \n" /* i_max = 30 */
"mov #0x40,r2 \n" /* mask for EOD check */ "mov #0x40,r2 \n" /* mask for EOD check */
"mov #0,%0 \n" /* i = 0; */ "mov #0,%0 \n" /* i = 0; */
"add %2,%1 \n" /* mp3buf_write -> cur_addr */ "add %2,%1 \n" /* audiobuf_write -> cur_addr */
"add %2,%3 \n" /* mp3buflen -> end_addr */ "add %2,%3 \n" /* audiobuflen -> end_addr */
"bra .r_start \n" "bra .r_start \n"
"mov.b @%4,r1 \n" /* read PBDR (first time) */ "mov.b @%4,r1 \n" /* read PBDR (first time) */
@ -607,13 +607,13 @@ void rec_tick(void)
"bt .r_loop \n" /* yes: next pass */ "bt .r_loop \n" /* yes: next pass */
".r_end: \n" ".r_end: \n"
"sub %2,%1 \n" /* cur_addr -> mp3buf_write */ "sub %2,%1 \n" /* cur_addr -> audiobuf_write */
: /* outputs */ : /* outputs */
/* %0 */ "=&r"(i), /* %0 */ "=&r"(i),
/* %1, in & out */ "+r"(mp3buf_write) /* %1, in & out */ "+r"(audiobuf_write)
: /* inputs */ : /* inputs */
/* %2 */ "r"(mp3buf), /* %2 */ "r"(audiobuf),
/* %3 */ "r"(mp3buflen), /* %3 */ "r"(audiobuflen),
/* %4 */ "r"(PBDR_ADDR), /* %4 */ "r"(PBDR_ADDR),
/* %5 = r0 */ "z"(&PADRH), /* %5 = r0 */ "z"(&PADRH),
/* %6 */ "r"(0x4000000) /* %6 */ "r"(0x4000000)
@ -634,7 +634,7 @@ void rec_tick(void)
prerecord_timeout = current_tick + HZ; prerecord_timeout = current_tick + HZ;
/* Store the write pointer every second */ /* Store the write pointer every second */
prerecord_buffer[prerecord_index++] = mp3buf_write; prerecord_buffer[prerecord_index++] = audiobuf_write;
/* Wrap if necessary */ /* Wrap if necessary */
if(prerecord_index == prerecording_max_seconds) if(prerecord_index == prerecording_max_seconds)
@ -649,11 +649,11 @@ void rec_tick(void)
{ {
/* Signal to save the data if we are running out of buffer /* Signal to save the data if we are running out of buffer
space */ space */
num_bytes = mp3buf_write - mp3buf_read; num_bytes = audiobuf_write - audiobuf_read;
if(num_bytes < 0) if(num_bytes < 0)
num_bytes += mp3buflen; num_bytes += audiobuflen;
if(mp3buflen - num_bytes < MPEG_RECORDING_LOW_WATER && !saving) if(audiobuflen - num_bytes < MPEG_RECORDING_LOW_WATER && !saving)
{ {
saving = true; saving = true;
queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0); queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0);
@ -673,10 +673,10 @@ void playback_tick(void)
static void reset_mp3_buffer(void) static void reset_mp3_buffer(void)
{ {
mp3buf_read = 0; audiobuf_read = 0;
mp3buf_write = 0; audiobuf_write = 0;
mp3buf_swapwrite = 0; audiobuf_swapwrite = 0;
lowest_watermark_level = mp3buflen; lowest_watermark_level = audiobuflen;
} }
/* DMA transfer end interrupt callback */ /* DMA transfer end interrupt callback */
@ -688,14 +688,14 @@ static void transfer_end(unsigned char** ppbuf, int* psize)
int space_until_end_of_buffer; int space_until_end_of_buffer;
int track_offset = (tag_read_idx+1) & MAX_ID3_TAGS_MASK; int track_offset = (tag_read_idx+1) & MAX_ID3_TAGS_MASK;
mp3buf_read += last_dma_chunk_size; audiobuf_read += last_dma_chunk_size;
if(mp3buf_read >= mp3buflen) if(audiobuf_read >= audiobuflen)
mp3buf_read = 0; audiobuf_read = 0;
/* First, check if we are on a track boundary */ /* First, check if we are on a track boundary */
if (num_tracks_in_memory() > 1) if (num_tracks_in_memory() > 1)
{ {
if (mp3buf_read == id3tags[track_offset].mempos) if (audiobuf_read == id3tags[track_offset].mempos)
{ {
queue_post(&mpeg_queue, MPEG_TRACK_CHANGE, 0); queue_post(&mpeg_queue, MPEG_TRACK_CHANGE, 0);
track_offset = (track_offset+1) & MAX_ID3_TAGS_MASK; track_offset = (track_offset+1) & MAX_ID3_TAGS_MASK;
@ -704,7 +704,7 @@ static void transfer_end(unsigned char** ppbuf, int* psize)
unplayed_space_left = get_unplayed_space(); unplayed_space_left = get_unplayed_space();
space_until_end_of_buffer = mp3buflen - mp3buf_read; space_until_end_of_buffer = audiobuflen - audiobuf_read;
if(!filling && unplayed_space_left < low_watermark) if(!filling && unplayed_space_left < low_watermark)
{ {
@ -722,18 +722,18 @@ static void transfer_end(unsigned char** ppbuf, int* psize)
if (num_tracks_in_memory() > 1) if (num_tracks_in_memory() > 1)
{ {
/* will we move across the track boundary? */ /* will we move across the track boundary? */
if (( mp3buf_read < id3tags[track_offset].mempos ) && if (( audiobuf_read < id3tags[track_offset].mempos ) &&
((mp3buf_read+last_dma_chunk_size) > ((audiobuf_read+last_dma_chunk_size) >
id3tags[track_offset].mempos )) id3tags[track_offset].mempos ))
{ {
/* Make sure that we end exactly on the boundary */ /* Make sure that we end exactly on the boundary */
last_dma_chunk_size = id3tags[track_offset].mempos last_dma_chunk_size = id3tags[track_offset].mempos
- mp3buf_read; - audiobuf_read;
} }
} }
*psize = last_dma_chunk_size & 0xffff; *psize = last_dma_chunk_size & 0xffff;
*ppbuf = mp3buf + mp3buf_read; *ppbuf = audiobuf + audiobuf_read;
id3tags[tag_read_idx].id3.offset += last_dma_chunk_size; id3tags[tag_read_idx].id3.offset += last_dma_chunk_size;
/* Update the watermark debug level */ /* Update the watermark debug level */
@ -785,7 +785,7 @@ static int add_track_to_tag_list(const char *filename)
DEBUGF("Bad mp3\n"); DEBUGF("Bad mp3\n");
return -1; return -1;
} }
id3tags[tag_write_idx].mempos = mp3buf_write; id3tags[tag_write_idx].mempos = audiobuf_write;
id3tags[tag_write_idx].id3.elapsed = 0; id3tags[tag_write_idx].id3.elapsed = 0;
tag_write_idx = (tag_write_idx+1) & MAX_ID3_TAGS_MASK; tag_write_idx = (tag_write_idx+1) & MAX_ID3_TAGS_MASK;
@ -932,9 +932,9 @@ static void start_playback_if_ready(void)
{ {
int playable_space; int playable_space;
playable_space = mp3buf_swapwrite - mp3buf_read; playable_space = audiobuf_swapwrite - audiobuf_read;
if(playable_space < 0) if(playable_space < 0)
playable_space += mp3buflen; playable_space += audiobuflen;
/* See if we have started playing yet. If not, do it. */ /* See if we have started playing yet. If not, do it. */
if(play_pending || dma_underrun) if(play_pending || dma_underrun)
@ -950,7 +950,7 @@ static void start_playback_if_ready(void)
playing = true; playing = true;
last_dma_chunk_size = MIN(0x2000, get_unplayed_space_current_song()); last_dma_chunk_size = MIN(0x2000, get_unplayed_space_current_song());
mp3_play_data(mp3buf + mp3buf_read, last_dma_chunk_size, transfer_end); mp3_play_data(audiobuf + audiobuf_read, last_dma_chunk_size, transfer_end);
dma_underrun = false; dma_underrun = false;
if (!paused) if (!paused)
@ -989,19 +989,19 @@ static bool swap_one_chunk(void)
amount_to_swap = MIN(MPEG_SWAP_CHUNKSIZE, free_space_left); amount_to_swap = MIN(MPEG_SWAP_CHUNKSIZE, free_space_left);
} }
if(mp3buf_write < mp3buf_swapwrite) if(audiobuf_write < audiobuf_swapwrite)
amount_to_swap = MIN(mp3buflen - mp3buf_swapwrite, amount_to_swap = MIN(audiobuflen - audiobuf_swapwrite,
amount_to_swap); amount_to_swap);
else else
amount_to_swap = MIN(mp3buf_write - mp3buf_swapwrite, amount_to_swap = MIN(audiobuf_write - audiobuf_swapwrite,
amount_to_swap); amount_to_swap);
bitswap(mp3buf + mp3buf_swapwrite, amount_to_swap); bitswap(audiobuf + audiobuf_swapwrite, amount_to_swap);
mp3buf_swapwrite += amount_to_swap; audiobuf_swapwrite += amount_to_swap;
if(mp3buf_swapwrite >= mp3buflen) if(audiobuf_swapwrite >= audiobuflen)
{ {
mp3buf_swapwrite = 0; audiobuf_swapwrite = 0;
} }
return true; return true;
@ -1058,7 +1058,7 @@ static void mpeg_thread(void)
else else
{ {
DEBUGF("S R:%x W:%x SW:%x\n", DEBUGF("S R:%x W:%x SW:%x\n",
mp3buf_read, mp3buf_write, mp3buf_swapwrite); audiobuf_read, audiobuf_write, audiobuf_swapwrite);
queue_wait(&mpeg_queue, &ev); queue_wait(&mpeg_queue, &ev);
} }
@ -1169,9 +1169,9 @@ static void mpeg_thread(void)
mp3_play_pause(false); mp3_play_pause(false);
track_change(); track_change();
mp3buf_read = id3tags[tag_read_idx].mempos; audiobuf_read = id3tags[tag_read_idx].mempos;
last_dma_chunk_size = MIN(0x2000, get_unplayed_space_current_song()); last_dma_chunk_size = MIN(0x2000, get_unplayed_space_current_song());
mp3_play_data(mp3buf + mp3buf_read, last_dma_chunk_size, transfer_end); mp3_play_data(audiobuf + audiobuf_read, last_dma_chunk_size, transfer_end);
dma_underrun = false; dma_underrun = false;
last_dma_tick = current_tick; last_dma_tick = current_tick;
@ -1186,7 +1186,7 @@ static void mpeg_thread(void)
} else if(unswapped_space_left && } else if(unswapped_space_left &&
unswapped_space_left > unplayed_space_left) { unswapped_space_left > unplayed_space_left) {
/* Stop swapping the data from the previous file */ /* Stop swapping the data from the previous file */
mp3buf_swapwrite = mp3buf_read; audiobuf_swapwrite = audiobuf_read;
play_pending = true; play_pending = true;
} else { } else {
playing = true; playing = true;
@ -1304,16 +1304,16 @@ static void mpeg_thread(void)
diffpos = curpos - newpos; diffpos = curpos - newpos;
if(!filling && diffpos >= 0 && diffpos < mp3buflen) if(!filling && diffpos >= 0 && diffpos < audiobuflen)
{ {
int unplayed_space_left, unswapped_space_left; int unplayed_space_left, unswapped_space_left;
/* We are changing to a position that's already in /* We are changing to a position that's already in
memory, so we just move the DMA read pointer. */ memory, so we just move the DMA read pointer. */
mp3buf_read = mp3buf_write - diffpos; audiobuf_read = audiobuf_write - diffpos;
if (mp3buf_read < 0) if (audiobuf_read < 0)
{ {
mp3buf_read += mp3buflen; audiobuf_read += audiobuflen;
} }
unplayed_space_left = get_unplayed_space(); unplayed_space_left = get_unplayed_space();
@ -1328,7 +1328,7 @@ static void mpeg_thread(void)
if (unswapped_space_left > unplayed_space_left) if (unswapped_space_left > unplayed_space_left)
{ {
DEBUGF("Moved swapwrite\n"); DEBUGF("Moved swapwrite\n");
mp3buf_swapwrite = mp3buf_read; audiobuf_swapwrite = audiobuf_read;
play_pending = true; play_pending = true;
} }
@ -1344,7 +1344,7 @@ static void mpeg_thread(void)
/* resume will start at new position */ /* resume will start at new position */
last_dma_chunk_size = last_dma_chunk_size =
MIN(0x2000, get_unplayed_space_current_song()); MIN(0x2000, get_unplayed_space_current_song());
mp3_play_data(mp3buf + mp3buf_read, mp3_play_data(audiobuf + audiobuf_read,
last_dma_chunk_size, transfer_end); last_dma_chunk_size, transfer_end);
dma_underrun = false; dma_underrun = false;
} }
@ -1402,12 +1402,12 @@ static void mpeg_thread(void)
int next = (tag_read_idx+1) & MAX_ID3_TAGS_MASK; int next = (tag_read_idx+1) & MAX_ID3_TAGS_MASK;
/* Reset the buffer */ /* Reset the buffer */
mp3buf_write = id3tags[next].mempos; audiobuf_write = id3tags[next].mempos;
/* Reset swapwrite unless we're still swapping current /* Reset swapwrite unless we're still swapping current
track */ track */
if (get_unplayed_space() <= get_playable_space()) if (get_unplayed_space() <= get_playable_space())
mp3buf_swapwrite = mp3buf_write; audiobuf_swapwrite = audiobuf_write;
close(mpeg_file); close(mpeg_file);
remove_all_non_current_tags(); remove_all_non_current_tags();
@ -1430,13 +1430,13 @@ static void mpeg_thread(void)
} }
case MPEG_NEED_DATA: case MPEG_NEED_DATA:
free_space_left = mp3buf_read - mp3buf_write; free_space_left = audiobuf_read - audiobuf_write;
/* We interpret 0 as "empty buffer" */ /* We interpret 0 as "empty buffer" */
if(free_space_left <= 0) if(free_space_left <= 0)
free_space_left = mp3buflen + free_space_left; free_space_left = audiobuflen + free_space_left;
unplayed_space_left = mp3buflen - free_space_left; unplayed_space_left = audiobuflen - free_space_left;
/* Make sure that we don't fill the entire buffer */ /* Make sure that we don't fill the entire buffer */
free_space_left -= MPEG_HIGH_WATER; free_space_left -= MPEG_HIGH_WATER;
@ -1458,7 +1458,7 @@ static void mpeg_thread(void)
amount_to_read = free_space_left; amount_to_read = free_space_left;
/* Don't read more than until the end of the buffer */ /* Don't read more than until the end of the buffer */
amount_to_read = MIN(mp3buflen - mp3buf_write, amount_to_read); amount_to_read = MIN(audiobuflen - audiobuf_write, amount_to_read);
#if MEM == 8 #if MEM == 8
amount_to_read = MIN(0x100000, amount_to_read); amount_to_read = MIN(0x100000, amount_to_read);
#endif /* #if MEM == 8 */ #endif /* #if MEM == 8 */
@ -1471,7 +1471,7 @@ static void mpeg_thread(void)
{ {
DEBUGF("R\n"); DEBUGF("R\n");
t1 = current_tick; t1 = current_tick;
len = read(mpeg_file, mp3buf+mp3buf_write, amount_to_read); len = read(mpeg_file, audiobuf+audiobuf_write, amount_to_read);
if(len > 0) if(len > 0)
{ {
t2 = current_tick; t2 = current_tick;
@ -1482,17 +1482,17 @@ static void mpeg_thread(void)
data */ data */
if (len < amount_to_read) if (len < amount_to_read)
{ {
int tagptr = mp3buf_write + len - 128; int tagptr = audiobuf_write + len - 128;
int i; int i;
char *tag = "TAG"; char *tag = "TAG";
int taglen = 128; int taglen = 128;
for(i = 0;i < 3;i++) for(i = 0;i < 3;i++)
{ {
if(tagptr >= mp3buflen) if(tagptr >= audiobuflen)
tagptr -= mp3buflen; tagptr -= audiobuflen;
if(mp3buf[tagptr] != tag[i]) if(audiobuf[tagptr] != tag[i])
taglen = 0; taglen = 0;
tagptr++; tagptr++;
@ -1512,11 +1512,11 @@ static void mpeg_thread(void)
} }
} }
mp3buf_write += len; audiobuf_write += len;
if(mp3buf_write >= mp3buflen) if(audiobuf_write >= audiobuflen)
{ {
mp3buf_write = 0; audiobuf_write = 0;
DEBUGF("W\n"); DEBUGF("W\n");
} }
@ -1597,48 +1597,48 @@ static void mpeg_thread(void)
startpos = prerecord_buffer[startpos]; startpos = prerecord_buffer[startpos];
DEBUGF("Start looking at address %x (%x)\n", DEBUGF("Start looking at address %x (%x)\n",
mp3buf+startpos, startpos); audiobuf+startpos, startpos);
saved_header = mpeg_get_last_header(); saved_header = mpeg_get_last_header();
mem_find_next_frame(startpos, &offset, 5000, mem_find_next_frame(startpos, &offset, 5000,
saved_header); saved_header);
mp3buf_read = startpos + offset; audiobuf_read = startpos + offset;
DEBUGF("New mp3buf_read address: %x (%x)\n", DEBUGF("New audiobuf_read address: %x (%x)\n",
mp3buf+mp3buf_read, mp3buf_read); audiobuf+audiobuf_read, audiobuf_read);
/* Make room for headers */ /* Make room for headers */
mp3buf_read -= MPEG_RESERVED_HEADER_SPACE; audiobuf_read -= MPEG_RESERVED_HEADER_SPACE;
if(mp3buf_read < 0) if(audiobuf_read < 0)
{ {
/* Clear the bottom half */ /* Clear the bottom half */
memset(mp3buf, 0, memset(audiobuf, 0,
mp3buf_read + MPEG_RESERVED_HEADER_SPACE); audiobuf_read + MPEG_RESERVED_HEADER_SPACE);
/* And the top half */ /* And the top half */
mp3buf_read += mp3buflen; audiobuf_read += audiobuflen;
memset(mp3buf + mp3buf_read, 0, memset(audiobuf + audiobuf_read, 0,
mp3buflen - mp3buf_read); audiobuflen - audiobuf_read);
} }
else else
{ {
memset(mp3buf + mp3buf_read, 0, memset(audiobuf + audiobuf_read, 0,
MPEG_RESERVED_HEADER_SPACE); MPEG_RESERVED_HEADER_SPACE);
} }
/* Copy the empty ID3 header */ /* Copy the empty ID3 header */
startpos = mp3buf_read; startpos = audiobuf_read;
for(i = 0;i < (int)sizeof(empty_id3_header);i++) for(i = 0;i < (int)sizeof(empty_id3_header);i++)
{ {
mp3buf[startpos++] = empty_id3_header[i]; audiobuf[startpos++] = empty_id3_header[i];
if(startpos == mp3buflen) if(startpos == audiobuflen)
startpos = 0; startpos = 0;
} }
DEBUGF("New mp3buf_read address (reservation): %x\n", DEBUGF("New audiobuf_read address (reservation): %x\n",
mp3buf+mp3buf_read); audiobuf+audiobuf_read);
DEBUGF("Prerecording...\n"); DEBUGF("Prerecording...\n");
} }
@ -1650,11 +1650,11 @@ static void mpeg_thread(void)
/* Advance the write pointer to make /* Advance the write pointer to make
room for an ID3 tag plus a VBR header */ room for an ID3 tag plus a VBR header */
mp3buf_write = MPEG_RESERVED_HEADER_SPACE; audiobuf_write = MPEG_RESERVED_HEADER_SPACE;
memset(mp3buf, 0, MPEG_RESERVED_HEADER_SPACE); memset(audiobuf, 0, MPEG_RESERVED_HEADER_SPACE);
/* Insert the ID3 header */ /* Insert the ID3 header */
memcpy(mp3buf, empty_id3_header, memcpy(audiobuf, empty_id3_header,
sizeof(empty_id3_header)); sizeof(empty_id3_header));
DEBUGF("Recording...\n"); DEBUGF("Recording...\n");
@ -1711,14 +1711,14 @@ static void mpeg_thread(void)
/* saved_header is saved right before stopping /* saved_header is saved right before stopping
the MAS */ the MAS */
framelen = create_xing_header(mpeg_file, 0, framelen = create_xing_header(mpeg_file, 0,
num_rec_bytes, mp3buf, num_rec_bytes, audiobuf,
num_recorded_frames, num_recorded_frames,
saved_header, NULL, saved_header, NULL,
false); false);
lseek(mpeg_file, MPEG_RESERVED_HEADER_SPACE-framelen, lseek(mpeg_file, MPEG_RESERVED_HEADER_SPACE-framelen,
SEEK_SET); SEEK_SET);
write(mpeg_file, mp3buf, framelen); write(mpeg_file, audiobuf, framelen);
close(mpeg_file); close(mpeg_file);
} }
mpeg_file = -1; mpeg_file = -1;
@ -1760,9 +1760,9 @@ static void mpeg_thread(void)
if(amount_to_save >= 1800) if(amount_to_save >= 1800)
{ {
/* Now find a frame boundary to split at */ /* Now find a frame boundary to split at */
startpos = mp3buf_write - 1800; startpos = audiobuf_write - 1800;
if(startpos < 0) if(startpos < 0)
startpos += mp3buflen; startpos += audiobuflen;
rc = mem_find_next_frame(startpos, &offset, 1800, rc = mem_find_next_frame(startpos, &offset, 1800,
saved_header); saved_header);
@ -1771,28 +1771,28 @@ static void mpeg_thread(void)
/* offset will now contain the number of bytes to /* offset will now contain the number of bytes to
add to startpos to find the frame boundary */ add to startpos to find the frame boundary */
startpos += offset; startpos += offset;
if(startpos >= mp3buflen) if(startpos >= audiobuflen)
startpos -= mp3buflen; startpos -= audiobuflen;
} }
else else
{ {
/* No header found. Let's save the whole buffer. */ /* No header found. Let's save the whole buffer. */
startpos = mp3buf_write; startpos = audiobuf_write;
} }
} }
else else
{ {
/* Too few bytes recorded, timeout */ /* Too few bytes recorded, timeout */
startpos = mp3buf_write; startpos = audiobuf_write;
} }
amount_to_save = startpos - mp3buf_read; amount_to_save = startpos - audiobuf_read;
if(amount_to_save < 0) if(amount_to_save < 0)
amount_to_save += mp3buflen; amount_to_save += audiobuflen;
/* First save up to the end of the buffer */ /* First save up to the end of the buffer */
writelen = MIN(amount_to_save, writelen = MIN(amount_to_save,
mp3buflen - mp3buf_read); audiobuflen - audiobuf_read);
if (mpeg_file < 0) /* delayed file opening */ if (mpeg_file < 0) /* delayed file opening */
{ {
@ -1804,7 +1804,7 @@ static void mpeg_thread(void)
if(writelen) if(writelen)
{ {
rc = write(mpeg_file, mp3buf + mp3buf_read, writelen); rc = write(mpeg_file, audiobuf + audiobuf_read, writelen);
if(rc < 0) if(rc < 0)
{ {
if(errno == ENOSPC) if(errno == ENOSPC)
@ -1826,7 +1826,7 @@ static void mpeg_thread(void)
writelen = amount_to_save - writelen; writelen = amount_to_save - writelen;
if(writelen) if(writelen)
{ {
rc = write(mpeg_file, mp3buf, writelen); rc = write(mpeg_file, audiobuf, writelen);
if(rc < 0) if(rc < 0)
{ {
if(errno == ENOSPC) if(errno == ENOSPC)
@ -1845,9 +1845,9 @@ static void mpeg_thread(void)
} }
/* Advance the buffer pointers */ /* Advance the buffer pointers */
mp3buf_read += amount_to_save; audiobuf_read += amount_to_save;
if(mp3buf_read >= mp3buflen) if(audiobuf_read >= audiobuflen)
mp3buf_read -= mp3buflen; audiobuf_read -= audiobuflen;
/* Close the current file */ /* Close the current file */
rc = close(mpeg_file); rc = close(mpeg_file);
@ -1867,23 +1867,23 @@ static void mpeg_thread(void)
wrapped */ wrapped */
if(amount_to_save < 0) if(amount_to_save < 0)
{ {
amount_to_save += mp3buflen; amount_to_save += audiobuflen;
} }
DEBUGF("r: %x w: %x\n", mp3buf_read, mp3buf_write); DEBUGF("r: %x w: %x\n", audiobuf_read, audiobuf_write);
DEBUGF("ats: %x\n", amount_to_save); DEBUGF("ats: %x\n", amount_to_save);
/* Save data only if the buffer is getting full, /* Save data only if the buffer is getting full,
or if we should stop recording */ or if we should stop recording */
if(amount_to_save) if(amount_to_save)
{ {
if(mp3buflen - if(audiobuflen -
amount_to_save < MPEG_RECORDING_LOW_WATER || amount_to_save < MPEG_RECORDING_LOW_WATER ||
stop_pending) stop_pending)
{ {
/* Only save up to the end of the buffer */ /* Only save up to the end of the buffer */
writelen = MIN(amount_to_save, writelen = MIN(amount_to_save,
mp3buflen - mp3buf_read); audiobuflen - audiobuf_read);
DEBUGF("wrl: %x\n", writelen); DEBUGF("wrl: %x\n", writelen);
@ -1896,7 +1896,7 @@ static void mpeg_thread(void)
panicf("recfile: %d", mpeg_file); panicf("recfile: %d", mpeg_file);
} }
rc = write(mpeg_file, mp3buf + mp3buf_read, rc = write(mpeg_file, audiobuf + audiobuf_read,
writelen); writelen);
if(rc < 0) if(rc < 0)
@ -1914,9 +1914,9 @@ static void mpeg_thread(void)
} }
} }
mp3buf_read += amount_to_save; audiobuf_read += amount_to_save;
if(mp3buf_read >= mp3buflen) if(audiobuf_read >= audiobuflen)
mp3buf_read = 0; audiobuf_read = 0;
rc = fsync(mpeg_file); rc = fsync(mpeg_file);
if(rc < 0) if(rc < 0)
@ -2468,9 +2468,9 @@ unsigned long mpeg_num_recorded_bytes(void)
if(index < 0) if(index < 0)
index += prerecording_max_seconds; index += prerecording_max_seconds;
num_bytes = mp3buf_write - prerecord_buffer[index]; num_bytes = audiobuf_write - prerecord_buffer[index];
if(num_bytes < 0) if(num_bytes < 0)
num_bytes += mp3buflen; num_bytes += audiobuflen;
return num_bytes;; return num_bytes;;
} }
@ -2765,7 +2765,7 @@ void audio_init(void)
mpeg_errno = 0; mpeg_errno = 0;
#ifndef SIMULATOR #ifndef SIMULATOR
mp3buflen = mp3end - mp3buf; audiobuflen = audiobufend - audiobuf;
queue_init(&mpeg_queue); queue_init(&mpeg_queue);
#endif /* #ifndef SIMULATOR */ #endif /* #ifndef SIMULATOR */
create_thread(mpeg_thread, mpeg_stack, create_thread(mpeg_thread, mpeg_stack,

12
firmware/rolo.c
View file

@ -120,7 +120,7 @@ int rolo_load(const char* filename)
} }
lseek(fd, FIRMWARE_OFFSET_FILE_DATA, SEEK_SET); lseek(fd, FIRMWARE_OFFSET_FILE_DATA, SEEK_SET);
if (read(fd, mp3buf, length) != length) { if (read(fd, audiobuf, length) != length) {
rolo_error("Error Reading File"); rolo_error("Error Reading File");
return -1; return -1;
} }
@ -128,7 +128,7 @@ int rolo_load(const char* filename)
checksum = 0; checksum = 0;
for(i = 0;i < length;i++) { for(i = 0;i < length;i++) {
checksum += mp3buf[i]; checksum += audiobuf[i];
} }
/* Verify checksum against file header */ /* Verify checksum against file header */
@ -162,12 +162,12 @@ int rolo_load(const char* filename)
lseek(fd, FIRMWARE_OFFSET_FILE_DATA, SEEK_SET); lseek(fd, FIRMWARE_OFFSET_FILE_DATA, SEEK_SET);
/* verify that file can be read and descrambled */ /* verify that file can be read and descrambled */
if ((mp3buf + (2*length)+4) >= mp3end) { if ((audiobuf + (2*length)+4) >= audiobufend) {
rolo_error("Not enough room to load file"); rolo_error("Not enough room to load file");
return -1; return -1;
} }
if (read(fd, &mp3buf[length], length) != (int)length) { if (read(fd, &audiobuf[length], length) != (int)length) {
rolo_error("Error Reading File"); rolo_error("Error Reading File");
return -1; return -1;
} }
@ -175,7 +175,7 @@ int rolo_load(const char* filename)
lcd_puts(0, 1, "Descramble"); lcd_puts(0, 1, "Descramble");
lcd_update(); lcd_update();
checksum = descramble(mp3buf + length, mp3buf, length); checksum = descramble(audiobuf + length, audiobuf, length);
/* Verify checksum against file header */ /* Verify checksum against file header */
if (checksum != file_checksum) { if (checksum != file_checksum) {
@ -201,7 +201,7 @@ int rolo_load(const char* filename)
PAIOR = 0x0FA0; PAIOR = 0x0FA0;
#endif #endif
#endif #endif
rolo_restart(mp3buf, ramstart, length); rolo_restart(audiobuf, ramstart, length);
return 0; /* this is never reached */ return 0; /* this is never reached */
} }

8
firmware/rom.lds
View file

@ -104,15 +104,15 @@ SECTIONS
_end = .; _end = .;
} > DRAM } > DRAM
.mp3buf : .audiobuf :
{ {
. = ALIGN(0x4); . = ALIGN(0x4);
_mp3buffer = .; _audiobuffer = .;
} > DRAM } > DRAM
.mp3end ENDADDR: .audiobufend ENDADDR:
{ {
_mp3end = .; _audiobufend = .;
} > DRAM } > DRAM
.plugin ENDADDR: .plugin ENDADDR: