PageRenderTime 1064ms CodeModel.GetById 35ms RepoModel.GetById 1ms app.codeStats 0ms

/xbmc/lib/mikxbox/Source/loaders/load_uni.c

https://github.com/jeppster/xbmc-fork
C | 723 lines | 583 code | 87 blank | 53 comment | 138 complexity | 1a4cf35a4ea01ca277f2ac6f5b65d936 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, AGPL-1.0 
    

  1. /*	MikMod sound library
    2. 

  2. 	(c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
    3. 

  3. 	AUTHORS for complete list.
    4. 

    5. 

  5. 	This library is free software; you can redistribute it and/or modify
    6. 

  6. 	it under the terms of the GNU Library General Public License as
    7. 

  7. 	published by the Free Software Foundation; either version 2 of
    8. 

  8. 	the License, or (at your option) any later version.
    9. 

  9.  
    10. 

  10. 	This program is distributed in the hope that it will be useful,
    11. 

  11. 	but WITHOUT ANY WARRANTY; without even the implied warranty of
    12. 

  12. 	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13. 

  13. 	GNU Library General Public License for more details.
    14. 

  14.  
    15. 

  15. 	You should have received a copy of the GNU Library General Public
    16. 

  16. 	License along with this library; if not, write to the Free Software
    17. 

  17. 	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
    18. 

  18. 	02111-1307, USA.
    19. 

  19. */
    20. 

  20. 

  21. /*==============================================================================
    22. 

    23. 

  23.   $Id$
    24. 

    25. 

  25.   UNIMOD (libmikmod's and APlayer's internal module format) loader
    26. 

    27. 

  27. ==============================================================================*/
    28. 

  28. #include "xbsection_start.h"
    29. 

  29. 

  30. 

  31. #ifdef HAVE_CONFIG_H
    32. 

  32. #include "config.h"
    33. 

  33. #endif
    34. 

  34. 

  35. #ifdef HAVE_UNISTD_H
    36. 

  36. #include <unistd.h>
    37. 

  37. #endif
    38. 

  38. 

  39. #include <stdio.h>
    40. 

  40. #ifdef HAVE_MEMORY_H
    41. 

  41. #include <memory.h>
    42. 

  42. #endif
    43. 

  43. #include <string.h>
    44. 

  44. #include "mikmod.h"
    45. 

  45. #include "mikmod_internals.h"
    46. 

  46. 

  47. #ifdef USE_UNI_FORMAT
    48. 

  48. 

  49. #ifdef SUNOS
    50. 

  50. extern int fprintf(FILE *, const char *, ...);
    51. 

  51. #endif
    52. 

  52. 

  53. /*========== Module structure */
    54. 

  54. 

  55. typedef struct UNIHEADER {
    56. 

  56. 	CHAR  id[4];
    57. 

  57. 	UBYTE numchn;
    58. 

  58. 	UWORD numpos;
    59. 

  59. 	UWORD reppos;
    60. 

  60. 	UWORD numpat;
    61. 

  61. 	UWORD numtrk;
    62. 

  62. 	UWORD numins;
    63. 

  63. 	UWORD numsmp;
    64. 

  64. 	UBYTE initspeed;
    65. 

  65. 	UBYTE inittempo;
    66. 

  66. 	UBYTE initvolume;
    67. 

  67. 	UWORD flags;
    68. 

  68. 	UBYTE numvoices;
    69. 

  69. 	UWORD bpmlimit;
    70. 

  70. 

  71. 	UBYTE positions[256];
    72. 

  72. 	UBYTE panning[32];
    73. 

  73. } UNIHEADER;
    74. 

  74. 

  75. typedef struct UNISMP05 {
    76. 

  76. 	UWORD c2spd;
    77. 

  77. 	UWORD transpose;
    78. 

  78. 	UBYTE volume;
    79. 

  79. 	UBYTE panning;
    80. 

  80. 	ULONG length;
    81. 

  81. 	ULONG loopstart;
    82. 

  82. 	ULONG loopend;
    83. 

  83. 	UWORD flags;
    84. 

  84. 	CHAR* samplename;
    85. 

  85. 	UBYTE vibtype;
    86. 

  86. 	UBYTE vibsweep;
    87. 

  87. 	UBYTE vibdepth;
    88. 

  88. 	UBYTE vibrate;
    89. 

  89. } UNISMP05;
    90. 

  90. 

  91. /*========== Loader variables */
    92. 

  92. 

  93. static UWORD universion;
    94. 

  94. static UNIHEADER mh;
    95. 

  95. 

  96. #define UNI_SMPINCR 64
    97. 

  97. static UNISMP05 *wh=NULL,*s=NULL;
    98. 

  98. 

  99. /*========== Loader code */
    100. 

  100. 

  101. static char* readstring(void)
    102. 

  102. {
    103. 

  103. 	char *s=NULL;
    104. 

  104. 	UWORD len;
    105. 

  105. 	
    106. 

  106. 	len=_mm_read_I_UWORD(modreader);
    107. 

  107. 	if(len) {
    108. 

  108. 		s=_mm_malloc(len+1);
    109. 

  109. 		_mm_read_UBYTES(s,len,modreader);
    110. 

  110. 		s[len]=0;
    111. 

  111. 	}
    112. 

  112. 	return s;
    113. 

  113. }
    114. 

  114. 

  115. BOOL UNI_Test(void)
    116. 

  116. {
    117. 

  117. 	char id[6];
    118. 

  118. 

  119. 	if(!_mm_read_UBYTES(id,6,modreader)) return 0;
    120. 

  120. 

  121. 	/* UNIMod created by MikCvt */
    122. 

  122. 	if(!(memcmp(id,"UN0",3))) {
    123. 

  123. 		if((id[3]>='4')&&(id[3]<='6')) return 1;
    124. 

  124. 	}
    125. 

  125. 	/* UNIMod created by APlayer */
    126. 

  126. 	if(!(memcmp(id,"APUN\01",5))) {
    127. 

  127. 		if((id[5]>=1)&&(id[5]<=6)) return 1;
    128. 

  128. 	}
    129. 

  129. 	return 0;
    130. 

  130. }
    131. 

  131. 

  132. BOOL UNI_Init(void)
    133. 

  133. {
    134. 

  134. 	return 1;
    135. 

  135. }
    136. 

  136. 

  137. void UNI_Cleanup(void)
    138. 

  138. {
    139. 

  139. 	_mm_free(wh);
    140. 

  140. 	s=NULL;
    141. 

  141. }
    142. 

  142. 

  143. static UBYTE* readtrack(void)
    144. 

  144. {
    145. 

  145. 	UBYTE *t;
    146. 

  146. 	UWORD len;
    147. 

  147. 	int cur=0,chunk;
    148. 

  148. 

  149. 	if(universion>=6)
    150. 

  150. 		len=_mm_read_M_UWORD(modreader);
    151. 

  151. 	else
    152. 

  152. 		len=_mm_read_I_UWORD(modreader);
    153. 

  153. 

  154. 	if(!len) return NULL;
    155. 

  155. 	if(!(t=_mm_malloc(len))) return NULL;
    156. 

  156. 	_mm_read_UBYTES(t,len,modreader);
    157. 

  157. 

  158. 	/* Check if the track is correct */
    159. 

  159. 	while(1) {
    160. 

  160. 		chunk=t[cur++];
    161. 

  161. 		if(!chunk) break;
    162. 

  162. 		chunk=(chunk&0x1f)-1;
    163. 

  163. 		while(chunk>0) {
    164. 

  164. 			int opcode,oplen;
    165. 

  165. 

  166. 			if(cur>=len) {
    167. 

  167. 				free(t);
    168. 

  168. 				return NULL;
    169. 

  169. 			}
    170. 

  170. 			opcode=t[cur];
    171. 

  171. 

  172. 			/* Remap opcodes */
    173. 

  173. 			if (universion <= 5) {
    174. 

  174. 				if (opcode > 29) {
    175. 

  175. 					free(t);
    176. 

  176. 					return NULL;
    177. 

  177. 				}
    178. 

  178. 				switch (opcode) {
    179. 

  179. 					/* UNI_NOTE .. UNI_S3MEFFECTQ are the same */
    180. 

  180. 					case 25:
    181. 

  181. 						opcode = UNI_S3MEFFECTT;
    182. 

  182. 						break;
    183. 

  183. 					case 26:
    184. 

  184. 						opcode = UNI_XMEFFECTA;
    185. 

  185. 						break;
    186. 

  186. 					case 27:
    187. 

  187. 						opcode = UNI_XMEFFECTG;
    188. 

  188. 						break;
    189. 

  189. 					case 28:
    190. 

  190. 						opcode = UNI_XMEFFECTH;
    191. 

  191. 						break;
    192. 

  192. 					case 29:
    193. 

  193. 						opcode = UNI_XMEFFECTP;
    194. 

  194. 						break;
    195. 

  195. 				}
    196. 

  196. 			} else {
    197. 

  197. 				/* APlayer < 1.05 does not have XMEFFECT6 */
    198. 

  198. 				if (opcode >= UNI_XMEFFECT6 && universion < 0x105)
    199. 

  199. 					opcode++;
    200. 

  200. 				/* APlayer < 1.03 does not have ITEFFECTT */
    201. 

  201. 				if (opcode >= UNI_ITEFFECTT && universion < 0x103)
    202. 

  202. 					opcode++;
    203. 

  203. 				/* APlayer < 1.02 does not have ITEFFECTZ */
    204. 

  204. 				if (opcode >= UNI_ITEFFECTZ && universion < 0x102)
    205. 

  205. 					opcode++;
    206. 

  206. 			}
    207. 

  207. 

  208. 			if((!opcode)||(opcode>=UNI_LAST)) {
    209. 

  209. 				free(t);
    210. 

  210. 				return NULL;
    211. 

  211. 			}
    212. 

  212. 			t[cur]=opcode;
    213. 

  213. 			oplen=unioperands[opcode]+1;
    214. 

  214. 			cur+=oplen;
    215. 

  215. 			chunk-=oplen;
    216. 

  216. 		}
    217. 

  217. 		if((chunk<0)||(cur>=len)) {
    218. 

  218. 			free(t);
    219. 

  219. 			return NULL;
    220. 

  220. 		}
    221. 

  221. 	}
    222. 

  222. 	return t;
    223. 

  223. }
    224. 

  224. 

  225. static BOOL loadsmp6(void)
    226. 

  226. {
    227. 

  227. 	int t;
    228. 

  228. 	SAMPLE *s;
    229. 

  229. 

  230. 	s=of.samples;
    231. 

  231. 	for(t=0;t<of.numsmp;t++,s++) {
    232. 

  232. 		int flags;
    233. 

  233. 

  234. 		flags         = _mm_read_M_UWORD(modreader);
    235. 

  235. 		s->flags=0;
    236. 

  236. 		if(flags&0x0004) s->flags|=SF_STEREO;
    237. 

  237. 		if(flags&0x0002) s->flags|=SF_SIGNED;
    238. 

  238. 		if(flags&0x0001) s->flags|=SF_16BITS;
    239. 

  239. 		/* convert flags */
    240. 

  240. 		if(universion>=0x104) {
    241. 

  241. 			if(flags&0x2000) s->flags|=SF_UST_LOOP;
    242. 

  242. 			if(flags&0x1000) s->flags|=SF_OWNPAN;
    243. 

  243. 			if(flags&0x0800) s->flags|=SF_SUSTAIN;
    244. 

  244. 			if(flags&0x0400) s->flags|=SF_REVERSE;
    245. 

  245. 			if(flags&0x0200) s->flags|=SF_BIDI;
    246. 

  246. 			if(flags&0x0100) s->flags|=SF_LOOP;
    247. 

  247. 			if(flags&0x0020) s->flags|=SF_ITPACKED;
    248. 

  248. 			if(flags&0x0010) s->flags|=SF_DELTA;
    249. 

  249. 			if(flags&0x0008) s->flags|=SF_BIG_ENDIAN;
    250. 

  250. 		} else if(universion>=0x102) {
    251. 

  251. 			if(flags&0x0800) s->flags|=SF_UST_LOOP;
    252. 

  252. 			if(flags&0x0400) s->flags|=SF_OWNPAN;
    253. 

  253. 			if(flags&0x0200) s->flags|=SF_SUSTAIN;
    254. 

  254. 			if(flags&0x0100) s->flags|=SF_REVERSE;
    255. 

  255. 			if(flags&0x0080) s->flags|=SF_BIDI;
    256. 

  256. 			if(flags&0x0040) s->flags|=SF_LOOP;
    257. 

  257. 			if(flags&0x0020) s->flags|=SF_ITPACKED;
    258. 

  258. 			if(flags&0x0010) s->flags|=SF_DELTA;
    259. 

  259. 			if(flags&0x0008) s->flags|=SF_BIG_ENDIAN;
    260. 

  260. 		} else {
    261. 

  261. 			if(flags&0x400) s->flags|=SF_UST_LOOP;
    262. 

  262. 			if(flags&0x200) s->flags|=SF_OWNPAN;
    263. 

  263. 			if(flags&0x100) s->flags|=SF_REVERSE;
    264. 

  264. 			if(flags&0x080) s->flags|=SF_SUSTAIN;
    265. 

  265. 			if(flags&0x040) s->flags|=SF_BIDI;
    266. 

  266. 			if(flags&0x020) s->flags|=SF_LOOP;
    267. 

  267. 			if(flags&0x010) s->flags|=SF_BIG_ENDIAN;
    268. 

  268. 			if(flags&0x008) s->flags|=SF_DELTA;
    269. 

  269. 		}
    270. 

  270. 

  271. 		s->speed      = _mm_read_M_ULONG(modreader);
    272. 

  272. 		s->volume     = _mm_read_UBYTE(modreader);
    273. 

  273. 		s->panning    = _mm_read_M_UWORD(modreader);
    274. 

  274. 		s->length     = _mm_read_M_ULONG(modreader);
    275. 

  275. 		s->loopstart  = _mm_read_M_ULONG(modreader);
    276. 

  276. 		s->loopend    = _mm_read_M_ULONG(modreader);
    277. 

  277. 		s->susbegin   = _mm_read_M_ULONG(modreader);
    278. 

  278. 		s->susend     = _mm_read_M_ULONG(modreader);
    279. 

  279. 		s->globvol    = _mm_read_UBYTE(modreader);
    280. 

  280. 		s->vibflags   = _mm_read_UBYTE(modreader);
    281. 

  281. 		s->vibtype    = _mm_read_UBYTE(modreader);
    282. 

  282. 		s->vibsweep   = _mm_read_UBYTE(modreader);
    283. 

  283. 		s->vibdepth   = _mm_read_UBYTE(modreader);
    284. 

  284. 		s->vibrate    = _mm_read_UBYTE(modreader);
    285. 

  285. 

  286. 		s->samplename=readstring();
    287. 

  287. 

  288. 		if(_mm_eof(modreader)) {
    289. 

  289. 			_mm_errno = MMERR_LOADING_SAMPLEINFO;
    290. 

  290. 			return 0;
    291. 

  291. 		}
    292. 

  292. 	}
    293. 

  293. 	return 1;
    294. 

  294. }
    295. 

  295. 

  296. static BOOL loadinstr6(void)
    297. 

  297. {
    298. 

  298. 	int t,w;
    299. 

  299. 	INSTRUMENT *i;
    300. 

  300. 

  301. 	i=of.instruments;
    302. 

  302. 	for(t=0;t<of.numins;t++,i++) {
    303. 

  303. 		i->flags        = _mm_read_UBYTE(modreader);
    304. 

  304. 		i->nnatype      = _mm_read_UBYTE(modreader);
    305. 

  305. 		i->dca          = _mm_read_UBYTE(modreader);
    306. 

  306. 		i->dct          = _mm_read_UBYTE(modreader);
    307. 

  307. 		i->globvol      = _mm_read_UBYTE(modreader);
    308. 

  308. 		i->panning      = _mm_read_M_UWORD(modreader);
    309. 

  309. 		i->pitpansep    = _mm_read_UBYTE(modreader);
    310. 

  310. 		i->pitpancenter = _mm_read_UBYTE(modreader);
    311. 

  311. 		i->rvolvar      = _mm_read_UBYTE(modreader);
    312. 

  312. 		i->rpanvar      = _mm_read_UBYTE(modreader);
    313. 

  313. 		i->volfade      = _mm_read_M_UWORD(modreader);
    314. 

  314. 

  315. #if defined __STDC__ || defined _MSC_VER
    316. 

  316. #define UNI_LoadEnvelope6(name) 										\
    317. 

  317. 		i-> name##flg=_mm_read_UBYTE(modreader);						\
    318. 

  318. 		i-> name##pts=_mm_read_UBYTE(modreader);						\
    319. 

  319. 		i-> name##susbeg=_mm_read_UBYTE(modreader);						\
    320. 

  320. 		i-> name##susend=_mm_read_UBYTE(modreader);						\
    321. 

  321. 		i-> name##beg=_mm_read_UBYTE(modreader);						\
    322. 

  322. 		i-> name##end=_mm_read_UBYTE(modreader);						\
    323. 

  323. 		for(w=0;w<(universion>=0x100?32:i-> name##pts);w++) {			\
    324. 

  324. 			i-> name##env[w].pos=_mm_read_M_SWORD(modreader);			\
    325. 

  325. 			i-> name##env[w].val=_mm_read_M_SWORD(modreader);			\
    326. 

  326. 		}
    327. 

  327. #else
    328. 

  328. #define UNI_LoadEnvelope6(name) 										\
    329. 

  329. 		i-> name/**/flg=_mm_read_UBYTE(modreader);						\
    330. 

  330. 		i-> name/**/pts=_mm_read_UBYTE(modreader);						\
    331. 

  331. 		i-> name/**/susbeg=_mm_read_UBYTE(modreader);					\
    332. 

  332. 		i-> name/**/susend=_mm_read_UBYTE(modreader);					\
    333. 

  333. 		i-> name/**/beg=_mm_read_UBYTE(modreader);						\
    334. 

  334. 		i-> name/**/end=_mm_read_UBYTE(modreader);						\
    335. 

  335. 		for (w=0;w<(universion>=0x100?32:i-> name/**/pts);w++) {		\
    336. 

  336. 			i-> name/**/env[w].pos=_mm_read_M_SWORD(modreader);			\
    337. 

  337. 			i-> name/**/env[w].val=_mm_read_M_SWORD(modreader);			\
    338. 

  338. 		}
    339. 

  339. #endif
    340. 

  340. 

  341. 		UNI_LoadEnvelope6(vol);
    342. 

  342. 		UNI_LoadEnvelope6(pan);
    343. 

  343. 		UNI_LoadEnvelope6(pit);
    344. 

  344. #undef UNI_LoadEnvelope6
    345. 

  345. 

  346. 		if(universion>=0x103)
    347. 

  347. 			_mm_read_M_UWORDS(i->samplenumber,120,modreader);
    348. 

  348. 		else
    349. 

  349. 			for(w=0;w<120;w++)
    350. 

  350. 				i->samplenumber[w]=_mm_read_UBYTE(modreader);
    351. 

  351. 		_mm_read_UBYTES(i->samplenote,120,modreader);
    352. 

  352. 

  353. 		i->insname=readstring();
    354. 

  354. 

  355. 		if(_mm_eof(modreader)) {
    356. 

  356. 			_mm_errno = MMERR_LOADING_SAMPLEINFO;
    357. 

  357. 			return 0;
    358. 

  358. 		}
    359. 

  359. 	}
    360. 

  360. 	return 1;
    361. 

  361. }
    362. 

  362. 

  363. static BOOL loadinstr5(void)
    364. 

  364. {
    365. 

  365. 	INSTRUMENT *i;
    366. 

  366. 	int t;
    367. 

  367. 	UWORD wavcnt=0;
    368. 

  368. 	UBYTE vibtype,vibsweep,vibdepth,vibrate;
    369. 

  369. 

  370. 	i=of.instruments;
    371. 

  371. 	for(of.numsmp=t=0;t<of.numins;t++,i++) {
    372. 

  372. 		int u,numsmp;
    373. 

  373. 

  374. 		numsmp=_mm_read_UBYTE(modreader);
    375. 

  375. 

  376. 		memset(i->samplenumber,0xff,INSTNOTES*sizeof(UWORD));
    377. 

  377. 		for(u=0;u<96;u++)
    378. 

  378. 			i->samplenumber[u]=of.numsmp+_mm_read_UBYTE(modreader);
    379. 

  379. 

  380. #if defined __STDC__ || defined _MSC_VER
    381. 

  381. #define UNI_LoadEnvelope5(name) 									\
    382. 

  382. 		i-> name##flg=_mm_read_UBYTE(modreader);					\
    383. 

  383. 		i-> name##pts=_mm_read_UBYTE(modreader);					\
    384. 

  384. 		i-> name##susbeg=_mm_read_UBYTE(modreader);					\
    385. 

  385. 		i-> name##susend=i-> name##susbeg;							\
    386. 

  386. 		i-> name##beg=_mm_read_UBYTE(modreader);					\
    387. 

  387. 		i-> name##end=_mm_read_UBYTE(modreader);					\
    388. 

  388. 		for(u=0;u<12;u++) {											\
    389. 

  389. 			i-> name##env[u].pos=_mm_read_I_SWORD(modreader);		\
    390. 

  390. 			i-> name##env[u].val=_mm_read_I_SWORD(modreader);		\
    391. 

  391. 		}
    392. 

  392. #else
    393. 

  393. #define UNI_LoadEnvelope5(name) 									\
    394. 

  394. 		i-> name/**/flg=_mm_read_UBYTE(modreader);					\
    395. 

  395. 		i-> name/**/pts=_mm_read_UBYTE(modreader);					\
    396. 

  396. 		i-> name/**/susbeg=_mm_read_UBYTE(modreader);				\
    397. 

  397. 		i-> name/**/susend=i-> name/**/susbeg;						\
    398. 

  398. 		i-> name/**/beg=_mm_read_UBYTE(modreader);					\
    399. 

  399. 		i-> name/**/end=_mm_read_UBYTE(modreader);					\
    400. 

  400. 		for(u=0;u<12;u++) {											\
    401. 

  401. 			i-> name/**/env[u].pos=_mm_read_I_SWORD(modreader);		\
    402. 

  402. 			i-> name/**/env[u].val=_mm_read_I_SWORD(modreader);		\
    403. 

  403. 		}
    404. 

  404. #endif
    405. 

  405. 

  406. 		UNI_LoadEnvelope5(vol);
    407. 

  407. 		UNI_LoadEnvelope5(pan);
    408. 

  408. #undef UNI_LoadEnvelope5
    409. 

  409. 

  410. 		vibtype      =_mm_read_UBYTE(modreader);
    411. 

  411. 		vibsweep     =_mm_read_UBYTE(modreader);
    412. 

  412. 		vibdepth     =_mm_read_UBYTE(modreader);
    413. 

  413. 		vibrate      =_mm_read_UBYTE(modreader);
    414. 

  414. 

  415. 		i->volfade=_mm_read_I_UWORD(modreader);
    416. 

  416. 		i->insname=readstring();
    417. 

  417. 

  418. 		for(u=0;u<numsmp;u++,s++,of.numsmp++) {
    419. 

  419. 			/* Allocate more room for sample information if necessary */
    420. 

  420. 			if(of.numsmp+u==wavcnt) {
    421. 

  421. 				wavcnt+=UNI_SMPINCR;
    422. 

  422. 				if(!(wh=realloc(wh,wavcnt*sizeof(UNISMP05)))) {
    423. 

  423. 					_mm_errno=MMERR_OUT_OF_MEMORY;
    424. 

  424. 					return 0;
    425. 

  425. 				}
    426. 

  426. 				s=wh+(wavcnt-UNI_SMPINCR);
    427. 

  427. 			}
    428. 

  428. 

  429. 			s->c2spd    =_mm_read_I_UWORD(modreader);
    430. 

  430. 			s->transpose=_mm_read_SBYTE(modreader);
    431. 

  431. 			s->volume   =_mm_read_UBYTE(modreader);
    432. 

  432. 			s->panning  =_mm_read_UBYTE(modreader);
    433. 

  433. 			s->length   =_mm_read_I_ULONG(modreader);
    434. 

  434. 			s->loopstart=_mm_read_I_ULONG(modreader);
    435. 

  435. 			s->loopend  =_mm_read_I_ULONG(modreader);
    436. 

  436. 			s->flags    =_mm_read_I_UWORD(modreader);
    437. 

  437. 			s->samplename=readstring();
    438. 

  438. 

  439. 			s->vibtype =vibtype;
    440. 

  440. 			s->vibsweep=vibsweep;
    441. 

  441. 			s->vibdepth=vibdepth;
    442. 

  442. 			s->vibrate =vibrate;
    443. 

  443. 

  444. 			if(_mm_eof(modreader)) {
    445. 

  445. 				free(wh);wh=NULL;
    446. 

  446. 				_mm_errno=MMERR_LOADING_SAMPLEINFO;
    447. 

  447. 				return 0;
    448. 

  448. 			}
    449. 

  449. 		}
    450. 

  450. 	}
    451. 

  451. 

  452. 	/* sanity check */
    453. 

  453. 	if(!of.numsmp) {
    454. 

  454. 		if(wh) { free(wh);wh=NULL; }
    455. 

  455. 		_mm_errno=MMERR_LOADING_SAMPLEINFO;
    456. 

  456. 		return 0;
    457. 

  457. 	}
    458. 

  458. 	return 1;
    459. 

  459. }
    460. 

  460. 

  461. static BOOL loadsmp5(void)
    462. 

  462. {
    463. 

  463. 	int t,u;
    464. 

  464. 	SAMPLE *q;
    465. 

  465. 	INSTRUMENT *d;
    466. 

  466. 

  467. 	q=of.samples;s=wh;
    468. 

  468. 	for(u=0;u<of.numsmp;u++,q++,s++) {
    469. 

  469. 		q->samplename=s->samplename;
    470. 

  470. 

  471. 		q->length   =s->length;
    472. 

  472. 		q->loopstart=s->loopstart;
    473. 

  473. 		q->loopend  =s->loopend;
    474. 

  474. 		q->volume   =s->volume;
    475. 

  475. 		q->speed    =s->c2spd;
    476. 

  476. 		q->panning  =s->panning;
    477. 

  477. 		q->vibtype  =s->vibtype;
    478. 

  478. 		q->vibsweep =s->vibsweep;
    479. 

  479. 		q->vibdepth =s->vibdepth;
    480. 

  480. 		q->vibrate  =s->vibrate;
    481. 

  481. 

  482. 		/* convert flags */
    483. 

  483. 		q->flags=0;
    484. 

  484. 		if(s->flags&128) q->flags|=SF_REVERSE;
    485. 

  485. 		if(s->flags& 64) q->flags|=SF_SUSTAIN;
    486. 

  486. 		if(s->flags& 32) q->flags|=SF_BIDI;
    487. 

  487. 		if(s->flags& 16) q->flags|=SF_LOOP;
    488. 

  488. 		if(s->flags&  8) q->flags|=SF_BIG_ENDIAN;
    489. 

  489. 		if(s->flags&  4) q->flags|=SF_DELTA;
    490. 

  490. 		if(s->flags&  2) q->flags|=SF_SIGNED;
    491. 

  491. 		if(s->flags&  1) q->flags|=SF_16BITS;
    492. 

  492. 	}
    493. 

  493. 

  494. 	d=of.instruments;s=wh;
    495. 

  495. 	for(u=0;u<of.numins;u++,d++)
    496. 

  496. 		for(t=0;t<INSTNOTES;t++)
    497. 

  497. 			d->samplenote[t]=(d->samplenumber[t]>=of.numsmp)?
    498. 

  498. 			  255:(t+s[d->samplenumber[t]].transpose);
    499. 

  499. 

  500. 	free(wh);wh=NULL;
    501. 

  501. 

  502. 	return 1;
    503. 

  503. }
    504. 

  504. 

  505. BOOL UNI_Load(BOOL curious)
    506. 

  506. {
    507. 

  507. 	int t;
    508. 

  508. 	char *modtype,*oldtype=NULL;
    509. 

  509. 	INSTRUMENT *d;
    510. 

  510. 	SAMPLE *q;
    511. 

  511. 	
    512. 

  512. 	/* read module header */
    513. 

  513. 	_mm_read_UBYTES(mh.id,4,modreader);
    514. 

  514. 	if(mh.id[3]!='N')
    515. 

  515. 		universion=mh.id[3]-'0';
    516. 

  516. 	else
    517. 

  517. 		universion=0x100;
    518. 

  518. 

  519. 	if(universion>=6) {
    520. 

  520. 		if (universion==6)
    521. 

  521. 			_mm_read_UBYTE(modreader);
    522. 

  522. 		else
    523. 

  523. 			universion=_mm_read_M_UWORD(modreader);
    524. 

  524. 

  525. 		mh.flags     =_mm_read_M_UWORD(modreader);
    526. 

  526. 		mh.numchn    =_mm_read_UBYTE(modreader);
    527. 

  527. 		mh.numvoices =_mm_read_UBYTE(modreader);
    528. 

  528. 		mh.numpos    =_mm_read_M_UWORD(modreader);
    529. 

  529. 		mh.numpat    =_mm_read_M_UWORD(modreader);
    530. 

  530. 		mh.numtrk    =_mm_read_M_UWORD(modreader);
    531. 

  531. 		mh.numins    =_mm_read_M_UWORD(modreader);
    532. 

  532. 		mh.numsmp    =_mm_read_M_UWORD(modreader);
    533. 

  533. 		mh.reppos    =_mm_read_M_UWORD(modreader);
    534. 

  534. 		mh.initspeed =_mm_read_UBYTE(modreader);
    535. 

  535. 		mh.inittempo =_mm_read_UBYTE(modreader);
    536. 

  536. 		mh.initvolume=_mm_read_UBYTE(modreader);
    537. 

  537. 		/* I expect this to show up soon in APlayer 1.06 format */
    538. 

  538. 		if (universion >= 0x106)
    539. 

  539. 			mh.bpmlimit=_mm_read_M_UWORD(modreader);
    540. 

  540. 		else
    541. 

  541. 			mh.bpmlimit=32;
    542. 

  542. 

  543. 		mh.flags &= UF_XMPERIODS | UF_LINEAR | UF_INST | UF_NNA;
    544. 

  544. 		mh.flags |= UF_PANNING;
    545. 

  545. 	} else {
    546. 

  546. 		mh.numchn    =_mm_read_UBYTE(modreader);
    547. 

  547. 		mh.numpos    =_mm_read_I_UWORD(modreader);
    548. 

  548. 		mh.reppos    =(universion==5)?_mm_read_I_UWORD(modreader):0;
    549. 

  549. 		mh.numpat    =_mm_read_I_UWORD(modreader);
    550. 

  550. 		mh.numtrk    =_mm_read_I_UWORD(modreader);
    551. 

  551. 		mh.numins    =_mm_read_I_UWORD(modreader);
    552. 

  552. 		mh.initspeed =_mm_read_UBYTE(modreader);
    553. 

  553. 		mh.inittempo =_mm_read_UBYTE(modreader);
    554. 

  554. 		_mm_read_UBYTES(mh.positions,256,modreader);
    555. 

  555. 		_mm_read_UBYTES(mh.panning,32,modreader);
    556. 

  556. 		mh.flags     =_mm_read_UBYTE(modreader);
    557. 

  557. 		mh.bpmlimit  =32;
    558. 

  558. 

  559. 		mh.flags &= UF_XMPERIODS | UF_LINEAR;
    560. 

  560. 		mh.flags |= UF_INST | UF_NOWRAP | UF_PANNING;
    561. 

  561. 	}
    562. 

  562. 	
    563. 

  563. 	/* set module parameters */
    564. 

  564. 	of.flags     =mh.flags;
    565. 

  565. 	of.numchn    =mh.numchn;
    566. 

  566. 	of.numpos    =mh.numpos;
    567. 

  567. 	of.numpat    =mh.numpat;
    568. 

  568. 	of.numtrk    =mh.numtrk;
    569. 

  569. 	of.numins    =mh.numins;
    570. 

  570. 	of.reppos    =mh.reppos;
    571. 

  571. 	of.initspeed =mh.initspeed;
    572. 

  572. 	of.inittempo =mh.inittempo;
    573. 

  573. 	if(mh.bpmlimit)
    574. 

  574. 		of.bpmlimit=mh.bpmlimit;
    575. 

  575. 	else
    576. 

  576. 		/* be bug-compatible with older releases */
    577. 

  577. 		of.bpmlimit=32;
    578. 

  578. 

  579. 	of.songname=readstring();
    580. 

  580. 	if(universion<0x102)
    581. 

  581. 		oldtype=readstring();
    582. 

  582. 	if(oldtype) {
    583. 

  583. 		int len=strlen(oldtype)+20;
    584. 

  584. 		if(!(modtype=_mm_malloc(len))) return 0;
    585. 

  585. #ifdef HAVE_SNPRINTF
    586. 

  586. 		snprintf(modtype,len,"%s (was %s)",(universion>=0x100)?"APlayer":"MikCvt2",oldtype);
    587. 

  587. #else
    588. 

  588. 		sprintf(modtype,"%s (was %s)",(universion>=0x100)?"APlayer":"MikCvt2",oldtype);
    589. 

  589. #endif
    590. 

  590. 	} else {
    591. 

  591. 		if(!(modtype=_mm_malloc(10))) return 0;
    592. 

  592. #ifdef HAVE_SNPRINTF
    593. 

  593. 		snprintf(modtype,10,"%s",(universion>=0x100)?"APlayer":"MikCvt3");
    594. 

  594. #else
    595. 

  595. 		sprintf(modtype,"%s",(universion>=0x100)?"APlayer":"MikCvt3");
    596. 

  596. #endif
    597. 

  597. 	}
    598. 

  598. 	of.modtype=strdup(modtype);
    599. 

  599. 	free(modtype);free(oldtype);
    600. 

  600. 	of.comment=readstring();
    601. 

  601. 

  602. 	if(universion>=6) {
    603. 

  603. 		of.numvoices=mh.numvoices;
    604. 

  604. 		of.initvolume=mh.initvolume;
    605. 

  605. 	}
    606. 

  606. 

  607. 	if(_mm_eof(modreader)) {
    608. 

  608. 		_mm_errno=MMERR_LOADING_HEADER;
    609. 

  609. 		return 0;
    610. 

  610. 	}
    611. 

  611. 

  612. 	/* positions */
    613. 

  613. 	if(!AllocPositions(of.numpos)) return 0;
    614. 

  614. 	if(universion>=6) {
    615. 

  615. 		if(universion>=0x100)
    616. 

  616. 			_mm_read_M_UWORDS(of.positions,of.numpos,modreader);
    617. 

  617. 		else
    618. 

  618. 			for(t=0;t<of.numpos;t++) of.positions[t]=_mm_read_UBYTE(modreader);
    619. 

  619. 		_mm_read_M_UWORDS(of.panning,of.numchn,modreader);
    620. 

  620. 		_mm_read_UBYTES(of.chanvol,of.numchn,modreader);
    621. 

  621. 	} else {
    622. 

  622. 		if((mh.numpos>256)||(mh.numchn>32)) {
    623. 

  623. 			_mm_errno=MMERR_LOADING_HEADER;
    624. 

  624. 			return 0;
    625. 

  625. 		}
    626. 

  626. 		for(t=0;t<of.numpos;t++) of.positions[t]=mh.positions[t];
    627. 

  627. 		for(t=0;t<of.numchn;t++) of.panning[t]=mh.panning[t];
    628. 

  628. 	}
    629. 

  629. 	/* convert the ``end of song'' pattern code if necessary */
    630. 

  630. 	if(universion<0x106)
    631. 

  631. 		for(t=0;t<of.numpos;t++)
    632. 

  632. 			if(of.positions[t]==255) of.positions[t]=LAST_PATTERN;
    633. 

  633. 

  634. 	/* instruments and samples */
    635. 

  635. 	if(universion>=6) {
    636. 

  636. 		of.numsmp=mh.numsmp;
    637. 

  637. 		if(!AllocSamples()) return 0;
    638. 

  638. 		if(!loadsmp6()) return 0;
    639. 

  639. 

  640. 		if(of.flags&UF_INST) {
    641. 

  641. 			if(!AllocInstruments()) return 0;
    642. 

  642. 			if(!loadinstr6()) return 0;
    643. 

  643. 		}
    644. 

  644. 	} else {
    645. 

  645. 		if(!AllocInstruments()) return 0;
    646. 

  646. 		if(!loadinstr5()) return 0;
    647. 

  647. 		if(!AllocSamples()) {
    648. 

  648. 			if(wh) { free(wh);wh=NULL; }
    649. 

  649. 			return 0;
    650. 

  650. 		}
    651. 

  651. 		if(!loadsmp5()) return 0;
    652. 

  652. 

  653. 		/* check if the original file had no instruments */
    654. 

  654. 		if(of.numsmp==of.numins) {
    655. 

  655. 			for(t=0,d=of.instruments;t<of.numins;t++,d++) {
    656. 

  656. 				int u;
    657. 

  657. 

  658. 				if((d->volpts)||(d->panpts)||(d->globvol!=64)) break;
    659. 

  659. 				for(u=0;u<96;u++)
    660. 

  660. 					if((d->samplenumber[u]!=t)||(d->samplenote[u]!=u)) break;
    661. 

  661. 				if(u!=96) break;
    662. 

  662. 			}
    663. 

  663. 			if(t==of.numins) {
    664. 

  664. 				of.flags&=~UF_INST;
    665. 

  665. 				of.flags&=~UF_NOWRAP;
    666. 

  666. 				for(t=0,d=of.instruments,q=of.samples;t<of.numins;t++,d++,q++) {
    667. 

  667. 					q->samplename=d->insname;
    668. 

  668. 					d->insname=NULL;
    669. 

  669. 				}
    670. 

  670. 			}
    671. 

  671. 		}
    672. 

  672. 	}
    673. 

  673. 

  674. 	/* patterns */
    675. 

  675. 	if(!AllocPatterns()) return 0;
    676. 

  676. 	if(universion>=6) {
    677. 

  677. 		_mm_read_M_UWORDS(of.pattrows,of.numpat,modreader);
    678. 

  678. 		_mm_read_M_UWORDS(of.patterns,of.numpat*of.numchn,modreader);
    679. 

  679. 	} else {
    680. 

  680. 		_mm_read_I_UWORDS(of.pattrows,of.numpat,modreader);
    681. 

  681. 		_mm_read_I_UWORDS(of.patterns,of.numpat*of.numchn,modreader);
    682. 

  682. 	}
    683. 

  683. 

  684. 	/* tracks */
    685. 

  685. 	if(!AllocTracks()) return 0;
    686. 

  686. 	for(t=0;t<of.numtrk;t++)
    687. 

  687. 		if(!(of.tracks[t]=readtrack())) {
    688. 

  688. 			_mm_errno=MMERR_LOADING_TRACK;
    689. 

  689. 			return 0;
    690. 

  690. 		}
    691. 

  691. 

  692. 	return 1;
    693. 

  693. }
    694. 

  694. 

  695. CHAR *UNI_LoadTitle(void)
    696. 

  696. {
    697. 

  697. 	UBYTE ver;
    698. 

  698. 	int posit[3]={304,306,26};
    699. 

  699. 

  700. 	_mm_fseek(modreader,3,SEEK_SET);
    701. 

  701. 	ver=_mm_read_UBYTE(modreader);
    702. 

  702. 	if(ver=='N') ver='6';
    703. 

  703. 

  704. 	_mm_fseek(modreader,posit[ver-'4'],SEEK_SET);
    705. 

  705. 	return readstring();
    706. 

  706. }
    707. 

  707. 

  708. /*========== Loader information */
    709. 

  709. 

  710. MIKMODAPI MLOADER load_uni={
    711. 

  711. 	NULL,
    712. 

  712. 	"UNI",
    713. 

  713. 	"APUN (APlayer) and UNI (MikMod)",
    714. 

  714. 	UNI_Init,
    715. 

  715. 	UNI_Test,
    716. 

  716. 	UNI_Load,
    717. 

  717. 	UNI_Cleanup,
    718. 

  718. 	UNI_LoadTitle
    719. 

  719. };
    720. 

  720. 

  721. #endif //USE_UNI_FORMAT
    722. 

  722. 

  723. /* ex:set ts=4: */
    724. 

  724.