Improve audio and midi support.

src/audio/midi/reader/MidiChannelEventAdapter.cpp

@@ -0,0 +1,77 @@
+#include "MidiChannelEventAdapter.h"
+
+#include "BinaryFile.h"
+#include "ByteUtils.h"
+
+#include <iostream>
+#include <bitset>
+
+int MidiChannelEventAdapter::ReadEvent(std::ifstream* file, char firstByte, MidiChannelEvent* event, MidiChannelEvent::Type& lastEventType)
+{
+    int first_four_bits = 0xF0;
+    int second_four_bits = 0xF;
+    int event_type = (firstByte & first_four_bits) >> 4;
+    int midi_channel = (firstByte & second_four_bits) >> 4;
+    unsigned byteCount = 0;
+    std::cout << "Channel: " << midi_channel << std::endl;
+
+    const bool isStatusByte = ByteUtils::MSBIsOne(firstByte);
+    if(isStatusByte)
+    {
+        event->SetTypeAndChannel(firstByte);
+        lastEventType = event->GetType();
+    }
+    else
+    {
+        event->SetType(lastEventType);
+    }
+    std::cout << "MC Type " << static_cast<int>(event->GetType()) << std::endl;
+    switch(event->GetType())
+    {
+    case MidiChannelEvent::Type::NOTE_ON:
+    case MidiChannelEvent::Type::NOTE_OFF:
+    case MidiChannelEvent::Type::CONTROLLER:
+    {
+        if (isStatusByte)
+        {
+            byteCount += ReadEventData(file, event);
+        }
+        else
+        {
+            byteCount += ReadEventData(file, event, firstByte);
+        }
+        break;
+    }
+    case MidiChannelEvent::Type::PROGRAM:
+    {
+        int value0 = 0;
+        BinaryFile::GetNextByteAsInt(file, value0);
+        byteCount ++;
+        break;
+    }
+    default:
+        std::cout << "Unknown status event: " << std::bitset<8>(firstByte) << "|" << event_type <<std::endl;
+        break;
+    }
+    return byteCount;
+}
+
+int MidiChannelEventAdapter::ReadEventData(std::ifstream* file, MidiChannelEvent* event, char c)
+{
+    int value0 = int(c);
+    int value1 = 0;
+    BinaryFile::GetNextByteAsInt(file, value1);
+    event->SetValues(value0, value1);
+    return 1;
+}
+
+int MidiChannelEventAdapter::ReadEventData(std::ifstream* file, MidiChannelEvent* event)
+{
+    int value0 = 0;
+    BinaryFile::GetNextByteAsInt(file, value0);
+
+    int value1 = 0;
+    BinaryFile::GetNextByteAsInt(file, value1);
+    event->SetValues(value0, value1);
+    return 2;
+}

src/audio/midi/reader/MidiChannelEventAdapter.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "MidiChannelEvent.h"
+
+#include <fstream>
+
+class MidiChannelEventAdapter
+{
+public:
+    static int ReadEvent(std::ifstream* file, char firstByte, MidiChannelEvent* event, MidiChannelEvent::Type& lastEventType);
+
+    static int ReadEventData(std::ifstream* file, MidiChannelEvent* event, char c);
+    static int ReadEventData(std::ifstream* file, MidiChannelEvent* event);
+};

src/audio/midi/reader/MidiMetaEventAdapter.cpp

