make gp2x mp3 playback functional (need to unpack and compile helix decoder separately in platform/common/helix)

platform/common/helix/lib.c

@@ -0,0 +1,122 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+// libgcc has this with gcc 4.x
+void raise(int sig)
+{
+}
+
+// very limited heap functions for helix decoder
+
+static char heap[65000] __attribute__((aligned(16)));
+static long heap_offs;
+
+void __malloc_init(void)
+{
+	heap_offs = 0;
+}
+
+void *malloc(size_t size)
+{
+        void *chunk = heap + heap_offs;
+        size = (size+15) & ~15;
+        if (heap_offs + size > sizeof(heap))
+                return NULL;
+        else {
+                heap_offs += size;
+                return chunk;
+        }
+}
+
+void free(void *chunk)
+{
+	if (chunk == heap)
+		heap_offs = 0;
+}
+
+#if 0
+void *memcpy (void *dest, const void *src, size_t n)
+{
+	char       *_dest = dest;
+        const char *_src = src;
+	while (n--) *_dest++ = *_src++;
+	return dest;
+}
+
+void *memmove (void *dest, const void *src, size_t n)
+{
+	char       *_dest = dest+n;
+        const char *_src = src+n;
+	if (dest <= src || dest >= _src)
+		return memcpy(dest, src, n);
+	while (n--) *--_dest = *--_src;
+	return dest;
+}
+#else
+/* memcpy/memmove in C with some simple optimizations.
+ * ATTN does dirty aliasing tricks with undefined behaviour by standard.
+ * (this works fine with gcc, though...)
+ */
+void *memcpy(void *dest, const void *src, size_t n)
+{
+	struct _16 { uint32_t a[4]; };
+	union { const void *v; char *c; uint64_t *l; struct _16 *s; }
+		ss = { src }, ds = { dest };
+	const int lm = sizeof(uint32_t)-1;
+
+	if ((((unsigned)ss.c ^ (unsigned)ds.c) & lm) == 0) {
+		/* fast copy if pointers have the same aligment */
+		while (((unsigned)ss.c & lm) && n > 0)	/* align to word */
+			*ds.c++ = *ss.c++, n--;
+		while (n >= sizeof(struct _16))	/* copy 16 bytes blocks */
+			*ds.s++ = *ss.s++, n -= sizeof(struct _16);
+		if (n >= sizeof(uint64_t))	/* copy leftover 8 byte block */
+			*ds.l++ = *ss.l++, n -= sizeof(uint64_t);
+	} else {
+		/* byte copy if pointers are unaligned */
+		while (n >= 8) {		/* copy 8 byte blocks */
+			*ds.c++ = *ss.c++, n--; *ds.c++ = *ss.c++, n--;
+			*ds.c++ = *ss.c++, n--; *ds.c++ = *ss.c++, n--;
+			*ds.c++ = *ss.c++, n--; *ds.c++ = *ss.c++, n--;
+			*ds.c++ = *ss.c++, n--; *ds.c++ = *ss.c++, n--;
+		}
+	}
+	/* copy max. 8 leftover bytes */
+	while (n > 0)
+		*ds.c++ = *ss.c++, n--;
+	return dest;
+}
+
+void *memmove (void *dest, const void *src, size_t n)
+{
+	struct _16 { uint32_t a[4]; };
+	union { const void *v; char *c; uint64_t *l; struct _16 *s; }
+		ss = { src+n }, ds = { dest+n };
+	const int lm = sizeof(uint32_t)-1;
+
+	if (dest <= src || dest >= src+n)
+		return memcpy(dest, src, n);
+
+	if ((((unsigned)ss.c ^ (unsigned)ds.c) & lm) == 0) {
+		/* fast copy if pointers have the same aligment */
+		while (((unsigned)ss.c & lm) && n > 0)
+			*--ds.c = *--ss.c, n--;
+		while (n >= sizeof(struct _16))
+			*--ds.s = *--ss.s, n -= sizeof(struct _16);
+		if (n >= sizeof(uint64_t))
+			*--ds.l = *--ss.l, n -= sizeof(uint64_t);
+	} else {
+		/* byte copy if pointers are unaligned */
+		while (n >= 8) {
+			*--ds.c = *--ss.c, n--; *--ds.c = *--ss.c, n--;
+			*--ds.c = *--ss.c, n--; *--ds.c = *--ss.c, n--;
+			*--ds.c = *--ss.c, n--; *--ds.c = *--ss.c, n--;
+			*--ds.c = *--ss.c, n--; *--ds.c = *--ss.c, n--;
+		}
+	}
+	/* copy max. 8 leftover bytes */
+	while (n > 0)
+		*--ds.c = *--ss.c, n--;
+	return dest;
+}
+#endif