Bump Melanchall.DryWetMidi from 5.2.1 to 8.0.3

[dependabot]

Updated Melanchall.DryWetMidi from 5.2.1 to 8.0.3.

Release notes

Sourced from Melanchall.DryWetMidi's releases.

8.0.3

This small release is the last in this year. And the last one with support of 32-bit processes for Multimedia API on Windows.

Happy New Year! 🎄 🎉

[!IMPORTANT]
You can help to make the library better! Please take a quick survey.

Small changes

• Stabilized Playback.
• Handled exceptions within Playback.
• DeviceErrorOccurred event of Playback has been replaced with ErrorOccurred one.
• Changed the type of the time parameter to ITimeSpan in TimeSpanUtilities.Round for BarBeatTicksTimeSpan and BarBeatFractionTimeSpan (#​333).
• Improved TempoMap operations performance.
• Improved performance of BarBeatTicksTimeSpan conversion for simple cases.
• Handled null custom timed events in timed events processing utilities.
• Handled null custom notes in notes processing utilities.
• Handled null custom chords in chords processing utilities.

Bug fixes

• Fixed: Playback.NoteCallback is still applied to already played notes after it has been set to null.
• Fixed: Result of GetObjects is not sorted when chords and timed events requested, and notes and chords passed.
• Fixed: GetTempoMap returns wrong tempo map after events were set on EventsCollection by index.

8.0.2

Another one minor release. It fixes critical bug with the Playback – Playback skips some notes (#​334). It's highly recommended to switch to the new version of the library.

8.0.1

This minor release addresses issues with the Playback.

First of all, performance of Playback instance creation was degraded in the 8.0.0 version. Now that is fixed. More than that, Playback's constructor is faster and consumes less memory than in the 7.2.0 version. It's highly recommended to switch to the new version of the library.

Also, a couple of bugs were fixed:

• If you create an instance of the Playback via passing an objects collection, playback can work unexpectedly if input objects are not sorted by their times.
• If you change the time of a playback (for example, via MoveToTime) and there is a note in the new position, NoteCallback won't be applied.

8.0.0

Major playback improvements

Now it’s possible to change playback’s data on the fly (#​78)! It was a big challenge to implement this functionality (do you even use red-black trees?). But now you can add, remove and change objects without needing to recreate an instance of the Playback or even stop it. You’ll find the detailed guide on how to use the feature in the Dynamic changes article of the library docs.

Also a bunch of bugs related to the Playback were fixed:

• currently playing note is not interrupted when PlaybackEnd reached;
• MoveToTime has no effect if it’s executed just before the first Start method call;
• IsRunning can return invalid value due to race conditions when Loop property is set to true;
• Start and then Stop calls in the middle of a note can cause unexpected behavior when InterruptNotesOnStop and TrackNotes are set to true.

Data tracking is now on by default. So in case of jumps in time you’ll get correctly applied program, pitch and control values. TrackNotes is now true by default too. Of course you can turn the feature off via corresponding properties if you want.

Several new things were added:

• Playback: added SendNoteOffEventsForNonActiveNotes and SendNoteOnEventsForActiveNotes properties;
• PlaybackSettings: added CalculateTempoMap property;
• NotesPlaybackStarted and NotesPlaybackFinished events args: added original notes (see NotesEventArgs.OriginalNotes).

Please note that there are some breaking changes:

• Play method has been removed. It causes confusion and does nothing but just calling Start and then SpinWait.SpinUntil(() => !IsRunning). You can do these actions by yourself if you for some reason want the blocking playback.
• PlaybackHint has been removed from PlaybackSettings. There was no noticeable performance gain in using this feature. You can just disable data tracking if you want.
• Snapping has been reworked. First of all, there is no Snapping property within the Playback anymore. Snapping functionality was moved just right into the Playback. Snapping.IsEnabled is replaced with IsSnappingEnabled. SnapToNotesStarts and SnapToNotesEnds methods are replaced with the much more flexible SnapToEvents one.

New features and improvements

• Split CsvSerializerSettings into CsvSerializationSettings for serialization methods and CsvDeserializationSettings for deserialization ones.
• Time, length and note formats can be resolved automatically on CSV deserialization (which is the default behavior now).
• Added UnknownRecordPolicy property to CsvDeserializationSettings.
• Introduced CsvException which replaces FormatException in CsvSerializer.
• Added BytesArrayDelimiter property to CsvSerializationSettings and CsvDeserializationSettings.
• Added RemoveDuplicatedControlChangeEvents property to SanitizingSettings.
• Replaced RemoveOrphanedNoteOnEvents property of SanitizingSettings with OrphanedNoteOnEventsPolicy which provides more ways to handle orphaned Note On events.

Small changes and bug fixes

• Implemented piano roll multi-cell custom actions.
• Print line and symbol indices in piano roll errors.
• Handle empty collections in ManageTempoMap methods of the TempoMapManagingUtilities (#​321).
• Optimized MidiFileUtilities.GetDuration methods.
• Fixed: MIDI devices session is not closed on domain unload or process exit (#​318).
• Fixed: Bytes array values with whitespaces causes CSV deserialization failed.

7.2.0

Objects managing methods are unified

Now it's possible to process objects of different types simultaneously. Thus now you can call, for example, just midiFile.ProcessObjects(ObjectType.Chord | ObjectType.Note, ...) instead of ProcessChords after ProcessNotes. The same story for objects removal. So in addition to this set of methods

• GetTimedEvents/GetNotes/GetChords
• ProcessTimedEvents/ProcessNotes/ProcessChords
• RemoveTimedEvents/RemoveNotes/RemoveChords

we have

• GetObjects
• ProcessObjects
• RemoveObjects

Also objects detection settings were decoupled. So ChordDetectionSettings doesn't contain NoteDetectionSettings from now, as well as NoteDetectionSettings doesn't contain TimedEventDetectionSettings. Methods shown in the first list accept those settings as separate parameters now.

PatternBuilder improvements

Now you can insert simple patterns more quickly – via new PianoRoll method. For example:

var midiFile = new PatternBuilder()
    .SetNoteLength(MusicalTimeSpan.Eighth)
    .PianoRoll(@"
        F#​2   ||||||||
        D2    --|---|-
        C2    |---|---")
    .Repeat(9)
    .Build()
    .ToFile(TempoMap.Default, (FourBitNumber)9);
midiFile.Write("pianoroll-simple.mid", true);

Please read the PianoRoll section of the Pattern article to learn more.

Also a couple of new methods have been added to the PatternBuilder: ControlChange and PitchBend.

Small changes

• Added SanitizingSettings.RemoveDuplicatedNotes property.
• Added SanitizingSettings.RemoveDuplicatedSequenceTrackNameEvents property.
• Added SanitizingSettings.NoteMinVelocity property.
• Changed default value of the SanitizingSettings.Trim property to false since trimming can be undesirable.
• settings parameter of the methods from RestsUtilities is optional now.

7.1.0

Rests redesigned

Now you can get rests between different types of objects and by any logic you will describe. Please read updated Rests section of the docs. This entails a breaking change – there is no ObjectType.Rest option anymore. So to get, for example, notes and rests between them you need to write following code:

var notesAndRests = midiFile
    .GetNotes()
    .WithRests(RestDetectionSettings.NoNotesByChannel);

To feel the power of the new approach, just take a look to the snippet:

var notesAndChordsAndRests = midiFile
    .GetObjects(ObjectType.Note | ObjectType.Chord)
    .WithRests(new RestDetectionSettings
    {
        KeySelector = obj => obj is Note note && note.NoteNumber > 100
            ? (object)note.NoteNumber
            : null
    });

Here we get notes, chords and rests between notes with note number > 100 separately for each note number. Rests won't be built for chords and notes with note number <= 100.

CSV serialization redesigned

CSV serialization and deserialization have been completely reworked with the new CsvSerializer class. Please read CSV serializer article to learn more.

Small changes

• Supported flats in chord progressions to parse.
• Added the EventRecorded event to the Recording.
• Allow zero repeats number for Repeater.
• Added the Trim feature to Sanitizer.

7.0.2

This a micro-release, which fixes a couple of bugs ✨ 🎄 ✨

Small changes and bug fixes

• Improved chord name detection (#​260).
• Fixed: SMPTE time divisions not being read/written correctly (#​275).

7.0.1

New features and improvements

• Concept of the IObjectId removed. Please read updated SplitByObjects section of the docs.
• Added filter parameter to SplitObjectsAtDistance, SplitObjectsByGrid, SplitObjectsByPartsNumber and SplitObjectsByStep methods of the Splitter.
• Added PlaybackHint.
• Improved performance of the TimedObjectsManager.SaveChanges method.
• Improved performance of the TimedObjectUtilities.AddObjects method when target events collection is empty.
• Improved performance of time changing methods of the Playback.

Small changes and bug fixes

• Implemented TempoMap.Equals.
• Added max value constants in the SmpteOffsetEvent.
• Fixed: Current time is managed improperly in the MidiClock when there are speed changes.
• Fixed: NotesPlaybackStarted and NotesPlaybackFinished events of the Playback can be fired with empty notes collection.

7.0.0

Breaking changes

This version of the library has following breaking changes:

• Removed obsolete API:
  • OBS19: Use Splitter.SplitByObjects method;
  • OBS18: Use Resizer class;
  • OBS17: Use Merger class;
  • OBS16: Use TimedEvent constructor and add an object manually;
  • OBS15: Use SetTime/SetLength methods from TimedObjectUtilities/LengthedObjectUtilities;
  • OBS14: Use SetTime method from TimedObjectUtilities;
  • OBS13: Use Quantizer class;
  • OBS12: Use Splitter class;
  • OBS11: Use TimedObjectsManager class;
  • OBS10: Use Quantizer class passing QuantizingSettings with its RandomizingSettings property set.
• Removed NoteSearchContext and ChordSearchContext.
• Renamed CombineInSequence and CombineInParallel methods of PatternUtilities to MergeSequentially and MergeSimultaneously correspondingly.

New features and improvements

• Added Sanitizer tool.
• Added MergeSequentially and MergeSimultaneously methods to the Merger tool.
• Added StopReadingOnExpectedTrackChunksCountReached property to ReadingSettings (#​244).
• Added ChordProcessingHint (#​256).
• Added NoteProcessingHint.
• Added TimedEventProcessingHint.
• Added FromDouble method for MusicalTimeSpan.
• Added Position and Length properties to MidiToken.

Small changes and bug fixes

• Improved Quantizer performance.
• Set default pitch value for PitchBendEvent to 8192.
• Fixed: GetTimedEvents methods for multiple track chunks returns original events if a single track chunk is in the collection.
• Fixed: Exception on Chord's length setting below the distance between chord's start and its last note's time.

6.1.4

Small changes and bug fixes

• Improved performance of GetTempoMap methods.
• Added WaitForCompleteSysExEvent property to InputDevice.
• Fixed: AccessViolationException thrown sometimes on HighPrecisionTickGenerator stop on Windows.
• Fixed: Multipacket SysEx is not received correctly on macOS (#​232).

6.1.3

Lazy reading/writing API

DryWetMIDI now provides ways to read/write data from/to a MIDI file sequentially token by token which allows to keep low memory consumption. Here the new methods and classes aimed for this task:

• MidiFile.ReadLazy;
• MidiFile.WriteLazy;
• MidiTokensReader;
• MidiTokensWriter;
• TimedObjectsWriter.

Small changes and bug fixes

• Added EnumerateObjects method to the GetObjectsUtilities.
• Fixed: MidiFile.Equals don't respect TimeDivision.
• Fixed: Merger skips objects sometimes (#​225).

6.1.2

Apple Silicon support

DryWetMIDI multimedia API now supports Apple Silicon chips when used on macOS (#​204). Thanks to @​ThaddeusChristopher for testing!

Nativeless version

The library has now nativeless version where all native-dependent API is cut out. More info in the Nativeless package article.

New features and improvements

• Added BytesFormat property to BytesToMidiEventConverter.
• Added BytesFormat property to MidiEventToBytesConverter.
• Removed FfStatusBytePolicy property from BytesToMidiEventConverter.
• IInputDevice/IOutputDevice are now derived from IDisposable (#​205).

6.1.1

This release continues unifying API to work with different MIDI objects finishing the work done in the previous release.

New features and improvements

• Added Resizer tool which can resize groups of objects of different types or entire MIDI files.
• Added Merger tool to merge nearby objects of different types.
• Added SplitByObjects method to the Splitter class.
• Added TimeSpanUtilities.Round method.
• Added TimeSpanUtilities.IsZeroTimeSpan method.
• Added Count property to the TimedObjectsCollection class.
• Added SplitFileByChunksSettings.PreserveTempoMap property.
• Added ILengthedObject.EndTime property.
• Added GetDuration methods for TrackChunk.

Small changes and bug fixes

• All exception classes are now serializable.
• Fixed: ReplaceTempoMap throws an exception for empty track chunks collections / MIDI file.

6.1.0

This release focuses on unifying API to work with different MIDI objects.

Tools

First of all, new tool added – Repeater. It allows repeat MIDI data specified number of times with different options applied.

Also, some old tools were unified into single ones:

• TimedEventsQuantizer, NotesQuantizer and ChordsQuantizer have been replaced by new Quantizer tool which can quantize objects of different types simultaneously. More than that, it can now quantize start and end times at the same time, applying randomization if specified (and thus Randomizer tool is now obsolete). More info in the Quantizer article.
• NotesSplitter and ChordsSplitter have been replaced by new Splitter tool which can split objects of different types simultaneously. Also all methods from MidiFileSplitter class have been moved to the Splitter one. More info in the Splitter articles.

Objects managers

Also the work has been done on unifying separate manager classes for each object type. So now TimedEventsManager, NotesManager and ChordsManager classes are now obsolete. You should use TimedObjectsManager class now which can manage objects of different types simultaneously. More info in the Objects managers article.

New features and improvements

• Clone method has been moved from separate classes (like Note or TimedEvent) to ITimedObject interface.
• Split method has been moved from separate classes (like Note or Chord) to ILengthedObject.
• Added SetTime method to TimedObjectUtilities (SetTime within TimedEventsManagingUtilities is obsolete now).
• Added SetLength method to LengthedObjectUtilities (SetTimeAndLength methods within NotesManagingUtilities and ChordsManagingUtilities are obsolete now).
• Added MoveToStart method to PatternBuilder class.
• Added parameter of RepeatSettings type to PatternBuilder's Repeat methods.
• Added Note methods by a note string to PatternBuilder.
• Added Chord methods by a chord string to PatternBuilder.
• Changed default value of the Playback.InterruptNotesOnStop property to true.
• Parsing of MusicTheory.Note ignores case now.
• Parsing of Chord.GetNames method supports 7b9, add11, 7#​11, 7+11, 7(#​11) and 7aug11 chords now (see complete list of supported chords here).
• Added TimeType property to the PlaybackCurrentTimeWatcher.
• Constructor of the PlaybackCurrentTimeWatcher is now public so you can create different watchers.
• Added WatchOnlyRunningPlaybacks property to the PlaybackCurrentTimeWatcherSettings.
• Added SetPlaybackTimeType method to the PlaybackCurrentTimeWatcher.
• Added Note's constructor by pair of timed events.
• Added parameter of the TimedEventDetectionSettings type to timed events managing methods.
• Added Constructor and TimedEventDetectionSettings properties to NoteDetectionSettings.
• Added Constructor property to ChordDetectionSettings.

Small changes and bug fixes

• Added new total properties for MetricTimeSpan (#​144).
• Handled big internal values within time spans conversions.
• Fixed: NotEnoughBytesPolicy is ignored on reading some events.
• Fixed: TrackChunk is written on saving to SingleTrack format even if there are no track chunks in a file.
• Fixed: PInvokeStackImbalance exception on native calls in 32-bit app (#​142).
• Fixed: Native binaries are visible in IDE solution explorer (#​158).
• Fixed: Playback position jumps on speed changing.
• Fixed: GetObjects methods sometimes return not all objects if uncompleted chord encountered.

6.0.1

This is a minor release containing following changes:

• HighPrecisionTickGenerator implementation for macOS uses less CPU now and comsume less power.
• GetAll static method for InputDevice and for OutputDevice returns ICollection now.
• Fixed: VirtualDevice.IsEnabled doesn't work.
• Fixed: EndOfTrackEvent written incorrectly in some cases if it present in a MIDI file with ReadingSettings.EndOfTrackStoringPolicy set to EndOfTrackStoringPolicy.Store on reading the file.
• Fixed: Events don't preserve order on transfer to next part on MIDI file splitting.

6.0.0

Devices API available for macOS now

DryWetMIDI allows now work with MIDI devices on macOS! More than that, a couple of new classes are available for macOS only:

• VirtualDevice;
• DevicesWatcher.

Also HighPrecisionTickGenerator implemented for macOS too so you can now use Playback with default settings on that platform. Its implementation for macOS is not good (in terms of performance) for now but will be optimized for the next release of the library.

Breaking changes

This version of the library has following breaking changes:

• Melanchall.DryWetMidi.Devices namespace renamed to Melanchall.DryWetMidi.Multimedia to reflect its content more precisely since not only devices are there.
• DriverManufacturer, ProductIdentifier and DriverVersion properties were removed from the MidiDevice class and replaced by GetProperty method for InputDevice and for OutputDevice.
• Channels, DeviceType, NotesNumber, SupportsLeftRightVolumeControl, SupportsPatchCaching, SupportsVolumeControl, VoicesNumber and Volume properties were removed from OutputDevice and replaced by GetProperty method.
• Removed InvalidSysExEventReceived and InvalidShortEventReceived events from InputDevice and replaced them with ErrorOccurred one.
• All obsolete APIs were removed from the library.

New features

• Added VirtualDevice class which allows create virtual MIDI devices on macOS.
• Added GetProperty method for InputDevice and for OutputDevice.
• Added GetSupportedProperties method for InputDevice and for OutputDevice.
• Added DevicesWatcher class which allows watch adding or removing a MIDI device.
• Added ConvertMultiple methods to BytesToMidiEventConverter (#​134).
• Added FfStatusBytesPolicy property to BytesToMidiEventConverter.
• Implemented delta-times support in BytesToMidiEventConverter and MidiEventToBytesConverter (#​134).
• Exploded WritingSettings property of MidiEventToBytesConverter into separate properties.
• Exploded ReadingSettings property of BytesToMidiEventConverter into separate properties.
• Added UnknownChannelEventPolicy property for BytesToMidiEventConverter.
• Added GetByIndex method for InputDevice and for OutputDevice.

Small changes and bug fixes

• MidiException class has been moved to Melanchall.DryWetMidi.Common namespace.
• MidiDeviceException is subclassed from MidiException now.
• Fixed: GetObjects methods of the GetObjectsUtilities sometimes return wrong chords when notes are gathered across different track chunks.

Commits viewable in compare view.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

---

Dependabot commands and options

You can trigger Dependabot actions by commenting on this PR:

• @dependabot rebase will rebase this PR
• @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
• @dependabot show <dependency name> ignore conditions will show all of the ignore conditions of the specified dependency
• @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
• @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
• @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)