nihilazo
/
rockbox
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

mp3buf renamed to audiobuf 

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
Show Stats 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)
audio_size = 8*1024*1024;
audio_buffer = mp3buf;
audio_buffer = audiobuf;
puts("Reading %d bytes..", audio_size);
@ -356,11 +356,11 @@ bool dbg_audio_thread(void)
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);
snprintf(buf, sizeof(buf), "write: %x", d.mp3buf_write);
snprintf(buf, sizeof(buf), "write: %x", d.audiobuf_write);
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);
snprintf(buf, sizeof(buf), "playing: %d", d.playing);
lcd_puts(0, 3, buf);
@ -370,11 +370,11 @@ bool dbg_audio_thread(void)
lcd_puts(0, 5, buf);
/* 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);
/* 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);
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)
{
char s[32], s2[32];
long buflen = ((mp3end - mp3buf) * 2) / 2097; /* avoid overflow */
long buflen = ((audiobufend - audiobuf) * 2) / 2097; /* avoid overflow */
int integer, decimal;
bool done = false;
int key;

10
apps/playlist.c
View File

@ -351,8 +351,8 @@ static int add_indices_to_playlist(struct playlist_info* playlist,
audio_stop();
talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
buffer = mp3buf;
buflen = (mp3end - mp3buf);
buffer = audiobuf;
buflen = (audiobufend - audiobuf);
}
store_index = true;
@ -1211,8 +1211,8 @@ int playlist_resume(void)
/* use mp3 buffer for maximum load speed */
talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
buflen = (mp3end - mp3buf);
buffer = mp3buf;
buflen = (audiobufend - audiobuf);
buffer = audiobuf;
empty_playlist(playlist, true);
@ -1294,7 +1294,7 @@ int playlist_resume(void)
if (str3[0] != '\0')
{
/* NOTE: add_indices_to_playlist() overwrites the
mp3buf so we need to reload control file
audiobuf so we need to reload control file
data */
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,
set_time,
plugin_get_buffer,
plugin_get_mp3_buffer,
plugin_get_audio_buffer,
#ifndef SIMULATOR
plugin_register_timer,
plugin_unregister_timer,
@ -407,12 +407,12 @@ void* plugin_get_buffer(int* buffer_size)
/* Returns a pointer to the mp3 buffer.
Playback gets stopped, to avoid conflicts. */
void* plugin_get_mp3_buffer(int* buffer_size)
void* plugin_get_audio_buffer(int* buffer_size)
{
audio_stop();
talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
*buffer_size = mp3end - mp3buf;
return mp3buf;
*buffer_size = audiobufend - audiobuf;
return audiobuf;
}
#ifndef SIMULATOR

4
apps/plugin.h
View File

@ -280,7 +280,7 @@ struct plugin_api {
struct tm* (*get_time)(void);
int (*set_time)(const struct tm *tm);
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
int (*plugin_register_timer)(int cycles, int prio, void (*timer_callback)(void));
void (*plugin_unregister_timer)(void);
@ -334,7 +334,7 @@ struct plugin_api {
/* defined by the plugin loader (plugin.c) */
int plugin_load(const char* plugin, void* parameter);
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));
void plugin_unregister_timer(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 f;
buffer = rb->plugin_get_mp3_buffer(&buffersize);
buffer = rb->plugin_get_audio_buffer(&buffersize);
#ifdef HAVE_MMC
/* 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));
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:

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

@ -29,9 +29,9 @@ static struct plugin_api* local_rb;
int mem_ptr;
int bufsize;
unsigned char* mp3buf; // The actual MP3 buffer from Rockbox
unsigned char* mallocbuf; // 512K from the start of MP3 buffer
unsigned char* filebuf; // The rest of the MP3 buffer
unsigned char* audiobuf; // The actual audio buffer from Rockbox
unsigned char* mallocbuf; // 512K from the start of audio buffer
unsigned char* filebuf; // The rest of the audio buffer
void* codec_malloc(size_t size) {
void* x;
@ -169,11 +169,11 @@ int local_init(char* infilename, char* outfilename, file_info_struct* file_info,
local_rb=rb;
mem_ptr=0;
mp3buf=local_rb->plugin_get_mp3_buffer(&bufsize);
mallocbuf=mp3buf;
filebuf=&mp3buf[MALLOC_BUFSIZE];
audiobuf=local_rb->plugin_get_audio_buffer(&bufsize);
mallocbuf=audiobuf;
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_update();

9
apps/plugins/rockboy.c
View File

@ -26,8 +26,8 @@
#define OVL_DISPLAYNAME "RockBoy"
struct plugin_api* rb;
unsigned char *mp3buf;
int mp3buf_size;
unsigned char *audiobuf;
int audiobuf_size;
/* this is the plugin entry point */
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;
}
mp3buf = rb->plugin_get_mp3_buffer(&mp3buf_size);
if (header.start_addr < mp3buf || header.end_addr > mp3buf + mp3buf_size)
audiobuf = rb->plugin_get_audio_buffer(&audiobuf_size);
if (header.start_addr < audiobuf ||
header.end_addr > audiobuf + audiobuf_size)
{
rb->close(fh);
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;
}
void *mp3_bufferbase;
void *mp3_bufferpointer;
unsigned int mp3_buffer_free;
void *audio_bufferbase;
void *audio_bufferpointer;
unsigned int audio_buffer_free;
void *my_malloc(size_t size)
{
void *alloc;
if (!mp3_bufferbase)
if (!audio_bufferbase)
{
mp3_bufferbase = mp3_bufferpointer
= rb->plugin_get_mp3_buffer(&mp3_buffer_free);
audio_bufferbase = audio_bufferpointer
= rb->plugin_get_audio_buffer(&audio_buffer_free);
#if MEM <= 8 && !defined(SIMULATOR)
/* loaded as an overlay, protect from overwriting ourselves */
if ((unsigned)(ovl_start_addr - (unsigned char *)mp3_bufferbase)
< mp3_buffer_free)
mp3_buffer_free = ovl_start_addr - (unsigned char *)mp3_bufferbase;
if ((unsigned)(ovl_start_addr - (unsigned char *)audio_bufferbase)
< audio_buffer_free)
audio_buffer_free = ovl_start_addr - (unsigned char *)audio_bufferbase;
#endif
}
if (size + 4 > mp3_buffer_free)
if (size + 4 > audio_buffer_free)
return 0;
alloc = mp3_bufferpointer;
mp3_bufferpointer += size + 4;
mp3_buffer_free -= size + 4;
alloc = audio_bufferpointer;
audio_bufferpointer += size + 4;
audio_buffer_free -= size + 4;
return alloc;
}
void setmallocpos(void *pointer)
{
mp3_bufferpointer = pointer;
mp3_buffer_free = mp3_bufferpointer - mp3_bufferbase;
audio_bufferpointer = pointer;
audio_buffer_free = audio_bufferpointer - audio_bufferbase;
}
/* this is the plugin entry point */
@ -113,8 +113,8 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
#endif
shut=0;
cleanshut=0;
mp3_bufferbase=mp3_bufferpointer=0;
mp3_buffer_free=0;
audio_bufferbase=audio_bufferpointer=0;
audio_buffer_free=0;
/* now go ahead and have fun! */
/* 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;
buf = rb->plugin_get_mp3_buffer(&buf_size); /* start munching memory */
buf = rb->plugin_get_audio_buffer(&buf_size); /* start munching memory */
stringbuffer = buf;
pointers = (char **)(buf + buf_size - sizeof(int));

26
apps/plugins/vbrfix.c
View File

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

2
apps/plugins/video.c
View File

@ -864,7 +864,7 @@ int main(char* filename)
// init buffer
rb->memset(&gBuf, 0, sizeof(gBuf));
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.pBufFill = gBuf.pBufStart; // all empty

20
apps/talk.c
View File

@ -131,7 +131,7 @@ static void load_voicefile(void)
goto load_err;
file_size = filesize(filehandle);
if (file_size > mp3end - mp3buf) /* won't fit? */
if (file_size > audiobufend - audiobuf) /* won't fit? */
goto load_err;
#ifdef HAVE_MMC /* load only the header for now */
@ -140,17 +140,17 @@ static void load_voicefile(void)
load_size = file_size;
#endif
got_size = read(filehandle, mp3buf, load_size);
got_size = read(filehandle, audiobuf, load_size);
if (got_size == load_size /* success */
&& ((struct voicefile*)mp3buf)->table /* format check */
&& ((struct voicefile*)audiobuf)->table /* format check */
== offsetof(struct voicefile, index))
{
p_voicefile = (struct voicefile*)mp3buf;
p_voicefile = (struct voicefile*)audiobuf;
/* 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 */
size_for_thumbnail = mp3end - p_thumbnail;
size_for_thumbnail = audiobufend - p_thumbnail;
}
else
goto load_err;
@ -160,7 +160,7 @@ static void load_voicefile(void)
load_size = (p_voicefile->id1_max + p_voicefile->id2_max)
* sizeof(struct clip_entry);
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 */
goto load_err;
#else
@ -356,7 +356,7 @@ static unsigned char* get_clip(long id, long* p_size)
clipsize = p_voicefile->index[id].size;
if (clipsize == 0) /* clip not included in voicefile */
return NULL;
clipbuf = mp3buf + p_voicefile->index[id].offset;
clipbuf = audiobuf + p_voicefile->index[id].offset;
#ifdef HAVE_MMC /* dynamic loading, on demand */
if (!(clipsize & LOADED_MASK))
@ -383,8 +383,8 @@ static void reset_state(void)
{
queue_write = queue_read = 0; /* reset the queue */
p_voicefile = NULL; /* indicate no voicefile (trashed) */
p_thumbnail = mp3buf; /* whole space for thumbnail */
size_for_thumbnail = mp3end - mp3buf;
p_thumbnail = audiobuf; /* whole space for thumbnail */
size_for_thumbnail = audiobufend - audiobuf;
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);
/* FIXME: Where to put mp3 buffer? */
/* FIXME: Where to put audio buffer? */
_mp3buffer = 0;
_mp3end = 0;
_audiobuffer = 0;
_audioend = 0;
/* Plugins are not supported on the Gmini*/
@ -217,16 +217,16 @@ SECTIONS
_end = .;
} > DRAM
.mp3buf ALIGN(4) :
.audiobuf ALIGN(4) :
{
_mp3buffer = .;
mp3buffer = .;
_audiobuffer = .;
audiobuffer = .;
} > DRAM
.mp3end ENDADDR:
.audiobufend ENDADDR:
{
mp3end = .;
_mp3end = .;
audiobufend = .;
_audiobufend = .;
} > DRAM
.plugin ENDADDR:

