transport.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2018-2023 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_TRANSPORT_H__
#define __AUDIO_TRANSPORT_H__
 
#include <stdint.h>
 
#include "dsp/port.h"
#include "dsp/region.h"
#include "utils/types.h"
 
#include "zix/sem.h"
 
typedef struct TimelineSelections TimelineSelections;
typedef struct AudioEngine        AudioEngine;
 
#define TIME_SIGNATURE_SCHEMA_VERSION 1
#define TRANSPORT_SCHEMA_VERSION 1
 
#define TRANSPORT (AUDIO_ENGINE->transport)
#define TRANSPORT_DEFAULT_TOTAL_BARS 128
 
#define PLAYHEAD (&TRANSPORT->playhead_pos)
#define TRANSPORT_IS_ROLLING \
  (TRANSPORT->play_state == PLAYSTATE_ROLLING)
#define TRANSPORT_IS_PAUSED \
  (TRANSPORT->play_state == PLAYSTATE_PAUSED)
#define TRANSPORT_IS_LOOPING (TRANSPORT->loop)
#define TRANSPORT_IS_RECORDING (TRANSPORT->recording)
 
typedef enum PrerollCountBars
{
  PREROLL_COUNT_BARS_NONE,
  PREROLL_COUNT_BARS_ONE,
  PREROLL_COUNT_BARS_TWO,
  PREROLL_COUNT_BARS_FOUR,
} PrerollCountBars;
 
static const char * preroll_count_bars_str[] = {
  N_ ("None"),
  N_ ("1 bar"),
  N_ ("2 bars"),
  N_ ("4 bars"),
};
 
static inline const char *
transport_preroll_count_to_str (PrerollCountBars bars)
{
  return preroll_count_bars_str[bars];
}
 
static inline int
transport_preroll_count_bars_enum_to_int (
  PrerollCountBars bars)
{
  switch (bars)
    {
    case PREROLL_COUNT_BARS_NONE:
      return 0;
    case PREROLL_COUNT_BARS_ONE:
      return 1;
    case PREROLL_COUNT_BARS_TWO:
      return 2;
    case PREROLL_COUNT_BARS_FOUR:
      return 4;
    }
  return -1;
}
 
typedef enum PlayState
{
  PLAYSTATE_ROLL_REQUESTED,
  PLAYSTATE_ROLLING,
  PLAYSTATE_PAUSE_REQUESTED,
  PLAYSTATE_PAUSED
} PlayState;
 
typedef enum TransportDisplay
{
  TRANSPORT_DISPLAY_BBT,
  TRANSPORT_DISPLAY_TIME,
} TransportDisplay;
 
typedef enum TransportRecordingMode
{
  RECORDING_MODE_OVERWRITE_EVENTS,
 
  RECORDING_MODE_MERGE_EVENTS,
 
  RECORDING_MODE_TAKES,
 
  RECORDING_MODE_TAKES_MUTED,
} TransportRecordingMode;
 
#if 0
typedef struct TimeSignature
{
  int           schema_version;
 
  int           beats_per_bar;
 
  int           beat_unit;
} TimeSignature;
 
static const cyaml_schema_field_t
time_signature_fields_schema[] =
{
  YAML_FIELD_INT (
    TimeSignature, schema_version),
  YAML_FIELD_INT (
    TimeSignature, beats_per_bar),
  YAML_FIELD_INT (
    TimeSignature, beat_unit),
 
  CYAML_FIELD_END
};
 
static const cyaml_schema_value_t
time_signature_schema =
{
  YAML_VALUE_PTR (
    TimeSignature, time_signature_fields_schema),
};
#endif
 
typedef struct Transport
{
  int schema_version;
 
  int total_bars;
 
  Position playhead_pos;
 
  Position cue_pos;
 
  Position loop_start_pos;
 
  Position loop_end_pos;
 
  Position punch_in_pos;
 
  Position punch_out_pos;
 
  Position range_1;
  Position range_2;
 
  int has_range;
 
  //TimeSignature time_sig;
 
  /* ---------- CACHE -------------- */
  int ticks_per_beat;
  int ticks_per_bar;
  int sixteenths_per_beat;
  int sixteenths_per_bar;
 
  /* ------------------------------- */
 
  nframes_t position;
 
  bool loop;
 
  bool punch_mode;
 
  bool recording;
 
  bool metronome_enabled;
 
  signed_frame_t preroll_frames_remaining;
 
  signed_frame_t countin_frames_remaining;
 
  bool start_playback_on_midi_input;
 
  TransportRecordingMode recording_mode;
 
  //int               starting_recording;
 
  ZixSem paused;
 
  Position playhead_before_pause;
 
  Port * roll;
 
  Port * stop;
 
  Port * backward;
 
  Port * forward;
 
  Port * loop_toggle;
 
  Port * rec_toggle;
 
  PlayState play_state;
 
  gint64 last_manual_playhead_change;
 
  AudioEngine * audio_engine;
} Transport;
 
