midi_event.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2018-2023 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_MIDI_EVENT_H__
#define __AUDIO_MIDI_EVENT_H__
 
#include "zrythm-config.h"
 
#include <stdint.h>
#include <string.h>
 
#include "utils/types.h"
 
#include "zix/sem.h"
 
#ifdef HAVE_JACK
#  include "weak_libjack.h"
#endif
 
#include <gtk/gtk.h>
 
#include "ext/midilib/src/midifile.h"
 
typedef struct ChordDescriptor ChordDescriptor;
 
#define MAX_MIDI_EVENTS 2560
 
typedef struct MidiEvent
{
  midi_time_t time;
 
  gint64 systime;
 
  midi_byte_t raw_buffer[3];
 
  size_t raw_buffer_sz;
 
} MidiEvent;
 
typedef struct MidiEvents MidiEvents;
typedef struct Port       Port;
 
typedef struct MidiEvents
{
  int num_events;
 
  MidiEvent events[MAX_MIDI_EVENTS];
 
  MidiEvent queued_events[MAX_MIDI_EVENTS];
  int       num_queued_events;
 
  ZixSem access_sem;
 
} MidiEvents;
 
typedef struct MidiEventHeader
{
  uint64_t time;
  size_t   size;
} MidiEventHeader;
 
void
midi_events_init (MidiEvents * self);
 
MidiEvents *
midi_events_new (void);
 
static inline void
midi_event_copy (MidiEvent * dest, MidiEvent * src)
{
  memcpy (dest, src, sizeof (MidiEvent));
}
 
NONNULL void
midi_event_set_velocity (MidiEvent * ev, midi_byte_t vel);
 
void
midi_event_print (const MidiEvent * ev);
 
PURE static inline bool
midi_events_are_equal (const MidiEvent * src, const MidiEvent * dest)
{
  return dest->time == src->time && dest->raw_buffer[0] == src->raw_buffer[0]
         && dest->raw_buffer[1] == src->raw_buffer[1]
         && dest->raw_buffer[2] == src->raw_buffer[2];
}
 
void
midi_events_print (MidiEvents * self, const int queued);
 
void
midi_events_append (
  MidiEvents *    dest,
  MidiEvents *    src,
  const nframes_t local_offset,
  const nframes_t nframes,
  bool            queued);
 
void
midi_events_transform_chord_and_append (
  MidiEvents *    dest,
  MidiEvents *    src,
  const nframes_t local_offset,
  const nframes_t nframes,
  bool            queued);
 
OPTIMIZE_O3
void
midi_events_append_w_filter (
  MidiEvents *    dest,
  MidiEvents *    src,
  int *           channels,
  const nframes_t start_frame,
  const nframes_t nframes,
  bool            queued);
 
void
midi_events_add_note_on (
  MidiEvents * self,
  midi_byte_t  channel,
  midi_byte_t  note_pitch,
  midi_byte_t  velocity,
  midi_time_t  time,
  int          queued);
 
void
midi_events_add_note_ons_from_chord_descr (
  MidiEvents *            self,
  const ChordDescriptor * descr,
  midi_byte_t             channel,
  midi_byte_t             velocity,
  midi_time_t             time,
  bool                    queued);
 
void
midi_events_add_note_offs_from_chord_descr (
  MidiEvents *            self,
  const ChordDescriptor * descr,
  midi_byte_t             channel,
  midi_time_t             time,
  bool                    queued);
 
void
midi_events_add_cc_volume (
  MidiEvents * self,
  midi_byte_t  channel,
  midi_byte_t  volume,
  midi_time_t  time,
  bool         queued);
 
int
midi_events_has_note_on (MidiEvents * self, int check_main, int check_queued);
 
static inline bool
midi_events_has_any (MidiEvents * self, bool check_queued)
{
  return (check_queued ? self->num_queued_events : self->num_events) > 0;
}
 
void
midi_events_add_event_from_buf (
  MidiEvents *  self,
  midi_time_t   time,
  midi_byte_t * buf,
  int           buf_size,
  int           queued);
 
void
midi_events_add_note_off (
  MidiEvents * self,
  midi_byte_t  channel,
  midi_byte_t  note_pitch,
  midi_time_t  time,
  int          queued);
 
void
midi_events_add_control_change (
  MidiEvents * self,
  midi_byte_t  channel,
  midi_byte_t  controller,
  midi_byte_t  control,
  midi_time_t  time,
  int          queued);
 
void
midi_events_add_song_pos (
  MidiEvents * self,
  int64_t      total_sixteenths,
  midi_time_t  time,
  bool         queued);
 
void
midi_events_add_raw (
  MidiEvents * self,
  uint8_t *    buf,
  size_t       buf_sz,
  midi_time_t  time,
  bool         queued);
 
void
midi_events_add_pitchbend (
  MidiEvents * self,
  midi_byte_t  channel,
  uint32_t     pitchbend,
  midi_time_t  time,
  bool         queued);
 
void
midi_events_add_channel_pressure (
  MidiEvents * self,
  midi_byte_t  channel,
  midi_byte_t  value,
  midi_time_t  time,
  bool         queued);
 
void
midi_events_add_all_notes_off (
  MidiEvents * self,
  midi_byte_t  channel,
  midi_time_t  time,
  bool         queued);
 
NONNULL void
midi_events_panic_without_lock (MidiEvents * self, bool queued);
 
NONNULL void
midi_events_panic (MidiEvents * self, bool queued);
 
NONNULL void
midi_events_write_to_midi_file (
  const MidiEvents * self,
  MIDI_FILE *        mf,
  int                midi_track);
 
void
midi_events_clear (MidiEvents * midi_events, int queued);
 
void
midi_events_clear_duplicates (MidiEvents * midi_events, const int queued);
 
void
midi_events_dequeue (MidiEvents * midi_events);
 
int
midi_events_check_for_note_on (MidiEvents * midi_events, int note, int queued);
 
int
midi_events_delete_note_on (MidiEvents * midi_events, int note, int queued);
 
#ifdef HAVE_JACK
void
midi_events_copy_to_jack (
  MidiEvents *    self,
  const nframes_t local_start_frames,
  const nframes_t nframes,
  void *          buff);
#endif
 
void
midi_events_sort (MidiEvents * self, const bool queued);
 
void
midi_events_set_channel (
  MidiEvents *      self,
  const int         queued,
  const midi_byte_t channel);
 
void
midi_events_delete_event (
  MidiEvents *      events,
  const MidiEvent * ev,
  const bool        queued);
 
void
midi_events_panic_all (const bool queued);
 
void
midi_events_free (MidiEvents * self);
 
#endif