gosu 1.3.0 → 1.4.0

data/dependencies/SDL_sound/libmodplug/load_umx.c

@@ -1,50 +1,330 @@
 /*
  * This source code is public domain.
  *
- * Authors: Olivier Lapicque <olivierl@jps.net>
+ * Epic Games Unreal UMX container loading for libmodplug
+ * Written by O. Sezer <sezero@users.sourceforge.net>
+ * UPKG parsing partially based on Unreal Media Ripper (UMR) v0.3
+ * by Andy Ward <wardwh@swbell.net>, with additional updates
+ * by O. Sezer - see git repo at https://github.com/sezero/umr.git
+ * Retrieves the offset, size and object type directly from umx.
 */
 
 #include "libmodplug.h"
 
-#define MODMAGIC_OFFSET	(20+31*30+130)
+
+typedef LONG fci_t;		/* FCompactIndex */
+
+#define UPKG_HDR_TAG	0x9e2a83c1
+
+struct _genhist {	/* for upkg versions >= 68 */
+	LONG export_count;
+	LONG name_count;
+};
+
+struct upkg_hdr {
+	DWORD tag;	/* UPKG_HDR_TAG */
+	LONG file_version;
+	DWORD pkg_flags;
+	LONG name_count;	/* number of names in name table (>= 0) */
+	LONG name_offset;		/* offset to name table  (>= 0) */
+	LONG export_count;	/* num. exports in export table  (>= 0) */
+	LONG export_offset;		/* offset to export table (>= 0) */
+	LONG import_count;	/* num. imports in export table  (>= 0) */
+	LONG import_offset;		/* offset to import table (>= 0) */
+
+	/* number of GUIDs in heritage table (>= 1) and table's offset:
+	 * only with versions < 68. */
+	LONG heritage_count;
+	LONG heritage_offset;
+	/* with versions >= 68:  a GUID, a dword for generation count
+	 * and export_count and name_count dwords for each generation: */
+	DWORD guid[4];
+	LONG generation_count;
+#define UPKG_HDR_SIZE 64			/* 64 bytes up until here */
+	/*struct _genhist *gen;*/
+};
+
+#define UMUSIC_IT	0
+#define UMUSIC_S3M	1
+#define UMUSIC_XM	2
+#define UMUSIC_MOD	3
+#define UMUSIC_WAV	4
+#define UMUSIC_MP2	5
+
+static const char *mustype[] = {
+	"IT", "S3M", "XM", "MOD",
+	NULL
+};
+
+/* decode an FCompactIndex.
+ * original documentation by Tim Sweeney was at
+ * http://unreal.epicgames.com/Packages.htm
+ * also see Unreal Wiki:
+ * http://wiki.beyondunreal.com/Legacy:Package_File_Format/Data_Details
+ */
+static fci_t get_fci (const char *in, int *pos)
+{
+	LONG a;
+	int size;
+
+	size = 1;
+	a = in[0] & 0x3f;
+
+	if (in[0] & 0x40) {
+		size++;
+		a |= (in[1] & 0x7f) << 6;
+
+		if (in[1] & 0x80) {
+			size++;
+			a |= (in[2] & 0x7f) << 13;
+
+			if (in[2] & 0x80) {
+				size++;
+				a |= (in[3] & 0x7f) << 20;
+
+				if (in[3] & 0x80) {
+					size++;
+					a |= (in[4] & 0x3f) << 27;
+				}
+			}
+		}
+	}
+
+	if (in[0] & 0x80)
+		a = -a;
+
+	*pos += size;
+
+	return a;
+}
+
+static int get_objtype (const BYTE *membase, LONG memlen,
+			LONG ofs, int type)
+{
+	if (type == UMUSIC_IT) {
+	_retry:
+		if (SDL_memcmp(membase + ofs, "IMPM", 4) == 0)
+			return UMUSIC_IT;
+		return -1;
+	}
+	if (type == UMUSIC_XM) {
+		if (SDL_memcmp(membase + ofs, "Extended Module: ", 17) != 0)
+			return -1;
+		if (*(membase + ofs + 37) != 0x1a) return -1;
+		return UMUSIC_XM;
+	}
+
+	if (type == UMUSIC_S3M) {
+		if (SDL_memcmp(membase + ofs + 44, "SCRM", 4) == 0)
+			return UMUSIC_S3M;
+		/*return -1;*/
+		/* SpaceMarines.umx and Starseek.umx from Return to NaPali
+		 * report as "s3m" whereas the actual music format is "it" */
+		goto _retry;
+	}
+
+	if (type == UMUSIC_MOD) {
+		membase += ofs + 1080;
+		if (SDL_memcmp(membase, "M.K.", 4) == 0 || SDL_memcmp(membase, "M!K!", 4) == 0)
+			return UMUSIC_MOD;
+		return -1;
+	}
+
+	return -1;
+}
+
+static int read_export (const BYTE *membase, LONG memlen,
+			const struct upkg_hdr *hdr,
+			LONG *ofs, LONG *objsize)
+{
+	char buf[40];
+	int idx = 0, t;
+
+	SDL_memcpy(buf, membase + *ofs, 40);
+
+	if (hdr->file_version < 40) idx += 8;	/* 00 00 00 00 00 00 00 00 */
+	if (hdr->file_version < 60) idx += 16;	/* 81 00 00 00 00 00 FF FF FF FF FF FF FF FF 00 00 */
+	get_fci(&buf[idx], &idx);		/* skip junk */
+	t = get_fci(&buf[idx], &idx);		/* type_name */
+	if (hdr->file_version > 61) idx += 4;	/* skip export size */
+	*objsize = get_fci(&buf[idx], &idx);
+	*ofs += idx;	/* offset for real data */
+
+	return t;	/* return type_name index */
+}
+
+static int read_typname(const BYTE *membase, LONG memlen,
+			const struct upkg_hdr *hdr,
+			int idx, char *out)
+{
+	int i, s;
+	long l, ofs, siz;
+	char buf[64];
+
+	if (idx >= hdr->name_count) return -1;
+	SDL_memset(buf, 0, 64);
+	for (i = 0, l = 0; i <= idx; i++) {
+		if ((ofs = hdr->name_offset + l) >= memlen)
+			return -1;
+		if ((siz = memlen - ofs) > 63) siz = 63;
+		SDL_memcpy(buf, membase + ofs, siz);
+		if (hdr->file_version >= 64) {
+			s = *(signed char *)buf; /* numchars *including* terminator */
+			if (s <= 0) return -1;
+			l += s + 5;	/* 1 for buf[0], 4 for int32_t name_flags */
+		} else {
+			l += (long)SDL_strlen(buf);
+			l +=  5;	/* 1 for terminator, 4 for int32_t name_flags */
+		}
+	}
+
+	SDL_strlcpy(out, (hdr->file_version >= 64)? &buf[1] : buf, 64);
+	return 0;
+}
+
+static void umx_strupr(char *str)
+{
+	while (*str) {
+		if (*str >= 'a' && *str <= 'z') {
+		    *str -= ('a' - 'A');
+		}
+		str++;
+	}
+}
+
+static int probe_umx   (const BYTE *membase, LONG memlen,
+			const struct upkg_hdr *hdr,
+			LONG *ofs, LONG *objsize)
+{
+	int i, idx, t;
+	LONG s, pos;
+	char buf[64];
+
+	if (hdr->name_offset	>= memlen ||
+	    hdr->export_offset	>= memlen ||
+	    hdr->import_offset	>= memlen) {
+		return -1;
+	}
+
+	/* Find the offset and size of the first IT, S3M or XM
+	 * by parsing the exports table. The umx files should
+	 * have only one export. Kran32.umx from Unreal has two,
+	 * but both pointing to the same music. */
+	s = memlen - hdr->export_offset;
+	if (s <= 0) return -1;
+	if (s > 64) s = 64;
+	SDL_memcpy(buf, membase + hdr->export_offset, s);
+	for (; s < 64; ++s) buf[s] = 0x0; /* really? */
+
+	idx = 0;
+
+	get_fci(&buf[idx], &idx);	/* skip class_index */
+	get_fci(&buf[idx], &idx);	/* skip super_index */
+	if (hdr->file_version >= 60) idx += 4; /* skip int32 package_index */
+	get_fci(&buf[idx], &idx);	/* skip object_name */
+	idx += 4;			/* skip int32 object_flags */
+
+	s = get_fci(&buf[idx], &idx);	/* get serial_size */
+	if (s <= 0) return -1;
+	pos = get_fci(&buf[idx],&idx);	/* get serial_offset */
+	if (pos < 0 || pos > memlen - 40) return -1;
+
+	if ((t = read_export(membase, memlen, hdr, &pos, &s)) < 0) return -1;
+	if (s <= 0 || s > memlen - pos) return -1;
+
+	if (read_typname(membase, memlen, hdr, t, buf) < 0) return -1;
+	umx_strupr(buf);
+	for (i = 0; mustype[i] != NULL; i++) {
+		if (!SDL_strcmp(buf, mustype[i])) {
+			t = i;
+			break;
+		}
+	}
+	if (mustype[i] == NULL) return -1;
+	if ((t = get_objtype(membase, memlen, pos, t)) < 0) return -1;
+
+	*ofs = pos;
+	*objsize = s;
+	return t;
+}
+
+static int probe_header (void *header)
+{
+	struct upkg_hdr *hdr;
+	unsigned char *p;
+	DWORD *swp;
+	int i;
+
+	/* byte swap the header - all members are 32 bit LE values */
+	p = (unsigned char *) header;
+	swp = (DWORD *) header;
+	for (i = 0; i < UPKG_HDR_SIZE/4; i++, p += 4) {
+		swp[i] = p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
+	}
+
+	hdr = (struct upkg_hdr *) header;
+	if (hdr->tag != UPKG_HDR_TAG) {
+		return -1;
+	}
+	if (hdr->name_count	< 0	||
+	    hdr->export_count	< 0	||
+	    hdr->import_count	< 0	||
+	    hdr->name_offset	< 36	||
+	    hdr->export_offset	< 36	||
+	    hdr->import_offset	< 36	) {
+		return -1;
+	}
+
+#if 1 /* no need being overzealous */
+	return 0;
+#else
+	switch (hdr->file_version) {
+	case 35: case 37:	/* Unreal beta - */
+	case 40: case 41:				/* 1998 */
+	case 61:/* Unreal */
+	case 62:/* Unreal Tournament */
+	case 63:/* Return to NaPali */
+	case 64:/* Unreal Tournament */
+	case 66:/* Unreal Tournament */
+	case 68:/* Unreal Tournament */
+	case 69:/* Tactical Ops */
+	case 83:/* Mobile Forces */
+		return 0;
+	}
+
+	return -1;/* Unknown upkg version for an UMX */
+#endif /* #if 0  */
+}
+
+static int process_upkg (const BYTE *membase, LONG memlen,
+			 LONG *ofs, LONG *objsize)
+{
+	char header[UPKG_HDR_SIZE];
+
+	SDL_memcpy(header, membase, UPKG_HDR_SIZE);
+	if (probe_header(header) < 0)
+		return -1;
+
+	return probe_umx(membase, memlen, (struct upkg_hdr *)header, ofs, objsize);
+}
 
 BOOL CSoundFile_ReadUMX(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLength)
 //---------------------------------------------------------------
 {
-	if ((!lpStream) || (dwMemLength < 0x800)) return FALSE;
+	int type;
+	LONG ofs = 0, size = 0;
+
+	if (!lpStream || dwMemLength < 0x800 || dwMemLength > 0x7fffffff)
+		return FALSE;
+	type = process_upkg(lpStream, (LONG)dwMemLength, &ofs, &size);
+	if (type < 0) return FALSE;
+
 	// Rip Mods from UMX
-	if ((bswapLE32(*((DWORD *)(lpStream+0x20))) < dwMemLength)
-	 && (bswapLE32(*((DWORD *)(lpStream+0x18))) <= dwMemLength - 0x10)
-	 && (bswapLE32(*((DWORD *)(lpStream+0x18))) >= dwMemLength - 0x200))
-	{
-		for (UINT uscan=0x40; uscan<0x500; uscan++)
-		{
-			DWORD dwScan = bswapLE32(*((DWORD *)(lpStream+uscan)));
-			// IT
-			if (dwScan == 0x4D504D49)
-			{
-				DWORD dwRipOfs = uscan;
-				return CSoundFile_ReadIT(_this, lpStream + dwRipOfs, dwMemLength - dwRipOfs);
-			}
-			// S3M
-			if (dwScan == 0x4D524353)
-			{
-				DWORD dwRipOfs = uscan - 44;
-				return CSoundFile_ReadS3M(_this, lpStream + dwRipOfs, dwMemLength - dwRipOfs);
-			}
-			// XM
-			if (!SDL_strncasecmp((LPCSTR)(lpStream+uscan), "Extended Module", 15))
-			{
-				DWORD dwRipOfs = uscan;
-				return CSoundFile_ReadXM(_this, lpStream + dwRipOfs, dwMemLength - dwRipOfs);
-			}
-			// MOD
-			if ((uscan > MODMAGIC_OFFSET) && (dwScan == 0x2e4b2e4d))
-			{
-				DWORD dwRipOfs = uscan - MODMAGIC_OFFSET;
-				return CSoundFile_ReadMod(_this, lpStream+dwRipOfs, dwMemLength-dwRipOfs);
-			}
-		}
+	switch (type) {
+	case UMUSIC_IT:  return CSoundFile_ReadIT(_this, lpStream + ofs, size);
+	case UMUSIC_S3M: return CSoundFile_ReadS3M(_this, lpStream + ofs, size);
+	case UMUSIC_XM:  return CSoundFile_ReadXM(_this, lpStream + ofs, size);
+	case UMUSIC_MOD: return CSoundFile_ReadMod(_this, lpStream + ofs, size);
 	}
 	return FALSE;
 }

data/dependencies/SDL_sound/libmodplug/load_xm.c

@@ -10,7 +10,7 @@
 ////////////////////////////////////////////////////////
 // FastTracker II XM file support
 
-#ifdef MSC_VER
+#ifdef _MSC_VER
 #pragma warning(disable:4244)
 #endif
 
@@ -29,7 +29,6 @@ typedef struct tagXMFILEHEADER
 	BYTE order[256];
 } XMFILEHEADER;
 