@@ -0,0 +1,190 @@
+#include "MidiMetaEventAdapter.h"
+
+#include "BinaryFile.h"
+#include "ByteUtils.h"
+
+#include <iostream>
+#include <bitset>
+
+int MidiMetaEventAdapter::ReadEvent(std::ifstream* file, MetaMidiEvent* event, int& lastMidiChannel)
+{
+    unsigned byteCount = 0;
+    char c;
+    file->get(c);
+    byteCount++;
+
+    event->SetType(c);
+
+    std::cout << "Meta event type: " << std::hex << int(c) << std::dec<<std::endl;
+
+    switch (event->GetType())
+    {
+    case MetaMidiEvent::Type::SEQ_NUM:
+        byteCount += ReadIntEvent(file, event, 2);
+        break;
+    case MetaMidiEvent::Type::TEXT:
+    case MetaMidiEvent::Type::COPYRIGHT:
+    case MetaMidiEvent::Type::TRACK_NAME:
+    case MetaMidiEvent::Type::INSTRUMENT_NAME:
+    case MetaMidiEvent::Type::MARKER:
+    case MetaMidiEvent::Type::CUE_POINT:
+        byteCount += ReadStringEvent(file, event);
+        break;
+    case MetaMidiEvent::Type::CHANNEL_PREFIX:
+        byteCount += ReadChannelPrefixEvent(file, event, lastMidiChannel);
+        break;
+    case MetaMidiEvent::Type::END_TRACK:
+    {
+        int length = 0;
+        BinaryFile::GetNextByteAsInt(file, length);
+        byteCount ++;
+        break;
+    }
+    case MetaMidiEvent::Type::SMPTE_OFFSET:
+        byteCount += ReadTimeCodeEvent(file, event);
+        break;
+    case MetaMidiEvent::Type::SET_TEMPO:
+        byteCount += ReadIntEvent(file, event);
+        break;
+    case MetaMidiEvent::Type::TIME_SIG:
+        byteCount += ReadTimeSignatureEvent(file, event);
+        break;
+    case MetaMidiEvent::Type::KEY_SIG:
+        byteCount += ReadKeySignatureEvent(file, event);
+        break;
+    case MetaMidiEvent::Type::SEQ_CUSTOM:
+        break;
+    case MetaMidiEvent::Type::UNKNOWN:
+        std::cout << "Unknown meta event " << std::bitset<8>(c) << "|"  <<std::endl;
+        byteCount += ReadUnknownEvent(file);
+        break;
+    default:
+        break;
+    }
+    return byteCount;
+}
+
+int MidiMetaEventAdapter::ReadUnknownEvent(std::ifstream* file)
+{
+    int length = 0;
+    BinaryFile::GetNextByteAsInt(file, length);
+
+    char c;
+    for(unsigned idx=0; idx<length; idx++)
+    {
+        file->get(c);
+    }
+    return length;
+}
+
+int MidiMetaEventAdapter::ReadStringEvent(std::ifstream* file, MetaMidiEvent* event)
+{
+    unsigned byteCount = 0;
+
+    int length = 0;
+    BinaryFile::GetNextByteAsInt(file, length);
+    byteCount++;
+
+    std::string name;
+    BinaryFile::GetNextString(file, name, length);
+    byteCount += length;
+    event->SetLabel(name);
+    return byteCount;
+}
+
+int MidiMetaEventAdapter::ReadIntEvent(std::ifstream* file, MetaMidiEvent* event, int lengthIn)
+{
+    unsigned byteCount = 0;
+    int length = 0;
+    if(lengthIn > -1)
+    {
+        length = lengthIn;
+    }
+    else
+    {
+        BinaryFile::GetNextByteAsInt(file, length);
+        byteCount ++;
+    }
+
+    std::string buffer;
+    BinaryFile::GetNextNBytes(file, buffer.data(), length);
+    byteCount += length;
+
+    const int value = ByteUtils::ToInt(buffer.data(), length);
+    event->SetValue(value);
+    return byteCount;
+}
+
+int MidiMetaEventAdapter::ReadChannelPrefixEvent(std::ifstream* file, MetaMidiEvent* event, int& lastMidiChannel)
+{
+    unsigned byteCount = 0;
+    int length = 0;
+    BinaryFile::GetNextByteAsInt(file, length);
+    byteCount ++;
+
+    std::string buffer;
+    BinaryFile::GetNextNBytes(file, buffer.data(), length);
+    byteCount += length;
+
+    const int value = ByteUtils::ToInt(buffer.data(), length);
+    event->SetValue(value);
+    lastMidiChannel = value;
+    return byteCount;
+}
+
+int MidiMetaEventAdapter::ReadTimeSignatureEvent(std::ifstream* file, MetaMidiEvent* event)
+{
+    unsigned byteCount = 0;
+    int length = 0;
+    BinaryFile::GetNextByteAsInt(file, length);
+    byteCount++;
+
+    MidiTimeSignature timeSig;
+    BinaryFile::GetNextByteAsInt(file, timeSig.mNumer);
+    BinaryFile::GetNextByteAsInt(file, timeSig.mDenom);
+    BinaryFile::GetNextByteAsInt(file, timeSig.mMetro);
+    BinaryFile::GetNextByteAsInt(file, timeSig.mF32);
+    byteCount +=4;
+
+    if (length > 4)
+    {
+        char c;
+        for(unsigned idx=0; idx<length-4; idx++)
+        {
+            file->get(c);
+            byteCount++;
+        }
+    }
+    return byteCount;
+}
+
+int MidiMetaEventAdapter::ReadKeySignatureEvent(std::ifstream* file, MetaMidiEvent* event)
+{
+    unsigned byteCount = 0;
+    int length = 0;
+    BinaryFile::GetNextByteAsInt(file, length);
+    byteCount++;
+
+    MidiKeySignature keySig;
+    BinaryFile::GetNextByteAsInt(file, keySig.mSharpsFlats);
+    BinaryFile::GetNextByteAsInt(file, keySig.mMinor);
+    byteCount +=2;
+    return byteCount;
+}
+
+int MidiMetaEventAdapter::ReadTimeCodeEvent(std::ifstream* file, MetaMidiEvent* event)
+{
+    unsigned byteCount = 0;
+    int length = 0;
+    BinaryFile::GetNextByteAsInt(file, length);
+    byteCount++;
+
+    MidiSmtpeTimecode timeCode;
+    BinaryFile::GetNextByteAsInt(file, timeCode.mHr);
+    BinaryFile::GetNextByteAsInt(file, timeCode.mMin);
+    BinaryFile::GetNextByteAsInt(file, timeCode.mSec);
+    BinaryFile::GetNextByteAsInt(file, timeCode.mFrame);
+    BinaryFile::GetNextByteAsInt(file, timeCode.mFrameFrac);
+    byteCount +=5;
+    return byteCount;
+}