14
firmware/buffer.c
View File

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

8
firmware/export/audio.h
View File

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

6
firmware/export/buffer.h
View File

@ -21,12 +21,12 @@
/* defined in linker script */
#ifdef SIMULATOR
extern unsigned char *mp3end;
extern unsigned char *audiobufend;
#else
extern unsigned char mp3end[];
extern unsigned char audiobufend[];
#endif
extern unsigned char *mp3buf;
extern unsigned char *audiobuf;
void buffer_init(void);
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)
{
*c = mp3buf[fnf_read_index++];
*c = audiobuf[fnf_read_index++];
return 1;
}
else
{
fnf_buf_len = read(fd, mp3buf, mp3end - mp3buf);
fnf_buf_len = read(fd, audiobuf, audiobufend - audiobuf);
if(fnf_buf_len < 0)
return -1;
@ -286,7 +286,7 @@ static int buf_getbyte(int fd, unsigned char *c)
if(fnf_buf_len > 0)
{
*c = mp3buf[fnf_read_index++];
*c = audiobuf[fnf_read_index++];
return 1;
}
else
@ -302,7 +302,7 @@ static int buf_seek(int fd, int 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)
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);
}
static int mp3buflen;
static int audiobuflen;
static int mem_pos;
static int mem_cnt;
static int mem_maxlen;
@ -339,8 +339,8 @@ static int mem_getbyte(int dummy, unsigned char *c)
{
dummy = dummy;
*c = mp3buf[mem_pos++];
if(mem_pos >= mp3buflen)
*c = audiobuf[mem_pos++];
if(mem_pos >= audiobuflen)
mem_pos = 0;
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 last_header)
{
mp3buflen = mp3end - mp3buf;
audiobuflen = audiobufend - audiobuf;
mem_pos = startpos;
mem_cnt = 0;
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 const char mpeg_thread_name[] = "mpeg";
static int mp3buflen;
static int mp3buf_write;
static int mp3buf_swapwrite;
static int mp3buf_read;
static int audiobuflen;
static int audiobuf_write;
static int audiobuf_swapwrite;
static int audiobuf_read;
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)
{
dbgdata->mp3buflen = mp3buflen;
dbgdata->mp3buf_write = mp3buf_write;
dbgdata->mp3buf_swapwrite = mp3buf_swapwrite;
dbgdata->mp3buf_read = mp3buf_read;
dbgdata->audiobuflen = audiobuflen;
dbgdata->audiobuf_write = audiobuf_write;
dbgdata->audiobuf_swapwrite = audiobuf_swapwrite;
dbgdata->audiobuf_read = audiobuf_read;
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)
{
int space = mp3buf_write - mp3buf_read;
int space = audiobuf_write - audiobuf_read;
if (space < 0)
space += mp3buflen;
space += audiobuflen;
return space;
}
static int get_playable_space(void)
{
int space = mp3buf_swapwrite - mp3buf_read;
int space = audiobuf_swapwrite - audiobuf_read;
if (space < 0)
space += mp3buflen;
space += audiobuflen;
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;
space = id3tags[track_offset].mempos - mp3buf_read;
space = id3tags[track_offset].mempos - audiobuf_read;
}
else
{
space = mp3buf_write - mp3buf_read;
space = audiobuf_write - audiobuf_read;
}
if (space < 0)
space += mp3buflen;
space += audiobuflen;
return space;
}
static int get_unswapped_space(void)
{
int space = mp3buf_write - mp3buf_swapwrite;
int space = audiobuf_write - audiobuf_swapwrite;
if (space < 0)
space += mp3buflen;
space += audiobuflen;
return space;
}
#if CONFIG_HWCODEC == MAS3587F
static int get_unsaved_space(void)
{
int space = mp3buf_write - mp3buf_read;
int space = audiobuf_write - audiobuf_read;
if (space < 0)
space += mp3buflen;
space += audiobuflen;
return space;
}
#endif /* #if CONFIG_HWCODEC == MAS3587F */
@ -570,8 +570,8 @@ void rec_tick(void)
"mov #30,r3 \n" /* i_max = 30 */
"mov #0x40,r2 \n" /* mask for EOD check */
"mov #0,%0 \n" /* i = 0; */
"add %2,%1 \n" /* mp3buf_write -> cur_addr */
"add %2,%3 \n" /* mp3buflen -> end_addr */
"add %2,%1 \n" /* audiobuf_write -> cur_addr */
"add %2,%3 \n" /* audiobuflen -> end_addr */
"bra .r_start \n"
"mov.b @%4,r1 \n" /* read PBDR (first time) */
@ -607,13 +607,13 @@ void rec_tick(void)
"bt .r_loop \n" /* yes: next pass */
".r_end: \n"
"sub %2,%1 \n" /* cur_addr -> mp3buf_write */
"sub %2,%1 \n" /* cur_addr -> audiobuf_write */
: /* outputs */
/* %0 */ "=&r"(i),
/* %1, in & out */ "+r"(mp3buf_write)
/* %1, in & out */ "+r"(audiobuf_write)
: /* inputs */
/* %2 */ "r"(mp3buf),
/* %3 */ "r"(mp3buflen),
/* %2 */ "r"(audiobuf),
/* %3 */ "r"(audiobuflen),
/* %4 */ "r"(PBDR_ADDR),
/* %5 = r0 */ "z"(&PADRH),
/* %6 */ "r"(0x4000000)
@ -634,7 +634,7 @@ void rec_tick(void)
prerecord_timeout = current_tick + HZ;
/* Store the write pointer every second */
prerecord_buffer[prerecord_index++] = mp3buf_write;
prerecord_buffer[prerecord_index++] = audiobuf_write;
/* Wrap if necessary */
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
space */
num_bytes = mp3buf_write - mp3buf_read;
num_bytes = audiobuf_write - audiobuf_read;
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;
queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0);
@ -673,10 +673,10 @@ void playback_tick(void)
static void reset_mp3_buffer(void)
{
mp3buf_read = 0;
mp3buf_write = 0;
mp3buf_swapwrite = 0;
lowest_watermark_level = mp3buflen;
audiobuf_read = 0;
audiobuf_write = 0;
audiobuf_swapwrite = 0;
lowest_watermark_level = audiobuflen;
}
/* 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 track_offset = (tag_read_idx+1) & MAX_ID3_TAGS_MASK;
mp3buf_read += last_dma_chunk_size;
if(mp3buf_read >= mp3buflen)
mp3buf_read = 0;
audiobuf_read += last_dma_chunk_size;
if(audiobuf_read >= audiobuflen)
audiobuf_read = 0;
/* First, check if we are on a track boundary */
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);
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();
space_until_end_of_buffer = mp3buflen - mp3buf_read;
space_until_end_of_buffer = audiobuflen - audiobuf_read;
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)
{
/* will we move across the track boundary? */
if (( mp3buf_read < id3tags[track_offset].mempos ) &&
((mp3buf_read+last_dma_chunk_size) >
if (( audiobuf_read < id3tags[track_offset].mempos ) &&
((audiobuf_read+last_dma_chunk_size) >
id3tags[track_offset].mempos ))
{
/* Make sure that we end exactly on the boundary */
last_dma_chunk_size = id3tags[track_offset].mempos
- mp3buf_read;
- audiobuf_read;
}
}
*psize = last_dma_chunk_size & 0xffff;
*ppbuf = mp3buf + mp3buf_read;
*ppbuf = audiobuf + audiobuf_read;
id3tags[tag_read_idx].id3.offset += last_dma_chunk_size;
/* Update the watermark debug level */
@ -785,7 +785,7 @@ static int add_track_to_tag_list(const char *filename)
DEBUGF("Bad mp3\n");
return -1;
}
id3tags[tag_write_idx].mempos = mp3buf_write;
id3tags[tag_write_idx].mempos = audiobuf_write;
id3tags[tag_write_idx].id3.elapsed = 0;
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;
playable_space = mp3buf_swapwrite - mp3buf_read;
playable_space = audiobuf_swapwrite - audiobuf_read;
if(playable_space < 0)
playable_space += mp3buflen;
playable_space += audiobuflen;
/* See if we have started playing yet. If not, do it. */
if(play_pending || dma_underrun)
@ -950,7 +950,7 @@ static void start_playback_if_ready(void)
playing = true;
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;
if (!paused)
@ -989,19 +989,19 @@ static bool swap_one_chunk(void)
amount_to_swap = MIN(MPEG_SWAP_CHUNKSIZE, free_space_left);
}
if(mp3buf_write < mp3buf_swapwrite)
amount_to_swap = MIN(mp3buflen - mp3buf_swapwrite,
if(audiobuf_write < audiobuf_swapwrite)
amount_to_swap = MIN(audiobuflen - audiobuf_swapwrite,
amount_to_swap);
else
amount_to_swap = MIN(mp3buf_write - mp3buf_swapwrite,
amount_to_swap = MIN(audiobuf_write - audiobuf_swapwrite,
amount_to_swap);
bitswap(mp3buf + mp3buf_swapwrite, amount_to_swap);
bitswap(audiobuf + audiobuf_swapwrite, amount_to_swap);
mp3buf_swapwrite += amount_to_swap;
if(mp3buf_swapwrite >= mp3buflen)
audiobuf_swapwrite += amount_to_swap;
if(audiobuf_swapwrite >= audiobuflen)
{
mp3buf_swapwrite = 0;
audiobuf_swapwrite = 0;
}
return true;
@ -1058,7 +1058,7 @@ static void mpeg_thread(void)
else
{
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);
}
@ -1169,9 +1169,9 @@ static void mpeg_thread(void)
mp3_play_pause(false);
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());
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;
last_dma_tick = current_tick;
@ -1186,7 +1186,7 @@ static void mpeg_thread(void)
} else if(unswapped_space_left &&
unswapped_space_left > unplayed_space_left) {
/* Stop swapping the data from the previous file */
mp3buf_swapwrite = mp3buf_read;
audiobuf_swapwrite = audiobuf_read;
play_pending = true;
} else {
playing = true;
@ -1304,16 +1304,16 @@ static void mpeg_thread(void)
diffpos = curpos - newpos;
if(!filling && diffpos >= 0 && diffpos < mp3buflen)
if(!filling && diffpos >= 0 && diffpos < audiobuflen)
{
int unplayed_space_left, unswapped_space_left;
/* We are changing to a position that's already in
memory, so we just move the DMA read pointer. */
mp3buf_read = mp3buf_write - diffpos;
if (mp3buf_read < 0)
audiobuf_read = audiobuf_write - diffpos;
if (audiobuf_read < 0)
{
mp3buf_read += mp3buflen;
audiobuf_read += audiobuflen;
}
unplayed_space_left = get_unplayed_space();
@ -1328,7 +1328,7 @@ static void mpeg_thread(void)
if (unswapped_space_left > unplayed_space_left)
{
DEBUGF("Moved swapwrite\n");
mp3buf_swapwrite = mp3buf_read;
audiobuf_swapwrite = audiobuf_read;
play_pending = true;
}
@ -1344,7 +1344,7 @@ static void mpeg_thread(void)
/* resume will start at new position */
last_dma_chunk_size =
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);
dma_underrun = false;
}
@ -1402,12 +1402,12 @@ static void mpeg_thread(void)
int next = (tag_read_idx+1) & MAX_ID3_TAGS_MASK;
/* Reset the buffer */
mp3buf_write = id3tags[next].mempos;
audiobuf_write = id3tags[next].mempos;
/* Reset swapwrite unless we're still swapping current
track */
if (get_unplayed_space() <= get_playable_space())
mp3buf_swapwrite = mp3buf_write;
audiobuf_swapwrite = audiobuf_write;
close(mpeg_file);
remove_all_non_current_tags();
@ -1430,13 +1430,13 @@ static void mpeg_thread(void)
}
case MPEG_NEED_DATA:
free_space_left = mp3buf_read - mp3buf_write;
free_space_left = audiobuf_read - audiobuf_write;
/* We interpret 0 as "empty buffer" */
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 */
free_space_left -= MPEG_HIGH_WATER;
@ -1458,7 +1458,7 @@ static void mpeg_thread(void)
amount_to_read = free_space_left;
/* 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
amount_to_read = MIN(0x100000, amount_to_read);
#endif /* #if MEM == 8 */
@ -1471,7 +1471,7 @@ static void mpeg_thread(void)
{
DEBUGF("R\n");
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)
{
t2 = current_tick;
@ -1482,17 +1482,17 @@ static void mpeg_thread(void)
data */
if (len < amount_to_read)
{
int tagptr = mp3buf_write + len - 128;
int tagptr = audiobuf_write + len - 128;
int i;
char *tag = "TAG";
int taglen = 128;
for(i = 0;i < 3;i++)
{
if(tagptr >= mp3buflen)
tagptr -= mp3buflen;
if(tagptr >= audiobuflen)
tagptr -= audiobuflen;
if(mp3buf[tagptr] != tag[i])
if(audiobuf[tagptr] != tag[i])
taglen = 0;
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");
}
@ -1597,48 +1597,48 @@ static void mpeg_thread(void)
startpos = prerecord_buffer[startpos];
DEBUGF("Start looking at address %x (%x)\n",
mp3buf+startpos, startpos);
audiobuf+startpos, startpos);
saved_header = mpeg_get_last_header();
mem_find_next_frame(startpos, &offset, 5000,
saved_header);
mp3buf_read = startpos + offset;
audiobuf_read = startpos + offset;
DEBUGF("New mp3buf_read address: %x (%x)\n",
mp3buf+mp3buf_read, mp3buf_read);
DEBUGF("New audiobuf_read address: %x (%x)\n",
audiobuf+audiobuf_read, audiobuf_read);
/* Make room for headers */
mp3buf_read -= MPEG_RESERVED_HEADER_SPACE;
if(mp3buf_read < 0)
audiobuf_read -= MPEG_RESERVED_HEADER_SPACE;
if(audiobuf_read < 0)
{
/* Clear the bottom half */
memset(mp3buf, 0,
mp3buf_read + MPEG_RESERVED_HEADER_SPACE);
memset(audiobuf, 0,
audiobuf_read + MPEG_RESERVED_HEADER_SPACE);
/* And the top half */
mp3buf_read += mp3buflen;
memset(mp3buf + mp3buf_read, 0,
mp3buflen - mp3buf_read);
audiobuf_read += audiobuflen;
memset(audiobuf + audiobuf_read, 0,
audiobuflen - audiobuf_read);
}
else
{
memset(mp3buf + mp3buf_read, 0,
memset(audiobuf + audiobuf_read, 0,
MPEG_RESERVED_HEADER_SPACE);
}
/* Copy the empty ID3 header */
startpos = mp3buf_read;
startpos = audiobuf_read;
for(i = 0;i < (int)sizeof(empty_id3_header);i++)
{
mp3buf[startpos++] = empty_id3_header[i];
if(startpos == mp3buflen)
audiobuf[startpos++] = empty_id3_header[i];
if(startpos == audiobuflen)
startpos = 0;
}
DEBUGF("New mp3buf_read address (reservation): %x\n",
mp3buf+mp3buf_read);
DEBUGF("New audiobuf_read address (reservation): %x\n",
audiobuf+audiobuf_read);
DEBUGF("Prerecording...\n");
}
@ -1650,11 +1650,11 @@ static void mpeg_thread(void)
/* Advance the write pointer to make
room for an ID3 tag plus a VBR header */
mp3buf_write = MPEG_RESERVED_HEADER_SPACE;
memset(mp3buf, 0, MPEG_RESERVED_HEADER_SPACE);
audiobuf_write = MPEG_RESERVED_HEADER_SPACE;
memset(audiobuf, 0, MPEG_RESERVED_HEADER_SPACE);
/* Insert the ID3 header */
memcpy(mp3buf, empty_id3_header,
memcpy(audiobuf, empty_id3_header,
sizeof(empty_id3_header));
DEBUGF("Recording...\n");
@ -1711,14 +1711,14 @@ static void mpeg_thread(void)
/* saved_header is saved right before stopping
the MAS */
framelen = create_xing_header(mpeg_file, 0,
num_rec_bytes, mp3buf,
num_rec_bytes, audiobuf,
num_recorded_frames,
saved_header, NULL,
false);
lseek(mpeg_file, MPEG_RESERVED_HEADER_SPACE-framelen,
SEEK_SET);
write(mpeg_file, mp3buf, framelen);
write(mpeg_file, audiobuf, framelen);
close(mpeg_file);
}
mpeg_file = -1;
@ -1760,9 +1760,9 @@ static void mpeg_thread(void)
if(amount_to_save >= 1800)
{
/* Now find a frame boundary to split at */
startpos = mp3buf_write - 1800;
startpos = audiobuf_write - 1800;
if(startpos < 0)
startpos += mp3buflen;
startpos += audiobuflen;
rc = mem_find_next_frame(startpos, &offset, 1800,
saved_header);
@ -1771,28 +1771,28 @@ static void mpeg_thread(void)
/* offset will now contain the number of bytes to
add to startpos to find the frame boundary */
startpos += offset;
if(startpos >= mp3buflen)
startpos -= mp3buflen;
if(startpos >= audiobuflen)
startpos -= audiobuflen;
}
else
{
/* No header found. Let's save the whole buffer. */
startpos = mp3buf_write;
startpos = audiobuf_write;
}
}
else
{
/* 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)
amount_to_save += mp3buflen;
amount_to_save += audiobuflen;
/* First save up to the end of the buffer */
writelen = MIN(amount_to_save,
mp3buflen - mp3buf_read);
audiobuflen - audiobuf_read);
if (mpeg_file < 0) /* delayed file opening */
{
@ -1804,7 +1804,7 @@ static void mpeg_thread(void)
if(writelen)
{
rc = write(mpeg_file, mp3buf + mp3buf_read, writelen);
rc = write(mpeg_file, audiobuf + audiobuf_read, writelen);
if(rc < 0)
{
if(errno == ENOSPC)
@ -1826,7 +1826,7 @@ static void mpeg_thread(void)
writelen = amount_to_save - writelen;
if(writelen)
{
rc = write(mpeg_file, mp3buf, writelen);
rc = write(mpeg_file, audiobuf, writelen);
if(rc < 0)
{
if(errno == ENOSPC)
@ -1845,9 +1845,9 @@ static void mpeg_thread(void)
}
/* Advance the buffer pointers */
mp3buf_read += amount_to_save;
if(mp3buf_read >= mp3buflen)
mp3buf_read -= mp3buflen;
audiobuf_read += amount_to_save;
if(audiobuf_read >= audiobuflen)
audiobuf_read -= audiobuflen;
/* Close the current file */
rc = close(mpeg_file);
@ -1867,23 +1867,23 @@ static void mpeg_thread(void)
wrapped */
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);
/* Save data only if the buffer is getting full,
or if we should stop recording */
if(amount_to_save)
{
if(mp3buflen -
if(audiobuflen -
amount_to_save < MPEG_RECORDING_LOW_WATER ||
stop_pending)
{
/* Only save up to the end of the buffer */
writelen = MIN(amount_to_save,
mp3buflen - mp3buf_read);
audiobuflen - audiobuf_read);
DEBUGF("wrl: %x\n", writelen);
@ -1896,7 +1896,7 @@ static void mpeg_thread(void)
panicf("recfile: %d", mpeg_file);
}
rc = write(mpeg_file, mp3buf + mp3buf_read,
rc = write(mpeg_file, audiobuf + audiobuf_read,
writelen);
if(rc < 0)
@ -1914,9 +1914,9 @@ static void mpeg_thread(void)
}
}
mp3buf_read += amount_to_save;
if(mp3buf_read >= mp3buflen)
mp3buf_read = 0;
audiobuf_read += amount_to_save;
if(audiobuf_read >= audiobuflen)
audiobuf_read = 0;
rc = fsync(mpeg_file);
if(rc < 0)
@ -2468,9 +2468,9 @@ unsigned long mpeg_num_recorded_bytes(void)
if(index < 0)
index += prerecording_max_seconds;
num_bytes = mp3buf_write - prerecord_buffer[index];
num_bytes = audiobuf_write - prerecord_buffer[index];
if(num_bytes < 0)
num_bytes += mp3buflen;
num_bytes += audiobuflen;
return num_bytes;;
}
@ -2765,7 +2765,7 @@ void audio_init(void)
mpeg_errno = 0;
#ifndef SIMULATOR
mp3buflen = mp3end - mp3buf;
audiobuflen = audiobufend - audiobuf;
queue_init(&mpeg_queue);
#endif /* #ifndef SIMULATOR */
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);
if (read(fd, mp3buf, length) != length) {
if (read(fd, audiobuf, length) != length) {
rolo_error("Error Reading File");
return -1;
}
@ -128,7 +128,7 @@ int rolo_load(const char* filename)
checksum = 0;
for(i = 0;i < length;i++) {
checksum += mp3buf[i];
checksum += audiobuf[i];
}
/* Verify checksum against file header */
@ -162,12 +162,12 @@ int rolo_load(const char* filename)
lseek(fd, FIRMWARE_OFFSET_FILE_DATA, SEEK_SET);
/* 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");
return -1;
}
if (read(fd, &mp3buf[length], length) != (int)length) {
if (read(fd, &audiobuf[length], length) != (int)length) {
rolo_error("Error Reading File");
return -1;
}
@ -175,7 +175,7 @@ int rolo_load(const char* filename)
lcd_puts(0, 1, "Descramble");
lcd_update();
checksum = descramble(mp3buf + length, mp3buf, length);
checksum = descramble(audiobuf + length, audiobuf, length);
/* Verify checksum against file header */
if (checksum != file_checksum) {
@ -201,7 +201,7 @@ int rolo_load(const char* filename)
PAIOR = 0x0FA0;
#endif
#endif
rolo_restart(mp3buf, ramstart, length);
rolo_restart(audiobuf, ramstart, length);
return 0; /* this is never reached */
}

8
firmware/rom.lds
View File

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