git subrepo clone --branch=sono6good https://github.com/essej/JUCE.git deps/juce
subrepo: subdir: "deps/juce" merged: "b13f9084e" upstream: origin: "https://github.com/essej/JUCE.git" branch: "sono6good" commit: "b13f9084e" git-subrepo: version: "0.4.3" origin: "https://github.com/ingydotnet/git-subrepo.git" commit: "2f68596"
This commit is contained in:
essej
807
deps/juce/modules/juce_audio_basics/midi/juce_MidiFile.cpp
vendored
Normal file
807
deps/juce/modules/juce_audio_basics/midi/juce_MidiFile.cpp
vendored
Normal file
@ -0,0 +1,807 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2020 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
namespace MidiFileHelpers
|
||||
{
|
||||
static void writeVariableLengthInt (OutputStream& out, uint32 v)
|
||||
{
|
||||
auto buffer = v & 0x7f;
|
||||
|
||||
while ((v >>= 7) != 0)
|
||||
{
|
||||
buffer <<= 8;
|
||||
buffer |= ((v & 0x7f) | 0x80);
|
||||
}
|
||||
|
||||
for (;;)
|
||||
{
|
||||
out.writeByte ((char) buffer);
|
||||
|
||||
if (buffer & 0x80)
|
||||
buffer >>= 8;
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
struct Optional
|
||||
{
|
||||
Optional() = default;
|
||||
|
||||
Optional (const Value& v)
|
||||
: value (v), valid (true) {}
|
||||
|
||||
Value value = Value();
|
||||
bool valid = false;
|
||||
};
|
||||
|
||||
template <typename Integral>
|
||||
struct ReadTrait;
|
||||
|
||||
template <>
|
||||
struct ReadTrait<uint32> { static constexpr auto read = ByteOrder::bigEndianInt; };
|
||||
|
||||
template <>
|
||||
struct ReadTrait<uint16> { static constexpr auto read = ByteOrder::bigEndianShort; };
|
||||
|
||||
template <typename Integral>
|
||||
Optional<Integral> tryRead (const uint8*& data, size_t& remaining)
|
||||
{
|
||||
using Trait = ReadTrait<Integral>;
|
||||
constexpr auto size = sizeof (Integral);
|
||||
|
||||
if (remaining < size)
|
||||
return {};
|
||||
|
||||
const Optional<Integral> result { Trait::read (data) };
|
||||
|
||||
data += size;
|
||||
remaining -= size;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
struct HeaderDetails
|
||||
{
|
||||
size_t bytesRead = 0;
|
||||
short timeFormat = 0;
|
||||
short fileType = 0;
|
||||
short numberOfTracks = 0;
|
||||
};
|
||||
|
||||
static Optional<HeaderDetails> parseMidiHeader (const uint8* const initialData,
|
||||
const size_t maxSize)
|
||||
{
|
||||
auto* data = initialData;
|
||||
auto remaining = maxSize;
|
||||
|
||||
auto ch = tryRead<uint32> (data, remaining);
|
||||
|
||||
if (! ch.valid)
|
||||
return {};
|
||||
|
||||
if (ch.value != ByteOrder::bigEndianInt ("MThd"))
|
||||
{
|
||||
auto ok = false;
|
||||
|
||||
if (ch.value == ByteOrder::bigEndianInt ("RIFF"))
|
||||
{
|
||||
for (int i = 0; i < 8; ++i)
|
||||
{
|
||||
ch = tryRead<uint32> (data, remaining);
|
||||
|
||||
if (! ch.valid)
|
||||
return {};
|
||||
|
||||
if (ch.value == ByteOrder::bigEndianInt ("MThd"))
|
||||
{
|
||||
ok = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (! ok)
|
||||
return {};
|
||||
}
|
||||
|
||||
const auto bytesRemaining = tryRead<uint32> (data, remaining);
|
||||
|
||||
if (! bytesRemaining.valid || bytesRemaining.value > remaining)
|
||||
return {};
|
||||
|
||||
const auto optFileType = tryRead<uint16> (data, remaining);
|
||||
|
||||
if (! optFileType.valid || 2 < optFileType.value)
|
||||
return {};
|
||||
|
||||
const auto optNumTracks = tryRead<uint16> (data, remaining);
|
||||
|
||||
if (! optNumTracks.valid || (optFileType.value == 0 && optNumTracks.value != 1))
|
||||
return {};
|
||||
|
||||
const auto optTimeFormat = tryRead<uint16> (data, remaining);
|
||||
|
||||
if (! optTimeFormat.valid)
|
||||
return {};
|
||||
|
||||
HeaderDetails result;
|
||||
|
||||
result.fileType = (short) optFileType.value;
|
||||
result.timeFormat = (short) optTimeFormat.value;
|
||||
result.numberOfTracks = (short) optNumTracks.value;
|
||||
result.bytesRead = maxSize - remaining;
|
||||
|
||||
return { result };
|
||||
}
|
||||
|
||||
static double convertTicksToSeconds (double time,
|
||||
const MidiMessageSequence& tempoEvents,
|
||||
int timeFormat)
|
||||
{
|
||||
if (timeFormat < 0)
|
||||
return time / (-(timeFormat >> 8) * (timeFormat & 0xff));
|
||||
|
||||
double lastTime = 0, correctedTime = 0;
|
||||
auto tickLen = 1.0 / (timeFormat & 0x7fff);
|
||||
auto secsPerTick = 0.5 * tickLen;
|
||||
auto numEvents = tempoEvents.getNumEvents();
|
||||
|
||||
for (int i = 0; i < numEvents; ++i)
|
||||
{
|
||||
auto& m = tempoEvents.getEventPointer(i)->message;
|
||||
auto eventTime = m.getTimeStamp();
|
||||
|
||||
if (eventTime >= time)
|
||||
break;
|
||||
|
||||
correctedTime += (eventTime - lastTime) * secsPerTick;
|
||||
lastTime = eventTime;
|
||||
|
||||
if (m.isTempoMetaEvent())
|
||||
secsPerTick = tickLen * m.getTempoSecondsPerQuarterNote();
|
||||
|
||||
while (i + 1 < numEvents)
|
||||
{
|
||||
auto& m2 = tempoEvents.getEventPointer(i + 1)->message;
|
||||
|
||||
if (m2.getTimeStamp() != eventTime)
|
||||
break;
|
||||
|
||||
if (m2.isTempoMetaEvent())
|
||||
secsPerTick = tickLen * m2.getTempoSecondsPerQuarterNote();
|
||||
|
||||
++i;
|
||||
}
|
||||
}
|
||||
|
||||
return correctedTime + (time - lastTime) * secsPerTick;
|
||||
}
|
||||
|
||||
template <typename MethodType>
|
||||
static void findAllMatchingEvents (const OwnedArray<MidiMessageSequence>& tracks,
|
||||
MidiMessageSequence& results,
|
||||
MethodType method)
|
||||
{
|
||||
for (auto* track : tracks)
|
||||
{
|
||||
auto numEvents = track->getNumEvents();
|
||||
|
||||
for (int j = 0; j < numEvents; ++j)
|
||||
{
|
||||
auto& m = track->getEventPointer(j)->message;
|
||||
|
||||
if ((m.*method)())
|
||||
results.addEvent (m);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static MidiMessageSequence readTrack (const uint8* data, int size)
|
||||
{
|
||||
double time = 0;
|
||||
uint8 lastStatusByte = 0;
|
||||
|
||||
MidiMessageSequence result;
|
||||
|
||||
while (size > 0)
|
||||
{
|
||||
const auto delay = MidiMessage::readVariableLengthValue (data, (int) size);
|
||||
|
||||
if (! delay.isValid())
|
||||
break;
|
||||
|
||||
data += delay.bytesUsed;
|
||||
size -= delay.bytesUsed;
|
||||
time += delay.value;
|
||||
|
||||
if (size <= 0)
|
||||
break;
|
||||
|
||||
int messSize = 0;
|
||||
const MidiMessage mm (data, size, messSize, lastStatusByte, time);
|
||||
|
||||
if (messSize <= 0)
|
||||
break;
|
||||
|
||||
size -= messSize;
|
||||
data += messSize;
|
||||
|
||||
result.addEvent (mm);
|
||||
|
||||
auto firstByte = *(mm.getRawData());
|
||||
|
||||
if ((firstByte & 0xf0) != 0xf0)
|
||||
lastStatusByte = firstByte;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
MidiFile::MidiFile() : timeFormat ((short) (unsigned short) 0xe728) {}
|
||||
MidiFile::~MidiFile() {}
|
||||
|
||||
MidiFile::MidiFile (const MidiFile& other) : timeFormat (other.timeFormat)
|
||||
{
|
||||
tracks.addCopiesOf (other.tracks);
|
||||
}
|
||||
|
||||
MidiFile& MidiFile::operator= (const MidiFile& other)
|
||||
{
|
||||
tracks.clear();
|
||||
tracks.addCopiesOf (other.tracks);
|
||||
timeFormat = other.timeFormat;
|
||||
return *this;
|
||||
}
|
||||
|
||||
MidiFile::MidiFile (MidiFile&& other)
|
||||
: tracks (std::move (other.tracks)),
|
||||
timeFormat (other.timeFormat)
|
||||
{
|
||||
}
|
||||
|
||||
MidiFile& MidiFile::operator= (MidiFile&& other)
|
||||
{
|
||||
tracks = std::move (other.tracks);
|
||||
timeFormat = other.timeFormat;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void MidiFile::clear()
|
||||
{
|
||||
tracks.clear();
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
int MidiFile::getNumTracks() const noexcept
|
||||
{
|
||||
return tracks.size();
|
||||
}
|
||||
|
||||
const MidiMessageSequence* MidiFile::getTrack (int index) const noexcept
|
||||
{
|
||||
return tracks[index];
|
||||
}
|
||||
|
||||
void MidiFile::addTrack (const MidiMessageSequence& trackSequence)
|
||||
{
|
||||
tracks.add (new MidiMessageSequence (trackSequence));
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
short MidiFile::getTimeFormat() const noexcept
|
||||
{
|
||||
return timeFormat;
|
||||
}
|
||||
|
||||
void MidiFile::setTicksPerQuarterNote (int ticks) noexcept
|
||||
{
|
||||
timeFormat = (short) ticks;
|
||||
}
|
||||
|
||||
void MidiFile::setSmpteTimeFormat (int framesPerSecond, int subframeResolution) noexcept
|
||||
{
|
||||
timeFormat = (short) (((-framesPerSecond) << 8) | subframeResolution);
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void MidiFile::findAllTempoEvents (MidiMessageSequence& results) const
|
||||
{
|
||||
MidiFileHelpers::findAllMatchingEvents (tracks, results, &MidiMessage::isTempoMetaEvent);
|
||||
}
|
||||
|
||||
void MidiFile::findAllTimeSigEvents (MidiMessageSequence& results) const
|
||||
{
|
||||
MidiFileHelpers::findAllMatchingEvents (tracks, results, &MidiMessage::isTimeSignatureMetaEvent);
|
||||
}
|
||||
|
||||
void MidiFile::findAllKeySigEvents (MidiMessageSequence& results) const
|
||||
{
|
||||
MidiFileHelpers::findAllMatchingEvents (tracks, results, &MidiMessage::isKeySignatureMetaEvent);
|
||||
}
|
||||
|
||||
double MidiFile::getLastTimestamp() const
|
||||
{
|
||||
double t = 0.0;
|
||||
|
||||
for (auto* ms : tracks)
|
||||
t = jmax (t, ms->getEndTime());
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
bool MidiFile::readFrom (InputStream& sourceStream,
|
||||
bool createMatchingNoteOffs,
|
||||
int* fileType)
|
||||
{
|
||||
clear();
|
||||
MemoryBlock data;
|
||||
|
||||
const int maxSensibleMidiFileSize = 200 * 1024 * 1024;
|
||||
|
||||
// (put a sanity-check on the file size, as midi files are generally small)
|
||||
if (! sourceStream.readIntoMemoryBlock (data, maxSensibleMidiFileSize))
|
||||
return false;
|
||||
|
||||
auto size = data.getSize();
|
||||
auto d = static_cast<const uint8*> (data.getData());
|
||||
|
||||
const auto optHeader = MidiFileHelpers::parseMidiHeader (d, size);
|
||||
|
||||
if (! optHeader.valid)
|
||||
return false;
|
||||
|
||||
const auto header = optHeader.value;
|
||||
timeFormat = header.timeFormat;
|
||||
|
||||
d += header.bytesRead;
|
||||
size -= (size_t) header.bytesRead;
|
||||
|
||||
for (int track = 0; track < header.numberOfTracks; ++track)
|
||||
{
|
||||
const auto optChunkType = MidiFileHelpers::tryRead<uint32> (d, size);
|
||||
|
||||
if (! optChunkType.valid)
|
||||
return false;
|
||||
|
||||
const auto optChunkSize = MidiFileHelpers::tryRead<uint32> (d, size);
|
||||
|
||||
if (! optChunkSize.valid)
|
||||
return false;
|
||||
|
||||
const auto chunkSize = optChunkSize.value;
|
||||
|
||||
if (size < chunkSize)
|
||||
return false;
|
||||
|
||||
if (optChunkType.value == ByteOrder::bigEndianInt ("MTrk"))
|
||||
readNextTrack (d, (int) chunkSize, createMatchingNoteOffs);
|
||||
|
||||
size -= chunkSize;
|
||||
d += chunkSize;
|
||||
}
|
||||
|
||||
const auto successful = (size == 0);
|
||||
|
||||
if (successful && fileType != nullptr)
|
||||
*fileType = header.fileType;
|
||||
|
||||
return successful;
|
||||
}
|
||||
|
||||
void MidiFile::readNextTrack (const uint8* data, int size, bool createMatchingNoteOffs)
|
||||
{
|
||||
auto sequence = MidiFileHelpers::readTrack (data, size);
|
||||
|
||||
// sort so that we put all the note-offs before note-ons that have the same time
|
||||
std::stable_sort (sequence.list.begin(), sequence.list.end(),
|
||||
[] (const MidiMessageSequence::MidiEventHolder* a,
|
||||
const MidiMessageSequence::MidiEventHolder* b)
|
||||
{
|
||||
auto t1 = a->message.getTimeStamp();
|
||||
auto t2 = b->message.getTimeStamp();
|
||||
|
||||
if (t1 < t2) return true;
|
||||
if (t2 < t1) return false;
|
||||
|
||||
return a->message.isNoteOff() && b->message.isNoteOn();
|
||||
});
|
||||
|
||||
if (createMatchingNoteOffs)
|
||||
sequence.updateMatchedPairs();
|
||||
|
||||
addTrack (sequence);
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void MidiFile::convertTimestampTicksToSeconds()
|
||||
{
|
||||
MidiMessageSequence tempoEvents;
|
||||
findAllTempoEvents (tempoEvents);
|
||||
findAllTimeSigEvents (tempoEvents);
|
||||
|
||||
if (timeFormat != 0)
|
||||
{
|
||||
for (auto* ms : tracks)
|
||||
{
|
||||
for (int j = ms->getNumEvents(); --j >= 0;)
|
||||
{
|
||||
auto& m = ms->getEventPointer(j)->message;
|
||||
m.setTimeStamp (MidiFileHelpers::convertTicksToSeconds (m.getTimeStamp(), tempoEvents, timeFormat));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
bool MidiFile::writeTo (OutputStream& out, int midiFileType) const
|
||||
{
|
||||
jassert (midiFileType >= 0 && midiFileType <= 2);
|
||||
|
||||
if (! out.writeIntBigEndian ((int) ByteOrder::bigEndianInt ("MThd"))) return false;
|
||||
if (! out.writeIntBigEndian (6)) return false;
|
||||
if (! out.writeShortBigEndian ((short) midiFileType)) return false;
|
||||
if (! out.writeShortBigEndian ((short) tracks.size())) return false;
|
||||
if (! out.writeShortBigEndian (timeFormat)) return false;
|
||||
|
||||
for (auto* ms : tracks)
|
||||
if (! writeTrack (out, *ms))
|
||||
return false;
|
||||
|
||||
out.flush();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool MidiFile::writeTrack (OutputStream& mainOut, const MidiMessageSequence& ms) const
|
||||
{
|
||||
MemoryOutputStream out;
|
||||
|
||||
int lastTick = 0;
|
||||
uint8 lastStatusByte = 0;
|
||||
bool endOfTrackEventWritten = false;
|
||||
|
||||
for (int i = 0; i < ms.getNumEvents(); ++i)
|
||||
{
|
||||
auto& mm = ms.getEventPointer(i)->message;
|
||||
|
||||
if (mm.isEndOfTrackMetaEvent())
|
||||
endOfTrackEventWritten = true;
|
||||
|
||||
auto tick = roundToInt (mm.getTimeStamp());
|
||||
auto delta = jmax (0, tick - lastTick);
|
||||
MidiFileHelpers::writeVariableLengthInt (out, (uint32) delta);
|
||||
lastTick = tick;
|
||||
|
||||
auto* data = mm.getRawData();
|
||||
auto dataSize = mm.getRawDataSize();
|
||||
auto statusByte = data[0];
|
||||
|
||||
if (statusByte == lastStatusByte
|
||||
&& (statusByte & 0xf0) != 0xf0
|
||||
&& dataSize > 1
|
||||
&& i > 0)
|
||||
{
|
||||
++data;
|
||||
--dataSize;
|
||||
}
|
||||
else if (statusByte == 0xf0) // Write sysex message with length bytes.
|
||||
{
|
||||
out.writeByte ((char) statusByte);
|
||||
|
||||
++data;
|
||||
--dataSize;
|
||||
|
||||
MidiFileHelpers::writeVariableLengthInt (out, (uint32) dataSize);
|
||||
}
|
||||
|
||||
out.write (data, (size_t) dataSize);
|
||||
lastStatusByte = statusByte;
|
||||
}
|
||||
|
||||
if (! endOfTrackEventWritten)
|
||||
{
|
||||
out.writeByte (0); // (tick delta)
|
||||
auto m = MidiMessage::endOfTrack();
|
||||
out.write (m.getRawData(), (size_t) m.getRawDataSize());
|
||||
}
|
||||
|
||||
if (! mainOut.writeIntBigEndian ((int) ByteOrder::bigEndianInt ("MTrk"))) return false;
|
||||
if (! mainOut.writeIntBigEndian ((int) out.getDataSize())) return false;
|
||||
|
||||
mainOut << out;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
//==============================================================================
|
||||
#if JUCE_UNIT_TESTS
|
||||
|
||||
struct MidiFileTest : public UnitTest
|
||||
{
|
||||
MidiFileTest()
|
||||
: UnitTest ("MidiFile", UnitTestCategories::midi)
|
||||
{}
|
||||
|
||||
void runTest() override
|
||||
{
|
||||
beginTest ("ReadTrack respects running status");
|
||||
{
|
||||
const auto sequence = parseSequence ([] (OutputStream& os)
|
||||
{
|
||||
MidiFileHelpers::writeVariableLengthInt (os, 100);
|
||||
writeBytes (os, { 0x90, 0x40, 0x40 });
|
||||
MidiFileHelpers::writeVariableLengthInt (os, 200);
|
||||
writeBytes (os, { 0x40, 0x40 });
|
||||
MidiFileHelpers::writeVariableLengthInt (os, 300);
|
||||
writeBytes (os, { 0xff, 0x2f, 0x00 });
|
||||
});
|
||||
|
||||
expectEquals (sequence.getNumEvents(), 3);
|
||||
expect (sequence.getEventPointer (0)->message.isNoteOn());
|
||||
expect (sequence.getEventPointer (1)->message.isNoteOn());
|
||||
expect (sequence.getEventPointer (2)->message.isEndOfTrackMetaEvent());
|
||||
}
|
||||
|
||||
beginTest ("ReadTrack returns available messages if input is truncated");
|
||||
{
|
||||
{
|
||||
const auto sequence = parseSequence ([] (OutputStream& os)
|
||||
{
|
||||
// Incomplete delta time
|
||||
writeBytes (os, { 0xff });
|
||||
});
|
||||
|
||||
expectEquals (sequence.getNumEvents(), 0);
|
||||
}
|
||||
|
||||
{
|
||||
const auto sequence = parseSequence ([] (OutputStream& os)
|
||||
{
|
||||
// Complete delta with no following event
|
||||
MidiFileHelpers::writeVariableLengthInt (os, 0xffff);
|
||||
});
|
||||
|
||||
expectEquals (sequence.getNumEvents(), 0);
|
||||
}
|
||||
|
||||
{
|
||||
const auto sequence = parseSequence ([] (OutputStream& os)
|
||||
{
|
||||
// Complete delta with malformed following event
|
||||
MidiFileHelpers::writeVariableLengthInt (os, 0xffff);
|
||||
writeBytes (os, { 0x90, 0x40 });
|
||||
});
|
||||
|
||||
expectEquals (sequence.getNumEvents(), 1);
|
||||
expect (sequence.getEventPointer (0)->message.isNoteOff());
|
||||
expectEquals (sequence.getEventPointer (0)->message.getNoteNumber(), 0x40);
|
||||
expectEquals (sequence.getEventPointer (0)->message.getVelocity(), (uint8) 0x00);
|
||||
}
|
||||
}
|
||||
|
||||
beginTest ("Header parsing works");
|
||||
{
|
||||
{
|
||||
// No data
|
||||
const auto header = parseHeader ([] (OutputStream&) {});
|
||||
expect (! header.valid);
|
||||
}
|
||||
|
||||
{
|
||||
// Invalid initial byte
|
||||
const auto header = parseHeader ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 0xff });
|
||||
});
|
||||
|
||||
expect (! header.valid);
|
||||
}
|
||||
|
||||
{
|
||||
// Type block, but no header data
|
||||
const auto header = parseHeader ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 'M', 'T', 'h', 'd' });
|
||||
});
|
||||
|
||||
expect (! header.valid);
|
||||
}
|
||||
|
||||
{
|
||||
// We (ll-formed header, but track type is 0 and channels != 1
|
||||
const auto header = parseHeader ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 'M', 'T', 'h', 'd', 0, 0, 0, 6, 0, 0, 0, 16, 0, 1 });
|
||||
});
|
||||
|
||||
expect (! header.valid);
|
||||
}
|
||||
|
||||
{
|
||||
// Well-formed header, but track type is 5
|
||||
const auto header = parseHeader ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 'M', 'T', 'h', 'd', 0, 0, 0, 6, 0, 5, 0, 16, 0, 1 });
|
||||
});
|
||||
|
||||
expect (! header.valid);
|
||||
}
|
||||
|
||||
{
|
||||
// Well-formed header
|
||||
const auto header = parseHeader ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 'M', 'T', 'h', 'd', 0, 0, 0, 6, 0, 1, 0, 16, 0, 1 });
|
||||
});
|
||||
|
||||
expect (header.valid);
|
||||
|
||||
expectEquals (header.value.fileType, (short) 1);
|
||||
expectEquals (header.value.numberOfTracks, (short) 16);
|
||||
expectEquals (header.value.timeFormat, (short) 1);
|
||||
expectEquals ((int) header.value.bytesRead, 14);
|
||||
}
|
||||
}
|
||||
|
||||
beginTest ("Read from stream");
|
||||
{
|
||||
{
|
||||
// Empty input
|
||||
const auto file = parseFile ([] (OutputStream&) {});
|
||||
expect (! file.valid);
|
||||
}
|
||||
|
||||
{
|
||||
// Malformed header
|
||||
const auto file = parseFile ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 'M', 'T', 'h', 'd' });
|
||||
});
|
||||
|
||||
expect (! file.valid);
|
||||
}
|
||||
|
||||
{
|
||||
// Header, no channels
|
||||
const auto file = parseFile ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 'M', 'T', 'h', 'd', 0, 0, 0, 6, 0, 1, 0, 0, 0, 1 });
|
||||
});
|
||||
|
||||
expect (file.valid);
|
||||
expectEquals (file.value.getNumTracks(), 0);
|
||||
}
|
||||
|
||||
{
|
||||
// Header, one malformed channel
|
||||
const auto file = parseFile ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 'M', 'T', 'h', 'd', 0, 0, 0, 6, 0, 1, 0, 1, 0, 1 });
|
||||
writeBytes (os, { 'M', 'T', 'r', '?' });
|
||||
});
|
||||
|
||||
expect (! file.valid);
|
||||
}
|
||||
|
||||
{
|
||||
// Header, one channel with malformed message
|
||||
const auto file = parseFile ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 'M', 'T', 'h', 'd', 0, 0, 0, 6, 0, 1, 0, 1, 0, 1 });
|
||||
writeBytes (os, { 'M', 'T', 'r', 'k', 0, 0, 0, 1, 0xff });
|
||||
});
|
||||
|
||||
expect (file.valid);
|
||||
expectEquals (file.value.getNumTracks(), 1);
|
||||
expectEquals (file.value.getTrack (0)->getNumEvents(), 0);
|
||||
}
|
||||
|
||||
{
|
||||
// Header, one channel with incorrect length message
|
||||
const auto file = parseFile ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 'M', 'T', 'h', 'd', 0, 0, 0, 6, 0, 1, 0, 1, 0, 1 });
|
||||
writeBytes (os, { 'M', 'T', 'r', 'k', 0x0f, 0, 0, 0, 0xff });
|
||||
});
|
||||
|
||||
expect (! file.valid);
|
||||
}
|
||||
|
||||
{
|
||||
// Header, one channel, all well-formed
|
||||
const auto file = parseFile ([] (OutputStream& os)
|
||||
{
|
||||
writeBytes (os, { 'M', 'T', 'h', 'd', 0, 0, 0, 6, 0, 1, 0, 1, 0, 1 });
|
||||
writeBytes (os, { 'M', 'T', 'r', 'k', 0, 0, 0, 4 });
|
||||
|
||||
MidiFileHelpers::writeVariableLengthInt (os, 0x0f);
|
||||
writeBytes (os, { 0x80, 0x00, 0x00 });
|
||||
});
|
||||
|
||||
expect (file.valid);
|
||||
expectEquals (file.value.getNumTracks(), 1);
|
||||
|
||||
auto& track = *file.value.getTrack (0);
|
||||
expectEquals (track.getNumEvents(), 1);
|
||||
expect (track.getEventPointer (0)->message.isNoteOff());
|
||||
expectEquals (track.getEventPointer (0)->message.getTimeStamp(), (double) 0x0f);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Fn>
|
||||
static MidiMessageSequence parseSequence (Fn&& fn)
|
||||
{
|
||||
MemoryOutputStream os;
|
||||
fn (os);
|
||||
|
||||
return MidiFileHelpers::readTrack (reinterpret_cast<const uint8*> (os.getData()),
|
||||
(int) os.getDataSize());
|
||||
}
|
||||
|
||||
template <typename Fn>
|
||||
static MidiFileHelpers::Optional<MidiFileHelpers::HeaderDetails> parseHeader (Fn&& fn)
|
||||
{
|
||||
MemoryOutputStream os;
|
||||
fn (os);
|
||||
|
||||
return MidiFileHelpers::parseMidiHeader (reinterpret_cast<const uint8*> (os.getData()),
|
||||
os.getDataSize());
|
||||
}
|
||||
|
||||
template <typename Fn>
|
||||
static MidiFileHelpers::Optional<MidiFile> parseFile (Fn&& fn)
|
||||
{
|
||||
MemoryOutputStream os;
|
||||
fn (os);
|
||||
|
||||
MemoryInputStream is (os.getData(), os.getDataSize(), false);
|
||||
MidiFile mf;
|
||||
|
||||
int fileType = 0;
|
||||
|
||||
if (mf.readFrom (is, true, &fileType))
|
||||
return mf;
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
static void writeBytes (OutputStream& os, const std::vector<uint8>& bytes)
|
||||
{
|
||||
for (const auto& byte : bytes)
|
||||
os.writeByte ((char) byte);
|
||||
}
|
||||
};
|
||||
|
||||
static MidiFileTest midiFileTests;
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace juce
|
||||
Reference in New Issue
Block a user