OneLoneCoder_PGE_MIDI.cpp

/*
	Programming MIDI: Parsing, Displaying (& Playing) MIDI Files
	"Better get these done before im virused..." - javidx9

	License (OLC-3)
	~~~~~~~~~~~~~~~

	Copyright 2018-2020 OneLoneCoder.com

	Redistribution and use in source and binary forms, with or without
	modification, are permitted provided that the following conditions
	are met:

	1. Redistributions or derivations of source code must retain the above
	copyright notice, this list of conditions and the following disclaimer.

	2. Redistributions or derivative works in binary form must reproduce
	the above copyright notice. This list of conditions and the following
	disclaimer must be reproduced in the documentation and/or other
	materials provided with the distribution.

	3. Neither the name of the copyright holder nor the names of its
	contributors may be used to endorse or promote products derived
	from this software without specific prior written permission.

	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	Relevant Video: https://youtu.be/040BKtnDdg0

	Links
	~~~~~
	YouTube:	https://www.youtube.com/javidx9
				https://www.youtube.com/javidx9extra
	Discord:	https://discord.gg/WhwHUMV
	Twitter:	https://www.twitter.com/javidx9
	Twitch:		https://www.twitch.tv/javidx9
	GitHub:		https://www.github.com/onelonecoder
	Patreon:	https://www.patreon.com/javidx9
	Homepage:	https://www.onelonecoder.com
	
	Community:	https://community.onelonecoder.com

	Author
	~~~~~~
	David Barr, aka javidx9, �OneLoneCoder 2018, 2019, 2020
*/

/*
On Linux need to install fluidsynth, compile with -lfluidsynth, 
and add a midi font file `midi_font.sf2`.
https://github.com/FluidSynth/fluidsynth

Install fluidsynth (default location is /usr/local)
```
wget https://github.com/FluidSynth/fluidsynth/archive/refs/tags/v2.3.2.zip
unzip v2.3.2.zip
cd fluidsynth-2.3.2
mkdir -p build
cd build
cmake ..
cmake --build .
cmake --install .
```

Compile with `-lfluidsynth`
```
g++ -o midi OneLoneCoder_PGE_MIDI.cpp -lfluidsynth -I../BiggerProjects/CarCrimeCity/Part2 -lGL -lpng -lX11 -lpthread -lstdc++fs -std=c++17
```

Download a MIDI Font (there are many online), or install `vlc-plugin-fluidsynth`, it adds a default.sf2 at `/usr/share/sounds/sf2/default-GM.sf2`
```
sudo apt install vlc-plugin-fluidsynth
```

Once you have `ff7_battle.mid` and `midi_font.sf2`, just run
```
./midi
```
*/

#define OLC_PGE_APPLICATION
#include "olcPixelGameEngine.h"

#include <fstream>
#include <array>

#ifdef WIN32
//#pragma comment(lib, "winmm.lib")
#else
#include <fluidsynth.h>
#endif


struct MidiEvent
{
	enum class Type
	{
		NoteOff,
		NoteOn,
		Other
	} event;

	uint8_t nKey = 0;
	uint8_t nVelocity = 0;
	uint32_t nDeltaTick = 0;
};


struct MidiNote
{
	uint8_t nKey = 0;
	uint8_t nVelocity = 0;
	uint32_t nStartTime = 0;
	uint32_t nDuration = 0;
};

struct MidiTrack
{
	std::string sName;
	std::string sInstrument;
	std::vector<MidiEvent> vecEvents;
	std::vector<MidiNote> vecNotes;
	uint8_t nMaxNote = 64;
	uint8_t nMinNote = 64;
};


class MidiFile
{
public:
	enum EventName : uint8_t
	{					
		VoiceNoteOff = 0x80,
		VoiceNoteOn = 0x90,
		VoiceAftertouch = 0xA0,
		VoiceControlChange = 0xB0,
		VoiceProgramChange = 0xC0,
		VoiceChannelPressure = 0xD0,
		VoicePitchBend = 0xE0,
		SystemExclusive = 0xF0,		
	};

