diff options
Diffstat (limited to 'apps/plugins/mikmod/mmio')
| -rw-r--r-- | apps/plugins/mikmod/mmio/mmalloc.c | 259 | ||||
| -rw-r--r-- | apps/plugins/mikmod/mmio/mmerror.c | 197 | ||||
| -rw-r--r-- | apps/plugins/mikmod/mmio/mmio.c | 427 | ||||
| -rw-r--r-- | apps/plugins/mikmod/mmio/old_mmalloc.c | 290 |
4 files changed, 1173 insertions, 0 deletions
diff --git a/apps/plugins/mikmod/mmio/mmalloc.c b/apps/plugins/mikmod/mmio/mmalloc.c new file mode 100644 index 0000000..7f7fdbf --- /dev/null +++ b/apps/plugins/mikmod/mmio/mmalloc.c @@ -0,0 +1,259 @@ +/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id: mmalloc.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $
+
+ Dynamic memory routines
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+
+size_t mem_offset = 0;
+char *mallocbuf = NULL;
+size_t mallocbuflen = 0;
+
+
+size_t mikmod_get_mbuffsize(size_t *buff)
+{
+ return buff[-1];
+}
+
+
+void mikmod_prepare_malloc(char *buff, int bufsize)
+{
+ mallocbuf = buff;
+ mallocbuflen = bufsize;
+ mem_offset = 0;
+}
+
+long mikmod_get_malloc_usage(void)
+{
+ return mem_offset;
+}
+
+int mikmod_abs(int num)
+{
+ if (num < 0)
+ return (num * -1);
+ else
+ return (num);
+}
+
+void* mikmod_memset(char *buf, int val, size_t count)
+{
+ size_t i;
+
+ for (i = 0; i < count; i++)
+ {
+ buf[i] = val;
+ }
+ return buf;
+}
+
+/* 'Poor man's malloc' taken from rockbox codeclib.c */
+void* mikmod_malloc(size_t size)
+{
+ void* x;
+
+ if (!mallocbuf)
+ return NULL;
+ if (mem_offset + (long)size + 4 > mallocbuflen)
+ return NULL;
+
+ mem_offset += 4;
+
+ x = &mallocbuf[mem_offset];
+ ((size_t*)x)[-1] = size;
+
+ mem_offset += (size + 3) & ~3; /* Keep memory 32-bit aligned */
+
+
+ memset(x, 0, size);
+
+ return(x);
+}
+
+void* mikmod_calloc(size_t nmemb, size_t size)
+{
+ void *x;
+ x = mikmod_malloc(nmemb * size);
+ if (x == NULL)
+ return NULL;
+ //memset(x, 0, nmemb*size); /* already done in mikmod_malloc() */
+ return(x);
+}
+
+void mikmod_free(void* ptr) {
+ (void)ptr;
+}
+
+void* mikmod_realloc(void* ptr, size_t size)
+{
+ void* x;
+ //(void)ptr;
+ x = mikmod_malloc(size);
+ if (ptr != NULL)
+ {
+ if (mikmod_get_mbuffsize(ptr) < size)
+ {
+ memcpy(x, ptr, mikmod_get_mbuffsize(ptr));
+ }
+ else
+ {
+ memcpy(x, ptr, size);
+ }
+ }
+ return(x);
+}
+
+unsigned int mikmod_strlen(const char *string)
+{
+ unsigned int i;
+ for (i = 0; string[i] != 0; i++);
+ return i;
+}
+
+char* mikmod_strdup(const char *srcbuf)
+{
+ char *newbuf;
+ unsigned int i, len;
+
+ len = mikmod_strlen(srcbuf);
+ newbuf = mikmod_malloc(len + 1);
+
+ if (newbuf)
+ {
+ for (i = 0; i <= len; i++)
+ newbuf[i] = srcbuf[i];
+ }
+ return newbuf;
+}
+
+char* mikmod_strncat(char *dest, const char *src, size_t count)
+{
+ size_t i, j;
+ j = mikmod_strlen(dest);
+
+ for(i = 0; i < count; i++)
+ {
+ if (src[i] == 0)
+ break;
+ dest[i + j] = src[i];
+ }
+ return dest;
+}
+
+int mikmod_memcmp(const char *buf1, const char *buf2, size_t count)
+{
+ size_t i;
+
+ for(i = 0; i < count; i++)
+ {
+ if (buf1[i] > buf2[i])
+ return 1;
+ if (buf1[i] < buf2[i])
+ return -1;
+ }
+ return 0;
+}
+
+char* mikmod_strstr(char *str, char *search)
+{
+ size_t i, j, k;
+
+ if (!mikmod_strlen(search))
+ return str;
+
+ j = mikmod_strlen(str);
+ k = mikmod_strlen(search);
+
+ for (i = 0; i < (j - k); i++)
+ {
+ if (!mikmod_memcmp(str, search, k))
+ return &str[i];
+ }
+ return NULL;
+}
+
+int mikmod_toupper(int character)
+{
+ if ((character > 96) && (character < 123))
+ return (character - 32);
+ else
+ return character;
+}
+
+int mikmod_isalnum(int character)
+{
+ if ((character > 96) && (character < 123))
+ return character;
+ if ((character > 64) && (character < 91))
+ return character;
+ if ((character > 47) && (character < 58))
+ return character;
+ return 0;
+}
+
+int mikmod_isdigit(char c)
+{
+ return (c >= '0') && (c <= '9');
+}
+
+
+/****************************************************
+ * 'Original' MikMod code goes here
+ *
+ ****************************************************/
+
+/* Same as malloc, but sets error variable _mm_error when fails */
+void* _mm_malloc(size_t size)
+{
+ void *d;
+
+ //if(!(d=mikmod_malloc(size))) {
+ if(!(d=mikmod_malloc(size))) {
+ _mm_errno = MMERR_OUT_OF_MEMORY;
+ if(_mm_errorhandler) _mm_errorhandler();
+ }
+ memset(d, 0, size);
+ return d;
+}
+
+/* Same as calloc, but sets error variable _mm_error when fails */
+void* _mm_calloc(size_t nitems,size_t size)
+{
+ void *d;
+
+ if(!(d=mikmod_calloc(nitems,size))) {
+ _mm_errno = MMERR_OUT_OF_MEMORY;
+ if(_mm_errorhandler) _mm_errorhandler();
+ }
+ return d;
+}
+
+/* ex:set ts=4: */
diff --git a/apps/plugins/mikmod/mmio/mmerror.c b/apps/plugins/mikmod/mmio/mmerror.c new file mode 100644 index 0000000..94d0122 --- /dev/null +++ b/apps/plugins/mikmod/mmio/mmerror.c @@ -0,0 +1,197 @@ +/* MikMod sound library
+ (c) 1998, 1999, 2000 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id: mmerror.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $
+
+ Error handling functions.
+ Register an error handler with _mm_RegisterErrorHandler() and you're all set.
+
+==============================================================================*/
+
+/*
+
+ The global variables _mm_errno, and _mm_critical are set before the error
+ handler in called. See below for the values of these variables.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+CHAR *_mm_errmsg[MMERR_MAX+1] =
+{
+/* No error */
+
+ "No error",
+
+/* Generic errors */
+
+ "Could not open requested file",
+ "Out of memory",
+ "Dynamic linking failed",
+
+/* Sample errors */
+
+ "Out of memory to load sample",
+ "Out of sample handles to load sample",
+ "Sample format not recognized",
+
+/* Module errors */
+
+ "Failure loading module pattern",
+ "Failure loading module track",
+ "Failure loading module header",
+ "Failure loading sampleinfo",
+ "Module format not recognized",
+ "Module sample format not recognized",
+ "Synthsounds not supported in MED files",
+ "Compressed sample is invalid",
+
+/* Driver errors: */
+
+ "Sound device not detected",
+ "Device number out of range",
+ "Software mixer failure",
+ "Could not open sound device",
+ "This driver supports 8 bit linear output only",
+ "This driver supports 16 bit linear output only",
+ "This driver supports stereo output only",
+ "This driver supports uLaw output (8 bit mono, 8 kHz) only",
+ "Unable to set non-blocking mode for audio device",
+
+/* AudioFile driver errors */
+
+ "Cannot find suitable AudioFile audio port",
+
+/* AIX driver errors */
+
+ "Configuration (init step) of audio device failed",
+ "Configuration (control step) of audio device failed",
+ "Configuration (start step) of audio device failed",
+
+/* ALSA driver errors */
+
+/* EsounD driver errors */
+
+/* Ultrasound driver errors */
+
+ "Ultrasound driver only works in 16 bit stereo 44 KHz",
+ "Ultrasound card could not be reset",
+ "Could not start Ultrasound timer",
+
+/* HP driver errors */
+
+ "Unable to select 16bit-linear sample format",
+ "Could not select requested sample-rate",
+ "Could not select requested number of channels",
+ "Unable to select audio output",
+ "Unable to get audio description",
+ "Could not set transmission buffer size",
+
+/* Open Sound System driver errors */
+
+ "Could not set fragment size",
+ "Could not set sample size",
+ "Could not set mono/stereo setting",
+ "Could not set sample rate",
+
+/* SGI driver errors */
+
+ "Unsupported sample rate",
+ "Hardware does not support 16 bit sound",
+ "Hardware does not support 8 bit sound",
+ "Hardware does not support stereo sound",
+ "Hardware does not support mono sound",
+
+/* Sun driver errors */
+
+ "Sound device initialization failed",
+
+/* OS/2 drivers errors */
+
+ "Could not set mixing parameters",
+ "Could not create playback semaphores",
+ "Could not create playback timer",
+ "Could not create playback thread",
+
+/* DirectSound driver errors */
+
+ "Could not set playback priority",
+ "Could not create playback buffers",
+ "Could not set playback format",
+ "Could not register callback",
+ "Could not register event",
+ "Could not create playback thread",
+ "Could not initialize playback thread",
+
+/* Windows Multimedia API driver errors */
+
+ "Invalid device handle",
+ "The resource is already allocated",
+ "Invalid device identifier",
+ "Unsupported output format",
+ "Unknown error",
+
+/* Macintosh driver errors */
+
+ "Unsupported sample rate",
+ "Could not start playback",
+
+/* Invalid error */
+
+ "Invalid error code"
+};
+
+MIKMODAPI char *MikMod_strerror(int code)
+{
+ if ((code<0)||(code>MMERR_MAX)) code=MMERR_MAX+1;
+ return _mm_errmsg[code];
+}
+
+/* User installed error callback */
+MikMod_handler_t _mm_errorhandler = NULL;
+MIKMODAPI int _mm_errno = 0;
+MIKMODAPI BOOL _mm_critical = 0;
+
+MikMod_handler_t _mm_registererrorhandler(MikMod_handler_t proc)
+{
+ MikMod_handler_t oldproc=_mm_errorhandler;
+
+ _mm_errorhandler = proc;
+ return oldproc;
+}
+
+MIKMODAPI MikMod_handler_t MikMod_RegisterErrorHandler(MikMod_handler_t proc)
+{
+ MikMod_handler_t result;
+
+ MUTEX_LOCK(vars);
+ result=_mm_registererrorhandler(proc);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+/* ex:set ts=4: */
diff --git a/apps/plugins/mikmod/mmio/mmio.c b/apps/plugins/mikmod/mmio/mmio.c new file mode 100644 index 0000000..50269fb --- /dev/null +++ b/apps/plugins/mikmod/mmio/mmio.c @@ -0,0 +1,427 @@ +/* MikMod sound library
+ (c) 1998, 1999, 2000 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id: mmio.c,v 1.2 2004/02/06 19:29:05 raph Exp $
+
+ Portable file I/O routines
+
+==============================================================================*/
+
+/*
+
+ The way this module works:
+
+ - _mm_fopen will call the errorhandler [see mmerror.c] in addition to
+ setting _mm_errno on exit.
+ - _mm_iobase is for internal use. It is used by Player_LoadFP to
+ ensure that it works properly with wad files.
+ - _mm_read_I_* and _mm_read_M_* differ : the first is for reading data
+ written by a little endian (intel) machine, and the second is for reading
+ big endian (Mac, RISC, Alpha) machine data.
+ - _mm_write functions work the same as the _mm_read functions.
+ - _mm_read_string is for reading binary strings. It is basically the same
+ as an fread of bytes.
+
+*/
+
+/* FIXME
+ the _mm_iobase variable ought to be MREADER-specific. It will eventually
+ become a private field of the MREADER structure, but this will require a
+ soname version bump.
+
+ In the meantime, the drawback is that if you use the xxx_LoadFP functions,
+ you can't have several MREADER objects with different iobase values.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#define COPY_BUFSIZE 1024
+
+static long _mm_iobase=0,temp_iobase=0;
+
+
+int _mm_fopen(CHAR* fname,int attrib)
+{
+ int fp;
+
+ fp=rb->open(fname,attrib);
+ if(fp == -1) {
+ fp = 0;
+ _mm_errno = MMERR_OPENING_FILE;
+ if(_mm_errorhandler) _mm_errorhandler();
+ }
+ return fp;
+}
+
+BOOL _mm_FileExists(CHAR* fname)
+{
+ int fp;
+
+ if(!(fp=rb->open(fname, O_RDONLY))) return 0;
+ rb->close(fp);
+
+ return 1;
+}
+
+int _mm_fclose(int fp)
+{
+ return rb->close(fp);
+}
+
+/* Sets the current file-position as the new _mm_iobase */
+void _mm_iobase_setcur(MREADER* reader)
+{
+ temp_iobase=_mm_iobase; /* store old value in case of revert */
+ _mm_iobase=reader->Tell(reader);
+}
+
+/* Reverts to the last known _mm_iobase value. */
+void _mm_iobase_revert(void)
+{
+ _mm_iobase=temp_iobase;
+}
+
+/*========== File Reader */
+
+typedef struct MFILEREADER {
+ MREADER core;
+ int file;
+ int waseof;
+} MFILEREADER;
+
+static BOOL _mm_FileReader_Eof(MREADER* reader)
+{
+ /*
+ if ((lseek(((MFILEREADER*)reader)->file, 0, SEEK_CUR)-_mm_iobase) < filesize(((MFILEREADER*)reader)->file))
+ return 0;
+ else
+ return 1;
+ */
+ return ((MFILEREADER*)reader)->waseof;
+}
+
+static BOOL _mm_FileReader_Read(MREADER* reader,void* ptr,size_t size)
+{
+ int tempb;
+ tempb = rb->read(((MFILEREADER*)reader)->file, ptr, size);
+ //printf("(**) READ: %i\n", tempb);
+ /*
+ if (tempb != size)
+ {
+ printf("Read: count: %i newpos: %i return: %i\n", size, lseek(((MFILEREADER*)reader)->file-_mm_iobase, 0, SEEK_CUR), tempb);
+ }
+ */
+ if ((tempb < 1) && size > 0)
+ {
+ tempb = 0;
+ ((MFILEREADER*)reader)->waseof = 1;
+ }
+ else
+ {
+ ((MFILEREADER*)reader)->waseof = 0;
+ }
+ return tempb;
+}
+
+static int _mm_FileReader_Get(MREADER* reader)
+{
+ char buf;
+ if ((rb->read(((MFILEREADER*)reader)->file, &buf, 1) > 0) == 1)
+ {
+ ((MFILEREADER*)reader)->waseof = 0;
+ //printf("Get: newpos: %i _mm_iobase: %i\n", lseek(((MFILEREADER*)reader)->file-_mm_iobase, 0, SEEK_CUR), _mm_iobase);
+ return buf;
+ }
+ else
+ {
+ ((MFILEREADER*)reader)->waseof = 1;
+ //printf("Get: newpos: %i _mm_iobase: %i\n", lseek(((MFILEREADER*)reader)->file-_mm_iobase, 0, SEEK_CUR), _mm_iobase);
+ return EOF;
+ }
+}
+
+static BOOL _mm_FileReader_Seek(MREADER* reader,long offset,int whence)
+{
+ long tempb;
+
+ tempb = rb->lseek(((MFILEREADER*)reader)->file,
+ (whence==SEEK_SET)?offset+_mm_iobase:offset,whence);
+ ((MFILEREADER*)reader)->waseof = 0;
+ //printf("(**) SEEK: %i\n", tempb);
+ if (tempb < 0)
+ {
+ //printf("Seek: count: %i newpos: %i return: %i\n", offset, lseek(((MFILEREADER*)reader)->file-_mm_iobase, 0, SEEK_CUR), tempb);
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+static long _mm_FileReader_Tell(MREADER* reader)
+{
+ return rb->lseek(((MFILEREADER*)reader)->file, 0, SEEK_CUR)-_mm_iobase;
+}
+
+MREADER *_mm_new_file_reader(int fp)
+{
+ MFILEREADER* reader=(MFILEREADER*)_mm_malloc(sizeof(MFILEREADER));
+ if (reader) {
+ reader->core.Eof =&_mm_FileReader_Eof;
+ reader->core.Read=&_mm_FileReader_Read;
+ reader->core.Get =&_mm_FileReader_Get;
+ reader->core.Seek=&_mm_FileReader_Seek;
+ reader->core.Tell=&_mm_FileReader_Tell;
+ reader->file=fp;
+ reader->waseof = 0;
+ }
+ return (MREADER*)reader;
+}
+
+void _mm_delete_file_reader (MREADER* reader)
+{
+ if(reader) free(reader);
+}
+
+/*========== File Writer */
+
+typedef struct MFILEWRITER {
+ MWRITER core;
+ int file;
+} MFILEWRITER;
+
+static BOOL _mm_FileWriter_Seek(MWRITER* writer,long offset,int whence)
+{
+ return rb->lseek(((MFILEWRITER*)writer)->file,offset,whence);
+}
+
+static long _mm_FileWriter_Tell(MWRITER* writer)
+{
+ return rb->lseek(((MFILEREADER*)writer)->file, 0, SEEK_CUR);
+}
+
+static BOOL _mm_FileWriter_Write(MWRITER* writer,void* ptr,size_t size)
+{
+ return (rb->write(((MFILEWRITER*)writer)->file, ptr, size)==size);
+}
+
+static BOOL _mm_FileWriter_Put(MWRITER* writer,int value)
+{
+ char buf = value;
+ if (rb->write(((MFILEWRITER*)writer)->file, &buf, 1))
+ return 0;
+ else
+ return -1;
+}
+
+MWRITER *_mm_new_file_writer(int fp)
+{
+ MFILEWRITER* writer=(MFILEWRITER*)_mm_malloc(sizeof(MFILEWRITER));
+ if (writer) {
+ writer->core.Seek =&_mm_FileWriter_Seek;
+ writer->core.Tell =&_mm_FileWriter_Tell;
+ writer->core.Write=&_mm_FileWriter_Write;
+ writer->core.Put =&_mm_FileWriter_Put;
+ writer->file=fp;
+ }
+ return (MWRITER*) writer;
+}
+
+void _mm_delete_file_writer (MWRITER* writer)
+{
+ if(writer) free (writer);
+}
+
+/*========== Write functions */
+
+void _mm_write_string(CHAR* data,MWRITER* writer)
+{
+ if(data)
+ _mm_write_UBYTES(data,strlen(data),writer);
+}
+
+void _mm_write_M_UWORD(UWORD data,MWRITER* writer)
+{
+ _mm_write_UBYTE(data>>8,writer);
+ _mm_write_UBYTE(data&0xff,writer);
+}
+
+void _mm_write_I_UWORD(UWORD data,MWRITER* writer)
+{
+ _mm_write_UBYTE(data&0xff,writer);
+ _mm_write_UBYTE(data>>8,writer);
+}
+
+void _mm_write_M_ULONG(ULONG data,MWRITER* writer)
+{
+ _mm_write_M_UWORD((UWORD)(data>>16),writer);
+ _mm_write_M_UWORD((UWORD)(data&0xffff),writer);
+}
+
+void _mm_write_I_ULONG(ULONG data,MWRITER* writer)
+{
+ _mm_write_I_UWORD((UWORD)(data&0xffff),writer);
+ _mm_write_I_UWORD((UWORD)(data>>16),writer);
+}
+
+void _mm_write_M_SWORD(SWORD data,MWRITER* writer)
+{
+ _mm_write_M_UWORD((UWORD)data,writer);
+}
+
+void _mm_write_I_SWORD(SWORD data,MWRITER* writer)
+{
+ _mm_write_I_UWORD((UWORD)data,writer);
+}
+
+void _mm_write_M_SLONG(SLONG data,MWRITER* writer)
+{
+ _mm_write_M_ULONG((ULONG)data,writer);
+}
+
+void _mm_write_I_SLONG(SLONG data,MWRITER* writer)
+{
+ _mm_write_I_ULONG((ULONG)data,writer);
+}
+
+#if defined __STDC__ || defined _MSC_VER || defined MPW_C
+#define DEFINE_MULTIPLE_WRITE_FUNCTION(type_name,type) \
+void _mm_write_##type_name##S (type *buffer,int number,MWRITER* writer) \
+{ \
+ while(number-->0) \
+ _mm_write_##type_name(*(buffer++),writer); \
+}
+#else
+#define DEFINE_MULTIPLE_WRITE_FUNCTION(type_name,type) \
+void _mm_write_/**/type_name/**/S (type *buffer,int number,MWRITER* writer) \
+{ \
+ while(number-->0) \
+ _mm_write_/**/type_name(*(buffer++),writer); \
+}
+#endif
+
+DEFINE_MULTIPLE_WRITE_FUNCTION(M_SWORD,SWORD)
+DEFINE_MULTIPLE_WRITE_FUNCTION(M_UWORD,UWORD)
+DEFINE_MULTIPLE_WRITE_FUNCTION(I_SWORD,SWORD)
+DEFINE_MULTIPLE_WRITE_FUNCTION(I_UWORD,UWORD)
+
+DEFINE_MULTIPLE_WRITE_FUNCTION(M_SLONG,SLONG)
+DEFINE_MULTIPLE_WRITE_FUNCTION(M_ULONG,ULONG)
+DEFINE_MULTIPLE_WRITE_FUNCTION(I_SLONG,SLONG)
+DEFINE_MULTIPLE_WRITE_FUNCTION(I_ULONG,ULONG)
+
+/*========== Read functions */
+
+int _mm_read_string(CHAR* buffer,int number,MREADER* reader)
+{
+ return reader->Read(reader,buffer,number);
+}
+
+UWORD _mm_read_M_UWORD(MREADER* reader)
+{
+ UWORD result=((UWORD)_mm_read_UBYTE(reader))<<8;
+ result|=_mm_read_UBYTE(reader);
+ return result;
+}
+
+UWORD _mm_read_I_UWORD(MREADER* reader)
+{
+ UWORD result=_mm_read_UBYTE(reader);
+ result|=((UWORD)_mm_read_UBYTE(reader))<<8;
+ return result;
+}
+
+ULONG _mm_read_M_ULONG(MREADER* reader)
+{
+ ULONG result=((ULONG)_mm_read_M_UWORD(reader))<<16;
+ result|=_mm_read_M_UWORD(reader);
+ return result;
+}
+
+ULONG _mm_read_I_ULONG(MREADER* reader)
+{
+ ULONG result=_mm_read_I_UWORD(reader);
+ result|=((ULONG)_mm_read_I_UWORD(reader))<<16;
+ return result;
+}
+
+SWORD _mm_read_M_SWORD(MREADER* reader)
+{
+ return((SWORD)_mm_read_M_UWORD(reader));
+}
+
+SWORD _mm_read_I_SWORD(MREADER* reader)
+{
+ return((SWORD)_mm_read_I_UWORD(reader));
+}
+
+SLONG _mm_read_M_SLONG(MREADER* reader)
+{
+ return((SLONG)_mm_read_M_ULONG(reader));
+}
+
+SLONG _mm_read_I_SLONG(MREADER* reader)
+{
+ return((SLONG)_mm_read_I_ULONG(reader));
+}
+
+#if defined __STDC__ || defined _MSC_VER || defined MPW_C
+#define DEFINE_MULTIPLE_READ_FUNCTION(type_name,type) \
+int _mm_read_##type_name##S (type *buffer,int number,MREADER* reader) \
+{ \
+ while(number-->0) \
+ *(buffer++)=_mm_read_##type_name(reader); \
+ return !reader->Eof(reader); \
+}
+#else
+#define DEFINE_MULTIPLE_READ_FUNCTION(type_name,type) \
+int _mm_read_/**/type_name/**/S (type *buffer,int number,MREADER* reader) \
+{ \
+ while(number-->0) \
+ *(buffer++)=_mm_read_/**/type_name(reader); \
+ return !reader->Eof(reader); \
+}
+#endif
+
+DEFINE_MULTIPLE_READ_FUNCTION(M_SWORD,SWORD)
+DEFINE_MULTIPLE_READ_FUNCTION(M_UWORD,UWORD)
+DEFINE_MULTIPLE_READ_FUNCTION(I_SWORD,SWORD)
+DEFINE_MULTIPLE_READ_FUNCTION(I_UWORD,UWORD)
+
+DEFINE_MULTIPLE_READ_FUNCTION(M_SLONG,SLONG)
+DEFINE_MULTIPLE_READ_FUNCTION(M_ULONG,ULONG)
+DEFINE_MULTIPLE_READ_FUNCTION(I_SLONG,SLONG)
+DEFINE_MULTIPLE_READ_FUNCTION(I_ULONG,ULONG)
+
+/* ex:set ts=4: */
diff --git a/apps/plugins/mikmod/mmio/old_mmalloc.c b/apps/plugins/mikmod/mmio/old_mmalloc.c new file mode 100644 index 0000000..ea9924e --- /dev/null +++ b/apps/plugins/mikmod/mmio/old_mmalloc.c @@ -0,0 +1,290 @@ +/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id: mmalloc.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $
+
+ Dynamic memory routines
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+
+size_t mem_offset = 0;
+char *mallocbuf = NULL;
+size_t mallocbuflen = 0;
+
+#define OTMAX 8192
+size_t offsettable[OTMAX];
+int otcounter = 0;
+
+size_t mikmod_get_mbuffsize(void *buff)
+{
+ int i;
+
+ for (i = 0; i < otcounter; i++)
+ {
+ if (offsettable[i] == (size_t)buff - (size_t)mallocbuf)
+ {
+ if (i < (otcounter - 1))
+ {
+ return (size_t)(offsettable[i + 1] - offsettable[i]);
+ }
+ else // i == (otcounter - 1)
+ {
+ return mem_offset - offsettable[i];
+ }
+ }
+ }
+
+ return 0; // i >= otcounter
+}
+
+
+void mikmod_prepare_malloc(char *buff, int bufsize)
+{
+ mallocbuf = buff;
+ mallocbuflen = bufsize;
+ mem_offset = 0;
+ otcounter = 0;
+}
+
+long mikmod_get_malloc_usage(void)
+{
+ return mem_offset;
+}
+
+int mikmod_abs(int num)
+{
+ if (num < 0)
+ return (num * -1);
+ else
+ return (num);
+}
+
+void* mikmod_memset(char *buf, int val, size_t count)
+{
+ size_t i;
+
+ for (i = 0; i < count; i++)
+ {
+ buf[i] = val;
+ }
+ return buf;
+}
+
+/* 'Poor man's malloc' taken from rockbox codeclib.c */
+void* mikmod_malloc(size_t size)
+{
+ void* x;
+
+ if (!mallocbuf)
+ return NULL;
+ if (mem_offset + (long)size > mallocbuflen)
+ return NULL;
+
+ x = &mallocbuf[mem_offset];
+
+
+ if (otcounter < OTMAX)
+ {
+ offsettable[otcounter] = mem_offset;
+ otcounter++;
+ }
+ else
+ {
+ if (otcounter == OTMAX)
+ {
+ rb->splash(HZ * 2, "Offset Table FULL !\n");
+ }
+ }
+ mem_offset += (size + 3) & ~3; /* Keep memory 32-bit aligned */
+
+
+ memset(x, 0, size);
+
+ return(x);
+}
+
+void* mikmod_calloc(size_t nmemb, size_t size)
+{
+ void *x;
+ x = mikmod_malloc(nmemb * size);
+ if (x == NULL)
+ return NULL;
+ //memset(x, 0, nmemb*size);
+ return(x);
+}
+
+void mikmod_free(void* ptr) {
+ (void)ptr;
+}
+
+void* mikmod_realloc(void* ptr, size_t size)
+{
+ void* x;
+ //(void)ptr;
+ x = mikmod_malloc(size);
+ if (ptr != NULL)
+ {
+ if (mikmod_get_mbuffsize(ptr))
+ {
+ memcpy(x, ptr, mikmod_get_mbuffsize(ptr));
+ }
+ else
+ {
+ memcpy(x, ptr, size); //FIXME: size has to be the size of the original buffer.....
+ }
+ }
+ return(x);
+}
+
+unsigned int mikmod_strlen(const char *string)
+{
+ unsigned int i;
+ for (i = 0; string[i] != 0; i++);
+ return i;
+}
+
+char* mikmod_strdup(const char *srcbuf)
+{
+ char *newbuf;
+ unsigned int i, len;
+
+ len = mikmod_strlen(srcbuf);
+ newbuf = mikmod_malloc(len + 1);
+
+ if (newbuf)
+ {
+ for (i = 0; i <= len; i++)
+ newbuf[i] = srcbuf[i];
+ }
+ return newbuf;
+}
+
+char* mikmod_strncat(char *dest, const char *src, size_t count)
+{
+ size_t i, j;
+ j = mikmod_strlen(dest);
+
+ for(i = 0; i < count; i++)
+ {
+ if (src[i] == 0)
+ break;
+ dest[i + j] = src[i];
+ }
+ return dest;
+}
+
+int mikmod_memcmp(const char *buf1, const char *buf2, size_t count)
+{
+ size_t i;
+
+ for(i = 0; i < count; i++)
+ {
+ if (buf1[i] > buf2[i])
+ return 1;
+ if (buf1[i] < buf2[i])
+ return -1;
+ }
+ return 0;
+}
+
+char* mikmod_strstr(char *str, char *search)
+{
+ size_t i, j, k;
+
+ if (!mikmod_strlen(search))
+ return str;
+
+ j = mikmod_strlen(str);
+ k = mikmod_strlen(search);
+
+ for (i = 0; i < (j - k); i++)
+ {
+ if (!mikmod_memcmp(str, search, k))
+ return &str[i];
+ }
+ return NULL;
+}
+
+int mikmod_toupper(int character)
+{
+ if ((character > 96) && (character < 123))
+ return (character - 32);
+ else
+ return character;
+}
+
+int mikmod_isalnum(int character)
+{
+ if ((character > 96) && (character < 123))
+ return character;
+ if ((character > 64) && (character < 91))
+ return character;
+ if ((character > 47) && (character < 58))
+ return character;
+ return 0;
+}
+
+int mikmod_isdigit(char c)
+{
+ return (c >= '0') && (c <= '9');
+}
+
+
+/****************************************************
+ * 'Original' MikMod code goes here
+ *
+ ****************************************************/
+
+/* Same as malloc, but sets error variable _mm_error when fails */
+void* _mm_malloc(size_t size)
+{
+ void *d;
+
+ //if(!(d=mikmod_malloc(size))) {
+ if(!(d=mikmod_malloc(size))) {
+ _mm_errno = MMERR_OUT_OF_MEMORY;
+ if(_mm_errorhandler) _mm_errorhandler();
+ }
+ memset(d, 0, size);
+ return d;
+}
+
+/* Same as calloc, but sets error variable _mm_error when fails */
+void* _mm_calloc(size_t nitems,size_t size)
+{
+ void *d;
+
+ if(!(d=mikmod_calloc(nitems,size))) {
+ _mm_errno = MMERR_OUT_OF_MEMORY;
+ if(_mm_errorhandler) _mm_errorhandler();
+ }
+ return d;
+}
+
+/* ex:set ts=4: */
|