midi_region.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2019-2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_MIDI_REGION_H__
#define __AUDIO_MIDI_REGION_H__
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "utils/types.h"
 
typedef struct Track           Track;
typedef struct Position        Position;
typedef struct MidiNote        MidiNote;
typedef struct ZRegion         ZRegion;
typedef struct MidiEvents      MidiEvents;
typedef struct ChordDescriptor ChordDescriptor;
typedef struct Velocity        Velocity;
typedef void                   MIDI_FILE;
 
ZRegion *
midi_region_new (
  const Position * start_pos,
  const Position * end_pos,
  unsigned int     track_name_hash,
  int              lane_pos,
  int              idx_inside_lane);
 
ZRegion *
midi_region_new_from_midi_file (
  const Position * start_pos,
  const char *     abs_path,
  unsigned int     track_name_hash,
  int              lane_pos,
  int              idx_inside_lane,
  int              idx);
 
ZRegion *
midi_region_new_from_chord_descr (
  const Position *  pos,
  ChordDescriptor * descr,
  unsigned int      track_name_hash,
  int               lane_pos,
  int               idx_inside_lane);
 
#define midi_region_add_midi_note(region, midi_note, pub_events) \
  midi_region_insert_midi_note ( \
    region, midi_note, ((ZRegion *) (region))->num_midi_notes, pub_events)
 
void
midi_region_insert_midi_note (
  ZRegion *  region,
  MidiNote * midi_note,
  int        idx,
  int        pub_events);
 
void
midi_region_start_unended_note (
  ZRegion *  self,
  Position * start_pos,
  Position * end_pos,
  int        pitch,
  int        vel,
  int        pub_events);
 
MidiNote *
midi_region_pop_unended_note (ZRegion * self, int pitch);
 
OPTIMIZE_O3
REALTIME
void
midi_region_fill_midi_events (
  ZRegion *                           self,
  const EngineProcessTimeInfo * const time_nfo,
  bool                                note_off_at_end,
  bool                                is_note_off_for_loop_or_region_end,
  MidiEvents *                        midi_events);
 
void
midi_region_print_midi_notes (ZRegion * self);
 
MidiNote *
midi_region_get_first_midi_note (ZRegion * region);
 
MidiNote *
midi_region_get_last_midi_note (ZRegion * region);
 
MidiNote *
midi_region_get_highest_midi_note (ZRegion * region);
 
MidiNote *
midi_region_get_lowest_midi_note (ZRegion * region);
 
void
midi_region_remove_midi_note (
  ZRegion *  region,
  MidiNote * midi_note,
  int        free,
  int        pub_event);
 
void
midi_region_remove_all_midi_notes (ZRegion * region);
 
NONNULL_ARGS (1, 2)
void midi_region_write_to_midi_file (
  const ZRegion * self,
  MIDI_FILE *     mf,
  const bool      add_region_start,
  bool            export_full);
 
NONNULL void
midi_region_export_to_midi_file (
  const ZRegion * self,
  const char *    full_path,
  int             midi_version,
  const bool      export_full);
 
uint8_t
midi_region_get_midi_ch (const ZRegion * self);
 
bool
midi_region_is_note_playable (const ZRegion * self, const MidiNote * midi_note);
 
void
midi_region_add_events (
  const ZRegion *  self,
  MidiEvents *     events,
  const Position * start,
  const Position * end,
  const bool       add_region_start,
  const bool       full);
 
void
midi_region_get_velocities_in_range (
  const ZRegion *  self,
  const Position * start_pos,
  const Position * end_pos,
  Velocity ***     velocities,
  int *            num_velocities,
  size_t *         velocities_size,
  int              inside);
 
void
midi_region_free_members (ZRegion * self);
 
#endif // __AUDIO_MIDI_REGION_H__