DryWetMIDI

DryWetMIDI includes several specialized tools designed to handle complex MIDI manipulation tasks. These tools can be used to process MIDI files or individual MIDI objects directly:

• Splitter: Splits objects or MIDI files using various criteria.
• Quantizer: Quantizes MIDI objects to a specific grid or timing.
• Merger: Merges nearby objects or combines multiple MIDI files.
• Resizer: Resizes groups of objects or MIDI files.
• Repeater: Repeats groups of objects or MIDI files.
• Sanitizer: Cleans MIDI files by removing redundant events and other inconsistencies.
• CSV serializer: Converts MIDI objects to a CSV representation and allows reading them back.

The Melanchall.DryWetMidi.Tools.Merger class provides extension methods to combine MIDI data. You can merge different types of MIDI objects or entire MIDI files.

Available merging strategies include:

• Objects merging: Combining individual MIDI objects (like tracks or events).
• MIDI files merging: Combining multiple MIDI files into a single output.

For a complete list of all available methods and their specific configuration settings, refer to the official API documentation for the Melanchall.DryWetMidi.Tools.Merger class.

The Melanchall.DryWetMidi.Tools.Splitter class provides extension methods to divide MIDI data into smaller parts. You can split MIDI objects (such as MidiFile or specific MIDI tracks/events) or entire MIDI files based on various criteria.

Available splitting strategies include:

• Objects splitting: Dividing specific MIDI objects or collections of objects.
• MIDI file splitting: Dividing a complete MIDI file into multiple files.

For a complete list of all available methods and their specific configuration settings, refer to the official Splitter API documentation.

DryWetMIDI includes a suite of music theory types that allow you to work with musical structures like scales, chords, and intervals. These objects can be integrated into MIDI processing workflows.

Supported music theory objects include:

• Octave
• Interval
• Note
• Chord
• Chord progression
• Scale

A TempoMap is a collection of tempo and time signature changes. It is a core object used for high-level MIDI management, specifically for converting between different time and length representations (e.g., converting between MIDI ticks and real-world time).

Key characteristics:

• It does not reflect original MIDI events directly; instead, it holds the actual tempo and time signature changes.
• Default values (120 BPM and 4/4 time signature) are not stored as changes unless they are explicitly modified.
• Repeated values are ignored to keep the map efficient.

Use ChordDetectionSettings to adjust how chords are built from notes.

Key properties include:

• NotesTolerance: Defines the maximum distance (time) of notes from the start of the first note in a chord. Notes within this tolerance are included in the chord. Default is 0.
• NotesMinCount: Defines the minimum number of notes required to form a chord. If the count of simultaneous notes is less than this value, they will not be grouped into a chord. Default is 1.

Note that chord building is hierarchical: ChordDetectionSettings can use NoteDetectionSettings to control note construction, which in turn can use TimedEventDetectionSettings to control event construction.

In DryWetMIDI, all time and length values are stored as long numbers in units defined by the MIDI file's time division. To work with human-readable formats, the library provides several ITimeSpan implementations.

Note that 'time' (position from start) and 'length' (duration) are treated interchangeably as 'time spans'.

Available representations:

• MetricTimeSpan: Time in microseconds.
• BarBeatTicksTimeSpan: Time in bars, beats, and ticks.
• BarBeatFractionTimeSpan: Time in bars and fractional beats (e.g., 0.5 beats).
• MusicalTimeSpan: Time as a fraction of a whole note length.
• MidiTimeSpan: A wrapper for the raw long value in MIDI ticks.

The Resizer tool allows you to resize a group of objects or an entire MIDI file. When resizing a group, the tool treats all passed objects as a single unit and scales them to the new length while preserving all time-to-length ratios. This ensures that the relative positioning of events remains consistent (e.g., an event at the midpoint of a group will remain at the midpoint after resizing).

You can resize using two primary approaches:

1. Specified New Length: Setting the group or file to a specific duration.
2. Ratio: Multiplying all distances from the start of the group by a factor (e.g., a ratio of 2 doubles the size, while 0.5 halves it).

When building with the Debug or ReleaseTestFull configurations and running tests that utilize playback functionality, the library generates diagnostic files.

Output Location: Files are stored in your machine's temporary folder (retrievable via Path.GetTempPath()).

Directory Structure:

• A root folder named PlaybackTraces and SysExTraces will be created in the temp directory.
• Inside these, subfolders corresponding to individual tests will be created.
• Diagnostic files are located within each specific test folder.

The GetObjects method is designed to ensure no data is lost when extracting high-level MIDI abstractions.

When you request multiple types (e.g., ObjectType.Note | ObjectType.TimedEvent), the engine attempts to form as many Note objects as possible. Any MIDI events that are not part of a completed Note (such as a Note On without a Note Off, or a TextEvent) are automatically returned as TimedEvent objects. This allows you to process the musical structure while still having access to the underlying raw event stream.