-
 typedef struct tagXMINSTRUMENTHEADER
 {
 	DWORD size;
@@ -39,7 +38,6 @@ typedef struct tagXMINSTRUMENTHEADER
 	BYTE samplesh;
 } XMINSTRUMENTHEADER;
 
-
 typedef struct tagXMSAMPLEHEADER
 {
 	DWORD shsize;
@@ -70,7 +68,6 @@ typedef struct tagXMSAMPLESTRUCT
 } XMSAMPLESTRUCT;
 #pragma pack()
 
-
 BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLength)
 //--------------------------------------------------------------
 {
@@ -88,14 +85,16 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 
 	_this->m_nChannels = 0;
 	if ((!lpStream) || (dwMemLength < 0x200)) return FALSE;
-	if (SDL_strncasecmp((LPCSTR)lpStream, "Extended Module", 15)) return FALSE;
+	if (SDL_strncmp((LPCSTR)lpStream, "Extended Module:", 16)) return FALSE;
 
 	SDL_memcpy(&xmhead, lpStream+60, sizeof (xmhead));
 	dwHdrSize = bswapLE32(xmhead.size);
 	norders = bswapLE16(xmhead.norder);
-	if ((!norders) || (norders > MAX_ORDERS)) return FALSE;
 	restartpos = bswapLE16(xmhead.restartpos);
 	channels = bswapLE16(xmhead.channels);
+
+	if ((!dwHdrSize) || dwHdrSize > dwMemLength - 60) return FALSE;
+	if ((!norders) || (norders > MAX_ORDERS)) return FALSE;
 	if ((!channels) || (channels > 64)) return FALSE;
 	_this->m_nType = MOD_TYPE_XM;
 	_this->m_nMinPeriod = 27;
@@ -162,6 +161,7 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 			dwMemPos++;
 			dwSize = bswapLE32(*((DWORD *)(lpStream+dwMemPos)));
 		}
