Implement the playback event handling as a system-wide multi-purpose event system. Unified mpeg.c and playback.c audio event handling. Converted ata_idle_notify to use the new event handling system also.

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

7 files changed, 161 insertions, 92 deletions

diff --git a/firmware/SOURCES b/firmware/SOURCES
index b5906d4648..ea8ce46cca 100644
--- a/firmware/SOURCES
+++ b/firmware/SOURCES
@@ -1,4 +1,5 @@
 ata_idle_notify.c
+events.c
 backlight.c
 buffer.c
 id3.c
diff --git a/firmware/ata_idle_notify.c b/firmware/ata_idle_notify.c
index 1fc6605ac6..a97c3538da 100644
--- a/firmware/ata_idle_notify.c
+++ b/firmware/ata_idle_notify.c
@@ -23,60 +23,31 @@
 #include "kernel.h"
 #include "string.h"
 
-#if USING_ATA_CALLBACK
-static ata_idle_notify ata_idle_notify_funcs[MAX_ATA_CALLBACKS];
-static int ata_callback_count = 0;
-#endif
-
-
-bool register_ata_idle_func(ata_idle_notify function)
+void register_ata_idle_func(ata_idle_notify function)
 {
 #if USING_ATA_CALLBACK
-    int i;
-    if (ata_callback_count >= MAX_ATA_CALLBACKS)
-        return false;
-    for (i=0; i<MAX_ATA_CALLBACKS; i++)
-    {
-        if (ata_idle_notify_funcs[i] == NULL)
-        {
-            ata_idle_notify_funcs[i] = function;
-            ata_callback_count++;
-            return true;
-        }
-        else if (ata_idle_notify_funcs[i] == function)
-            return true;
-    }
-    return false;
+    add_event(DISK_EVENT_SPINUP, function);
 #else
     function(); /* just call the function now */
 /* this _may_ cause problems later if the calling function
    sets a variable expecting the callback to unset it, because
    the callback will be run before this function exits, so before the var is set */
-    return true;
 #endif
 }
 
 #if USING_ATA_CALLBACK
 void unregister_ata_idle_func(ata_idle_notify func, bool run)
 {
-    int i;
-    for (i=0; i<MAX_ATA_CALLBACKS; i++)
-    {
-        if (ata_idle_notify_funcs[i] == func)
-        {
-            ata_idle_notify_funcs[i] = NULL;
-            ata_callback_count--;
-            if (run) func();
-        }
-    }
-    return;
+    remove_event(DISK_EVENT_SPINUP, func);
+    
+    if (run)
+        func();
 }
 
 bool call_ata_idle_notifys(bool force)
 {
-    int i;
     static int lock_until = 0;
-    ata_idle_notify function;
+
     if (!force)
     {
         if (TIME_BEFORE(current_tick,lock_until) )
@@ -84,22 +55,8 @@ bool call_ata_idle_notifys(bool force)
     }
     lock_until = current_tick + 30*HZ;
 
-    for (i = 0; i < MAX_ATA_CALLBACKS; i++)
-    {
-        if (ata_idle_notify_funcs[i])
-        {
-            function = ata_idle_notify_funcs[i];
-            ata_idle_notify_funcs[i] = NULL;
-            function();
-            ata_callback_count--;
-        }
-    }
+    send_event(DISK_EVENT_SPINUP, true, NULL);
+    
     return true;
 }
-
-void ata_idle_notify_init(void)
-{
-    ata_callback_count = 0;
-    memset(ata_idle_notify_funcs, 0, sizeof(ata_idle_notify_funcs));
-}
 #endif
