mpegplayer: Make playback engine fully seekable and frame-accurate and split into logical parts. Be sure to have all current features work. Actual UI for seeking will be added soon. Recommended GOP size is about 15-30 frames depending on target or seeking can be slow with really long GOPs (nature of MPEG video). More refined encoding recommendations for a particular player should be posted soon.

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

apps/plugins/mpegplayer/mpeg_linkedlist.c

@@ -0,0 +1,149 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Linked list API definitions
+ *
+ * Copyright (c) 2007 Michael Sevakis
+ *
+ * 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 "plugin.h"
+#include "mpegplayer.h"
+#include "mpeg_linkedlist.h"
+
+/* Initialize a master list head */
+void list_initialize(struct list_item *master_list_head)
+{
+    master_list_head->prev = master_list_head->next = NULL;
+}
+
+/* Are there items after the head item? */
+bool list_is_empty(struct list_item *head_item)
+{
+    return head_item->next == NULL;
+}
+
+/* Does the item belong to a list? */
+bool list_is_item_listed(struct list_item *item)
+{
+    return item->prev != NULL;
+}
+
+/* Is the item a member in a particular list? */
+bool list_is_member(struct list_item *master_list_head,
+                    struct list_item *item)
+{
+    if (item != master_list_head && item->prev != NULL)
+    {
+        struct list_item *curr = master_list_head->next;
+
+        while (curr != NULL)
+        {
+            if (item != curr)
+            {
+                curr = curr->next;
+                continue;
+            }
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/* Remove an item from a list - no head item needed */
+void list_remove_item(struct list_item *item)
+{
+    if (item->prev == NULL)
+    {
+        /* Not in a list - no change - could be the master list head
+         * as well which cannot be removed */
+        return;
+    }
+
+    item->prev->next = item->next;
+
+    if (item->next != NULL)
+    {
+        /* Not last item */
+        item->next->prev = item->prev;
+    }
+
+    /* Mark as not in a list */
+    item->prev = NULL;
+}
+
+/* Add a list item after the base item */
+void list_add_item(struct list_item *head_item,
+                   struct list_item *item)
+{
+    if (item->prev != NULL)
+    {
+        /* Already in a list - no change */
+        DEBUGF("list_add_item: item already in a list\n");
+        return;
+    }
+
+    if (item == head_item)
+    {
+        /* Cannot add the item to itself */
+        DEBUGF("list_add_item: item == head_item\n");
+        return;
+    }
+
+    /* Insert first */
+    item->prev = head_item;
+    item->next = head_item->next;
+
+    if (head_item->next != NULL)
+    {
+        /* Not first item */
+        head_item->next->prev = item;
+    }
+
+    head_item->next = item;
+}
+
+/* Clear list items after the head item */
+void list_clear_all(struct list_item *head_item)
+{
+    struct list_item *curr = head_item->next;
+
+    while (curr != NULL)
+    {
+        list_remove_item(curr);
+        curr = head_item->next;
+    }
+}
+
+/* Enumerate all items after the head item - passing each item in turn
+ * to the callback as well as the data value. The current item may be
+ * safely removed. Items added after the current position will be enumated
+ * but not ones added before it. The callback may return false to stop
+ * the enumeration. */
+void list_enum_items(struct list_item *head_item,
+                     list_enum_callback_t callback,
+                     intptr_t data)
+{
+    struct list_item *next = head_item->next;
+
+    while (next != NULL)
+    {
+        struct list_item *curr = next;
+        next = curr->next;
+        if (!callback(curr, data))
+            break;
+    }
+}