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

platform/common/helix/Makefile

@@ -0,0 +1,42 @@
+CROSS ?= arm-linux-gnueabi-
+
+CC = $(CROSS)gcc
+AS = $(CROSS)as
+AR = $(CROSS)ar
+TOOLCHAIN = $(notdir $(CROSS))
+
+CFLAGS += -Ipub -O2 -Wall -fstrict-aliasing -ffast-math
+ifneq ($(findstring arm-,$(TOOLCHAIN)),)
+CFLAGS += -mcpu=arm940t -mtune=arm940t -mfloat-abi=soft -mfpu=fpa -mabi=apcs-gnu -mno-thumb-interwork
+ASFLAGS = -mcpu=arm940t -mfloat-abi=soft -mfpu=fpa -mabi=apcs-gnu
+OBJS += real/arm/asmpoly_gcc.o
+else
+CFLAGS += -m32
+ASFLAGS += -m32
+OBJS += real/polyphase.o
+endif
+
+LIB = $(TOOLCHAIN)helix_mp3.a
+SHLIB = $(TOOLCHAIN)helix_mp3.so
+
+all: $(LIB) $(SHLIB)
+
+
+OBJS += mp3dec.o mp3tabs.o
+#OBJS += ipp/bitstream.o ipp/buffers.o ipp/dequant.o ipp/huffman.o ipp/imdct.o ipp/subband.o
+OBJS += real/bitstream.o real/buffers.o real/dct32.o real/dequant.o real/dqchan.o real/huffman.o
+OBJS += real/hufftabs.o real/imdct.o real/scalfact.o real/stproc.o real/subband.o real/trigtabs.o
+
+OBJS += lib.o
+
+real/arm/asmpoly_gcc.o: real/arm/asmpoly_gcc.s
+	$(CC) -o $@ $(ASFLAGS) -c $<
+
+$(LIB) : $(OBJS)
+	$(AR) r $@ $^
+$(SHLIB) : $(OBJS) /home/build/opt/open2x/gcc-4.1.1-glibc-2.3.6/lib/gcc/arm-open2x-linux/4.1.1/libgcc.a
+	$(CC) -o $@ -nostdlib -shared $(CFLAGS) $^
+
+clean:
+	$(RM) -f $(OBJS)
+

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