Parse Midi from byte array as well as string.

neogeek · neogeek · commit 26bab696f629 · 2025-01-18T18:05:46.000-05:00
diff --git a/RhythmGameUtilities.Tests/MidiTest.cs b/RhythmGameUtilities.Tests/MidiTest.cs
@@ -7,6 +7,49 @@ namespace RhythmGameUtilities.Tests
     public class MidiTest
     {
 
+        [Test]
+        public void TestReadMidiData()
+        {
+            var directory = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
+            var path = Path.GetFullPath(Path.Combine(directory, "../../../Mocks/song.mid"));
+
+            var content = File.ReadAllBytes(path);
+
+            var notes = Midi.ReadMidiData(content);
+
+            Assert.That(notes.Count, Is.EqualTo(10));
+
+            Assert.That(notes[0].Position, Is.EqualTo(0));
+            Assert.That(notes[0].HandPosition, Is.EqualTo(48));
+
+            Assert.That(notes[1].Position, Is.EqualTo(480));
+            Assert.That(notes[1].HandPosition, Is.EqualTo(50));
+
+            Assert.That(notes[2].Position, Is.EqualTo(960));
+            Assert.That(notes[2].HandPosition, Is.EqualTo(52));
+
+            Assert.That(notes[3].Position, Is.EqualTo(1440));
+            Assert.That(notes[3].HandPosition, Is.EqualTo(54));
+
+            Assert.That(notes[4].Position, Is.EqualTo(1920));
+            Assert.That(notes[4].HandPosition, Is.EqualTo(56));
+
+            Assert.That(notes[5].Position, Is.EqualTo(2400));
+            Assert.That(notes[5].HandPosition, Is.EqualTo(48));
+
+            Assert.That(notes[6].Position, Is.EqualTo(2400));
+            Assert.That(notes[6].HandPosition, Is.EqualTo(50));
+
+            Assert.That(notes[7].Position, Is.EqualTo(2400));
+            Assert.That(notes[7].HandPosition, Is.EqualTo(52));
+
+            Assert.That(notes[8].Position, Is.EqualTo(2400));
+            Assert.That(notes[8].HandPosition, Is.EqualTo(54));
+
+            Assert.That(notes[9].Position, Is.EqualTo(2400));
+            Assert.That(notes[9].HandPosition, Is.EqualTo(56));
+        }
+
         [Test]
         public void TestReadMidiFile()
         {
diff --git a/RhythmGameUtilities/Scripts/Midi.cs b/RhythmGameUtilities/Scripts/Midi.cs
@@ -8,6 +8,9 @@ namespace RhythmGameUtilities
     internal static class MidiInternal
     {
 
+        [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr ReadMidiDataInternal(byte[] bytes, int dataSize, out int size);
+
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
         public static extern IntPtr ReadMidiFileInternal(string filename, out int size);
 
@@ -16,6 +19,27 @@ internal static class MidiInternal
     public static class Midi
     {
 
+        public static List<Note> ReadMidiData(byte[] bytes)
+        {
+            var notes = new List<Note>();
+
+            var ptrArray = MidiInternal.ReadMidiDataInternal(bytes, bytes.Length, out var size);
+
+            var noteSize = Marshal.SizeOf(typeof(Note));
+
+            for (var i = 0; i < size; i += 1)
+            {
+                var noteSizePtr = new IntPtr(ptrArray.ToInt64() + noteSize * i);
+                var note = Marshal.PtrToStructure<Note>(noteSizePtr);
+
+                notes.Add(note);
+            }
+
+            Marshal.FreeHGlobal(ptrArray);
+
+            return notes;
+        }
+
         public static List<Note> ReadMidiFile(string path)
         {
             var notes = new List<Note>();
diff --git a/UnityPackage/Editor/Tests/MidiTest.cs b/UnityPackage/Editor/Tests/MidiTest.cs
@@ -7,6 +7,49 @@ namespace RhythmGameUtilities.Tests
     public class MidiTest
     {
 
+        [Test]
+        public void TestReadMidiData()
+        {
+            var directory = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
+            var path = Path.GetFullPath(Path.Combine(directory, "../../../Mocks/song.mid"));
+
+            var content = File.ReadAllBytes(path);
+
+            var notes = Midi.ReadMidiData(content);
+
+            Assert.That(notes.Count, Is.EqualTo(10));
+
+            Assert.That(notes[0].Position, Is.EqualTo(0));
+            Assert.That(notes[0].HandPosition, Is.EqualTo(48));
+
+            Assert.That(notes[1].Position, Is.EqualTo(480));
+            Assert.That(notes[1].HandPosition, Is.EqualTo(50));
+
+            Assert.That(notes[2].Position, Is.EqualTo(960));
+            Assert.That(notes[2].HandPosition, Is.EqualTo(52));
+
+            Assert.That(notes[3].Position, Is.EqualTo(1440));
+            Assert.That(notes[3].HandPosition, Is.EqualTo(54));
+
+            Assert.That(notes[4].Position, Is.EqualTo(1920));
+            Assert.That(notes[4].HandPosition, Is.EqualTo(56));
+
+            Assert.That(notes[5].Position, Is.EqualTo(2400));
+            Assert.That(notes[5].HandPosition, Is.EqualTo(48));
+
+            Assert.That(notes[6].Position, Is.EqualTo(2400));
+            Assert.That(notes[6].HandPosition, Is.EqualTo(50));
+
+            Assert.That(notes[7].Position, Is.EqualTo(2400));
+            Assert.That(notes[7].HandPosition, Is.EqualTo(52));
+
+            Assert.That(notes[8].Position, Is.EqualTo(2400));
+            Assert.That(notes[8].HandPosition, Is.EqualTo(54));
+
+            Assert.That(notes[9].Position, Is.EqualTo(2400));
+            Assert.That(notes[9].HandPosition, Is.EqualTo(56));
+        }
+
         [Test]
         public void TestReadMidiFile()
         {
diff --git a/UnityPackage/Editor/Tests/MidiTest.cs.meta b/UnityPackage/Editor/Tests/MidiTest.cs.meta
diff --git a/UnityPackage/Scripts/Midi.cs b/UnityPackage/Scripts/Midi.cs
@@ -8,6 +8,9 @@ namespace RhythmGameUtilities
     internal static class MidiInternal
     {
 
+        [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr ReadMidiDataInternal(byte[] bytes, int dataSize, out int size);
+
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
         public static extern IntPtr ReadMidiFileInternal(string filename, out int size);
 
@@ -16,6 +19,27 @@ internal static class MidiInternal
     public static class Midi
     {
 
+        public static List<Note> ReadMidiData(byte[] bytes)
+        {
+            var notes = new List<Note>();
+
+            var ptrArray = MidiInternal.ReadMidiDataInternal(bytes, bytes.Length, out var size);
+
+            var noteSize = Marshal.SizeOf(typeof(Note));
+
+            for (var i = 0; i < size; i += 1)
+            {
+                var noteSizePtr = new IntPtr(ptrArray.ToInt64() + noteSize * i);
+                var note = Marshal.PtrToStructure<Note>(noteSizePtr);
+
+                notes.Add(note);
+            }
+
+            Marshal.FreeHGlobal(ptrArray);
+
+            return notes;
+        }
+
         public static List<Note> ReadMidiFile(string path)
         {
             var notes = new List<Note>();
diff --git a/UnityPackage/Scripts/Midi.cs.meta b/UnityPackage/Scripts/Midi.cs.meta
diff --git a/include/RhythmGameUtilities/Midi.hpp b/include/RhythmGameUtilities/Midi.hpp
@@ -1,6 +1,8 @@
 #pragma once
 
+#include <cstdint>
 #include <fstream>
+#include <sstream>
 #include <string>
 #include <vector>
 
@@ -14,27 +16,28 @@ template <typename T> T ByteSwap(T value, int length = 8)
     return (value >> length) | (value << length);
 }
 
-template <typename T> T ReadChunk(std::ifstream &file, int length = sizeof(T))
+template <typename T>
+T ReadChunk(std::istringstream &stream, int length = sizeof(T))
 {
     T chunk{};
-    file.read(reinterpret_cast<char *>(&chunk), length);
+    stream.read(reinterpret_cast<char *>(&chunk), length);
     return chunk;
 }
 
-std::string ReadString(std::ifstream &file, int length)
+std::string ReadString(std::istringstream &stream, int length)
 {
     std::string chunk(length, '\0');
-    file.read(&chunk[0], length);
-    return file.gcount() == length ? chunk : "";
+    stream.read(&chunk[0], length);
+    return stream.gcount() == length ? chunk : "";
 }
 
-uint32_t ReadVarLen(std::ifstream &file)
+uint32_t ReadVarLen(std::istringstream &stream)
 {
     uint32_t value = 0;
     uint8_t byte = 0;
     do
     {
-        byte = ReadChunk<uint8_t>(file);
+        byte = ReadChunk<uint8_t>(stream);
         value = (value << 7) | (byte & 0x7F);
     } while (byte & 0x80);
     return value;
@@ -44,60 +47,56 @@ auto STATUS_NOTE_EVENT = 0x90;
 auto STATUS_META_EVENT = 0xFF;
 auto TYPE_END_OF_TRACK = 0x2F;
 
-std::vector<Note> ReadMidiFile(const std::string &path)
+std::vector<Note> ReadMidiData(const std::vector<uint8_t> &data)
 {
-    std::ifstream file(path, std::ios::binary);
-
-    if (!file.is_open())
-    {
-        throw std::runtime_error("Cannot open MIDI file");
-    }
+    std::istringstream stream(std::string(data.begin(), data.end()),
+                              std::ios::binary);
 
-    if (ReadString(file, 4) != "MThd")
+    if (ReadString(stream, 4) != "MThd")
     {
         throw std::runtime_error("Invalid MIDI file header");
     }
 
-    auto headerLength = ByteSwap(ReadChunk<uint32_t>(file));
-    auto format = ByteSwap(ReadChunk<uint16_t>(file));
-    auto tracks = ByteSwap(ReadChunk<uint16_t>(file));
-    auto resolution = ByteSwap(ReadChunk<uint16_t>(file));
+    auto headerLength = ByteSwap(ReadChunk<uint32_t>(stream));
+    auto format = ByteSwap(ReadChunk<uint16_t>(stream));
+    auto tracks = ByteSwap(ReadChunk<uint16_t>(stream));
+    auto resolution = ByteSwap(ReadChunk<uint16_t>(stream));
 
     std::vector<Note> notes;
 
     for (int t = 0; t < tracks; t += 1)
     {
-        if (ReadString(file, 4) != "MTrk")
+        if (ReadString(stream, 4) != "MTrk")
         {
             throw std::runtime_error("Invalid track header");
         }
 
-        auto trackLength = ByteSwap(ReadChunk<uint32_t>(file));
+        auto trackLength = ByteSwap(ReadChunk<uint32_t>(stream));
 
         uint32_t absoluteTick = 0;
 
         while (true)
         {
-            absoluteTick += ReadVarLen(file);
+            absoluteTick += ReadVarLen(stream);
 
-            auto status = ReadChunk<uint8_t>(file);
+            auto status = ReadChunk<uint8_t>(stream);
 
             if ((status & 0xF0) == STATUS_NOTE_EVENT)
             {
                 Note note{.Position = static_cast<int>(absoluteTick),
-                          .HandPosition = ReadChunk<uint8_t>(file)};
+                          .HandPosition = ReadChunk<uint8_t>(stream)};
 
-                auto velocity = ReadChunk<uint8_t>(file);
+                auto velocity = ReadChunk<uint8_t>(stream);
 
                 notes.push_back(note);
             }
             else if (status == STATUS_META_EVENT)
             {
-                auto type = ReadChunk<uint8_t>(file);
+                auto type = ReadChunk<uint8_t>(stream);
 
-                auto length = ReadVarLen(file);
+                auto length = ReadVarLen(stream);
 
-                file.seekg(length, std::ios::cur);
+                stream.seekg(length, std::ios::cur);
 
                 if (type == TYPE_END_OF_TRACK)
                 {
@@ -106,16 +105,36 @@ std::vector<Note> ReadMidiFile(const std::string &path)
             }
             else if ((status & 0xF0) == 0xC0 || (status & 0xF0) == 0xD0)
             {
-                file.seekg(1, std::ios::cur);
+                stream.seekg(1, std::ios::cur);
             }
             else
             {
-                file.seekg(2, std::ios::cur);
+                stream.seekg(2, std::ios::cur);
             }
         }
     }
 
     return notes;
 }
 
+std::vector<Note> ReadMidiFile(const std::string &path)
+{
+    std::ifstream file(path, std::ios::binary | std::ios::ate);
+
+    if (!file.is_open())
+    {
+        throw std::runtime_error("Cannot open MIDI file");
+    }
+
+    auto fileSize = file.tellg();
+
+    std::vector<uint8_t> buffer(static_cast<size_t>(fileSize));
+
+    file.seekg(0, std::ios::beg);
+
+    file.read(reinterpret_cast<char *>(buffer.data()), fileSize);
+
+    return ReadMidiData(buffer);
+}
+
 } // namespace RhythmGameUtilities
diff --git a/include/RhythmGameUtilities/MidiInternal.hpp b/include/RhythmGameUtilities/MidiInternal.hpp
@@ -18,6 +18,25 @@ namespace RhythmGameUtilities
 extern "C"
 {
 
+    PACKAGE_API Note *ReadMidiDataInternal(const uint8_t *data, int dataSize,
+                                           int *outSize)
+    {
+        std::vector<uint8_t> byteVector(data, data + dataSize);
+
+        auto internalNotes = ReadMidiData(byteVector);
+
+        *outSize = internalNotes.size();
+
+        auto notes = (Note *)malloc(internalNotes.size() * sizeof(Note));
+
+        for (auto i = 0; i < internalNotes.size(); i += 1)
+        {
+            notes[i] = internalNotes[i];
+        }
+
+        return notes;
+    }
+
     PACKAGE_API Note *ReadMidiFileInternal(const std::string &path,
                                            int *outSize)
     {
diff --git a/tests/RhythmGameUtilities/Midi.cpp b/tests/RhythmGameUtilities/Midi.cpp