static const cyaml_schema_field_t transport_fields_schema[] = {
  YAML_FIELD_INT (Transport, schema_version),
  YAML_FIELD_INT (Transport, total_bars),
  YAML_FIELD_MAPPING_EMBEDDED (
    Transport,
    playhead_pos,
    position_fields_schema),
  YAML_FIELD_MAPPING_EMBEDDED (
    Transport,
    cue_pos,
    position_fields_schema),
  YAML_FIELD_MAPPING_EMBEDDED (
    Transport,
    loop_start_pos,
    position_fields_schema),
  YAML_FIELD_MAPPING_EMBEDDED (
    Transport,
    loop_end_pos,
    position_fields_schema),
  YAML_FIELD_MAPPING_EMBEDDED (
    Transport,
    punch_in_pos,
    position_fields_schema),
  YAML_FIELD_MAPPING_EMBEDDED (
    Transport,
    punch_out_pos,
    position_fields_schema),
  YAML_FIELD_MAPPING_EMBEDDED (
    Transport,
    range_1,
    position_fields_schema),
  YAML_FIELD_MAPPING_EMBEDDED (
    Transport,
    range_2,
    position_fields_schema),
  YAML_FIELD_INT (Transport, has_range),
  YAML_FIELD_INT (Transport, position),
  YAML_FIELD_MAPPING_PTR_OPTIONAL (
    Transport,
    roll,
    port_fields_schema),
  YAML_FIELD_MAPPING_PTR_OPTIONAL (
    Transport,
    stop,
    port_fields_schema),
  YAML_FIELD_MAPPING_PTR_OPTIONAL (
    Transport,
    backward,
    port_fields_schema),
  YAML_FIELD_MAPPING_PTR_OPTIONAL (
    Transport,
    forward,
    port_fields_schema),
  YAML_FIELD_MAPPING_PTR_OPTIONAL (
    Transport,
    loop_toggle,
    port_fields_schema),
  YAML_FIELD_MAPPING_PTR_OPTIONAL (
    Transport,
    rec_toggle,
    port_fields_schema),
 
  CYAML_FIELD_END
};
 
static const cyaml_schema_value_t transport_schema = {
  YAML_VALUE_PTR (Transport, transport_fields_schema),
};
 
NONNULL Transport *
transport_new (AudioEngine * engine);
 
void
transport_init_loaded (
  Transport *   self,
  AudioEngine * engine,
  Track *       tempo_track);
 
Transport *
transport_clone (const Transport * src);
 
void
transport_prepare_audio_regions_for_stretch (
  Transport *          self,
  TimelineSelections * sel);
 
bool
transport_stretch_regions (
  Transport *          self,
  TimelineSelections * sel,
  bool                 with_fixed_ratio,
  double               time_ratio,
  bool                 force,
  GError **            error);
 
void
transport_set_punch_mode_enabled (
  Transport * self,
  bool        enabled);
 
void
transport_set_start_playback_on_midi_input (
  Transport * self,
  bool        enabled);
 
void
transport_set_recording_mode (
  Transport *            self,
  TransportRecordingMode mode);
 
void
transport_set_metronome_enabled (
  Transport * self,
  const int   enabled);
 
void
transport_add_to_playhead (
  Transport *          self,
  const signed_frame_t nframes);
 
void
transport_request_pause (Transport * self, bool with_wait);
 
void
transport_request_roll (Transport * self, bool with_wait);
 
void
transport_set_playhead_pos (Transport * self, Position * pos);
 
void
transport_set_playhead_to_bar (Transport * self, int bar);
 
void
transport_get_playhead_pos (Transport * self, Position * pos);
 
void
transport_move_backward (Transport * self, bool with_wait);
 
void
transport_move_forward (Transport * self, bool with_wait);
 
bool
transport_can_user_move_playhead (const Transport * self);
 
void
transport_move_playhead (
  Transport *      self,
  const Position * target,
  bool             panic,
  bool             set_cue_point,
  bool             fire_events);
 
void
transport_set_loop (
  Transport * self,
  bool        enabled,
  bool        with_wait);
 
void
transport_goto_start_marker (Transport * self);
 
void
transport_goto_end_marker (Transport * self);
 
void
transport_goto_prev_marker (Transport * self);
 
void
transport_goto_next_marker (Transport * self);
 
void
transport_update_positions (
  Transport * self,
  bool        update_from_ticks);
 
#if 0
long
transport_frames_add_frames (
  const Transport * self,
  const long        gframes,
  const nframes_t   frames);
#endif
 
void
transport_position_add_frames (
  const Transport *    self,
  Position *           pos,
  const signed_frame_t frames);
 
double
transport_get_ppqn (Transport * self);
 
void
transport_get_range_pos (
  Transport * self,
  bool        first,
  Position *  pos);
 
void
transport_set_has_range (Transport * self, bool has_range);
 
void
transport_set_range (
  Transport *      self,
  bool             range1,
  const Position * start_pos,
  const Position * pos,
  bool             snap);
 
HOT NONNULL WARN_UNUSED_RESULT static inline nframes_t
transport_is_loop_point_met (
  const Transport *    self,
  const signed_frame_t g_start_frames,
  const nframes_t      nframes)
{
  if (
    self->loop
    && G_UNLIKELY (
      self->loop_end_pos.frames > g_start_frames
      && self->loop_end_pos.frames
           <= g_start_frames + (long) nframes))
    {
      return (
        nframes_t) (self->loop_end_pos.frames - g_start_frames);
    }
  return 0;
}
 
bool
transport_position_is_inside_punch_range (
  Transport * self,
  Position *  pos);
 
void
transport_recalculate_total_bars (
  Transport *          self,
  ArrangerSelections * sel);
 
void
transport_update_total_bars (
  Transport * self,
  int         total_bars,
  bool        fire_events);
 
void
transport_update_caches (
  Transport * self,
  int         beats_per_bar,
  int         beat_unit);
 
void
transport_set_recording (
  Transport * self,
  bool        record,
  bool        with_wait,
  bool        fire_events);
 
void
transport_free (Transport * self);
 
#endif