jgrogan/stuff-from-scratch
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Clean up some tests.

Browse source
This commit is contained in:
James Grogan 2022-12-01 10:52:48 +00:00
parent b17ba8b3a7
commit c102ebb6da
64 changed files with 615 additions and 541 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/audio/midi/reader/MidiChannelEventAdapter.cpp
View file

@ -13,7 +13,7 @@ int MidiChannelEventAdapter::ReadEvent(std::ifstream* file, char firstByte, Midi
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;
//std::cout << "Channel: " << midi_channel << std::endl;
const bool isStatusByte = ByteUtils::MostSignificantBitIsOne(firstByte);
if(isStatusByte)
@ -25,7 +25,7 @@ int MidiChannelEventAdapter::ReadEvent(std::ifstream* file, char firstByte, Midi
{
event->SetType(lastEventType);
}
std::cout << "MC Type " << static_cast<int>(event->GetType()) << std::endl;
//std::cout << "MC Type " << static_cast<int>(event->GetType()) << std::endl;
switch(event->GetType())
{
case MidiChannelEvent::Type::NOTE_ON:
@ -49,7 +49,7 @@ int MidiChannelEventAdapter::ReadEvent(std::ifstream* file, char firstByte, Midi
break;
}
default:
std::cout << "Unknown status event: " << std::bitset<8>(firstByte) << "|" << event_type <<std::endl;
//std::cout << "Unknown status event: " << std::bitset<8>(firstByte) << "|" << event_type <<std::endl;
break;
}
return byteCount;

2
src/audio/midi/reader/MidiMetaEventAdapter.cpp
View file

@ -15,7 +15,7 @@ int MidiMetaEventAdapter::ReadEvent(std::ifstream* file, MetaMidiEvent* event, i
event->SetType(c);
std::cout << "Meta event type: " << std::hex << int(c) << std::dec<<std::endl;
//std::cout << "Meta event type: " << std::hex << int(c) << std::dec<<std::endl;
switch (event->GetType())
{

56
src/audio/midi/reader/MidiReader.cpp
View file

@ -22,32 +22,32 @@ MidiReader::MidiReader()
}
MidiDocument* MidiReader::GetDocument() const
MidiDocument* MidiReader::getDocument() const
{
return mDocument.get();
}
bool MidiReader::ProcessHeader()
bool MidiReader::processHeader()
{
if(!BinaryStream::checkNextDWord(mFile->GetInHandle(), HeaderLabel))
if(!BinaryStream::checkNextDWord(mFile->getInHandle(), HeaderLabel))
{
return false;
}
const auto length = BinaryStream::getNextDWord(mFile->GetInHandle());
const auto length = BinaryStream::getNextDWord(mFile->getInHandle());
if(!length)
{
return false;
}
const auto formatType = BinaryStream::getNextWord(mFile->GetInHandle());
const auto formatType = BinaryStream::getNextWord(mFile->getInHandle());
if(!formatType)
{
return false;
}
mDocument->SetFormatType(*formatType);
const auto expectedTracks = BinaryStream::getNextWord(mFile->GetInHandle());
const auto expectedTracks = BinaryStream::getNextWord(mFile->getInHandle());
if(!expectedTracks)
{
return false;
@ -55,52 +55,52 @@ bool MidiReader::ProcessHeader()
mDocument->SetExpectedTracks(*expectedTracks);
MidiTimeDivision timeDivision;
MidiTimeAdapter::ReadTimeDivision(mFile->GetInHandle(), timeDivision);
MidiTimeAdapter::ReadTimeDivision(mFile->getInHandle(), timeDivision);
mDocument->SetTimeDivision(timeDivision);
return true;
}
int MidiReader::ProcessEvent(MidiTrack* track)
int MidiReader::processEvent(MidiTrack* track)
{
int timeDelta {0};
unsigned byteCount {0};
byteCount += MidiTimeAdapter::ReadEventTimeDelta(mFile->GetInHandle(), timeDelta);
byteCount += MidiTimeAdapter::ReadEventTimeDelta(mFile->getInHandle(), timeDelta);
char c;
mFile->GetInHandle()->get(c);
std::cout << "Event check: " << std::bitset<8>(c) << std::endl;
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);
//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;
//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);
//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)
bool MidiReader::processTrackChunk(bool debug)
{
if(!BinaryStream::checkNextDWord(mFile->GetInHandle(), TrackChunkLabel))
if(!BinaryStream::checkNextDWord(mFile->getInHandle(), TrackChunkLabel))
{
return false;
}
const auto chunkSize = BinaryStream::getNextDWord(mFile->GetInHandle());
const auto chunkSize = BinaryStream::getNextDWord(mFile->getInHandle());
if(!chunkSize)
{
return false;
@ -111,9 +111,9 @@ bool MidiReader::ProcessTrackChunk(bool debug)
unsigned iter_count = 0;
while(byteCount < static_cast<unsigned>(*chunkSize))
{
std::cout << "-------------" << std::endl;
byteCount += ProcessEvent(track.get());
std::cout << "Track byte count: " << byteCount << " of " << *chunkSize << std::endl;
//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;
@ -124,30 +124,30 @@ bool MidiReader::ProcessTrackChunk(bool debug)
return true;
}
void MidiReader::Read(const std::string& path)
void MidiReader::read(const Path& path)
{
mFile = std::make_unique<File>(path);
mFile->Open(true);
if(!ProcessHeader())
mFile->open(File::AccessMode::Read);
if(!processHeader())
{
MLOG_ERROR("Problem processing header");
return;
}
int trackCount = 0;
if(!ProcessTrackChunk(false))
if(!processTrackChunk(false))
{
MLOG_ERROR("Problem processing track chunk");
return;
}
trackCount++;
if(!ProcessTrackChunk(true))
if(!processTrackChunk(true))
{
MLOG_ERROR("Problem processing track chunk");
return;
}
trackCount++;
mFile->Close();
mFile->close();
}

17
src/audio/midi/reader/MidiReader.h
View file

@ -5,29 +5,30 @@
#include "MidiTrack.h"
#include "MidiChannelEvent.h"
#include "File.h"
#include <filesystem>
#include <string>
using Path = std::filesystem::path;
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;
MidiDocument* GetDocument() const;
void read(const Path& path);
private:
bool ProcessHeader();
bool ProcessTrackChunk(bool debug=false);
int ProcessEvent(MidiTrack* track);
bool processHeader();
bool processTrackChunk(bool debug=false);
int processEvent(MidiTrack* track);
private:
std::unique_ptr<File> mFile;
MidiDocumentPtr mDocument;
int mLastMidiChannel {0};

12
src/audio/midi/reader/MidiTimeAdapter.cpp
View file

@ -16,14 +16,14 @@ int MidiTimeAdapter::ReadEventTimeDelta(std::ifstream* file, int& delta)
if(!ByteUtils::MostSignificantBitIsOne(c))
{
delta = int(c);
std::cout << "Time delta final: " << delta << std::endl;
//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;
//std::cout << "Working " << std::bitset<8>(working_c) << std::endl;
while(unsigned(working_c >> 7) != 0)
{
char corrected = (working_c &= ~(1UL << 7));
@ -33,16 +33,16 @@ int MidiTimeAdapter::ReadEventTimeDelta(std::ifstream* file, int& delta)
file->get(file_c);
byteCount++;
working_c = int(file_c);
std::cout << "Working " << std::bitset<8>(working_c) << std::endl;
//std::cout << "Working " << std::bitset<8>(working_c) << std::endl;
count++;
}
std::cout << "Time delta start: " << std::bitset<16>(final_c) << std::endl;
//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;
//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;
//std::cout << "Time delta final: " << delta << "|" << std::bitset<16>(final_c)<< std::endl;
return byteCount;
}