diff --git a/firmware/events.c b/firmware/events.c
new file mode 100644
index 0000000000..eaf2e5c352
--- /dev/null
+++ b/firmware/events.c
@@ -0,0 +1,88 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2008 by Miika Pekkarinen
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <stdio.h>
+#include "events.h"
+#include "panic.h"
+
+struct sysevent {
+    unsigned short id;
+    void (*callback)(void *data);
+};
+
+struct sysevent events[MAX_SYS_EVENTS];
+
+bool add_event(unsigned short id, void (*handler))
+{
+    int i;
+    
+    /* Chcek if the event already exists. */
+    for (i = 0; i < MAX_SYS_EVENTS; i++)
+    {
+        if (events[i].callback == handler && events[i].id == id)
+            return false;
+    }
+    
+    /* Try to find a free slot. */
+    for (i = 0; i < MAX_SYS_EVENTS; i++)
+    {
+        if (events[i].callback == NULL)
+        {
+            events[i].id = id;
+            events[i].callback = handler;
+            return true;
+        }
+    }
+    
+    panicf("event line full");
+    return false;
+}
+
+void remove_event(unsigned short id, void (*handler))
+{
+    int i;
+    
+    for (i = 0; i < MAX_SYS_EVENTS; i++)
+    {
+        if (events[i].id == id && events[i].callback == handler)
+        {
+            events[i].callback = NULL;
+            return;
+        }
+    }
+    
+    panicf("event not found");
+}
+
+void send_event(unsigned short id, bool oneshot, void *data)
+{
+    int i;
+    
+    for (i = 0; i < MAX_SYS_EVENTS; i++)
+    {
+        if (events[i].id == id && events[i].callback != NULL)
+        {
+            events[i].callback(data);
+            
+            if (oneshot)
+                events[i].callback = NULL;
+        }
+    }
+}
+
diff --git a/firmware/export/ata_idle_notify.h b/firmware/export/ata_idle_notify.h
index ee825c967e..1dda3e196a 100644
--- a/firmware/export/ata_idle_notify.h
+++ b/firmware/export/ata_idle_notify.h
@@ -19,7 +19,9 @@
 #ifndef __ATACALLBACK_H__
 #define __ATACALLBACK_H__
 
+
 #include <stdbool.h>
+#include "events.h"
 
 #if 0
                 NOTE: ata_idle_nofity usage notes..
@@ -34,15 +36,17 @@
         5) Dont Panic!
 #endif
 
+enum {
+    DISK_EVENT_SPINUP = (EVENT_CLASS_DISK|1),
+};
+
 #define USING_ATA_CALLBACK  !defined(SIMULATOR)             \
                             && !defined(HAVE_FLASH_DISK)
 
-#define MAX_ATA_CALLBACKS 5
 typedef bool (*ata_idle_notify)(void);
 
-extern bool register_ata_idle_func(ata_idle_notify function);
+extern void register_ata_idle_func(ata_idle_notify function);
 #if USING_ATA_CALLBACK
-extern void ata_idle_notify_init(void);
 extern void unregister_ata_idle_func(ata_idle_notify function, bool run);
 extern bool call_ata_idle_notifys(bool force);
 #else
diff --git a/firmware/export/events.h b/firmware/export/events.h
new file mode 100644
index 0000000000..b27b5dee4c
--- /dev/null
+++ b/firmware/export/events.h
@@ -0,0 +1,51 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2008 by Miika Pekkarinen
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#ifndef _EVENTS_H
+#define _EVENTS_H
+
+#include <stdbool.h>
+
+#define MAX_SYS_EVENTS 10
+
+/**
+ * High nibble = Event class definition
+ * Low nibble  = Event ID
+ */
+
+#define EVENT_CLASS_DISK       0x0100
+#define EVENT_CLASS_PLAYBACK   0x0200
+
+/**
+ * Because same playback events are used in mpeg.c and playback.c, define
+ * them here to prevent cluttering and ifdefs.
+ */
+enum {
+    PLAYBACK_EVENT_TRACK_BUFFER = (EVENT_CLASS_PLAYBACK|1),
+    PLAYBACK_EVENT_TRACK_FINISH,
+    PLAYBACK_EVENT_TRACK_CHANGE,
+};
+
+
+bool add_event(unsigned short id, void (*handler));
+void remove_event(unsigned short id, void (*handler));
+void send_event(unsigned short id, bool oneshot, void *data);
+
+#endif
+
diff --git a/firmware/export/mpeg.h b/firmware/export/mpeg.h
index 3e36c44ac5..0a9d62cdf0 100644
--- a/firmware/export/mpeg.h
+++ b/firmware/export/mpeg.h
@@ -21,6 +21,7 @@
 
 #include <stdbool.h>
 #include "id3.h"