src/audio/midi/reader/MidiMetaEventAdapter.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "MetaMidiEvent.h"
+#include <fstream>
+
+
+class MidiMetaEventAdapter
+{
+public:
+
+    static int ReadEvent(std::ifstream* file, MetaMidiEvent* event, int& lastMidiChannel);
+
+    static int ReadIntEvent(std::ifstream* file, MetaMidiEvent* event, int length=-1);
+    static int ReadStringEvent(std::ifstream* file, MetaMidiEvent* event);
+
+    static int ReadChannelPrefixEvent(std::ifstream* file, MetaMidiEvent* event, int& lastMidiChannel);
+    static int ReadTimeSignatureEvent(std::ifstream* file, MetaMidiEvent* event);
+    static int ReadKeySignatureEvent(std::ifstream* file, MetaMidiEvent* event);
+    static int ReadTimeCodeEvent(std::ifstream* file, MetaMidiEvent* event);
+    static int ReadUnknownEvent(std::ifstream* file);
+};

src/audio/midi/reader/MidiReader.cpp

@@ -0,0 +1,153 @@
+#include "MidiReader.h"
+
+#include "MidiDocument.h"
+#include "ByteUtils.h"
+#include "MidiTrack.h"
+#include "BinaryFile.h"
+#include "FileLogger.h"
+#include "MidiElements.h"
+#include "MidiTimeAdapter.h"
+#include "MidiMetaEventAdapter.h"
+#include "MidiChannelEventAdapter.h"
+
+#include <fstream>
+#include <iostream>
+#include <cstring>
+#include <bitset>
+
+MidiReader::MidiReader()
+    : mDocument(MidiDocument::Create()),
+      mLastChannelEventType(MidiChannelEvent::Type::NONE)
+{
+
+}
+
+MidiDocument* MidiReader::GetDocument() const
+{
+    return mDocument.get();
+}
+
+bool MidiReader::ProcessHeader()
+{
+    if(!BinaryFile::CheckNextDWord(mFile->GetInHandle(), HeaderLabel))
+    {
+        return false;
+    }
+
+    int length = 0;
+    if(!BinaryFile::GetNextDWord(mFile->GetInHandle(), length))
+    {
+        return false;
+    }
+
+    int formatType { 0 };
+    if(!BinaryFile::GetNextWord(mFile->GetInHandle(), formatType))
+    {
+        return false;
+    }
+    mDocument->SetFormatType(formatType);
+
+    int expectedTracks { 0 };
+    if(!BinaryFile::GetNextWord(mFile->GetInHandle(), expectedTracks))
+    {
+        return false;
+    }
+    mDocument->SetExpectedTracks(expectedTracks);
+
+    MidiTimeDivision timeDivision;
+    MidiTimeAdapter::ReadTimeDivision(mFile->GetInHandle(), timeDivision);
+    mDocument->SetTimeDivision(timeDivision);
+    return true;
+}
+
+int MidiReader::ProcessEvent(MidiTrack* track)
+{
+    int timeDelta {0};
+    unsigned byteCount {0};
+    byteCount += MidiTimeAdapter::ReadEventTimeDelta(mFile->GetInHandle(), timeDelta);
+
+    char c;
+    mFile->GetInHandle()->get(c);
+    std::cout << "Event check: " << std::bitset<8>(c) << std::endl;
+    byteCount++;
+    if(MidiEvent::IsMetaEvent(c))
+    {
+        auto event = std::make_unique<MetaMidiEvent>();
+        event->SetTimeDelta(timeDelta);
+        std::cout << "Meta event " <<std::endl;
+        byteCount += MidiMetaEventAdapter::ReadEvent(mFile->GetInHandle(), event.get(), mLastMidiChannel);
+        track->AddEvent(std::move(event));
+    }
+    else if(MidiEvent::IsSysExEvent(c))
+    {
+        std::cout << "Sysex event" << std::endl;
+    }
+    else
+    {   // Midi event
+        auto event = std::make_unique<MidiChannelEvent>();
+        event->SetTimeDelta(timeDelta);
+        std::cout << "Midi event" << std::endl;
+        byteCount += MidiChannelEventAdapter::ReadEvent(mFile->GetInHandle(), c, event.get(), mLastChannelEventType);
+        track->AddEvent(std::move(event));
+    }
+    return byteCount;
+}
+
+bool MidiReader::ProcessTrackChunk(bool debug)
+{
+    if(!BinaryFile::CheckNextDWord(mFile->GetInHandle(), TrackChunkLabel))
+    {
+        return false;
+    }
+
+    int chunkSize = 0;
+    if(!BinaryFile::GetNextDWord(mFile->GetInHandle(), chunkSize))
+    {
+        return false;
+    }
+
+    unsigned byteCount = 0;
+    auto track = std::make_unique<MidiTrack>();
+    unsigned iter_count = 0;
+    while(byteCount < unsigned(chunkSize))
+    {
+        std::cout << "-------------" << std::endl;
+        byteCount += ProcessEvent(track.get());
+        std::cout << "Track byte count: " << byteCount << " of " << chunkSize << std::endl;
+        if(debug && iter_count == 40)
+        {
+            return true;
+        }
+        iter_count ++;
+    }
+    mDocument->AddTrack(std::move(track));
+    return true;
+}
+
+void MidiReader::Read(const std::string& path)
+{
+    mFile = std::make_unique<File>(path);
+    mFile->Open(true);
+    if(!ProcessHeader())
+    {
+        MLOG_ERROR("Problem processing header");
+        return;
+    }
+
+    int trackCount = 0;
+    if(!ProcessTrackChunk(false))
+    {
+        MLOG_ERROR("Problem processing track chunk");
+        return;
+    }
+    trackCount++;
+
+    if(!ProcessTrackChunk(true))
+    {
+        MLOG_ERROR("Problem processing track chunk");
+        return;
+    }
+    trackCount++;
+
+    mFile->Close();
+}