	enum MetaEventName : uint8_t
	{
		MetaSequence = 0x00,
		MetaText = 0x01,
		MetaCopyright = 0x02,
		MetaTrackName = 0x03,
		MetaInstrumentName = 0x04,
		MetaLyrics = 0x05,
		MetaMarker = 0x06,
		MetaCuePoint = 0x07,
		MetaChannelPrefix = 0x20,
		MetaEndOfTrack = 0x2F,
		MetaSetTempo = 0x51,
		MetaSMPTEOffset = 0x54,
		MetaTimeSignature = 0x58,
		MetaKeySignature = 0x59,
		MetaSequencerSpecific = 0x7F,
	};

public:
	MidiFile()
	{
	}

	MidiFile(const std::string& sFileName)
	{
		ParseFile(sFileName);
	}

	void Clear()
	{

	}

	bool ParseFile(const std::string& sFileName)
	{
		// Open the MIDI File as a stream
		std::ifstream ifs;
		ifs.open(sFileName, std::fstream::in | std::ios::binary);
		if (!ifs.is_open())
			return false;


		// Helper Utilities ====================

		// Swaps byte order of 32-bit integer
		auto Swap32 = [](uint32_t n)
		{
			return (((n >> 24) & 0xff) | ((n << 8) & 0xff0000) | ((n >> 8) & 0xff00) | ((n << 24) & 0xff000000));
		};

		// Swaps byte order of 16-bit integer
		auto Swap16 = [](uint16_t n)
		{
			return ((n >> 8) | (n << 8));
		};

		// Reads nLength bytes form file stream, and constructs a text string
		auto ReadString = [&ifs](uint32_t nLength)
		{
			std::string s;
			for (uint32_t i = 0; i < nLength; i++) s += ifs.get();
			return s;
		};

		// Reads a compressed MIDI value. This can be up to 32 bits long. Essentially if the first byte, first
		// bit is set to 1, that indicates that the next byte is required to construct the full word. Only
		// the bottom 7 bits of each byte are used to construct the final word value. Each successive byte 
		// that has MSB set, indicates a further byte needs to be read.
		auto ReadValue = [&ifs]()
		{
			uint32_t nValue = 0;
			uint8_t nByte = 0;

			// Read byte
			nValue = ifs.get();

			// Check MSB, if set, more bytes need reading
			if (nValue & 0x80)
			{
				// Extract bottom 7 bits of read byte
				nValue &= 0x7F;
				do
				{
					// Read next byte
					nByte = ifs.get();

					// Construct value by setting bottom 7 bits, then shifting 7 bits
					nValue = (nValue << 7) | (nByte & 0x7F);
				} 
				while (nByte & 0x80); // Loop whilst read byte MSB is 1
			}

			// Return final construction (always 32-bit unsigned integer internally)
			return nValue;
		};

		uint32_t n32 = 0;
		uint16_t n16 = 0;

		// Read MIDI Header (Fixed Size)
		ifs.read((char*)&n32, sizeof(uint32_t));
		uint32_t nFileID = Swap32(n32);
		ifs.read((char*)&n32, sizeof(uint32_t));
		uint32_t nHeaderLength = Swap32(n32);
		ifs.read((char*)&n16, sizeof(uint16_t));
		uint16_t nFormat = Swap16(n16);
		ifs.read((char*)&n16, sizeof(uint16_t));
		uint16_t nTrackChunks = Swap16(n16);
		ifs.read((char*)&n16, sizeof(uint16_t));
		uint16_t nDivision = Swap16(n16);

		for (uint16_t nChunk = 0; nChunk < nTrackChunks; nChunk++)
		{			
			std::cout << "===== NEW TRACK" << std::endl;
			// Read Track Header
			ifs.read((char*)&n32, sizeof(uint32_t));
			uint32_t nTrackID = Swap32(n32);
			ifs.read((char*)&n32, sizeof(uint32_t));
			uint32_t nTrackLength = Swap32(n32);

			bool bEndOfTrack = false;

			vecTracks.push_back(MidiTrack());

			uint32_t nWallTime = 0;

			uint8_t nPreviousStatus = 0;

			while (!ifs.eof() && !bEndOfTrack)
			{
				// Fundamentally all MIDI Events contain a timecode, and a status byte*
				uint32_t nStatusTimeDelta = 0;
				uint8_t nStatus = 0;


				// Read Timecode from MIDI stream. This could be variable in length
				// and is the delta in "ticks" from the previous event. Of course this value
				// could be 0 if two events happen simultaneously.
				nStatusTimeDelta = ReadValue();

				// Read first byte of message, this could be the status byte, or it could not...
				nStatus = ifs.get();

				// All MIDI Status events have the MSB set. The data within a standard MIDI event
				// does not. A crude yet utilised form of compression is to omit sending status
				// bytes if the following sequence of events all refer to the same MIDI Status.
				// This is called MIDI Running Status, and is essential to succesful decoding of
				// MIDI streams and files.
				//
				// If the MSB of the read byte was not set, and on the whole we were expecting a
				// status byte, then Running Status is in effect, so we refer to the previous 
				// confirmed status byte.
				if (nStatus < 0x80)
				{
					// MIDI Running Status is happening, so refer to previous valid MIDI Status byte
					nStatus = nPreviousStatus;

					// We had to read the byte to assess if MIDI Running Status is in effect. But!
					// that read removed the byte form the stream, and that will desync all of the 
					// following code because normally we would have read a status byte, but instead
					// we have read the data contained within a MIDI message. The simple solution is 
					// to put the byte back :P
					ifs.seekg(-1, std::ios_base::cur);
				}

				

				if ((nStatus & 0xF0) == EventName::VoiceNoteOff)
				{
					nPreviousStatus = nStatus;
					uint8_t nChannel = nStatus & 0x0F;
					uint8_t nNoteID = ifs.get();
					uint8_t nNoteVelocity = ifs.get();
					vecTracks[nChunk].vecEvents.push_back({ MidiEvent::Type::NoteOff, nNoteID, nNoteVelocity, nStatusTimeDelta });
				}

				else if ((nStatus & 0xF0) == EventName::VoiceNoteOn)
				{
					nPreviousStatus = nStatus;
					uint8_t nChannel = nStatus & 0x0F;
					uint8_t nNoteID = ifs.get();
					uint8_t nNoteVelocity = ifs.get();
					if(nNoteVelocity == 0)
						vecTracks[nChunk].vecEvents.push_back({ MidiEvent::Type::NoteOff, nNoteID, nNoteVelocity, nStatusTimeDelta });
					else
						vecTracks[nChunk].vecEvents.push_back({ MidiEvent::Type::NoteOn, nNoteID, nNoteVelocity, nStatusTimeDelta });
				}

				else if ((nStatus & 0xF0) == EventName::VoiceAftertouch)
				{
					nPreviousStatus = nStatus;
					uint8_t nChannel = nStatus & 0x0F;
					uint8_t nNoteID = ifs.get();
					uint8_t nNoteVelocity = ifs.get();
					vecTracks[nChunk].vecEvents.push_back({ MidiEvent::Type::Other });
				}

				else if ((nStatus & 0xF0) == EventName::VoiceControlChange)
				{
					nPreviousStatus = nStatus;
					uint8_t nChannel = nStatus & 0x0F;
					uint8_t nControlID = ifs.get();
					uint8_t nControlValue = ifs.get();
					vecTracks[nChunk].vecEvents.push_back({ MidiEvent::Type::Other });
				}

				else if ((nStatus & 0xF0) == EventName::VoiceProgramChange)
				{
					nPreviousStatus = nStatus;
					uint8_t nChannel = nStatus & 0x0F;
					uint8_t nProgramID = ifs.get();					
					vecTracks[nChunk].vecEvents.push_back({ MidiEvent::Type::Other });
				}

				else if ((nStatus & 0xF0) == EventName::VoiceChannelPressure)
				{
					nPreviousStatus = nStatus;
					uint8_t nChannel = nStatus & 0x0F;
					uint8_t nChannelPressure = ifs.get();
					vecTracks[nChunk].vecEvents.push_back({ MidiEvent::Type::Other });
				}

				else if ((nStatus & 0xF0) == EventName::VoicePitchBend)
				{
					nPreviousStatus = nStatus;
					uint8_t nChannel = nStatus & 0x0F;
					uint8_t nLS7B = ifs.get();
					uint8_t nMS7B = ifs.get();
					vecTracks[nChunk].vecEvents.push_back({ MidiEvent::Type::Other });

				}

				else if ((nStatus & 0xF0) == EventName::SystemExclusive)
				{
					nPreviousStatus = 0;

					if (nStatus == 0xFF)
					{
						// Meta Message
						uint8_t nType = ifs.get();
						uint8_t nLength = ReadValue();

						switch (nType)
						{
						case MetaSequence:
							std::cout << "Sequence Number: " << ifs.get() << ifs.get() << std::endl;
							break;
						case MetaText:
							std::cout << "Text: " << ReadString(nLength) << std::endl;
							break;
						case MetaCopyright:
							std::cout << "Copyright: " << ReadString(nLength) << std::endl;
							break;
						case MetaTrackName:
							vecTracks[nChunk].sName = ReadString(nLength);
							std::cout << "Track Name: " << vecTracks[nChunk].sName << std::endl;							
							break;
						case MetaInstrumentName:
							vecTracks[nChunk].sInstrument = ReadString(nLength);
							std::cout << "Instrument Name: " << vecTracks[nChunk].sInstrument << std::endl;
							break;
						case MetaLyrics:
							std::cout << "Lyrics: " << ReadString(nLength) << std::endl;
							break;
						case MetaMarker:
							std::cout << "Marker: " << ReadString(nLength) << std::endl;
							break;
						case MetaCuePoint:
							std::cout << "Cue: " << ReadString(nLength) << std::endl;
							break;
						case MetaChannelPrefix:
							std::cout << "Prefix: " << ifs.get() << std::endl;
							break;
						case MetaEndOfTrack:
							bEndOfTrack = true;
							break;
						case MetaSetTempo:
							// Tempo is in microseconds per quarter note	
							if (m_nTempo == 0)
							{
								(m_nTempo |= (ifs.get() << 16));
								(m_nTempo |= (ifs.get() << 8));
								(m_nTempo |= (ifs.get() << 0));
								m_nBPM = (60000000 / m_nTempo);
								std::cout << "Tempo: " << m_nTempo << " (" << m_nBPM << "bpm)" << std::endl;
							}
							break;
						case MetaSMPTEOffset:
							std::cout << "SMPTE: H:" << ifs.get() << " M:" << ifs.get() << " S:" << ifs.get() << " FR:" << ifs.get() << " FF:" << ifs.get() << std::endl;
							break;
						case MetaTimeSignature:
							std::cout << "Time Signature: " << ifs.get() << "/" << (2 << ifs.get()) << std::endl;
							std::cout << "ClocksPerTick: " << ifs.get() << std::endl;

							// A MIDI "Beat" is 24 ticks, so specify how many 32nd notes constitute a beat
							std::cout << "32per24Clocks: " << ifs.get() << std::endl;
							break;
						case MetaKeySignature:
							std::cout << "Key Signature: " << ifs.get() << std::endl;
							std::cout << "Minor Key: " << ifs.get() << std::endl;
							break;
						case MetaSequencerSpecific:
							std::cout << "Sequencer Specific: " << ReadString(nLength) << std::endl;
							break;
						default:
							std::cout << "Unrecognised MetaEvent: " << nType << std::endl;
						}
					}

					if (nStatus == 0xF0)
					{
						// System Exclusive Message Begin
						std::cout << "System Exclusive Begin: " << ReadString(ReadValue())  << std::endl;
					}

					if (nStatus == 0xF7)
					{
						// System Exclusive Message Begin
						std::cout << "System Exclusive End: " << ReadString(ReadValue()) << std::endl;
					}
				}			
				else
				{
					std::cout << "Unrecognised Status Byte: " << nStatus << std::endl;
				}
			}
		}


		// Convert Time Events to Notes
		for (auto& track : vecTracks)
		{
			uint32_t nWallTime = 0;

			std::list<MidiNote> listNotesBeingProcessed;

			for (auto& event : track.vecEvents)
			{
				nWallTime += event.nDeltaTick;

				if (event.event == MidiEvent::Type::NoteOn)
				{
					// New Note
					listNotesBeingProcessed.push_back({ event.nKey, event.nVelocity, nWallTime, 0 });
				}

				if (event.event == MidiEvent::Type::NoteOff)
				{
					auto note = std::find_if(listNotesBeingProcessed.begin(), listNotesBeingProcessed.end(), [&](const MidiNote& n) { return n.nKey == event.nKey; });
					if (note != listNotesBeingProcessed.end())
					{
						note->nDuration = nWallTime - note->nStartTime;
						track.vecNotes.push_back(*note);
						track.nMinNote = std::min(track.nMinNote, note->nKey);
						track.nMaxNote = std::max(track.nMaxNote, note->nKey);
						listNotesBeingProcessed.erase(note);
					}
				}
			}
		}

		return true;
	}

public:
	std::vector<MidiTrack> vecTracks;
	uint32_t m_nTempo = 0;
	uint32_t m_nBPM = 0;

};


