PageRenderTime 54ms CodeModel.GetById 27ms RepoModel.GetById 0ms app.codeStats 0ms

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

https://github.com/gusax/plex
C | 744 lines | 614 code | 75 blank | 55 comment | 103 complexity | 53373a3f3abdead1059e4fa6bc3a769f MD5 | raw file
Possible License(s): Unlicense, AGPL-1.0, GPL-2.0, LGPL-2.1, GPL-3.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. 

    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. 

    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.   Imago Orpheus (IMF) module 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_IMF_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. /* module header */
    56. 

  56. typedef struct IMFHEADER {
    57. 

  57. 	CHAR  songname[32];
    58. 

  58. 	UWORD ordnum;
    59. 

  59. 	UWORD patnum;
    60. 

  60. 	UWORD insnum;
    61. 

  61. 	UWORD flags;
    62. 

  62. 	UBYTE initspeed;
    63. 

  63. 	UBYTE inittempo;
    64. 

  64. 	UBYTE mastervol;
    65. 

  65. 	UBYTE mastermult;
    66. 

  66. 	UBYTE orders[256];
    67. 

  67. } IMFHEADER;
    68. 

  68. 

  69. /* channel settings */
    70. 

  70. typedef struct IMFCHANNEL {
    71. 

  71. 	CHAR  name[12];
    72. 

  72. 	UBYTE chorus;
    73. 

  73. 	UBYTE reverb;
    74. 

  74. 	UBYTE pan;
    75. 

  75. 	UBYTE status;
    76. 

  76. } IMFCHANNEL;
    77. 

  77. 

  78. /* instrument header */
    79. 

  79. #define IMFNOTECNT (10*OCTAVE)
    80. 

  80. #define IMFENVCNT (16*2)
    81. 

  81. typedef struct IMFINSTHEADER {
    82. 

  82. 	CHAR  name[32];
    83. 

  83. 	UBYTE what[IMFNOTECNT];
    84. 

  84. 	UWORD volenv[IMFENVCNT];
    85. 

  85. 	UWORD panenv[IMFENVCNT];
    86. 

  86. 	UWORD pitenv[IMFENVCNT];
    87. 

  87. 	UBYTE volpts;
    88. 

  88. 	UBYTE volsus;
    89. 

  89. 	UBYTE volbeg;
    90. 

  90. 	UBYTE volend;
    91. 

  91. 	UBYTE volflg;
    92. 

  92. 	UBYTE panpts;
    93. 

  93. 	UBYTE pansus;
    94. 

  94. 	UBYTE panbeg;
    95. 

  95. 	UBYTE panend;
    96. 

  96. 	UBYTE panflg;
    97. 

  97. 	UBYTE pitpts;
    98. 

  98. 	UBYTE pitsus;
    99. 

  99. 	UBYTE pitbeg;
    100. 

  100. 	UBYTE pitend;
    101. 

  101. 	UBYTE pitflg;
    102. 

  102. 	UWORD volfade;
    103. 

  103. 	UWORD numsmp;
    104. 

  104. 	ULONG signature;
    105. 

  105. } IMFINSTHEADER;
    106. 

  106. 

  107. /* sample header */
    108. 

  108. typedef struct IMFWAVHEADER {
    109. 

  109. 	CHAR  samplename[13];
    110. 

  110. 	ULONG length;
    111. 

  111. 	ULONG loopstart;
    112. 

  112. 	ULONG loopend;
    113. 

  113. 	ULONG samplerate;
    114. 

  114. 	UBYTE volume;
    115. 

  115. 	UBYTE pan;
    116. 

  116. 	UBYTE flags;
    117. 

  117. } IMFWAVHEADER;
    118. 

  118. 

  119. typedef struct IMFNOTE {
    120. 

  120. 	UBYTE note,ins,eff1,dat1,eff2,dat2;
    121. 

  121. } IMFNOTE;
    122. 

  122. 

  123. /*========== Loader variables */
    124. 

  124. 

  125. static	CHAR IMF_Version[]="Imago Orpheus";
    126. 

  126. 

  127. static	IMFNOTE *imfpat=NULL;
    128. 

  128. static	IMFHEADER *mh=NULL;
    129. 

  129. 

  130. /*========== Loader code */
    131. 

  131. 

  132. BOOL IMF_Test(void)
    133. 

  133. {
    134. 

  134. 	UBYTE id[4];
    135. 

  135. 

  136. 	_mm_fseek(modreader,0x3c,SEEK_SET);
    137. 

  137. 	if(!_mm_read_UBYTES(id,4,modreader)) return 0;
    138. 

  138. 	if(!memcmp(id,"IM10",4)) return 1;
    139. 

  139. 	return 0;
    140. 

  140. }
    141. 

  141. 

  142. BOOL IMF_Init(void)
    143. 

  143. {
    144. 

  144. 	if(!(imfpat=(IMFNOTE*)_mm_malloc(32*256*sizeof(IMFNOTE)))) return 0;
    145. 

  145. 	if(!(mh=(IMFHEADER*)_mm_malloc(sizeof(IMFHEADER)))) return 0;
    146. 

  146. 

  147. 	return 1;
    148. 

  148. }
    149. 

  149. 

  150. void IMF_Cleanup(void)
    151. 

  151. {
    152. 

  152. 	FreeLinear();
    153. 

  153. 

  154. 	_mm_free(imfpat);
    155. 

  155. 	_mm_free(mh);
    156. 

  156. }
    157. 

  157. 

  158. static BOOL IMF_ReadPattern(SLONG size,UWORD rows)
    159. 

  159. {
    160. 

  160. 	int row=0,flag,ch;
    161. 

  161. 	IMFNOTE *n,dummy;
    162. 

  162. 

  163. 	/* clear pattern data */
    164. 

  164. 	memset(imfpat,255,32*256*sizeof(IMFNOTE));
    165. 

  165. 

  166. 	while((size>0)&&(row<rows)) {
    167. 

  167. 		flag=_mm_read_UBYTE(modreader);size--;
    168. 

  168. 

  169. 		if(_mm_eof(modreader)) {
    170. 

  170. 			_mm_errno=MMERR_LOADING_PATTERN;
    171. 

  171. 			return 0;
    172. 

  172. 		}
    173. 

  173. 

  174. 		if(flag) {
    175. 

  175. 			ch=remap[flag&31];
    176. 

  176. 

  177. 			if(ch!=-1)
    178. 

  178. 				n=&imfpat[256*ch+row];
    179. 

  179. 			else
    180. 

  180. 				n=&dummy;
    181. 

  181. 

  182. 			if(flag&32) {
    183. 

  183. 				n->note=_mm_read_UBYTE(modreader);
    184. 

  184. 				if(n->note>=0xa0) n->note=0xa0; /* note off */
    185. 

  185. 				n->ins =_mm_read_UBYTE(modreader);
    186. 

  186. 				size-=2;
    187. 

  187. 			}
    188. 

  188. 			if(flag&64) {
    189. 

  189. 				size-=2;
    190. 

  190. 				n->eff2=_mm_read_UBYTE(modreader);
    191. 

  191. 				n->dat2=_mm_read_UBYTE(modreader);
    192. 

  192. 			}
    193. 

  193. 			if(flag&128) {
    194. 

  194. 				n->eff1=_mm_read_UBYTE(modreader);
    195. 

  195. 				n->dat1=_mm_read_UBYTE(modreader);
    196. 

  196. 				size-=2;
    197. 

  197. 			}
    198. 

  198. 		} else row++;
    199. 

  199. 	}
    200. 

  200. 	if((size)||(row!=rows)) {
    201. 

  201. 		_mm_errno=MMERR_LOADING_PATTERN;
    202. 

  202. 		return 0;
    203. 

  203. 	}
    204. 

  204. 	return 1;
    205. 

  205. }
    206. 

  206. 

  207. static void IMF_ProcessCmd(UBYTE eff,UBYTE inf)
    208. 

  208. {
    209. 

  209. 	if((eff)&&(eff!=255))
    210. 

  210. 		switch (eff) {
    211. 

  211. 			case 0x01:	/* set tempo */
    212. 

  212. 				UniEffect(UNI_S3MEFFECTA,inf);
    213. 

  213. 				break;
    214. 

  214. 			case 0x02:	/* set BPM */
    215. 

  215. 				if(inf>=0x20) UniEffect(UNI_S3MEFFECTT,inf);
    216. 

  216. 				break;
    217. 

  217. 			case 0x03:	/* tone portamento */
    218. 

  218. 				UniEffect(UNI_ITEFFECTG,inf);
    219. 

  219. 				break;
    220. 

  220. 			case 0x04:	/* porta + volslide */
    221. 

  221. 				UniEffect(UNI_ITEFFECTG,inf);
    222. 

  222. 				UniEffect(UNI_S3MEFFECTD,0);
    223. 

  223. 				break;
    224. 

  224. 			case 0x05:	/* vibrato */
    225. 

  225. 				UniEffect(UNI_XMEFFECT4,inf);
    226. 

  226. 				break;
    227. 

  227. 			case 0x06:	/* vibrato + volslide */
    228. 

  228. 				UniEffect(UNI_XMEFFECT6,inf);
    229. 

  229. 				break;
    230. 

  230. 			case 0x07:	/* fine vibrato */
    231. 

  231. 				UniEffect(UNI_ITEFFECTU,inf);
    232. 

  232. 				break;
    233. 

  233. 			case 0x08:	/* tremolo */
    234. 

  234. 				UniEffect(UNI_S3MEFFECTR,inf);
    235. 

  235. 				break;
    236. 

  236. 			case 0x09:	/* arpeggio */
    237. 

  237. 				UniPTEffect(0x0,inf);
    238. 

  238. 				break;
    239. 

  239. 			case 0x0a:	/* panning */
    240. 

  240. 				UniPTEffect(0x8,(inf>=128)?255:(inf<<1));
    241. 

  241. 				break;
    242. 

  242. 			case 0x0b:	/* pan slide */
    243. 

  243. 				UniEffect(UNI_XMEFFECTP,inf);
    244. 

  244. 				break;
    245. 

  245. 			case 0x0c:	/* set channel volume */
    246. 

  246. 				if(inf<=64) UniPTEffect(0xc,inf);
    247. 

  247. 				break;
    248. 

  248. 			case 0x0d:	/* volume slide */
    249. 

  249. 				UniEffect(UNI_S3MEFFECTD,inf);
    250. 

  250. 				break;
    251. 

  251. 			case 0x0e:	/* fine volume slide */
    252. 

  252. 				if(inf) {
    253. 

  253. 					if(inf>>4)
    254. 

  254. 						UniEffect(UNI_S3MEFFECTD,0x0f|inf);
    255. 

  255. 					else
    256. 

  256. 						UniEffect(UNI_S3MEFFECTD,0xf0|inf);
    257. 

  257. 				} else
    258. 

  258. 					UniEffect(UNI_S3MEFFECTD,0);
    259. 

  259. 				break;
    260. 

  260. 			case 0x0f:	/* set finetune */
    261. 

  261. 				UniPTEffect(0xe,0x50|(inf>>4));
    262. 

  262. 				break;
    263. 

  263. #ifdef MIKMOD_DEBUG
    264. 

  264. 			case 0x10:	/* note slide up */
    265. 

  265. 			case 0x11:	/* not slide down */
    266. 

  266. 				fprintf(stderr,"\rIMF effect 0x10/0x11 (note slide)"
    267. 

  267. 				               " not implemented (eff=%2X inf=%2X)\n",eff,inf);
    268. 

  268. 				break;
    269. 

  269. #endif
    270. 

  270. 			case 0x12:	/* slide up */
    271. 

  271. 				UniEffect(UNI_S3MEFFECTF,inf);
    272. 

  272. 				break;
    273. 

  273. 			case 0x13:	/* slide down */
    274. 

  274. 				UniEffect(UNI_S3MEFFECTE,inf);
    275. 

  275. 				break;
    276. 

  276. 			case 0x14:	/* fine slide up */
    277. 

  277. 				if (inf) {
    278. 

  278. 					if (inf<0x40)
    279. 

  279. 						UniEffect(UNI_S3MEFFECTF,0xe0|(inf>>2));
    280. 

  280. 					else
    281. 

  281. 						UniEffect(UNI_S3MEFFECTF,0xf0|(inf>>4));
    282. 

  282. 				} else
    283. 

  283. 					UniEffect(UNI_S3MEFFECTF,0);
    284. 

  284. 				break;
    285. 

  285. 			case 0x15:	/* fine slide down */
    286. 

  286. 				if (inf) {
    287. 

  287. 					if (inf<0x40)
    288. 

  288. 						UniEffect(UNI_S3MEFFECTE,0xe0|(inf>>2));
    289. 

  289. 					else
    290. 

  290. 						UniEffect(UNI_S3MEFFECTE,0xf0|(inf>>4));
    291. 

  291. 				} else
    292. 

  292. 					UniEffect(UNI_S3MEFFECTE,0);
    293. 

  293. 				break;
    294. 

  294. 			/* 0x16 set filter cutoff (awe32) */
    295. 

  295. 			/* 0x17 filter side + resonance (awe32) */
    296. 

  296. 			case 0x18:	/* sample offset */
    297. 

  297. 				UniPTEffect(0x9,inf);
    298. 

  298. 				break;
    299. 

  299. #ifdef MIKMOD_DEBUG
    300. 

  300. 			case 0x19:	/* set fine sample offset */
    301. 

  301. 				fprintf(stderr,"\rIMF effect 0x19 (fine sample offset)"
    302. 

  302. 				               " not implemented (inf=%2X)\n",inf);
    303. 

  303. 				break;
    304. 

  304. #endif
    305. 

  305. 			case 0x1a:	/* keyoff */
    306. 

  306. 				UniWriteByte(UNI_KEYOFF);
    307. 

  307. 				break;
    308. 

  308. 			case 0x1b:	/* retrig */
    309. 

  309. 				UniEffect(UNI_S3MEFFECTQ,inf);
    310. 

  310. 				break;
    311. 

  311. 			case 0x1c:	/* tremor */
    312. 

  312. 				UniEffect(UNI_S3MEFFECTI,inf);
    313. 

  313. 				break;
    314. 

  314. 			case 0x1d:	/* position jump */
    315. 

  315. 				UniPTEffect(0xb,inf);
    316. 

  316. 				break;
    317. 

  317. 			case 0x1e:	/* pattern break */
    318. 

  318. 				UniPTEffect(0xd,(inf>>4)*10+(inf&0xf));
    319. 

  319. 				break;
    320. 

  320. 			case 0x1f:	/* set master volume */
    321. 

  321. 				if(inf<=64) UniEffect(UNI_XMEFFECTG,inf<<1);
    322. 

  322. 				break;
    323. 

  323. 			case 0x20:	/* master volume slide */
    324. 

  324. 				UniEffect(UNI_XMEFFECTH,inf);
    325. 

  325. 				break;
    326. 

  326. 			case 0x21:	/* extended effects */
    327. 

  327. 				switch(inf>>4) {
    328. 

  328. 					case 0x1:	/* set filter */
    329. 

  329. 					case 0x5:	/* vibrato waveform */
    330. 

  330. 					case 0x8:	/* tremolo waveform */
    331. 

  331. 						UniPTEffect(0xe,inf-0x10);
    332. 

  332. 						break;
    333. 

  333. 					case 0xa:	/* pattern loop */
    334. 

  334. 						UniPTEffect(0xe,0x60|(inf&0xf));
    335. 

  335. 						break;
    336. 

  336. 					case 0xb:	/* pattern delay */
    337. 

  337. 						UniPTEffect(0xe,0xe0|(inf&0xf));
    338. 

  338. 						break;
    339. 

  339. 					case 0x3:	/* glissando */
    340. 

  340. 					case 0xc:	/* note cut */
    341. 

  341. 					case 0xd:	/* note delay */
    342. 

  342. 					case 0xf:	/* invert loop */
    343. 

  343. 						UniPTEffect(0xe,inf);
    344. 

  344. 						break;
    345. 

  345. 					case 0xe:	/* ignore envelope */
    346. 

  346. 						UniEffect(UNI_ITEFFECTS0, 0x77);    /* vol */
    347. 

  347. 						UniEffect(UNI_ITEFFECTS0, 0x79);    /* pan */
    348. 

  348. 						UniEffect(UNI_ITEFFECTS0, 0x7b);    /* pit */
    349. 

  349. 						break;
    350. 

  350. 				}
    351. 

  351. 				break;
    352. 

  352. 			/* 0x22 chorus (awe32) */
    353. 

  353. 			/* 0x23 reverb (awe32) */
    354. 

  354. 		}
    355. 

  355. }
    356. 

  356. 

  357. static UBYTE* IMF_ConvertTrack(IMFNOTE* tr,UWORD rows)
    358. 

  358. {
    359. 

  359. 	int t;
    360. 

  360. 	UBYTE note,ins;
    361. 

  361. 

  362. 	UniReset();
    363. 

  363. 	for(t=0;t<rows;t++) {
    364. 

  364. 		note=tr[t].note;
    365. 

  365. 		ins=tr[t].ins;
    366. 

  366. 

  367. 		if((ins)&&(ins!=255)) UniInstrument(ins-1);
    368. 

  368. 		if(note!=255) {
    369. 

  369. 			if(note==0xa0) {
    370. 

  370. 				UniPTEffect(0xc,0); /* Note cut */
    371. 

  371. 				if(tr[t].eff1==0x0c) tr[t].eff1=0;
    372. 

  372. 				if(tr[t].eff2==0x0c) tr[t].eff2=0;
    373. 

  373. 			} else
    374. 

  374. 				UniNote(((note>>4)*OCTAVE)+(note&0xf));
    375. 

  375. 		}
    376. 

  376. 

  377. 		IMF_ProcessCmd(tr[t].eff1,tr[t].dat1);
    378. 

  378. 		IMF_ProcessCmd(tr[t].eff2,tr[t].dat2);
    379. 

  379. 		UniNewline();
    380. 

  380. 	}
    381. 

  381. 	return UniDup();
    382. 

  382. }
    383. 

  383. 

  384. BOOL IMF_Load(BOOL curious)
    385. 

  385. {
    386. 

  386. #define IMF_SMPINCR 64
    387. 

  387. 	int t,u,track=0,oldnumsmp;
    388. 

  388. 	IMFCHANNEL channels[32];
    389. 

  389. 	INSTRUMENT *d;
    390. 

  390. 	SAMPLE *q;
    391. 

  391. 	IMFWAVHEADER *wh=NULL,*s=NULL;
    392. 

  392. 	ULONG *nextwav=NULL;
    393. 

  393. 	UWORD wavcnt=0;
    394. 

  394. 	UBYTE id[4];
    395. 

  395. 

  396. 	/* try to read the module header */
    397. 

  397. 	_mm_read_string(mh->songname,32,modreader);
    398. 

  398. 	mh->ordnum=_mm_read_I_UWORD(modreader);
    399. 

  399. 	mh->patnum=_mm_read_I_UWORD(modreader);
    400. 

  400. 	mh->insnum=_mm_read_I_UWORD(modreader);
    401. 

  401. 	mh->flags =_mm_read_I_UWORD(modreader);
    402. 

  402. 	_mm_fseek(modreader,8,SEEK_CUR);
    403. 

  403. 	mh->initspeed =_mm_read_UBYTE(modreader);
    404. 

  404. 	mh->inittempo =_mm_read_UBYTE(modreader);
    405. 

  405. 	mh->mastervol =_mm_read_UBYTE(modreader);
    406. 

  406. 	mh->mastermult=_mm_read_UBYTE(modreader);
    407. 

  407. 	_mm_fseek(modreader,64,SEEK_SET);
    408. 

  408. 

  409. 	if(_mm_eof(modreader)) {
    410. 

  410. 		_mm_errno = MMERR_LOADING_HEADER;
    411. 

  411. 		return 0;
    412. 

  412. 	}
    413. 

  413. 

  414. 	/* set module variables */
    415. 

  415. 	of.songname=DupStr(mh->songname,31,1);
    416. 

  416. 	of.modtype=strdup(IMF_Version);
    417. 

  417. 	of.numpat=mh->patnum;
    418. 

  418. 	of.numins=mh->insnum;
    419. 

  419. 	of.reppos=0;
    420. 

  420. 	of.initspeed=mh->initspeed;
    421. 

  421. 	of.inittempo=mh->inittempo;
    422. 

  422. 	of.initvolume=mh->mastervol<<1;
    423. 

  423. 	of.flags |= UF_INST | UF_ARPMEM | UF_PANNING;
    424. 

  424. 	if(mh->flags&1) of.flags |= UF_LINEAR;
    425. 

  425. 	of.bpmlimit=32;
    426. 

  426. 

  427. 	/* read channel information */
    428. 

  428. 	of.numchn=0;
    429. 

  429. 	memset(remap,-1,32*sizeof(UBYTE));
    430. 

  430. 	for(t=0;t<32;t++) {
    431. 

  431. 		_mm_read_string(channels[t].name,12,modreader);
    432. 

  432. 		channels[t].chorus=_mm_read_UBYTE(modreader);
    433. 

  433. 		channels[t].reverb=_mm_read_UBYTE(modreader);
    434. 

  434. 		channels[t].pan   =_mm_read_UBYTE(modreader);
    435. 

  435. 		channels[t].status=_mm_read_UBYTE(modreader);
    436. 

  436. 	}
    437. 

  437. 	/* bug in Imago Orpheus ? If only channel 1 is enabled, in fact we have to
    438. 

  438. 	   enable 16 channels */
    439. 

  439. 	if(!channels[0].status) {
    440. 

  440. 		for(t=1;t<16;t++) if(channels[t].status!=1) break;
    441. 

  441. 		if(t==16) for(t=1;t<16;t++) channels[t].status=0;
    442. 

  442. 	}
    443. 

  443. 	for(t=0;t<32;t++) {
    444. 

  444. 		if(channels[t].status!=2)
    445. 

  445. 			remap[t]=of.numchn++;
    446. 

  446. 		else
    447. 

  447. 			remap[t]=-1;
    448. 

  448. 	}
    449. 

  449. 	for(t=0;t<32;t++)
    450. 

  450. 		if(remap[t]!=-1) {
    451. 

  451. 			of.panning[remap[t]]=channels[t].pan;
    452. 

  452. 			of.chanvol[remap[t]]=channels[t].status?0:64;
    453. 

  453. 		}
    454. 

  454. 

  455. 	if(_mm_eof(modreader)) {
    456. 

  456. 		_mm_errno = MMERR_LOADING_HEADER;
    457. 

  457. 		return 0;
    458. 

  458. 	}
    459. 

  459. 

  460. 	/* read order list */
    461. 

  461. 	_mm_read_UBYTES(mh->orders,256,modreader);
    462. 

  462. 	if(_mm_eof(modreader)) {
    463. 

  463. 		_mm_errno = MMERR_LOADING_HEADER;
    464. 

  464. 		return 0;
    465. 

  465. 	}
    466. 

  466. 

  467. 	of.numpos=0;
    468. 

  468. 	for(t=0;t<mh->ordnum;t++)
    469. 

  469. 		if(mh->orders[t]!=0xff) of.numpos++;
    470. 

  470. 	if(!AllocPositions(of.numpos)) return 0;
    471. 

  471. 	for(t=u=0;t<mh->ordnum;t++)
    472. 

  472. 		if(mh->orders[t]!=0xff) of.positions[u++]=mh->orders[t];
    473. 

  473. 

  474. 	/* load pattern info */
    475. 

  475. 	of.numtrk=of.numpat*of.numchn;
    476. 

  476. 	if(!AllocTracks()) return 0;
    477. 

  477. 	if(!AllocPatterns()) return 0;
    478. 

  478. 

  479. 	for(t=0;t<of.numpat;t++) {
    480. 

  480. 		SLONG size;
    481. 

  481. 		UWORD rows;
    482. 

  482. 

  483. 		size=(SLONG)_mm_read_I_UWORD(modreader);
    484. 

  484. 		rows=_mm_read_I_UWORD(modreader);
    485. 

  485. 		if((rows>256)||(size<4)) {
    486. 

  486. 			_mm_errno=MMERR_LOADING_PATTERN;
    487. 

  487. 			return 0;
    488. 

  488. 		}
    489. 

  489. 

  490. 		of.pattrows[t]=rows;
    491. 

  491. 		if(!IMF_ReadPattern(size-4,rows)) return 0;
    492. 

  492. 		for(u=0;u<of.numchn;u++)
    493. 

  493. 			if(!(of.tracks[track++]=IMF_ConvertTrack(&imfpat[u*256],rows)))
    494. 

  494. 				return 0;
    495. 

  495. 	}
    496. 

  496. 

  497. 	/* load instruments */
    498. 

  498. 	if(!AllocInstruments()) return 0;
    499. 

  499. 	d=of.instruments;
    500. 

  500. 

  501. 	for(oldnumsmp=t=0;t<of.numins;t++) {
    502. 

  502. 		IMFINSTHEADER ih;
    503. 

  503. 

  504. 		memset(d->samplenumber,0xff,INSTNOTES*sizeof(UWORD));
    505. 

  505. 

  506. 		/* read instrument header */
    507. 

  507. 		_mm_read_string(ih.name,32,modreader);
    508. 

  508. 		d->insname=DupStr(ih.name,31,1);
    509. 

  509. 		_mm_read_UBYTES(ih.what,IMFNOTECNT,modreader);
    510. 

  510. 		_mm_fseek(modreader,8,SEEK_CUR);
    511. 

  511. 		_mm_read_I_UWORDS(ih.volenv,IMFENVCNT,modreader);
    512. 

  512. 		_mm_read_I_UWORDS(ih.panenv,IMFENVCNT,modreader);
    513. 

  513. 		_mm_read_I_UWORDS(ih.pitenv,IMFENVCNT,modreader);
    514. 

  514. 

  515. #if defined __STDC__ || defined _MSC_VER
    516. 

  516. #define IMF_FinishLoadingEnvelope(name)					\
    517. 

  517. 		ih. name##pts=_mm_read_UBYTE(modreader);		\
    518. 

  518. 		ih. name##sus=_mm_read_UBYTE(modreader);		\
    519. 

  519. 		ih. name##beg=_mm_read_UBYTE(modreader);		\
    520. 

  520. 		ih. name##end=_mm_read_UBYTE(modreader);		\
    521. 

  521. 		ih. name##flg=_mm_read_UBYTE(modreader);		\
    522. 

  522. 		_mm_read_UBYTE(modreader);						\
    523. 

  523. 		_mm_read_UBYTE(modreader);						\
    524. 

  524. 		_mm_read_UBYTE(modreader)
    525. 

  525. #else
    526. 

  526. #define IMF_FinishLoadingEnvelope(name)				\
    527. 

  527. 		ih. name/**/pts=_mm_read_UBYTE(modreader);	\
    528. 

  528. 		ih. name/**/sus=_mm_read_UBYTE(modreader);	\
    529. 

  529. 		ih. name/**/beg=_mm_read_UBYTE(modreader);	\
    530. 

  530. 		ih. name/**/end=_mm_read_UBYTE(modreader);	\
    531. 

  531. 		ih. name/**/flg=_mm_read_UBYTE(modreader);	\
    532. 

  532. 		_mm_read_UBYTE(modreader);					\
    533. 

  533. 		_mm_read_UBYTE(modreader);					\
    534. 

  534. 		_mm_read_UBYTE(modreader)
    535. 

  535. #endif
    536. 

  536. 

  537. 		IMF_FinishLoadingEnvelope(vol);
    538. 

  538. 		IMF_FinishLoadingEnvelope(pan);
    539. 

  539. 		IMF_FinishLoadingEnvelope(pit);
    540. 

  540. 

  541. 		ih.volfade=_mm_read_I_UWORD(modreader);
    542. 

  542. 		ih.numsmp =_mm_read_I_UWORD(modreader);
    543. 

  543. 

  544. 		_mm_read_UBYTES(id,4,modreader);
    545. 

  545. 		/* Looks like Imago Orpheus forgets the signature for empty
    546. 

  546. 		   instruments following a multi-sample instrument... */
    547. 

  547. 		if(memcmp(id,"II10",4) && 
    548. 

  548. 		   (oldnumsmp && memcmp(id,"\x0\x0\x0\x0",4))) {
    549. 

  549. 			if(nextwav) free(nextwav);
    550. 

  550. 			if(wh) free(wh);
    551. 

  551. 			_mm_errno=MMERR_LOADING_SAMPLEINFO;
    552. 

  552. 			return 0;
    553. 

  553. 		}
    554. 

  554. 		oldnumsmp=ih.numsmp;
    555. 

  555. 

  556. 		if((ih.numsmp>16)||(ih.volpts>IMFENVCNT/2)||(ih.panpts>IMFENVCNT/2)||
    557. 

  557. 		   (ih.pitpts>IMFENVCNT/2)||(_mm_eof(modreader))) {
    558. 

  558. 			if(nextwav) free(nextwav);
    559. 

  559. 			if(wh) free(wh);
    560. 

  560. 			_mm_errno=MMERR_LOADING_SAMPLEINFO;
    561. 

  561. 			return 0;
    562. 

  562. 		}
    563. 

  563. 

  564. 		for(u=0;u<IMFNOTECNT;u++)
    565. 

  565. 			d->samplenumber[u]=ih.what[u]>ih.numsmp?0xffff:ih.what[u]+of.numsmp;
    566. 

  566. 		d->volfade=ih.volfade;
    567. 

  567. 

  568. #if defined __STDC__ || defined _MSC_VER
    569. 

  569. #define IMF_ProcessEnvelope(name) 									\
    570. 

  570. 		for (u = 0; u < (IMFENVCNT >> 1); u++) {					\
    571. 

  571. 			d-> name##env[u].pos = ih. name##env[u << 1];			\
    572. 

  572. 			d-> name##env[u].val = ih. name##env[(u << 1)+ 1];		\
    573. 

  573. 		}															\
    574. 

  574. 		if (ih. name##flg&1) d-> name##flg|=EF_ON;					\
    575. 

  575. 		if (ih. name##flg&2) d-> name##flg|=EF_SUSTAIN;				\
    576. 

  576. 		if (ih. name##flg&4) d-> name##flg|=EF_LOOP;				\
    577. 

  577. 		d-> name##susbeg=d-> name##susend=ih. name##sus;			\
    578. 

  578. 		d-> name##beg=ih. name##beg;								\
    579. 

  579. 		d-> name##end=ih. name##end;								\
    580. 

  580. 		d-> name##pts=ih. name##pts;								\
    581. 

  581. 																	\
    582. 

  582. 		if ((d-> name##flg&EF_ON)&&(d-> name##pts<2))				\
    583. 

  583. 			d-> name##flg&=~EF_ON
    584. 

  584. #else
    585. 

  585. #define IMF_ProcessEnvelope(name) 									\
    586. 

  586. 		for (u = 0; u < (IMFENVCNT >> 1); u++) {					\
    587. 

  587. 			d-> name/**/env[u].pos = ih. name/**/env[u << 1];		\
    588. 

  588. 			d-> name/**/env[u].val = ih. name/**/env[(u << 1)+ 1];	\
    589. 

  589. 		}															\
    590. 

  590. 		if (ih. name/**/flg&1) d-> name/**/flg|=EF_ON;				\
    591. 

  591. 		if (ih. name/**/flg&2) d-> name/**/flg|=EF_SUSTAIN;			\
    592. 

  592. 		if (ih. name/**/flg&4) d-> name/**/flg|=EF_LOOP;			\
    593. 

  593. 		d-> name/**/susbeg=d-> name/**/susend=ih. name/**/sus;		\
    594. 

  594. 		d-> name/**/beg=ih. name/**/beg;							\
    595. 

  595. 		d-> name/**/end=ih. name/**/end;							\
    596. 

  596. 		d-> name/**/pts=ih. name/**/pts;							\
    597. 

  597. 																	\
    598. 

  598. 		if ((d-> name/**/flg&EF_ON)&&(d-> name/**/pts<2))			\
    599. 

  599. 			d-> name/**/flg&=~EF_ON
    600. 

  600. #endif
    601. 

  601. 

  602. 		IMF_ProcessEnvelope(vol);
    603. 

  603. 		IMF_ProcessEnvelope(pan);
    604. 

  604. 		IMF_ProcessEnvelope(pit);
    605. 

  605. #undef IMF_ProcessEnvelope
    606. 

  606. 

  607. 		if(ih.pitflg&1) {
    608. 

  608. 			d->pitflg&=~EF_ON;
    609. 

  609. #ifdef MIKMOD_DEBUG
    610. 

  610. 			fprintf(stderr, "\rFilter envelopes not supported yet\n");
    611. 

  611. #endif
    612. 

  612. 		}
    613. 

  613. 

  614. 		/* gather sample information */
    615. 

  615. 		for(u=0;u<ih.numsmp;u++,s++) {
    616. 

  616. 			/* allocate more room for sample information if necessary */
    617. 

  617. 			if(of.numsmp+u==wavcnt) {
    618. 

  618. 				wavcnt+=IMF_SMPINCR;
    619. 

  619. 				if(!(nextwav=realloc(nextwav,wavcnt*sizeof(ULONG)))) {
    620. 

  620. 					if(wh) free(wh);
    621. 

  621. 					_mm_errno=MMERR_OUT_OF_MEMORY;
    622. 

  622. 					return 0;
    623. 

  623. 				}
    624. 

  624. 				if(!(wh=realloc(wh,wavcnt*sizeof(IMFWAVHEADER)))) {
    625. 

  625. 					free(nextwav);
    626. 

  626. 					_mm_errno=MMERR_OUT_OF_MEMORY;
    627. 

  627. 					return 0;
    628. 

  628. 				}
    629. 

  629. 				s=wh+(wavcnt-IMF_SMPINCR);
    630. 

  630. 			}
    631. 

  631. 

  632. 			_mm_read_string(s->samplename,13,modreader);
    633. 

  633. 			_mm_read_UBYTE(modreader);_mm_read_UBYTE(modreader);_mm_read_UBYTE(modreader);
    634. 

  634. 			s->length    =_mm_read_I_ULONG(modreader);
    635. 

  635. 			s->loopstart =_mm_read_I_ULONG(modreader);
    636. 

  636. 			s->loopend   =_mm_read_I_ULONG(modreader);
    637. 

  637. 			s->samplerate=_mm_read_I_ULONG(modreader);
    638. 

  638. 			s->volume    =_mm_read_UBYTE(modreader)&0x7f;
    639. 

  639. 			s->pan       =_mm_read_UBYTE(modreader);
    640. 

  640. 			_mm_fseek(modreader,14,SEEK_CUR);
    641. 

  641. 			s->flags     =_mm_read_UBYTE(modreader);
    642. 

  642. 			_mm_fseek(modreader,11,SEEK_CUR);
    643. 

  643. 			_mm_read_UBYTES(id,4,modreader);
    644. 

  644. 			if(((memcmp(id,"IS10",4))&&(memcmp(id,"IW10",4)))||
    645. 

  645. 			   (_mm_eof(modreader))) {
    646. 

  646. 				free(nextwav);free(wh);
    647. 

  647. 				_mm_errno=MMERR_LOADING_SAMPLEINFO;
    648. 

  648. 				return 0;
    649. 

  649. 			}
    650. 

  650. 			nextwav[of.numsmp+u]=_mm_ftell(modreader);
    651. 

  651. 			_mm_fseek(modreader,s->length,SEEK_CUR);
    652. 

  652. 		}
    653. 

  653. 

  654. 		of.numsmp+=ih.numsmp;
    655. 

  655. 		d++;
    656. 

  656. 	}
    657. 

  657. 

  658. 	/* sanity check */
    659. 

  659. 	if(!of.numsmp) {
    660. 

  660. 		if(nextwav) free(nextwav);
    661. 

  661. 		if(wh) free(wh);
    662. 

  662. 		_mm_errno=MMERR_LOADING_SAMPLEINFO;
    663. 

  663. 		return 0;
    664. 

  664. 	}
    665. 

  665. 

  666. 	/* load samples */
    667. 

  667. 	if(!AllocSamples()) {
    668. 

  668. 		free(nextwav);free(wh);
    669. 

  669. 		return 0;
    670. 

  670. 	}
    671. 

  671. 	if(!AllocLinear()) {
    672. 

  672. 		free(nextwav);free(wh);
    673. 

  673. 		return 0;
    674. 

  674. 	}
    675. 

  675. 	q=of.samples;
    676. 

  676. 	s=wh;
    677. 

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

  678. 		q->samplename=DupStr(s->samplename,12,1);
    679. 

  679. 		q->length   =s->length;
    680. 

  680. 		q->loopstart=s->loopstart;
    681. 

  681. 		q->loopend  =s->loopend;
    682. 

  682. 		q->volume   =s->volume;
    683. 

  683. 		q->speed    =s->samplerate;
    684. 

  684. 		if(of.flags&UF_LINEAR)
    685. 

  685. 			q->speed=speed_to_finetune(s->samplerate<<1,u);
    686. 

  686. 		q->panning  =s->pan;
    687. 

  687. 		q->seekpos  =nextwav[u];
    688. 

  688. 

  689. 		q->flags|=SF_SIGNED;
    690. 

  690. 		if(s->flags&0x1) q->flags|=SF_LOOP;
    691. 

  691. 		if(s->flags&0x2) q->flags|=SF_BIDI;
    692. 

  692. 		if(s->flags&0x8) q->flags|=SF_OWNPAN;
    693. 

  693. 		if(s->flags&0x4) {
    694. 

  694. 			q->flags|=SF_16BITS;
    695. 

  695. 			q->length   >>=1;
    696. 

  696. 			q->loopstart>>=1;
    697. 

  697. 			q->loopend  >>=1;
    698. 

  698. 		}
    699. 

  699. 	}
    700. 

  700. 

  701. 	d=of.instruments;
    702. 

  702. 	s=wh;
    703. 

  703. 	for(u=0;u<of.numins;u++,d++) {
    704. 

  704. 		for(t=0;t<IMFNOTECNT;t++) {
    705. 

  705. 			if(d->samplenumber[t]>=of.numsmp)
    706. 

  706. 				d->samplenote[t]=255;
    707. 

  707. 			else if (of.flags&UF_LINEAR) {
    708. 

  708. 				int note=(int)d->samplenote[u]+noteindex[d->samplenumber[u]];
    709. 

  709. 				d->samplenote[u]=(note<0)?0:(note>255?255:note);
    710. 

  710. 			} else
    711. 

  711. 				d->samplenote[t]=t;
    712. 

  712. 		}
    713. 

  713. 	}
    714. 

  714. 

  715. 	free(wh);free(nextwav);
    716. 

  716. 	return 1;
    717. 

  717. }
    718. 

  718. 

  719. CHAR *IMF_LoadTitle(void)
    720. 

  720. {
    721. 

  721. 	CHAR s[31];
    722. 

  722. 

  723. 	_mm_fseek(modreader,0,SEEK_SET);
    724. 

  724. 	if(!_mm_read_UBYTES(s,31,modreader)) return NULL;
    725. 

  725. 

  726. 	return(DupStr(s,31,1));
    727. 

  727. }
    728. 

  728. 

  729. /*========== Loader information */
    730. 

  730. 

  731. MIKMODAPI MLOADER load_imf={
    732. 

  732. 	NULL,
    733. 

  733. 	"IMF",
    734. 

  734. 	"IMF (Imago Orpheus)",
    735. 

  735. 	IMF_Init,
    736. 

  736. 	IMF_Test,
    737. 

  737. 	IMF_Load,
    738. 

  738. 	IMF_Cleanup,
    739. 

  739. 	IMF_LoadTitle
    740. 

  740. };
    741. 

  741. 

  742. #endif //USE_IMF_FORMAT
    743. 

  743. 

  744. /* ex:set ts=4: */
    745. 

  745.