src/audio/midi/reader/MidiReader.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "MidiDocument.h"
+#include "MetaMidiEvent.h"
+#include "MidiTrack.h"
+#include "MidiChannelEvent.h"
+#include "File.h"
+#include <string>
+
+class MidiReader
+{
+    static constexpr const char TrackChunkLabel[] = "MTrk";
+    static constexpr const char HeaderLabel[] = "MThd";
+
+public:
+
+    MidiReader();
+
+    void Read(const std::string& path);
+
+    MidiDocument* GetDocument() const;
+
+private:
+
+    bool ProcessHeader();
+    bool ProcessTrackChunk(bool debug=false);
+    int ProcessEvent(MidiTrack* track);
+
+private:
+
+    std::unique_ptr<File> mFile;
+    MidiDocumentPtr mDocument;
+    int mLastMidiChannel {0};
+    MidiChannelEvent::Type mLastChannelEventType;
+};

src/audio/midi/reader/MidiTimeAdapter.cpp

@@ -0,0 +1,66 @@
+#include "MidiTimeAdapter.h"
+
+#include "BinaryFile.h"
+#include "ByteUtils.h"
+
+#include <iostream>
+#include <bitset>
+
+int MidiTimeAdapter::ReadEventTimeDelta(std::ifstream* file, int& delta)
+{
+    unsigned byteCount = 0;
+    char c;
+    file->get(c);
+    byteCount++;
+
+    if(!ByteUtils::MSBIsOne(c))
+    {
+        delta = int(c);
+        std::cout << "Time delta final: " << delta << std::endl;
+        return byteCount;
+    }
+
+    int working_c = c;
+    int final_c = 0;
+    unsigned count = 0;
+    std::cout << "Working " << std::bitset<8>(working_c) << std::endl;
+    while(unsigned(working_c >> 7) != 0)
+    {
+        char corrected = (working_c &= ~(1UL << 7));
+        final_c <<= 7;
+        final_c |= (corrected << 7*count);
+        char file_c;
+        file->get(file_c);
+        byteCount++;
+        working_c = int(file_c);
+        std::cout << "Working " << std::bitset<8>(working_c) << std::endl;
+        count++;
+    }
+    std::cout << "Time delta start: " << std::bitset<16>(final_c) << std::endl;
+    final_c <<= 7;
+    std::cout << "Time delta pre: " << std::bitset<16>(final_c) << std::endl;
+    final_c |= (working_c << 7*(count-1));
+
+    delta = int(final_c);
+    std::cout << "Time delta final: " << delta << "|" << std::bitset<16>(final_c)<< std::endl;
+    return byteCount;
+}
+
+int MidiTimeAdapter::ReadTimeDivision(std::ifstream* file, MidiTimeDivision& division)
+{
+    int time_division;
+    if(!BinaryFile::GetNextWord(file, time_division, false))
+    {
+        return -1;
+    }
+
+    division.mUseFps = ByteUtils::GetWordFirstBit(time_division);
+    if (division.mUseFps)
+    {
+        const int TOP_7_BITS = 0x7F00; // 0111 1111 - 0000 0000
+        division.mFps = ((~time_division & TOP_7_BITS) >> 8) - 1; // Reverse 2complement of next 7 bits
+    }
+
+    division.mTicks = ByteUtils::GetWordLastByte(time_division);
+    return 2; // Bytes advanced
+}

src/audio/midi/reader/MidiTimeAdapter.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "MidiElements.h"
+
+#include <fstream>
+
+class MidiTimeAdapter
+{
+public:
+    static int ReadEventTimeDelta(std::ifstream* file, int& delta);
+
+    static int ReadTimeDivision(std::ifstream* file, MidiTimeDivision& division);
+};