track_processor.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2019-2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_TRACK_PROCESSOR_H__
#define __AUDIO_TRACK_PROCESSOR_H__
 
#include "dsp/port.h"
#include "utils/midi.h"
#include "utils/types.h"
#include "utils/yaml.h"
 
typedef struct StereoPorts           StereoPorts;
typedef struct Port                  Port;
typedef struct Track                 Track;
typedef struct MidiMappings          MidiMappings;
typedef struct EngineProcessTimeInfo EngineProcessTimeInfo;
TYPEDEF_STRUCT (MPMCQueue);
 
#define TRACK_PROCESSOR_SCHEMA_VERSION 1
 
#define TRACK_PROCESSOR_MAGIC 81213128
#define IS_TRACK_PROCESSOR(tr) ((tr) && (tr)->magic == TRACK_PROCESSOR_MAGIC)
 
#define track_processor_is_in_active_project(self) \
  (self->track && track_is_in_active_project (self->track))
 
typedef struct TrackProcessor
{
  StereoPorts * stereo_in;
 
  Port * mono;
 
  Port * input_gain;
 
  Port * output_gain;
 
  StereoPorts * stereo_out;
 
  Port * midi_in;
 
  Port * midi_out;
 
  Port * piano_roll;
 
  Port * monitor_audio;
 
  /* --- MIDI controls --- */
 
  MidiMappings * cc_mappings;
 
  Port * midi_cc[128 * 16];
 
  Port * pitch_bend[16];
 
  Port * poly_key_pressure[16];
 
  Port * channel_pressure[16];
 
  /* --- end MIDI controls --- */
 
  float l_port_db;
  float r_port_db;
 
  Track * track;
 
  bool pending_midi_panic;
 
  MPMCQueue * updated_midi_automatable_ports;
 
  int magic;
} TrackProcessor;
 
COLD NONNULL_ARGS (
  1) void track_processor_init_loaded (TrackProcessor * self, Track * track);
 
#if 0
void
track_processor_set_is_project (
  TrackProcessor * self,
  bool             is_project);
#endif
 
COLD WARN_UNUSED_RESULT TrackProcessor *
track_processor_new (Track * track);
 
void
track_processor_copy_values (TrackProcessor * dest, TrackProcessor * src);
 
void
track_processor_clear_buffers (TrackProcessor * self);
 
void
track_processor_disconnect_all (TrackProcessor * self);
 
static inline Track *
track_processor_get_track (const TrackProcessor * self)
{
#if 0
  g_return_val_if_fail (
    IS_TRACK_PROCESSOR (self) && IS_TRACK (self->track), NULL);
#endif
  g_return_val_if_fail (self->track, NULL);
 
  return self->track;
}
 
void
track_processor_process (
  TrackProcessor *                    self,
  const EngineProcessTimeInfo * const time_nfo);
 
void
track_processor_disconnect_from_prefader (TrackProcessor * self);
 
void
track_processor_connect_to_prefader (TrackProcessor * self);
 
void
track_processor_disconnect_from_plugin (TrackProcessor * self, Plugin * pl);
 
void
track_processor_connect_to_plugin (TrackProcessor * self, Plugin * pl);
 
#if 0
void
track_processor_update_track_name_hash (
  TrackProcessor * self);
#endif
 
void
track_processor_append_ports (TrackProcessor * self, GPtrArray * ports);
 
void
track_processor_free (TrackProcessor * self);
 
#endif