transport.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2018-2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_TRANSPORT_H__
#define __AUDIO_TRANSPORT_H__
 
#include <cstdint>
 
#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)
/* FIXME remove these globals */
#define TRANSPORT_IS_ROLLING \
  (TRANSPORT->play_state == PlayState::PLAYSTATE_ROLLING)
#define TRANSPORT_IS_PAUSED \
  (TRANSPORT->play_state == PlayState::PLAYSTATE_PAUSED)
#define TRANSPORT_IS_LOOPING (TRANSPORT->loop)
#define TRANSPORT_IS_RECORDING (TRANSPORT->recording)
 
enum class PrerollCountBars
{
  PREROLL_COUNT_BARS_NONE,
  PREROLL_COUNT_BARS_ONE,
  PREROLL_COUNT_BARS_TWO,
  PREROLL_COUNT_BARS_FOUR,
};
 
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[static_cast<int> (bars)];
}
 
static inline int
transport_preroll_count_bars_enum_to_int (PrerollCountBars bars)
{
  switch (bars)
    {
    case PrerollCountBars::PREROLL_COUNT_BARS_NONE:
      return 0;
    case PrerollCountBars::PREROLL_COUNT_BARS_ONE:
      return 1;
    case PrerollCountBars::PREROLL_COUNT_BARS_TWO:
      return 2;
    case PrerollCountBars::PREROLL_COUNT_BARS_FOUR:
      return 4;
    }
  return -1;
}
 
enum class PlayState
{
  PLAYSTATE_ROLL_REQUESTED,
  PLAYSTATE_ROLLING,
  PLAYSTATE_PAUSE_REQUESTED,
  PLAYSTATE_PAUSED
};
 
enum class TransportDisplay
{
  TRANSPORT_DISPLAY_BBT,
  TRANSPORT_DISPLAY_TIME,
};
 
enum class TransportRecordingMode
{
  RECORDING_MODE_OVERWRITE_EVENTS,
 
  RECORDING_MODE_MERGE_EVENTS,
 
  RECORDING_MODE_TAKES,
 
  RECORDING_MODE_TAKES_MUTED,
};
 
typedef struct Transport
{
  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;
 
NONNULL Transport *
transport_new (AudioEngine * engine);
 
void
transport_init_loaded (
  Transport *   self,
  AudioEngine * engine,
  Track *       tempo_track);
 
Transport *
transport_clone (const Transport * src);
 
bool
transport_is_rolling (const Transport * self);
 
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_get_loop_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);
 
void
transport_set_loop_range (
  Transport *      self,
  bool             start,
  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