+#include "events.h"
 
 #define MPEG_SWAP_CHUNKSIZE  0x2000
 #define MPEG_HIGH_WATER  2 /* We leave 2 bytes empty because otherwise we
diff --git a/firmware/mpeg.c b/firmware/mpeg.c
index 693e2df480..9023c304d2 100644
--- a/firmware/mpeg.c
+++ b/firmware/mpeg.c
@@ -100,7 +100,6 @@ struct trackdata
     struct mp3entry id3;
     int mempos;
     int load_ahead_index;
-    bool event_sent;
 };
 
 static struct trackdata trackdata[MAX_TRACK_ENTRIES];
@@ -116,11 +115,6 @@ static int track_read_idx = 0;
 static int track_write_idx = 0;
 #endif /* !SIMULATOR */
 
-/* Callback function to call when current track has really changed. */
-void (*track_changed_callback)(struct mp3entry *id3) = NULL;
-void (*track_buffer_callback)(struct mp3entry *id3) = NULL;
-void (*track_unbuffer_callback)(struct mp3entry *id3) = NULL;
-
 /* Cuesheet callback */
 static bool (*cuesheet_callback)(const char *filename) = NULL;
 
@@ -475,21 +469,6 @@ unsigned long mpeg_get_last_header(void)
 #endif /* !SIMULATOR */
 }
 
-void audio_set_track_buffer_event(void (*handler)(struct mp3entry *id3))
-{
-    track_buffer_callback = handler;
-}
-
-void audio_set_track_unbuffer_event(void (*handler)(struct mp3entry *id3))
-{
-    track_unbuffer_callback = handler;
-}
-
-void audio_set_track_changed_event(void (*handler)(struct mp3entry *id3))
-{
-    track_changed_callback = handler;
-}
-
 void audio_set_cuesheet_callback(bool (*handler)(const char *filename))
 {
     cuesheet_callback = handler;
@@ -506,12 +485,7 @@ static void generate_unbuffer_events(void)
     for (i = 0; i < numentries; i++)
     {
         /* Send an event to notify that track has finished. */
-        if (trackdata[cur_idx].event_sent)
-        {
-            if (track_unbuffer_callback)
-                track_unbuffer_callback(&trackdata[cur_idx].id3);
-            trackdata[cur_idx].event_sent = false;
-        }
+        send_event(PLAYBACK_EVENT_TRACK_FINISH, false, &trackdata[cur_idx].id3);
         cur_idx = (cur_idx + 1) & MAX_TRACK_ENTRIES_MASK;
     }
 }
@@ -525,12 +499,7 @@ static void generate_postbuffer_events(void)
 
     for (i = 0; i < numentries; i++)
     {
-        if (!trackdata[cur_idx].event_sent)
-        {
-            if (track_buffer_callback)
-                track_buffer_callback(&trackdata[cur_idx].id3);
-            trackdata[cur_idx].event_sent = true;
-        }
+        send_event(PLAYBACK_EVENT_TRACK_BUFFER, false, &trackdata[cur_idx].id3);
         cur_idx = (cur_idx + 1) & MAX_TRACK_ENTRIES_MASK;
     }
 }
@@ -1080,8 +1049,7 @@ static void track_change(void)
     if (num_tracks_in_memory() > 0)
     {
         remove_current_tag();
-        if (track_changed_callback)
-            track_changed_callback(audio_current_track());
+        send_event(PLAYBACK_EVENT_TRACK_CHANGE, false, audio_current_track());
         update_playlist();
     }
 
@@ -1134,8 +1102,7 @@ static void start_playback_if_ready(void)
                 if (play_pending_track_change)
                 {
                     play_pending_track_change = false;
-                    if(track_changed_callback)
-                        track_changed_callback(audio_current_track());
+                    send_event(PLAYBACK_EVENT_TRACK_CHANGE, false, audio_current_track());
                 }
                 play_pending = false;
             }