+		if (dwMemPos + 9 > dwMemLength) return TRUE;		
 		rows = bswapLE16(*((WORD *)(lpStream+dwMemPos+5)));
 		if ((!rows) || (rows > 256)) rows = 64;
 		packsize = bswapLE16(*((WORD *)(lpStream+dwMemPos+7)));
@@ -188,13 +188,14 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 					UINT vol = 0;
 					if (b & 0x80)
 					{
-						if (b & 1) p->note = src[j++];
-						if (b & 2) p->instr = src[j++];
-						if (b & 4) vol = src[j++];
-						if (b & 8) p->command = src[j++];
-						if (b & 16) p->param = src[j++];
+						if ((b & 1)  && j < packsize) p->note = src[j++];
+						if ((b & 2)  && j < packsize) p->instr = src[j++];
+						if ((b & 4)  && j < packsize) vol = src[j++];
+						if ((b & 8)  && j < packsize) p->command = src[j++];
+						if ((b & 16) && j < packsize) p->param = src[j++];
 					} else
 					{
+						if (j + 5 > packsize) break;
 						p->note = b;
 						p->instr = src[j++];
 						vol = src[j++];
@@ -276,15 +277,16 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 		DWORD samplesize[32];
 		UINT samplemap[32];
 		WORD nsamples;
+		DWORD pihlen;
 
 		if (dwMemPos + sizeof(XMINSTRUMENTHEADER) >= dwMemLength) return TRUE;
 		pih = (XMINSTRUMENTHEADER *)(lpStream+dwMemPos);
-		if (dwMemPos + bswapLE32(pih->size) > dwMemLength) return TRUE;
-		if ((_this->Headers[iIns] = (INSTRUMENTHEADER *) SDL_malloc(sizeof (INSTRUMENTHEADER))) == NULL) continue;
-		SDL_memset(_this->Headers[iIns], 0, sizeof(INSTRUMENTHEADER));
+		pihlen = bswapLE32(pih->size);
+		if (pihlen >= dwMemLength || dwMemPos > dwMemLength - pihlen) return TRUE;
+		if ((_this->Headers[iIns] = (INSTRUMENTHEADER *) SDL_calloc(1, sizeof(INSTRUMENTHEADER))) == NULL) continue;
 		if ((nsamples = pih->samples) > 0)
 		{
-			if (dwMemPos + sizeof(XMSAMPLEHEADER) > dwMemLength) return TRUE;
+			if (dwMemPos + sizeof(XMINSTRUMENTHEADER) + sizeof(XMSAMPLEHEADER) > dwMemLength) return TRUE;
 			SDL_memcpy(&xmsh, lpStream+dwMemPos+sizeof(XMINSTRUMENTHEADER), sizeof(XMSAMPLEHEADER));
 			xmsh.shsize = bswapLE32(xmsh.shsize);
 			for (int i = 0; i < 24; ++i) {
@@ -293,10 +295,10 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 			}
 			xmsh.volfade = bswapLE16(xmsh.volfade);
 			xmsh.res = bswapLE16(xmsh.res);
-			dwMemPos += bswapLE32(pih->size);
+			dwMemPos += pihlen;
 		} else
 		{
-			if (bswapLE32(pih->size)) dwMemPos += bswapLE32(pih->size);
+			if (pihlen) dwMemPos += pihlen;
 			else dwMemPos += sizeof(XMINSTRUMENTHEADER);
 			continue;
 		}
@@ -431,7 +433,7 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 		for (UINT ins=0; ins<nsamples; ins++)
 		{
 			if ((dwMemPos + sizeof(xmss) > dwMemLength)
-			 || (dwMemPos + xmsh.shsize > dwMemLength)) return TRUE;
+			 || (xmsh.shsize >= dwMemLength) || (dwMemPos > dwMemLength - xmsh.shsize)) return TRUE;
 			SDL_memcpy(&xmss, lpStream+dwMemPos, sizeof(xmss));
 			xmss.samplen = bswapLE32(xmss.samplen);
 			xmss.loopstart = bswapLE32(xmss.loopstart);
@@ -512,6 +514,7 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 	{
 		UINT len = *((DWORD *)(lpStream+dwMemPos+4));
 		dwMemPos += 8;
+		if (len >= dwMemLength || dwMemPos > dwMemLength - len) return TRUE;
 		if (len == sizeof(MODMIDICFG))
 		{
 			SDL_memcpy(&_this->m_MidiCfg, lpStream+dwMemPos, len);
@@ -523,7 +526,8 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 	{
 		UINT len = *((DWORD *)(lpStream+dwMemPos+4));
 		dwMemPos += 8;
-		if ((dwMemPos + len <= dwMemLength) && (len <= MAX_PATTERNS*MAX_PATTERNNAME) && (len >= MAX_PATTERNNAME))
+		if (len >= dwMemLength || dwMemPos > dwMemLength - len) return TRUE;
+		if ((len <= MAX_PATTERNS*MAX_PATTERNNAME) && (len >= MAX_PATTERNNAME))
 		{
 			_this->m_lpszPatternNames = (char *) SDL_malloc(len);
 			if (_this->m_lpszPatternNames)
@@ -539,7 +543,8 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 	{
 		UINT len = *((DWORD *)(lpStream+dwMemPos+4));
 		dwMemPos += 8;
-		if ((dwMemPos + len <= dwMemLength) && (len <= MAX_BASECHANNELS*MAX_CHANNELNAME))
+		if (len >= dwMemLength || dwMemPos > dwMemLength - len) return TRUE;
+		if (len <= MAX_BASECHANNELS*MAX_CHANNELNAME)
 		{
 			dwMemPos += len;
 		}
@@ -551,4 +556,3 @@ BOOL CSoundFile_ReadXM(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLengt
 	}
 	return TRUE;
 }
-