merge_receiver.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2024 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************
 * This file is a part of sACN. For more information, go to:
 * https://github.com/ETCLabs/sACN
 *****************************************************************************/
 
#ifndef SACN_MERGE_RECEIVER_H_
#define SACN_MERGE_RECEIVER_H_
 
#include <stdbool.h>
#include <stdint.h>
#include "sacn/receiver.h"
#include "sacn/dmx_merger.h"
 
#define SACN_MERGE_RECEIVER_MAX_SLOTS \
  ((SACN_DMX_MERGER_MAX_SLOTS > kSacnDmxAddressCount) ? kSacnDmxAddressCount : SACN_DMX_MERGER_MAX_SLOTS)
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef int sacn_merge_receiver_t;
static const sacn_merge_receiver_t kSacnMergeReceiverInvalid = -1;
 
typedef struct SacnRecvMergedData
{
  uint16_t universe_id;
  SacnRecvUniverseSubrange slot_range;
  const uint8_t* levels;
  const uint8_t* priorities;
  const sacn_remote_source_t* owners;
  const sacn_remote_source_t* active_sources;
  size_t num_active_sources;
} SacnRecvMergedData;
 
typedef void (*SacnMergeReceiverMergedDataCallback)(sacn_merge_receiver_t     handle,
                                                    const SacnRecvMergedData* merged_data,
                                                    void*                     context);
 
typedef void (*SacnMergeReceiverNonDmxCallback)(sacn_merge_receiver_t       receiver_handle,
                                                const EtcPalSockAddr*       source_addr,
                                                const SacnRemoteSource*     source_info,
                                                const SacnRecvUniverseData* universe_data,
                                                void*                       context);
 
typedef void (*SacnMergeReceiverSourcesLostCallback)(sacn_merge_receiver_t handle,
                                                     uint16_t              universe,
                                                     const SacnLostSource* lost_sources,
                                                     size_t                num_lost_sources,
                                                     void*                 context);
 
typedef void (*SacnMergeReceiverSamplingPeriodStartedCallback)(sacn_merge_receiver_t handle,
                                                               uint16_t              universe,
                                                               void*                 context);
 
typedef void (*SacnMergeReceiverSamplingPeriodEndedCallback)(sacn_merge_receiver_t handle,
                                                             uint16_t              universe,
                                                             void*                 context);
 
typedef void (*SacnMergeReceiverSourcePapLostCallback)(sacn_merge_receiver_t   handle,
                                                       uint16_t                universe,
                                                       const SacnRemoteSource* source,
                                                       void*                   context);
 
typedef void (*SacnMergeReceiverSourceLimitExceededCallback)(sacn_merge_receiver_t handle,
                                                             uint16_t              universe,
                                                             void*                 context);
 
typedef struct SacnMergeReceiverCallbacks
{
  SacnMergeReceiverMergedDataCallback            universe_data;           
  SacnMergeReceiverNonDmxCallback                universe_non_dmx;        
  SacnMergeReceiverSourcesLostCallback           sources_lost;            
  SacnMergeReceiverSamplingPeriodStartedCallback sampling_period_started; 
  SacnMergeReceiverSamplingPeriodEndedCallback   sampling_period_ended;   
  SacnMergeReceiverSourcePapLostCallback         source_pap_lost;         
  SacnMergeReceiverSourceLimitExceededCallback   source_limit_exceeded;   
  void* callback_context; 
} SacnMergeReceiverCallbacks;
 
typedef struct SacnMergeReceiverConfig
{
  /********* Required values **********/
 
  uint16_t universe_id;
  SacnMergeReceiverCallbacks callbacks;
 
  /********* Optional values **********/
 
  SacnRecvUniverseSubrange footprint;
 
  int source_count_max;
 
  bool use_pap;
 
  sacn_ip_support_t ip_supported;
} SacnMergeReceiverConfig;
 
#define SACN_MERGE_RECEIVER_CONFIG_DEFAULT_INIT                                                      \
  {0,    {NULL, NULL, NULL, NULL}, {1, SACN_MERGE_RECEIVER_MAX_SLOTS}, kSacnReceiverInfiniteSources, \
   true, kSacnIpV4AndIpV6}
 
typedef struct SacnMergeReceiverNetintList
{
  sacn_merge_receiver_t handle;
 
  SacnMcastInterface* netints;
  size_t num_netints;
  bool no_netints;
} SacnMergeReceiverNetintList;
 
typedef struct SacnMergeReceiverSource
{
  sacn_remote_source_t handle;
  EtcPalUuid cid;
  char name[kSacnSourceNameMaxLen];
  EtcPalSockAddr addr;
  bool per_address_priorities_active;
  uint8_t universe_priority;
} SacnMergeReceiverSource;
 
void sacn_merge_receiver_config_init(SacnMergeReceiverConfig* config);
 
etcpal_error_t sacn_merge_receiver_create(const SacnMergeReceiverConfig* config,
                                          sacn_merge_receiver_t*         handle,
                                          const SacnNetintConfig*        netint_config);
etcpal_error_t sacn_merge_receiver_destroy(sacn_merge_receiver_t handle);
etcpal_error_t sacn_merge_receiver_get_universe(sacn_merge_receiver_t handle, uint16_t* universe_id);
etcpal_error_t sacn_merge_receiver_get_footprint(sacn_merge_receiver_t handle, SacnRecvUniverseSubrange* footprint);
etcpal_error_t sacn_merge_receiver_change_universe(sacn_merge_receiver_t handle, uint16_t new_universe_id);
etcpal_error_t sacn_merge_receiver_change_footprint(sacn_merge_receiver_t           handle,
                                                    const SacnRecvUniverseSubrange* new_footprint);
etcpal_error_t sacn_merge_receiver_change_universe_and_footprint(sacn_merge_receiver_t           handle,
                                                                 uint16_t                        new_universe_id,
                                                                 const SacnRecvUniverseSubrange* new_footprint);
etcpal_error_t sacn_merge_receiver_reset_networking(const SacnNetintConfig* sys_netint_config);
etcpal_error_t sacn_merge_receiver_reset_networking_per_receiver(
    const SacnNetintConfig*            sys_netint_config,
    const SacnMergeReceiverNetintList* per_receiver_netint_lists,
    size_t                             num_per_receiver_netint_lists);
size_t         sacn_merge_receiver_get_network_interfaces(sacn_merge_receiver_t handle,
                                                          EtcPalMcastNetintId*  netints,
                                                          size_t                netints_size);
etcpal_error_t sacn_merge_receiver_get_source(sacn_merge_receiver_t    merge_receiver_handle,
                                              sacn_remote_source_t     source_handle,
                                              SacnMergeReceiverSource* source_info);
 
#ifdef __cplusplus
}
#endif
 
#endif /* SACN_MERGE_RECEIVER_H_ */