ravenna_node.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
/*
 * Project: RAVENNAKIT (RAVENNA / AES67 / ST2110-30 SDK)
 * Copyright (c) 2024-2025 Sound on Digital
 *
 * This file is part of RAVENNAKIT.
 *
 * RAVENNAKIT is dual-licensed:
 *   1) Under the terms of the GNU Affero General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version (the "AGPL License"); and
 *   2) Under a commercial license from Sound on Digital, for customers who
 *      cannot (or do not wish to) comply with the AGPL License terms.
 *
 * If you obtained this file under the AGPL License, you may redistribute it
 * and/or modify it under the terms of the AGPL License. See the LICENSE
 * file in the project root for details.
 *
 * For commercial licensing, support, and other inquiries, please visit:
 *
 *     https://ravennakit.com
 *
 */
 
#pragma once
 
#include "ravenna_browser.hpp"
#include "ravenna_rtsp_client.hpp"
#include "ravenna_receiver.hpp"
#include "ravenna_sender.hpp"
#include "ravennakit/core/audio/audio_buffer_view.hpp"
#include "ravennakit/core/sync/realtime_shared_object.hpp"
#include "ravennakit/core/util/id.hpp"
#include "ravennakit/dnssd/dnssd_advertiser.hpp"
#include "ravennakit/nmos/nmos_node.hpp"
#include "ravennakit/ptp/ptp_instance.hpp"
#include "ravennakit/rtp/detail/rtp_audio_sender.hpp"
#include "ravennakit/rtp/detail/rtp_sender.hpp"
#include "ravennakit/rtsp/rtsp_server.hpp"
 
#include <string>
 
namespace rav {

class RavennaNode {
  public:
    struct Configuration {
        bool enable_dnssd_node_discovery {};

        bool enable_dnssd_session_advertisement {};

        bool enable_dnssd_session_discovery {};
    };

    class Subscriber: public RavennaBrowser::Subscriber {
      public:
        ~Subscriber() override = default;

        virtual void ravenna_node_configuration_updated(const Configuration& configuration) {
            std::ignore = configuration;
        }

        virtual void ravenna_receiver_added(const RavennaReceiver& receiver) {
            std::ignore = receiver;
        }

        virtual void ravenna_receiver_removed(const Id receiver_id) {
            std::ignore = receiver_id;
        }

        virtual void ravenna_sender_added(const RavennaSender& sender) {
            std::ignore = sender;
        }

        virtual void ravenna_sender_removed(const Id sender_id) {
            std::ignore = sender_id;
        }

        virtual void nmos_node_config_updated(const nmos::Node::Configuration& config) {
            std::ignore = config;
        }

        virtual void nmos_node_status_changed(const nmos::Node::Status status, const nmos::Node::StatusInfo& registry_info) {
            std::ignore = status;
            std::ignore = registry_info;
        }

        virtual void network_interface_config_updated(const NetworkInterfaceConfig& config) {
            std::ignore = config;
        }
    };
 
    explicit RavennaNode();
    ~RavennaNode();
 
    // MARK: Receivers

    [[nodiscard]] std::future<tl::expected<Id, std::string>> create_receiver(RavennaReceiver::Configuration initial_config);

    [[nodiscard]] std::future<void> remove_receiver(Id receiver_id);

    [[nodiscard]] std::future<tl::expected<void, std::string>>
    update_receiver_configuration(Id receiver_id, RavennaReceiver::Configuration config);

    [[nodiscard]] std::future<void> subscribe_to_receiver(Id receiver_id, RavennaReceiver::Subscriber* subscriber);

    [[nodiscard]] std::future<void> unsubscribe_from_receiver(Id receiver_id, RavennaReceiver::Subscriber* subscriber);

    [[nodiscard]] std::optional<uint32_t> read_data_realtime(
        Id receiver_id, uint8_t* buffer, size_t buffer_size, std::optional<uint32_t> at_timestamp, std::optional<uint32_t> require_delay
    );

    [[nodiscard]] std::optional<uint32_t> read_audio_data_realtime(
        Id receiver_id, AudioBufferView<float>& output_buffer, std::optional<uint32_t> at_timestamp, std::optional<uint32_t> require_delay
    );

    std::future<tl::expected<sdp::SessionDescription, std::string>> get_sdp_for_sender(Id sender_id);

