fork download
copy 
  1. // Mucom88 -> Midi Converter
  2. // -------------------------
  3. // Written by Valley Bell, 09 March 2015
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <math.h>
  8. #include <memory.h>
  9. #ifndef __CST_STDTYPE_H__
  10. #define __CST_STDTYPE_H__
  11.  
  12. #ifdef HAVE_STDINT
  13.  
  14. #include <stdint.h>
  15.  
  16. typedef uint8_t	UINT8;
  17. typedef  int8_t	 INT8;
  18. typedef uint16_t	UINT16;
  19. typedef  int16_t	 INT16;
  20. typedef uint32_t	UINT32;
  21. typedef  int32_t	 INT32;
  22. typedef uint64_t	UINT64;
  23. typedef  int64_t	 INT64;
  24.  
  25. #else	// ! HAVE_STDINT
  26.  
  27. // typedefs to use MAME's (U)INTxx types (copied from MAME\src\ods\odscomm.h)
  28. // 8-bit values
  29. typedef unsigned char		UINT8;
  30. typedef   signed char 		 INT8;
  31.  
  32. // 16-bit values
  33. typedef unsigned short		UINT16;
  34. typedef   signed short		 INT16;
  35.  
  36. // 32-bit values
  37. #ifndef _WINDOWS_H
  38. typedef unsigned int		UINT32;
  39. typedef   signed int		 INT32;
  40.  
  41. // 64-bit values
  42. #ifdef _MSC_VER
  43. typedef unsigned __int64	UINT64;
  44. typedef   signed __int64	 INT64;
  45. #else
  46. __extension__ typedef unsigned long long	UINT64;
  47. __extension__ typedef   signed long long	 INT64;
  48. #endif
  49. #endif	// _WINDOWS_H
  50.  
  51. #endif	// HAVE_STDINT
  52.  
  53. #endif	// __CST_STDTYPE_H__
  54.  
  55. #define INLINE	static __inline
  56.  
  57. int main(int argc, char* argv[]);
  58. void ConvertMucom2MID(void);
  59. INLINE UINT8 MucomVol2Mid(UINT8 TrkMode, UINT8 Vol, UINT8 PanBoost);
  60. INLINE double FMVol2DB(UINT8 Vol);
  61. INLINE double PSGVol2DB(UINT8 Vol);
  62. INLINE double DeltaTVol2DB(UINT8 Vol);
  63. INLINE UINT8 DB2Mid(double DB);
  64. INLINE UINT32 Tempo2Mid(UINT8 TempoVal);
  65.  
  66. static void WriteEvent(UINT8* Buffer, UINT32* Pos, UINT32* Delay, UINT8 Evt, UINT8 Val1, UINT8 Val2);
  67. static void WriteMidiValue(UINT8* Buffer, UINT32* Pos, UINT32 Value);
  68. INLINE UINT16 ReadLE16(const UINT8* Data);
  69. INLINE void WriteBE16(UINT8* Buffer, UINT16 Value);
  70. INLINE void WriteBE32(UINT8* Buffer, UINT32 Value);
  71.  
  72.  
  73. #define USE_VELOCITY	1
  74. #define NO_NOTESTOP		0
  75.  
  76. static UINT32 SeqSize;
  77. static UINT8* SeqData;
  78. static UINT32 MidSize;
  79. static UINT8* MidData;
  80.  
  81. static UINT16 MIDI_RES;
  82. static UINT16 NUM_LOOPS;
  83.  
  84. int main(int argc, char* argv[])
  85. {
  86. 	FILE* hFile;
  87. 	//char FileName[0x10];
  88.  
  89. 	if (argc <= 2)
  90. 	{
  91. 		printf("Usage: mucom2mid input.bin output.mid\n");
  92. #ifdef _DEBUG
  93. 		_getch();
  94. #endif
  95. 		return 0;
  96. 	}
  97.  
  98. 	MIDI_RES = 24;
  99. 	//MIDI_RES = 0x20;
  100. 	NUM_LOOPS = 2;
  101.  
  102. 	hFile = fopen(argv[1], "rb");
  103. 	if (hFile == NULL)
  104. 		return 1;
  105.  
  106. 	fseek(hFile, 0, SEEK_END);
  107. 	SeqSize = ftell(hFile);
  108.  
  109. 	SeqData = (UINT8*)malloc(SeqSize);
  110. 	fseek(hFile, 0, SEEK_SET);
  111. 	fread(SeqData, 0x01, SeqSize, hFile);
  112.  
  113. 	fclose(hFile);
  114.  
  115. 	printf("Converting %s ...\n", argv[1]);
  116. 	MidSize = 0x20000;
  117. 	MidData = (UINT8*)malloc(MidSize);
  118. 	ConvertMucom2MID();
  119.  
  120. 	hFile = fopen(argv[2], "wb");
  121. 	if (hFile == NULL)
  122. 	{
  123. 		printf("Error saving %s!\n", argv[2]);
  124. 	}
  125. 	else
  126. 	{
  127. 		fwrite(MidData, 0x01, MidSize, hFile);
  128. 		fclose(hFile);
  129. 	}
  130. 	free(MidData);
  131. 	MidData = NULL;
  132. 	free(SeqData);
  133. 	SeqData = NULL;
  134.  
  135. 	printf("Done.\n");
  136.  
  137. #ifdef _DEBUG
  138. 	getchar();
  139. #endif
  140.  
  141. 	return 0;
  142. }
  143.  
  144. typedef struct _track_header
  145. {
  146. 	UINT16 StartOfs;
  147. 	UINT16 LoopOfs;
  148. } TRK_HDR;
  149. #define SEQ_BASEOFS	0x0005
  150.  
  151. void ConvertMucom2MID(void)
  152. {
  153. 	static const UINT8 NOTE_ARRAY[0x10] =
  154. 	    //	00  01  02  03  04  05  06  07  08  09  0A  0B  0C  0D  0E  0F
  155. 	    //	C   C#  D   D#  E   --  F   F#  G   G#  A   A#  B   --  --  --
  156. 	{	 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,255,255,255,255};
  157. 	static const UINT8 RHYTHM_NOTES[0x06] =
  158. 	{0x24, 0x26, 0x33, 0x2A, 0x2D, 0x25};
  159. 	UINT8 Mucom88Win;
  160. 	UINT16 SeqSize;
  161. 	UINT16 TrkHdrPos;
  162. 	UINT16 FMInsPos;
  163. 	UINT16 SSGInsPos;
  164. 	TRK_HDR TrkHdrs[11];
  165. 	UINT16 SeqPos;
  166. 	UINT32 MidPos;
  167. 	UINT8 TrkCnt;
  168. 	UINT8 CurTrk;
  169. 	UINT32 MidTrkBase;
  170. 	UINT32 CurDly;
  171. 	UINT8 MidChn;
  172. 	UINT8 TrkEnd;
  173. 	UINT8 MstLoopCnt;
  174. 	UINT8 TrkMode;	// 00 - FM, 01 - SSG
  175. 	INT8 NoteMove;
  176.  
  177. 	UINT8 CurCmd;
  178.  
  179. 	UINT8 CurNote;
  180. 	UINT8 CurNoteVol;
  181. 	UINT8 CurChnVol;
  182. 	UINT8 ChnPanOn;
  183. 	UINT8 LastNote;
  184. 	UINT8 HoldNote;
  185. 	UINT8 NoteStop;
  186. 	UINT8 CurRhythmMask;
  187. 	UINT8 CurRhythmOn;
  188.  
  189. 	UINT8 LoopIdx;
  190. 	UINT8 LoopStkIdx;
  191. 	UINT8 LoopCnt[0x10];
  192.  
  193. 	UINT8 TempByt;
  194. 	INT16 TempPos;
  195. 	UINT32 TempLng;
  196.  
  197. 	TrkHdrPos = 0x0000;
  198. 	if (!memcmp(SeqData, "MUB8", 4))
  199. 	{
  200. 		printf("Detected Mucom88win header.\n");
  201. 		Mucom88Win = 1;
  202. 		TrkHdrPos = ReadLE16(&SeqData[4]) + 5;
  203. 	}
  204. 	else
  205. 	{
  206. 		Mucom88Win = 0;
  207. 		for (SeqPos = 0x00; SeqPos < 0x08; SeqPos ++)
  208. 		{
  209. 			TempPos = ReadLE16(&SeqData[SeqPos + 0x01]);
  210. 			if (TempPos == 0x002F)
  211. 			{
  212. 				TrkHdrPos = SeqPos;
  213. 				break;
  214. 			}
  215. 		}
  216. 	}
  217. 	if (! TrkHdrPos)
  218. 	{
  219. 		printf("Unable to find sequence header!\n");
  220. 		return;
  221. 	}
  222. 	printf("Sequence header found at %04X.\n", TrkHdrPos);
  223.  
  224. 	TrkCnt = 11;
  225. 	SeqPos = 0x01;
  226. 	FMInsPos = ReadLE16(&SeqData[TrkHdrPos]);
  227. 	SSGInsPos = ReadLE16(&SeqData[TrkHdrPos+2]);
  228.  
  229. 	SeqPos = TrkHdrPos;
  230.  
  231. 	MidPos = 0x00;
  232. 	WriteBE32(&MidData[MidPos], 0x4D546864);
  233. 	MidPos += 0x04;	// 'MThd' Signature
  234. 	WriteBE32(&MidData[MidPos], 0x00000006);
  235. 	MidPos += 0x04;	// Header Size
  236. 	WriteBE16(&MidData[MidPos], 0x0001);
  237. 	MidPos += 0x02;	// Format: 1
  238. 	WriteBE16(&MidData[MidPos], 1+TrkCnt);
  239. 	MidPos += 0x02;	// Tracks (+1 for tempo)
  240. 	WriteBE16(&MidData[MidPos], MIDI_RES);
  241. 	MidPos += 0x02;	// Ticks per Quarter
  242.  
  243. #if 1
  244. 	WriteBE32(&MidData[MidPos], 0x4D54726B);
  245. 	MidPos += 0x04;	// 'MTrk' Signature
  246. 	WriteBE32(&MidData[MidPos], 0x00000000);
  247. 	MidPos += 0x04;	// Track Size
  248. 	MidTrkBase = MidPos;
  249. 	CurDly = 0;
  250.  
  251. 	TempLng = Tempo2Mid(SeqData[SeqPos]);	// default tempo value
  252. 	WriteEvent(MidData, &MidPos, &CurDly, 0xFF, 0x51, 0x03);
  253. 	WriteBE32(&MidData[MidPos - 0x01], TempLng);
  254. 	MidData[MidPos - 0x01] = 0x03;	// write again, because the above instruction overwrote it
  255. 	MidPos += 0x03;
  256. 	SeqPos ++;
  257.  
  258. 	WriteEvent(MidData, &MidPos, &CurDly, 0xFF, 0x2F, 0x00);
  259. 	WriteBE32(&MidData[MidTrkBase - 0x04], MidPos - MidTrkBase);	// write Track Length
  260. #endif
  261.  
  262. 	for (CurTrk = 0; CurTrk < TrkCnt; CurTrk ++, SeqPos += 0x04)
  263. 	{
  264. 		TrkHdrs[CurTrk].StartOfs = ReadLE16(&SeqData[SeqPos + 0x00]);
  265. 		if (TrkHdrs[CurTrk].StartOfs)
  266. 			TrkHdrs[CurTrk].StartOfs += TrkHdrPos;
  267. 		TrkHdrs[CurTrk].LoopOfs = ReadLE16(&SeqData[SeqPos + 0x02]);
  268. 		if (TrkHdrs[CurTrk].LoopOfs)
  269. 			TrkHdrs[CurTrk].LoopOfs += TrkHdrPos;
  270. 	}
  271. 	SeqSize = ReadLE16(&SeqData[SeqPos]) + TrkHdrPos;
  272. 	SeqPos += 0x02;
  273.  
  274. 	for (CurTrk = 0; CurTrk < TrkCnt; CurTrk ++)
  275. 	{
  276. 		WriteBE32(&MidData[MidPos], 0x4D54726B);	// write 'MTrk'
  277. 		MidPos += 0x08;
  278. 		MidTrkBase = MidPos;
  279.  
  280. 		SeqPos = TrkHdrs[CurTrk].StartOfs;
  281. 		if (CurTrk < 3)			// FM 1..3
  282. 		{
  283. 			TrkMode = 0;
  284. 			MidChn = CurTrk;
  285. 		}
  286. 		else if (CurTrk < 6)	// SSG 1..3
  287. 		{
  288. 			TrkMode = 1;
  289. 			MidChn = 10 + CurTrk - 3;
  290. 		}
  291. 		else if (CurTrk == 6)	// ADPCMA Rhythm
  292. 		{
  293. 			TrkMode = 3;
  294. 			MidChn = 9;
  295. 		}
  296. 		else if (CurTrk == 10)	// ADPCMB/DeltaT
  297. 		{
  298. 			TrkMode = 2;
  299. 			MidChn = 9;
  300. 		}
  301. 		else
  302. 		{
  303. 			TrkMode = 0;
  304. 			MidChn = 3 + CurTrk - 7;
  305. 		}
  306. 		printf("Track %u ...\n", CurTrk);
  307.  
  308. 		CurDly = 0;
  309. 		TrkEnd = (SeqPos == 0x0000);
  310. 		MstLoopCnt = 0x00;
  311. 		NoteMove = TrkMode ? +12 : 0;
  312. 		//WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x65, 0x00);	// RPN MSB: 0
  313. 		//WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x64, 0x00);	// RPN LSB: 0
  314. 		//WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x06, 12);	// Data MSB - set Pitch Bend Range
  315.  
  316. 		memset(LoopCnt, 0x00, 0x10);
  317. 		CurNote = 0xFF;
  318. 		LastNote = 0xFF;
  319. 		CurNoteVol = 0x7F;
  320. 		CurChnVol = 0x00;
  321. 		ChnPanOn = 0x00;
  322. 		HoldNote = 0x00;
  323. 		NoteStop = 0;
  324. 		CurRhythmMask = 0x00;
  325. 		CurRhythmOn = 0x00;
  326. 		LoopStkIdx = 0x00;
  327. 		LoopIdx = 0x00;
  328. 		while(! TrkEnd)
  329. 		{
  330. 			if (! MstLoopCnt && SeqPos == TrkHdrs[CurTrk].LoopOfs)
  331. 			{
  332. 				MstLoopCnt ++;
  333. 				WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x6F, 0x00);
  334. 			}
  335.  
  336. 			CurCmd = SeqData[SeqPos];
  337. 			SeqPos ++;
  338. 			if (CurCmd == 0x00)
  339. 			{
  340. 				if (TrkHdrs[CurTrk].LoopOfs)
  341. 					WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x6F, MstLoopCnt);
  342. 				if (TrkHdrs[CurTrk].LoopOfs && MstLoopCnt < NUM_LOOPS)
  343. 				{
  344. 					SeqPos = TrkHdrs[CurTrk].LoopOfs;
  345. 					MstLoopCnt ++;
  346. 				}
  347. 				else
  348. 				{
  349. 					TrkEnd = 0x01;
  350. 				}
  351. 			}
  352. 			else if (CurCmd < 0x80)
  353. 			{
  354. 				TempByt = SeqData[SeqPos];
  355. 				SeqPos ++;
  356. 				CurNote = NOTE_ARRAY[TempByt & 0x0F];
  357. 				if (CurNote == 0xFF)
  358. 					printf("Warning: Invalid Note %02X!\n", TempByt);
  359. 				CurNote += (TempByt >> 4) * 12;
  360. 				CurNote += NoteMove + 12;
  361.  
  362. 				if (TrkMode == 3)
  363. 				{
  364. 					if (! HoldNote)
  365. 					{
  366. 						for (TempByt = 0x00; TempByt < 0x06; TempByt ++)
  367. 						{
  368. 							if (CurRhythmOn & (1 << TempByt))
  369. 							{
  370. 								CurRhythmOn &= ~(1 << TempByt);
  371. 								WriteEvent(MidData, &MidPos, &CurDly, 0x90 | MidChn, RHYTHM_NOTES[TempByt], 0x00);
  372. 							}
  373. 						}
  374. 						for (TempByt = 0x00; TempByt < 0x06; TempByt ++)
  375. 						{
  376. 							if (CurRhythmMask & (1 << TempByt))
  377. 							{
  378. 								CurRhythmOn |= (1 << TempByt);
  379. 								WriteEvent(MidData, &MidPos, &CurDly, 0x90 | MidChn, RHYTHM_NOTES[TempByt], CurNoteVol);
  380. 							}
  381. 						}
  382. 					}
  383. 				}
  384. 				else if (LastNote != CurNote || ! HoldNote)
  385. 				{
  386. 					if (HoldNote)
  387. 					{
  388. 						if (CurDly >= 1)
  389. 						{
  390. 							CurDly --;
  391. 							WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x41, 0x7F);
  392. 							CurDly ++;
  393. 						}
  394. 						else
  395. 						{
  396. 							WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x41, 0x7F);
  397. 						}
  398. 					}
  399.  
  400. 					if (LastNote != 0xFF)
  401. 						WriteEvent(MidData, &MidPos, &CurDly, 0x90 | MidChn, LastNote, 0x00);
  402. 					if (CurNote != 0xFF)
  403. 						WriteEvent(MidData, &MidPos, &CurDly, 0x90 | MidChn, CurNote, CurNoteVol);
  404. 					LastNote = CurNote;
  405.  
  406. 					if (HoldNote)
  407. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x41, 0x00);
  408. 				}
  409. 				HoldNote = 0x00;
  410.  
  411. 				CurDly += CurCmd;
  412. 				if (NoteStop && CurDly > NoteStop && SeqData[SeqPos] != 0xFD)
  413. 				{
  414. 					CurDly -= NoteStop;
  415. 					if (TrkMode == 3)
  416. 					{
  417. 						for (TempByt = 0x00; TempByt < 0x06; TempByt ++)
  418. 						{
  419. 							if (CurRhythmOn & (1 << TempByt))
  420. 							{
  421. 								CurRhythmOn &= ~(1 << TempByt);
  422. 								WriteEvent(MidData, &MidPos, &CurDly, 0x90 | MidChn, RHYTHM_NOTES[TempByt], 0x00);
  423. 							}
  424. 						}
  425. 					}
  426. 					else if (LastNote != 0xFF)
  427. 					{
  428. 						WriteEvent(MidData, &MidPos, &CurDly, 0x90 | MidChn, LastNote, 0x00);
  429. 						LastNote = 0xFF;
  430. 					}
  431. 					CurDly += NoteStop;
  432. 				}
  433. 			}
  434. 			else if (CurCmd < 0xF0)
  435. 			{
  436. 				if (! HoldNote && LastNote != 0xFF)
  437. 				{
  438. 					WriteEvent(MidData, &MidPos, &CurDly, 0x90 | MidChn, LastNote, 0x00);
  439. 					LastNote = 0xFF;
  440. 				}
  441. 				HoldNote = 0x00;
  442.  
  443. 				CurDly += CurCmd & 0x7F;
  444. 			}
  445. 			else
  446. 			{
  447. 				switch(CurCmd)
  448. 				{
  449. 				case 0xF0:	// Set Instrument
  450. 					if (TrkMode == 3 && Mucom88Win)
  451. 					{
  452. 						// set Rhythm Mask
  453. 						CurRhythmMask = SeqData[SeqPos];
  454. 					}
  455. 					else
  456. 					{
  457. 						TempByt = SeqData[SeqPos] & 0x7F;
  458. 						WriteEvent(MidData, &MidPos, &CurDly, 0xC0 | MidChn, TempByt, 0x00);
  459. 					}
  460. 					SeqPos ++;
  461. 					break;
  462. 				case 0xF1:	// Set Volume
  463. 					CurChnVol = SeqData[SeqPos];
  464. 					TempByt = MucomVol2Mid(TrkMode, CurChnVol, ChnPanOn);
  465. 					if (! USE_VELOCITY)
  466. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x07, TempByt);
  467. 					else
  468. 						CurNoteVol = TempByt;
  469. 					SeqPos ++;
  470. 					if (TrkMode == 3)
  471. 						SeqPos += 0x06;
  472. 					break;
  473. 				case 0xF2:	// Detune
  474. 					//WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x6E, CurCmd & 0x0F);
  475. 					//WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x26, SeqData[SeqPos]);
  476. 					TempPos = ReadLE16(&SeqData[SeqPos]);
  477. 					TempPos = 0x2000 - (TempPos << 5);
  478. 					WriteEvent(MidData, &MidPos, &CurDly, 0xE0 | MidChn, TempPos & 0x7F, (TempPos >> 7) & 0x7F);
  479. 					SeqPos += 0x03;
  480. 					break;
  481. 				case 0xF3:
  482. 					if (TrkMode == 3)
  483. 					{
  484. 						// set Rhythm Mask
  485. 						CurRhythmMask = SeqData[SeqPos];
  486. 					}
  487. 					else
  488. 					{
  489. 						// Note Stop/Echo Volume?
  490. 						NoteStop = SeqData[SeqPos];
  491. 						//if (TrkMode == 0 && NoteStop >= 4)
  492. 						//	NoteStop = 0;
  493. 						if (NO_NOTESTOP)
  494. 							NoteStop = 0;
  495. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x29, SeqData[SeqPos]);
  496. 					}
  497. 					SeqPos ++;
  498. 					break;
  499. 				case 0xF4:	// Modulation
  500. 					if (! SeqData[SeqPos + 0x00])
  501. 					{
  502. 						// Set Modulation
  503. 						TempPos = ReadLE16(&SeqData[SeqPos + 0x03]);
  504. 						TempByt = SeqData[SeqPos + 0x05];
  505. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x10, SeqData[SeqPos + 0x01]);
  506. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x11, SeqData[SeqPos + 0x02]);
  507. 						if (! TrkMode)
  508. 							WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x12, TempPos & 0x7F);
  509. 						else
  510. 							WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x12, (TempPos/8) & 0x7F);
  511. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x13, TempByt & 0x7F);
  512.  
  513. 						if (TempPos < 0)
  514. 							TempPos = -TempPos;
  515. 						TempLng = (TempPos * TempPos) / 8;
  516.  
  517. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x01, TempLng);
  518. 						SeqPos += 0x06;
  519. 					}
  520. 					else
  521. 					{
  522. 						// Disable Modulation
  523. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x01, 0x00);
  524. 						SeqPos ++;
  525. 					}
  526. 					break;
  527. 				case 0xF5:	// Loop Start
  528. 					TempPos = ReadLE16(&SeqData[SeqPos]);	// get offset of Loop Count
  529. 					LoopStkIdx ++;
  530. 					if (SeqPos + TempPos < SeqSize)
  531. 						LoopCnt[LoopStkIdx] = SeqData[SeqPos + TempPos];
  532. 					else
  533. 						LoopCnt[LoopStkIdx] = 0x00;
  534. 					SeqPos += 0x02;
  535. 					break;
  536. 				case 0xF6:	// Loop End
  537. 					TempByt = SeqData[SeqPos + 0x01];
  538. 					if (! LoopCnt[LoopStkIdx])
  539. 						LoopCnt[LoopStkIdx] = TempByt;
  540. 					SeqPos += 0x02;
  541.  
  542. 					TempPos = ReadLE16(&SeqData[SeqPos]);
  543. 					LoopCnt[LoopStkIdx] --;
  544. 					if (LoopCnt[LoopStkIdx])
  545. 					{
  546. 						SeqPos -= TempPos;
  547. 					}
  548. 					else
  549. 					{
  550. 						LoopStkIdx --;
  551. 						SeqPos += 0x02;
  552. 					}
  553. 					break;
  554. 				case 0xF7: // FM3 special mode
  555. 					WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x6E, CurCmd & 0x0F);
  556. 					SeqPos ++;
  557. 					break;
  558. 				case 0xF8:
  559. 				case 0xF9:	// Pan
  560. 					if((Mucom88Win && CurCmd == 0xf8) || (!Mucom88Win && CurCmd == 0xf9))
  561. 					{
  562. 						TempByt = SeqData[SeqPos];
  563. 						if (TrkMode == 3)	// rhythm mode works differently
  564. 						{
  565. 							WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x26, TempByt);
  566. 							TempByt = 0x00;
  567. 						}
  568. 						TempByt &= 0x03;
  569. 						if (TempByt == 0x01)	// right speaker
  570. 							TempByt = 0x7F;
  571. 						else if (TempByt == 0x02)	// left speaker
  572. 							TempByt = 0x00;
  573. 						else	// both speakers
  574. 							TempByt = 0x40;
  575. 						ChnPanOn = (TempByt == 0x40) ? 0x00 : 0x01;
  576.  
  577. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x0A, TempByt);
  578. 						TempByt = MucomVol2Mid(TrkMode, CurChnVol, ChnPanOn);
  579. 						if (! USE_VELOCITY)
  580. 							WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x07, TempByt);
  581. 						else
  582. 							CurNoteVol = TempByt;
  583. 						SeqPos ++;
  584. 						break;
  585. 					}
  586. 					else
  587. 					{
  588. 						// seems to just write a communication byte
  589. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x6E, CurCmd & 0x0F);
  590. 						SeqPos ++;
  591. 						break;
  592. 					}
  593. 				case 0xFA:	// Register Write
  594. 					if (TrkMode == 1)
  595. 					{
  596. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x6E, CurCmd & 0x0F);
  597. 						SeqPos += 0x06;
  598. 					}
  599. 					else	// YM2203/2608 Register Write
  600. 					{
  601. 						if (SeqData[SeqPos + 0x00] == 0x26)	// Timer B - change Tempo
  602. 						{
  603. 							TempLng = Tempo2Mid(SeqData[SeqPos + 0x01]);
  604. 							WriteEvent(MidData, &MidPos, &CurDly, 0xFF, 0x51, 0x03);
  605. 							WriteBE32(&MidData[MidPos - 0x01], TempLng);
  606. 							MidData[MidPos - 0x01] = 0x03;	// write again, because the above instruction overwrote it
  607. 							MidPos += 0x03;
  608. 						}
  609. 						else
  610. 						{
  611. 							WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 50, SeqData[SeqPos + 0x00]);
  612. 							WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 51, SeqData[SeqPos + 0x01]);
  613. 						}
  614. 						SeqPos += 0x02;
  615. 					}
  616. 					break;
  617. 				case 0xFB:	// Change Volume
  618. 					CurChnVol += SeqData[SeqPos];
  619. 					TempByt = MucomVol2Mid(TrkMode, CurChnVol, ChnPanOn);
  620. 					if (! USE_VELOCITY)
  621. 					{
  622. 						if (SeqData[SeqPos] != 0xFB)
  623. 							WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x07, TempByt);
  624. 					}
  625. 					else
  626. 						CurNoteVol = TempByt;
  627. 					SeqPos ++;
  628. 					break;
  629. 				case 0xFC:
  630. 					WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x6E, CurCmd & 0x0F);
  631. 					//printf("Unknown command %02X at %04X!\n", CurCmd, SeqPos - 0x01);
  632. 					//getchar();
  633. 					SeqPos += 0x03;
  634. 					break;
  635. 				case 0xFD:	// Hold
  636. 					HoldNote = 0x01;
  637. 					break;
  638. 				case 0xFE:	// Loop Exit
  639. 					TempPos = ReadLE16(&SeqData[SeqPos]);	// get offset of Loop Exit Counter
  640. 					TempByt = SeqData[SeqPos + TempPos];
  641. 					if (LoopCnt[LoopStkIdx] == 1)
  642. 					{
  643. 						LoopCnt[LoopStkIdx] = 0;
  644. 						LoopStkIdx --;
  645. 						SeqPos += TempPos + 0x04;
  646. 					}
  647. 					else
  648. 					{
  649. 						SeqPos += 0x02;
  650. 					}
  651. 					break;
  652. 				case 0xFF:	// Master Loop Start??
  653. 					if(Mucom88Win)
  654. 					{
  655. 						TempByt = SeqData[SeqPos];
  656. 						SeqPos ++;
  657. 						switch(TempByt)
  658. 						{
  659. 						case 0xf0: // PCM volume mode ('vm')
  660. 							SeqPos++;
  661. 							break;
  662. 						case 0xf1: // PSG hardware support (mucom88 v1.5 / music lalf 1.0 only)
  663. 						case 0xf2:
  664. 							SeqPos++;
  665. 							break;
  666. 						case 0xf3: // Reverb enable
  667. 						case 0xf4: // Reverb mode
  668. 						case 0xf5: // Reverb switch
  669. 							SeqPos++;
  670. 							break;
  671. 						default:
  672. 							printf("unknown extra command %02x at %04x\n", TempByt, SeqPos);
  673. 							break;
  674. 						}
  675. 						WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x71, TempByt & 0x0F);
  676. 					}
  677. 					//WriteEvent(MidData, &MidPos, &CurDly, 0xB0 | MidChn, 0x6F, 0x00);
  678. 					//SeqPos += 0x02;
  679. 					break;
  680. 				}
  681. 			}
  682. 		}
  683. 		if (LastNote != 0xFF)
  684. 			WriteEvent(MidData, &MidPos, &CurDly, 0x90 | MidChn, LastNote, 0x00);
  685.  
  686. 		WriteEvent(MidData, &MidPos, &CurDly, 0xFF, 0x2F, 0x00);
  687. 		WriteBE32(&MidData[MidTrkBase - 0x04], MidPos - MidTrkBase);	// write Track Length
  688. 	}
  689. 	MidSize = MidPos;
  690.  
  691. 	return;
  692. }
  693.  
  694. INLINE UINT8 MucomVol2Mid(UINT8 TrkMode, UINT8 Vol, UINT8 PanBoost)
  695. {
  696. 	double DBVol;
  697.  
  698. 	if (TrkMode == 0)
  699. 		DBVol = FMVol2DB(Vol);
  700. 	else if (TrkMode == 1)
  701. 		DBVol = PSGVol2DB(Vol);
  702. 	else if (TrkMode == 2)
  703. 		DBVol = DeltaTVol2DB(Vol);
  704. 	else if (TrkMode == 3)
  705. 		DBVol = DeltaTVol2DB(Vol * 4);
  706. 	else
  707. 		return Vol;
  708. 	if (PanBoost)
  709. 		DBVol -= 3.0;
  710. 	return DB2Mid(DBVol);
  711. }
  712.  
  713. INLINE double FMVol2DB(UINT8 Vol)
  714. {
  715. 	// Mucom uses a FM volume lookup table to map its volume value to 8/3 FM steps. (2 db steps)
  716. 	// The table contains 20 values and looks like this:
  717. 	// 36 33 30 2D 2A 28 25 22 20 1D 1A 18 15 12 10 0D 0A 08 05 02
  718. #if 0
  719. 	UINT8 FmVol;
  720.  
  721. 	if (Vol < 20)
  722. 		FmVol = (20 - Vol) * 8 / 3;
  723. 	else
  724. 		FmVol = 0;
  725. 	return FmVol * -0.75;
  726. #else
  727. 	if (Vol < 20)
  728. 		return (20 - Vol) * -2.0;
  729. 	else
  730. 		return 0;
  731. #endif
  732. }
  733.  
  734. INLINE double PSGVol2DB(UINT8 Vol)
  735. {
  736. 	if (Vol > 0x0F)
  737. 		return 0.0;
  738. 	else if (Vol > 0x00)
  739. 		return (0x0F - Vol) * -3.0;	// AY8910 volume is 3 db per step
  740. 	else
  741. 		return -999;
  742. }
  743.  
  744. INLINE double DeltaTVol2DB(UINT8 Vol)
  745. {
  746. 	//return log(Vol / 255.0) / log(2.0) * 6.0;
  747. 	return log(Vol / 255.0) * 8.65617024533378 + 6.0;	// boost its volume
  748. }
  749.  
  750. INLINE UINT8 DB2Mid(double DB)
  751. {
  752. 	DB += 6.0;
  753. 	if (DB > 0.0)
  754. 		DB = 0.0;
  755. 	return (UINT8)(pow(10.0, DB / 40.0) * 0x7F + 0.5);
  756. }
  757.  
  758. INLINE UINT32 Tempo2Mid(UINT8 TempoVal)
  759. {
  760. 	// Note: The tempo value is the value of YM Timer B.
  761. 	// higher value = higher tick frequency = higher tempo
  762.  
  763. 	// Base Clock = 2 MHz
  764. 	// Prescaler: 6 * 12
  765. 	// internal Timer Countdown: (100h - value) * 10h
  766. 	// Timer Frequency: Clock / (Countdown * Prescaler)
  767. 	double TicksPerSec;
  768. 	UINT16 TmrVal;
  769.  
  770. 	TmrVal = (0x100 - TempoVal) << 4;
  771. 	TicksPerSec = 2000000.0 / (6 * 12 * TmrVal);
  772. 	return (UINT32)(500000 * MIDI_RES / TicksPerSec + 0.5);
  773. }
  774.  
  775.  
  776.  
  777. static void WriteEvent(UINT8* Buffer, UINT32* Pos, UINT32* Delay, UINT8 Evt, UINT8 Val1, UINT8 Val2)
  778. {
  779. 	if (! (Evt & 0x80))
  780. 		return;
  781.  
  782. 	WriteMidiValue(Buffer, Pos, *Delay);
  783. 	*Delay = 0x00;
  784.  
  785. 	switch(Evt & 0xF0)
  786. 	{
  787. 	case 0x80:
  788. 	case 0x90:
  789. 	case 0xA0:
  790. 	case 0xB0:
  791. 	case 0xE0:
  792. 		MidData[*Pos + 0x00] = Evt;
  793. 		MidData[*Pos + 0x01] = Val1;
  794. 		MidData[*Pos + 0x02] = Val2;
  795. 		*Pos += 0x03;
  796. 		break;
  797. 	case 0xC0:
  798. 	case 0xD0:
  799. 		MidData[*Pos + 0x00] = Evt;
  800. 		MidData[*Pos + 0x01] = Val1;
  801. 		*Pos += 0x02;
  802. 		break;
  803. 	case 0xF0:	// for Meta Event: Track End
  804. 		MidData[*Pos + 0x00] = Evt;
  805. 		MidData[*Pos + 0x01] = Val1;
  806. 		MidData[*Pos + 0x02] = Val2;
  807. 		*Pos += 0x03;
  808. 		break;
  809. 	default:
  810. 		break;
  811. 	}
  812.  
  813. 	return;
  814. }
  815.  
  816. static void WriteMidiValue(UINT8* Buffer, UINT32* Pos, UINT32 Value)
  817. {
  818. 	UINT8 ValSize;
  819. 	UINT8* ValData;
  820. 	UINT32 TempLng;
  821. 	UINT32 CurPos;
  822.  
  823. 	ValSize = 0x00;
  824. 	TempLng = Value;
  825. 	do
  826. 	{
  827. 		TempLng >>= 7;
  828. 		ValSize ++;
  829. 	} while(TempLng);
  830.  
  831. 	ValData = &Buffer[*Pos];
  832. 	CurPos = ValSize;
  833. 	TempLng = Value;
  834. 	do
  835. 	{
  836. 		CurPos --;
  837. 		ValData[CurPos] = 0x80 | (TempLng & 0x7F);
  838. 		TempLng >>= 7;
  839. 	} while(TempLng);
  840. 	ValData[ValSize - 1] &= 0x7F;
  841.  
  842. 	*Pos += ValSize;
  843.  
  844. 	return;
  845. }
  846.  
  847. INLINE UINT16 ReadLE16(const UINT8* Data)
  848. {
  849. 	return (Data[0x00] << 0) | (Data[0x01] << 8);
  850. }
  851.  
  852. INLINE void WriteBE16(UINT8* Buffer, UINT16 Value)
  853. {
  854. 	Buffer[0x00] = (Value & 0xFF00) >> 8;
  855. 	Buffer[0x01] = (Value & 0x00FF) >> 0;
  856.  
  857. 	return;
  858. }
  859.  
  860. INLINE void WriteBE32(UINT8* Buffer, UINT32 Value)
  861. {
  862. 	Buffer[0x00] = (Value & 0xFF000000) >> 24;
  863. 	Buffer[0x01] = (Value & 0x00FF0000) >> 16;
  864. 	Buffer[0x02] = (Value & 0x0000FF00) >>  8;
  865. 	Buffer[0x03] = (Value & 0x000000FF) >>  0;
  866.  
  867. 	return;
  868. }