class olcMIDIViewer : public olc::PixelGameEngine
{
public:
	olcMIDIViewer()
	{
		sAppName = "MIDI File Viewer";
	}


	MidiFile midi;

#ifdef WIN32
	//HMIDIOUT hInstrument;
#else
	fluid_settings_t *settings = NULL;
	fluid_synth_t *synth = NULL;
	fluid_audio_driver_t *adriver = NULL;
	int sfont_id;
	int i, key;
	const char *sMidiFontFile = "midi_font.sf2";
#endif
	size_t nCurrentNote[16]{ 0 };

	double dSongTime = 0.0;
	double dRunTime = 0.0;
	uint32_t nMidiClock = 0;
	

public:
	bool OnUserCreate() override
	{

		midi.ParseFile("ff7_battle.mid");

#ifdef WIN32
		/*
		int nMidiDevices = midiOutGetNumDevs();
		if (nMidiDevices > 0)
		{
			if (midiOutOpen(&hInstrument, 2, NULL, 0, NULL) == MMSYSERR_NOERROR)
			{
				std::cout << "Opened midi" << std::endl;
			}
		}
		*/
#else
		/* Create the settings. */
		settings = new_fluid_settings();
		if (settings == NULL)
		{
			puts("Failed to create the settings!");
			return false;
		}

		/* Change the settings if necessary*/

		/* Create the synthesizer. */
		synth = new_fluid_synth(settings);
		if (synth == NULL)
		{
			puts("Failed to create the synth!");
			return false;
		}

		/* Load a SoundFont and reset presets (so that new instruments
		 * get used from the SoundFont)
		 * Depending on the size of the SoundFont, this will take some time to complete...
		 */
		sfont_id = fluid_synth_sfload(synth, sMidiFontFile, 1);
		if (sfont_id == FLUID_FAILED)
		{
			puts("Loading the SoundFont failed!");
			return false;
		}

		/* Create the audio driver. The synthesizer starts playing as soon
		   as the driver is created. */
		adriver = new_fluid_audio_driver(settings, synth);
		if (adriver == NULL)
		{
			puts("Failed to create the audio driver!");
			return false;
		}
#endif

		return true;
	}