    [[nodiscard]] std::future<std::optional<sdp::SessionDescription>> get_sdp_for_receiver(Id receiver_id);

    [[nodiscard]] std::future<std::optional<std::string>> get_sdp_text_for_receiver(Id receiver_id);
 
    // MARK: Senders

    [[nodiscard]] std::future<tl::expected<Id, std::string>> create_sender(RavennaSender::Configuration initial_config);

    [[nodiscard]] std::future<void> remove_sender(Id sender_id);

    [[nodiscard]] std::future<tl::expected<void, std::string>>
    update_sender_configuration(Id sender_id, RavennaSender::Configuration config);

    [[nodiscard]] std::future<void> subscribe_to_sender(Id sender_id, RavennaSender::Subscriber* subscriber);

    [[nodiscard]] std::future<void> unsubscribe_from_sender(Id sender_id, RavennaSender::Subscriber* subscriber);

    [[nodiscard]] bool send_data_realtime(Id sender_id, BufferView<const uint8_t> buffer, uint32_t timestamp);

    [[nodiscard]] bool send_audio_data_realtime(Id sender_id, const AudioBufferView<const float>& buffer, uint32_t timestamp);
 
    // MARK: PTP

    [[nodiscard]] std::future<void> subscribe_to_ptp_instance(ptp::Instance::Subscriber* subscriber);

    [[nodiscard]] std::future<void> unsubscribe_from_ptp_instance(ptp::Instance::Subscriber* subscriber);

    [[nodiscard]] std::future<tl::expected<void, std::string>> set_ptp_instance_configuration(ptp::Instance::Configuration update);
 
    // MARK: NMOS

    [[nodiscard]] std::future<tl::expected<void, std::string>> set_nmos_configuration(nmos::Node::Configuration update);

    std::future<boost::uuids::uuid> get_nmos_device_id();
 
    // MARK: RavennaNode

    [[nodiscard]] std::future<void> subscribe(Subscriber* subscriber);

    [[nodiscard]] std::future<void> unsubscribe(Subscriber* subscriber);

    [[nodiscard]] std::future<void> set_network_interface_config(NetworkInterfaceConfig interface_config);

    std::future<void> set_configuration(Configuration config);

    [[nodiscard]] bool is_maintenance_thread() const;

    [[nodiscard]] std::future<boost::json::object> to_boost_json();

    [[nodiscard]] std::future<tl::expected<void, std::string>> restore_from_boost_json(const boost::json::value& json);

    template<typename CompletionToken>
    [[nodiscard]] auto dispatch(CompletionToken&& token) {
        return boost::asio::dispatch(io_context_, token);
    }

    template<typename CompletionToken>
    [[nodiscard]] auto post(CompletionToken&& token) {
        return boost::asio::post(io_context_, token);
    }
 
  private:
    boost::asio::io_context io_context_;
    Configuration configuration_;
    rtp::AudioReceiver rtp_receiver_ {io_context_};
    rtp::AudioSender rtp_sender_ {io_context_};
    std::atomic<bool> keep_going_ {true};
    std::thread network_thread_;
    std::thread maintenance_thread_;
    std::thread::id maintenance_thread_id_;
    Id::Generator id_generator_;
 
    RavennaBrowser browser_ {io_context_};
    RavennaRtspClient rtsp_client_ {io_context_, browser_};
    std::vector<std::unique_ptr<RavennaReceiver>> receivers_;
 
    std::unique_ptr<dnssd::Advertiser> advertiser_;
    rtsp::Server rtsp_server_;
    ptp::Instance ptp_instance_;
    std::vector<std::unique_ptr<RavennaSender>> senders_;
 
    nmos::Node nmos_node_ {io_context_, ptp_instance_};
    nmos::Device nmos_device_;
 
    SubscriberList<Subscriber> subscribers_;
    NetworkInterfaceConfig network_interface_config_;
 
    uint32_t generate_unique_session_id() const;
    void do_maintenance() const;
    void update_ravenna_browser();
};

std::string to_string(const RavennaNode::Configuration& configuration);
 
}  // namespace rav

#define RAV_ASSERT_NODE_MAINTENANCE_THREAD(node) RAV_ASSERT((node).is_maintenance_thread(), "Not on maintenance thread")