Success #stdin #stdout 0s 5276KB
comments (?)
stdin
copy 
/*  Berechnung des Hamming-Abstandes zwischen zwei 128-Bit Werten in 	*/
/*	einer Textdatei. 													*/
/*  Die Werte müssen auf einer separaten Zeile gespeichert sein			*/
/* 																		*/
/*	Erstellt: 17.5.2010													*/
/*  Autor: Thomas Scheffler												*/

#include <stdio.h>
#include <stdlib.h>

#define ARRAY_SIZE 32

unsigned Hamdist(unsigned x, unsigned y)
{
  unsigned dist = 0, val = x ^ y;
 
  // Count the number of set bits
  while(val)
  {
    ++dist; 
    val &= val - 1;
  }
 
  return dist;
}



int main (void)
{
	char hex;
	int i;
	int a[ARRAY_SIZE];
	int b[ARRAY_SIZE];
	int hamDist = 0;
	FILE* fp;
	
	//Arrays mit 0 initialisieren
	for (i = 0; i < ARRAY_SIZE; ++i)
	{
  		a[i] = 0;
  		b[i] = 0;
	}

	
	fp = fopen("hex.txt","r");
	if (fp == NULL) 
	{
		printf("Die Datei hex.txt wurde nicht gefunden!");
		exit(EXIT_FAILURE);
	}

	i=0;
	printf("1.Zeile einlesen.\n");

 	while((hex=fgetc(fp))!='\n' && hex != EOF)
    {
        a[i]=strtol(&hex,0,16);
		i++;
    }
	i=0;
	printf("2.Zeile einlesen.\n");

 	while((hex=fgetc(fp))!='\n' && hex != EOF)
    {
    	b[i]=strtol(&hex,0,16);
        i++;
    }
	fclose(fp);

	printf("Hamming-Abweichung pro Nibble:\n");
	for (i = 0; i < ARRAY_SIZE; ++i)
	{
		printf ("%i\t%i\t%i\n",a[i],b[i],Hamdist(a[i],b[i]));
		hamDist += Hamdist(a[i],b[i]);
	}
	printf ("\nHamming-Abweichung der Hash-Werte:%d\n",hamDist);
}
stdout
copy 
Usage: mucom2mid input.bin output.mid
https://ideone.com/ayVb4L
language:
C (gcc 8.3)
created:
6 hours ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!