	float nTrackOffset = 1000;

	bool OnUserUpdate(float fElapsedTime) override
	{
		Clear(olc::BLACK);
		uint32_t nTimePerColumn = 50;
		uint32_t nNoteHeight = 2;
		uint32_t nOffsetY = 0;
		
		if (GetKey(olc::Key::LEFT).bHeld) nTrackOffset -= 10000.0f * fElapsedTime;
		if (GetKey(olc::Key::RIGHT).bHeld) nTrackOffset += 10000.0f * fElapsedTime;


		for (auto& track : midi.vecTracks)
		{
			if (!track.vecNotes.empty())
			{
				uint32_t nNoteRange = track.nMaxNote - track.nMinNote;

				FillRect(0, nOffsetY, ScreenWidth(), (nNoteRange + 1) * nNoteHeight, olc::DARK_GREY);
				DrawString(1, nOffsetY + 1, track.sName);

				for (auto& note : track.vecNotes)
				{
					FillRect((note.nStartTime - nTrackOffset) / nTimePerColumn, (nNoteRange - (note.nKey - track.nMinNote)) * nNoteHeight + nOffsetY, note.nDuration / nTimePerColumn, nNoteHeight, olc::WHITE);
				}
				 
				nOffsetY += (nNoteRange + 1) * nNoteHeight + 4;
			}
		}

		// BELOW - ABSOLUTELY HORRIBLE BODGE TO PLAY SOUND
		// DO NOT USE THIS CODE...
		
		/*
		dRunTime += fElapsedTime;
		uint32_t nTempo = 4;
		int nTrack = 1;
		while (dRunTime >= 1.0 / double(midi.m_nBPM * 8))
		{
			dRunTime -= 1.0 / double(midi.m_nBPM * 8);

			// Single MIDI Clock
			nMidiClock++;

			int i = 0;
			int nTrack = 1;
			//for (nTrack = 1; nTrack < 3; nTrack++)
			{
				if (nCurrentNote[nTrack] < midi.vecTracks[nTrack].vecEvents.size())
				{
					if (midi.vecTracks[nTrack].vecEvents[nCurrentNote[nTrack]].nDeltaTick == 0)
					{
						uint32_t nStatus = 0;
						uint32_t nNote = midi.vecTracks[nTrack].vecEvents[nCurrentNote[nTrack]].nKey;
						uint32_t nVelocity = midi.vecTracks[nTrack].vecEvents[nCurrentNote[nTrack]].nVelocity;

#ifdef WIN32
						if (midi.vecTracks[nTrack].vecEvents[nCurrentNote[nTrack]].event == MidiEvent::Type::NoteOn)
							nStatus = 0x90;
						else
							nStatus = 0x80;

						midiOutShortMsg(hInstrument, (nVelocity << 16) | (nNote << 8) | nStatus);
#else
						if (midi.vecTracks[nTrack].vecEvents[nCurrentNote[nTrack]].event == MidiEvent::Type::NoteOn)
							fluid_synth_noteon(synth, nTrack, nNote, nVelocity);
						else
							fluid_synth_noteoff(synth, nTrack, nNote);
#endif
						nCurrentNote[nTrack]++;
					}
					else
						midi.vecTracks[nTrack].vecEvents[nCurrentNote[nTrack]].nDeltaTick--;
				}
			}
		}

#ifdef WIN32
		if (GetKey(olc::Key::SPACE).bPressed)
		{
			midiOutShortMsg(hInstrument, 0x00403C90);
		}

		if (GetKey(olc::Key::SPACE).bReleased)
		{
			midiOutShortMsg(hInstrument, 0x00003C80);
		}
#else
		if (GetKey(olc::Key::SPACE).bPressed)
		{
			fluid_synth_noteon(synth, 0, 0x3C, 0x40);
		}
		if (GetKey(olc::Key::SPACE).bReleased)
		{
			fluid_synth_noteoff(synth, 0, 0x3C);
		}
#endif
		*/


		return true;
	}

#ifndef WIN32
    bool OnUserDestroy() override
    {
        /* Clean up */
        delete_fluid_audio_driver(adriver);
        delete_fluid_synth(synth);
        delete_fluid_settings(settings);

        return true;
    }
#endif
	
};

int main()
{
	olcMIDIViewer demo;
	if (demo.Construct(1280, 960, 1, 1))
		demo.Start();
	return 0;
}