ravenna_sender.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 "ravennakit/aes67/aes67_packet_time.hpp"
#include "ravennakit/core/util/uri.hpp"
#include "ravennakit/core/containers/fifo_buffer.hpp"
#include "ravennakit/core/util/rank.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/rtsp/rtsp_server.hpp"
#include "ravennakit/sdp/sdp_session_description.hpp"
 
#include <boost/uuid/uuid.hpp>
 
namespace rav {
 
class RavennaSender: public rtsp::Server::PathHandler, public ptp::Instance::Subscriber {
  public:
    static constexpr uint32_t k_buffer_num_packets = 30;

    static constexpr uint32_t k_max_num_frames = 4096;

    static constexpr auto k_supported_encodings = {AudioEncoding::pcm_s16, AudioEncoding::pcm_s24};

    struct Destination {
        uint8_t interface_by_rank;
        boost::asio::ip::udp::endpoint endpoint {};
        bool enabled {};
 
        friend bool operator==(const Destination& lhs, const Destination& rhs) {
            return std::tie(lhs.interface_by_rank, lhs.endpoint, lhs.enabled) == std::tie(rhs.interface_by_rank, rhs.endpoint, rhs.enabled);
        }
 
        friend bool operator!=(const Destination& lhs, const Destination& rhs) {
            return !(lhs == rhs);
        }
    };
 
    /*
     * Defines the configuration for the sender.
     */
    struct Configuration {
        std::string session_name;
        std::vector<Destination> destinations;
        uint8_t ttl {};
        uint8_t payload_type {};
        AudioFormat audio_format;
        aes67::PacketTime packet_time;
        bool enabled {};
    };
 
    class Subscriber {
      public:
        virtual ~Subscriber() = default;
 
        virtual void ravenna_sender_configuration_updated(const Id sender_id, const Configuration& configuration) {
            std::ignore = sender_id;
            std::ignore = configuration;
        }
    };
 
    RavennaSender(
        rtp::AudioSender& rtp_audio_sender, dnssd::Advertiser* advertiser, rtsp::Server& rtsp_server, ptp::Instance& ptp_instance, Id id,
        uint32_t session_id, NetworkInterfaceConfig network_interface_config
    );
 
    ~RavennaSender() override;
 
    RavennaSender(const RavennaSender& other) = delete;
    RavennaSender& operator=(const RavennaSender& other) = delete;
 
    RavennaSender(RavennaSender&& other) noexcept = delete;
    RavennaSender& operator=(RavennaSender&& other) noexcept = delete;

    [[nodiscard]] Id get_id() const;

    [[nodiscard]] const boost::uuids::uuid& get_uuid() const;

    [[nodiscard]] uint32_t get_session_id() const;

    [[nodiscard]] tl::expected<void, std::string> set_configuration(Configuration config);

    [[nodiscard]] const Configuration& get_configuration() const;

    [[nodiscard]] bool subscribe(Subscriber* subscriber);

    [[nodiscard]] bool unsubscribe(const Subscriber* subscriber);

    void set_nmos_node(nmos::Node* nmos_node);

    void set_nmos_device_id(const boost::uuids::uuid& device_id);

    [[nodiscard]] float get_signaled_ptime() const;

    [[nodiscard]] uint32_t get_framecount() const;

    void set_network_interface_config(NetworkInterfaceConfig network_interface_config);

    void set_advertiser(dnssd::Advertiser* advertiser);

    [[nodiscard]] tl::expected<sdp::SessionDescription, std::string> generate_sdp() const;

    boost::json::object to_boost_json() const;

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

    [[nodiscard]] const nmos::SourceAudio& get_nmos_source() const;

    [[nodiscard]] const nmos::FlowAudioRaw& get_nmos_flow() const;

    [[nodiscard]] const nmos::Sender& get_nmos_sender() const;
 
    // rtsp_server::handler overrides
    void on_request(rtsp::Connection::RequestEvent event) const override;
 
    // ptp::Instance::Subscriber overrides
    void ptp_parent_changed(const ptp::ParentDs& parent) override;
 
  private:
    rtp::AudioSender& rtp_audio_sender_;
    dnssd::Advertiser* advertiser_ {nullptr};
    rtsp::Server& rtsp_server_;
    ptp::Instance& ptp_instance_;
    nmos::Node* nmos_node_ {nullptr};
 
    Id id_;
    uint32_t session_id_ {};
    Configuration configuration_;
    std::string rtsp_path_by_name_;
    std::string rtsp_path_by_id_;
    Id advertisement_id_;
    int32_t clock_domain_ {};
    ptp::ClockIdentity grandmaster_identity_;
    NetworkInterfaceConfig network_interface_config_;
 
    nmos::SourceAudio nmos_source_;
    nmos::FlowAudioRaw nmos_flow_;
    nmos::Sender nmos_sender_;
 
    SubscriberList<Subscriber> subscribers_;
    std::string status_message_;

    void send_announce() const;
    void update_nmos();
    void update_advertisement();
    void generate_auto_addresses_if_needed(bool notify_subscribers);
    bool generate_auto_addresses_if_needed(std::vector<Destination>& destinations) const;
    void restart_streaming() const;
    tl::expected<void, rav::nmos::ApiError> handle_patch_request(const boost::json::value& patch_request);
    void register_dnssd_session_advertisement();
};
 
void tag_invoke(const boost::json::value_from_tag&, boost::json::value& jv, const RavennaSender::Destination& destination);
 
RavennaSender::Destination tag_invoke(const boost::json::value_to_tag<RavennaSender::Destination>&, const boost::json::value& jv);
 
void tag_invoke(const boost::json::value_from_tag&, boost::json::value& jv, const RavennaSender::Configuration& config);
 
RavennaSender::Configuration tag_invoke(const boost::json::value_to_tag<RavennaSender::Configuration>&, const boost::json::value& jv);
 
}  // namespace rav