mp3buf renamed to audiobuf

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@6252 a1c6a512-1295-4272-9138-f99709370657

22 files changed, 239 insertions, 238 deletions

diff --git a/apps/debug_menu.c b/apps/debug_menu.c
index d8ebe9bfb1..2ab2194199 100644
--- a/apps/debug_menu.c
+++ b/apps/debug_menu.c
@@ -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",
diff --git a/apps/main_menu.c b/apps/main_menu.c
index c7cfb0ea70..055a83bc24 100644
--- a/apps/main_menu.c
+++ b/apps/main_menu.c
@@ -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;
diff --git a/apps/playlist.c b/apps/playlist.c
index 3370937a69..8c9d6d11c7 100644
--- a/apps/playlist.c
+++ b/apps/playlist.c
@@ -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);
                         }
diff --git a/apps/plugin.c b/apps/plugin.c
index 412d86b4c9..7a9875ac2c 100644
--- a/apps/plugin.c
+++ b/apps/plugin.c
@@ -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
diff --git a/apps/plugin.h b/apps/plugin.h
index ff37a7c46d..9fd9a9421c 100644
--- a/apps/plugin.h
+++ b/apps/plugin.h
@@ -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));
diff --git a/apps/plugins/battery_test.c b/apps/plugins/battery_test.c
index 73affddf8b..47042e6cf0 100644
--- a/apps/plugins/battery_test.c
+++ b/apps/plugins/battery_test.c
@@ -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. */
diff --git a/apps/plugins/jpeg.c b/apps/plugins/jpeg.c
index f705271240..7ca59b29cd 100644
--- a/apps/plugins/jpeg.c
+++ b/apps/plugins/jpeg.c
@@ -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:
diff --git a/apps/plugins/lib/xxx2wav.c b/apps/plugins/lib/xxx2wav.c
index 4d0c139f1b..d864527fc2 100644
--- a/apps/plugins/lib/xxx2wav.c
+++ b/apps/plugins/lib/xxx2wav.c
@@ -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();
 
diff --git a/apps/plugins/rockboy.c b/apps/plugins/rockboy.c
index 4778fa8ee6..d531c9405b 100644
--- a/apps/plugins/rockboy.c
+++ b/apps/plugins/rockboy.c
@@ -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 
diff --git a/apps/plugins/rockboy/rockboy.c b/apps/plugins/rockboy/rockboy.c
index c6d006a131..1b4c0c7a7d 100644
--- a/apps/plugins/rockboy/rockboy.c
+++ b/apps/plugins/rockboy/rockboy.c
@@ -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"); */
diff --git a/apps/plugins/sort.c b/apps/plugins/sort.c
index b17f5a441a..cf91dbb4dd 100644
--- a/apps/plugins/sort.c
+++ b/apps/plugins/sort.c
@@ -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));
diff --git a/apps/plugins/vbrfix.c b/apps/plugins/vbrfix.c
index 0077340ec9..7fb072c656 100644
--- a/apps/plugins/vbrfix.c
+++ b/apps/plugins/vbrfix.c
@@ -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);
 
diff --git a/apps/plugins/video.c b/apps/plugins/video.c
index 0257ad26b7..db371392d5 100644
--- a/apps/plugins/video.c
+++ b/apps/plugins/video.c
@@ -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
 
diff --git a/apps/talk.c b/apps/talk.c
index 2b97629d55..b6e2ec57a1 100644
--- a/apps/talk.c
+++ b/apps/talk.c
@@ -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 */
 }
 
diff --git a/firmware/app.lds b/firmware/app.lds
index a7ca57e54e..45bd8567f2 100644
--- a/firmware/app.lds
+++ b/firmware/app.lds
@@ -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:
diff --git a/firmware/buffer.c b/firmware/buffer.c
index 180ded8268..d89d30b6ba 100644
--- a/firmware/buffer.c
+++ b/firmware/buffer.c
@@ -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;
 }
diff --git a/firmware/export/audio.h b/firmware/export/audio.h
index b276490ab3..6490aeaefd 100644
--- a/firmware/export/audio.h
+++ b/firmware/export/audio.h
@@ -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;
 
diff --git a/firmware/export/buffer.h b/firmware/export/buffer.h
index c031a4f213..bced85ecff 100644
--- a/firmware/export/buffer.h
+++ b/firmware/export/buffer.h
@@ -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);
diff --git a/firmware/mp3data.c b/firmware/mp3data.c
index 7b6da1144f..7a8af34d56 100644
--- a/firmware/mp3data.c
+++ b/firmware/mp3data.c
@@ -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;
diff --git a/firmware/mpeg.c b/firmware/mpeg.c
index 79265e4452..a7d5480706 100644
--- a/firmware/mpeg.c
+++ b/firmware/mpeg.c
@@ -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,
diff --git a/firmware/rolo.c b/firmware/rolo.c
index e2ef26b3aa..ca68596112 100644
--- a/firmware/rolo.c
+++ b/firmware/rolo.c
@@ -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 */
 }
diff --git a/firmware/rom.lds b/firmware/rom.lds
index 55346dc122..81c266ae4f 100644
--- a/firmware/rom.lds
+++ b/firmware/rom.lds
@@ -104,15 +104,15 @@ SECTIONS
        _end = .;
     } > DRAM
 
-    .mp3buf :
+    .audiobuf :
     {
         . = ALIGN(0x4);
-        _mp3buffer = .;
+        _audiobuffer = .;
     } > DRAM
 
-    .mp3end ENDADDR:
+    .audiobufend ENDADDR:
     {
-        _mp3end = .;
+        _audiobufend = .;
     } > DRAM
 
     .plugin ENDADDR: