dmx_merger.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2022 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_CPP_DMX_MERGER_H_
#define SACN_CPP_DMX_MERGER_H_
 
#include "sacn/cpp/common.h"
 
#include "sacn/dmx_merger.h"
#include "etcpal/cpp/inet.h"
#include "etcpal/cpp/opaque_id.h"
 
namespace sacn
{
namespace detail
{
class DmxMergerHandleType
{
};
};  // namespace detail
 
class DmxMerger
{
public:
  using Handle = etcpal::OpaqueId<detail::DmxMergerHandleType, sacn_dmx_merger_t, SACN_DMX_MERGER_INVALID>;
 
  struct Settings
  {
    /********* Required values **********/
 
    uint8_t* levels{nullptr};
 
    /********* Optional values **********/
 
    uint8_t* per_address_priorities{nullptr};
 
    bool* per_address_priorities_active{nullptr};
 
    uint8_t* universe_priority{nullptr};
 
    sacn_dmx_merger_source_t* owners{nullptr};
 
    int source_count_max{SACN_RECEIVER_INFINITE_SOURCES}; 
    Settings() = default;
 
    Settings(uint8_t* levels_ptr);
 
    bool IsValid() const;
  };
 
  DmxMerger() = default;
  DmxMerger(const DmxMerger& other) = delete;
  DmxMerger& operator=(const DmxMerger& other) = delete;
  DmxMerger(DmxMerger&& other) = default;            
  DmxMerger& operator=(DmxMerger&& other) = default; 
  etcpal::Error Startup(const Settings& settings);
  void Shutdown();
 
  etcpal::Expected<sacn_dmx_merger_source_t> AddSource();
  etcpal::Error RemoveSource(sacn_dmx_merger_source_t source);
  const SacnDmxMergerSource* GetSourceInfo(sacn_dmx_merger_source_t source) const;
 
  etcpal::Error UpdateLevels(sacn_dmx_merger_source_t source, const uint8_t* new_levels, size_t new_levels_count);
  etcpal::Error UpdatePap(sacn_dmx_merger_source_t source, const uint8_t* pap, size_t pap_count);
  etcpal::Error UpdateUniversePriority(sacn_dmx_merger_source_t source, uint8_t universe_priority);
  etcpal::Error RemovePap(sacn_dmx_merger_source_t source);
 
  constexpr Handle handle() const;
 
private:
  SacnDmxMergerConfig TranslateConfig(const Settings& settings);
 
  Handle handle_;
};
 
inline DmxMerger::Settings::Settings(uint8_t* levels_ptr) : levels(levels_ptr)
{
}
 
inline bool DmxMerger::Settings::IsValid() const
{
  return (levels != nullptr);
}
 
inline etcpal::Error DmxMerger::Startup(const Settings& settings)
{
  SacnDmxMergerConfig config = TranslateConfig(settings);
 
  sacn_dmx_merger_t c_handle = SACN_DMX_MERGER_INVALID;
  etcpal::Error result = sacn_dmx_merger_create(&config, &c_handle);
 
  handle_.SetValue(c_handle);
 
  return result;
}
 
inline void DmxMerger::Shutdown()
{
  sacn_dmx_merger_destroy(handle_.value());
  handle_.Clear();
}
 
inline etcpal::Expected<sacn_dmx_merger_source_t> DmxMerger::AddSource()
{
  sacn_dmx_merger_source_t result = SACN_DMX_MERGER_SOURCE_INVALID;
  etcpal_error_t err = sacn_dmx_merger_add_source(handle_.value(), &result);
  if (err == kEtcPalErrOk)
    return result;
  else
    return err;
}
 
inline etcpal::Error DmxMerger::RemoveSource(sacn_dmx_merger_source_t source)
{
  return sacn_dmx_merger_remove_source(handle_.value(), source);
}
 
inline const SacnDmxMergerSource* DmxMerger::GetSourceInfo(sacn_dmx_merger_source_t source) const
{
  return sacn_dmx_merger_get_source(handle_.value(), source);
}
 
inline etcpal::Error DmxMerger::UpdateLevels(sacn_dmx_merger_source_t source, const uint8_t* new_levels,
                                             size_t new_levels_count)
{
  return sacn_dmx_merger_update_levels(handle_.value(), source, new_levels, new_levels_count);
}
 
inline etcpal::Error DmxMerger::UpdatePap(sacn_dmx_merger_source_t source, const uint8_t* pap, size_t pap_count)
{
  return sacn_dmx_merger_update_pap(handle_.value(), source, pap, pap_count);
}
 
inline etcpal::Error DmxMerger::UpdateUniversePriority(sacn_dmx_merger_source_t source, uint8_t universe_priority)
{
  return sacn_dmx_merger_update_universe_priority(handle_.value(), source, universe_priority);
}
 
inline etcpal::Error DmxMerger::RemovePap(sacn_dmx_merger_source_t source)
{
  return sacn_dmx_merger_remove_pap(handle_.value(), source);
}
 
inline constexpr DmxMerger::Handle DmxMerger::handle() const
{
  return handle_;
}
 
inline SacnDmxMergerConfig DmxMerger::TranslateConfig(const Settings& settings)
{
  // clang-format off
  SacnDmxMergerConfig config = {
    settings.levels,
    settings.per_address_priorities,
    settings.per_address_priorities_active,
    settings.universe_priority,
    settings.owners,
    settings.source_count_max
  };
  // clang-format on
 
  return config;
}
 
};  // namespace sacn
 
#endif  // SACN_CPP_DMX_MERGER_H_