port_connections_manager.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2021 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_PORT_CONNECTIONS_MANAGER_H__
#define __AUDIO_PORT_CONNECTIONS_MANAGER_H__
 
#include "zrythm-config.h"
 
#include "dsp/port_connection.h"
#include "utils/types.h"
#include "utils/yaml.h"
 
#include <glib.h>
 
typedef struct Port           Port;
typedef struct PortIdentifier PortIdentifier;
typedef struct PortConnection PortConnection;
 
#define PORT_CONNECTIONS_MANAGER_SCHEMA_VERSION 1
 
#define PORT_CONNECTIONS_MGR (PROJECT->port_connections_manager)
 
typedef struct PortConnectionsManager
{
  PortConnection ** connections;
  int               num_connections;
  size_t            connections_size;
 
  GHashTable * src_ht;
 
  GHashTable * dest_ht;
} PortConnectionsManager;
 
NONNULL void
port_connections_manager_init_loaded (PortConnectionsManager * self);
 
PortConnectionsManager *
port_connections_manager_new (void);
 
void
port_connections_manager_regenerate_hashtables (PortConnectionsManager * self);
 
NONNULL_ARGS (1, 3)
int port_connections_manager_get_sources_or_dests (
  const PortConnectionsManager * self,
  GPtrArray *                    arr,
  const PortIdentifier *         id,
  bool                           sources);
 
NONNULL_ARGS (1, 3)
int port_connections_manager_get_unlocked_sources_or_dests (
  const PortConnectionsManager * self,
  GPtrArray *                    arr,
  const PortIdentifier *         id,
  bool                           sources);
 
PortConnection *
port_connections_manager_get_source_or_dest (
  const PortConnectionsManager * self,
  const PortIdentifier *         id,
  bool                           sources);
 
PortConnection *
port_connections_manager_find_connection (
  const PortConnectionsManager * self,
  const PortIdentifier *         src,
  const PortIdentifier *         dest);
 
bool
port_connections_manager_predicate_is_send_of (
  const void * obj,
  const void * user_data);
 
int
port_connections_manager_find (
  const PortConnectionsManager * self,
  GPtrArray *                    arr,
  GenericPredicateFunc           predicate);
 
const PortConnection *
port_connections_manager_ensure_connect (
  PortConnectionsManager * self,
  const PortIdentifier *   src,
  const PortIdentifier *   dest,
  float                    multiplier,
  bool                     locked,
  bool                     enabled);
 
#define port_connections_manager_ensure_connect_from_connection(self, conn) \
  port_connections_manager_ensure_connect ( \
    self, conn->src_id, conn->dest_id, conn->multiplier, conn->locked, \
    conn->enabled)
 
bool
port_connections_manager_ensure_disconnect (
  PortConnectionsManager * self,
  const PortIdentifier *   src,
  const PortIdentifier *   dest);
 
void
port_connections_manager_ensure_disconnect_all (
  PortConnectionsManager * self,
  const PortIdentifier *   pi);
 
void
port_connections_manager_reset (
  PortConnectionsManager *       self,
  const PortConnectionsManager * src);
 
bool
port_connections_manager_contains_connection (
  const PortConnectionsManager * self,
  const PortConnection * const   conn);
 
void
port_connections_manager_print_ht (GHashTable * ht);
 
void
port_connections_manager_print (const PortConnectionsManager * self);
 
NONNULL PortConnectionsManager *
port_connections_manager_clone (const PortConnectionsManager * src);
 
NONNULL void
port_connections_manager_free (PortConnectionsManager * self);
 
#endif /* __AUDIO_PORT_CONNECTIONS_MANAGER_H__ */