midi_file.h

// SPDX-FileCopyrightText: © 2020-2021, 2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <filesystem>
 
#include "utils/types.h"
 
#include <juce_audio_basics/juce_audio_basics.h>
 
namespace zrythm
{
namespace structure
{
namespace arrangement
{
class MidiRegion;
}
namespace tracks
{
class Tracklist;
}
}


class MidiFile
{
public:
  enum class Format
  {
    MIDI0,
    MIDI1,
    MIDI2,
  };
 
  using TrackIndex = unsigned int;

  MidiFile (Format format);

  MidiFile (const std::filesystem::path &path);

  bool track_has_midi_note_events (TrackIndex track_idx) const;

  int get_num_tracks (bool non_empty_only) const;
 
  [[nodiscard]] Format get_format () const;

  int get_ppqn () const;

  void
  into_region (structure::arrangement::MidiRegion &region, int midi_track_idx)
    const;

  static void export_midi_region_to_midi_file (
    const structure::arrangement::MidiRegion &region,
    const std::filesystem::path              &full_path,
    int                                       midi_version,
    bool                                      export_full);

  static void export_midi_lane_to_sequence (
    juce::MidiMessageSequence          &message_sequence,
    const structure::tracks::Tracklist &tracklist,
    const structure::tracks::Track     &track,
    const structure::tracks::TrackLane &lane,
    dsp::MidiEventVector *              events,
    std::optional<double>               start,
    std::optional<double>               end,
    bool                                lanes_as_tracks,
    bool                                use_track_or_lane_pos);

  static void export_track_to_sequence (
    juce::MidiMessageSequence          &message_sequence,
    const structure::tracks::Tracklist &tracklist,
    const structure::tracks::Track     &track,
    dsp::MidiEventVector *              events,
    std::optional<double>               start,
    std::optional<double>               end,
    int                                 track_index,
    bool                                lanes_as_tracks,
    bool                                use_track_pos)
  {
// TODO
#if 0
  std::unique_ptr<dsp::MidiEventVector> own_events;
  if (!lanes_as_tracks && use_track_pos)
    {
      z_return_if_fail (!events);
      midiTrackAddText (mf, track_index, textTrackName, name_.c_str ());
      own_events = std::make_unique<dsp::MidiEventVector> ();
    }
 
  for (auto &lane : laned_track_mixin_->lanes ())
    {
      lane->write_to_midi_file (
        mf, own_events ? own_events.get () : events, start, end,
        lanes_as_tracks, use_track_pos);
    }
 
  if (own_events)
    {
      own_events->write_to_midi_file (mf, midi_track_pos);
    }
#endif
  }
 
private:
  juce::MidiFile midi_file_;
  Format         format_ = Format::MIDI0;
  bool           for_reading_ = false;
};

}