ravenna_receiver.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_rtsp_client.hpp"
#include "ravennakit/core/containers/fifo_buffer.hpp"
#include "ravennakit/core/util/id.hpp"
#include "ravennakit/nmos/nmos_node.hpp"
#include "ravennakit/nmos/models/nmos_receiver_audio.hpp"
#include "ravennakit/rtp/detail/rtp_audio_receiver.hpp"
#include "ravennakit/sdp/sdp_session_description.hpp"
 
namespace rav {
 
class RavennaReceiver: public RavennaRtspClient::Subscriber {
  public:
    static constexpr auto k_supported_encodings = {AudioEncoding::pcm_s16, AudioEncoding::pcm_s24};

    struct Configuration {
        sdp::SessionDescription sdp;
        std::string session_name;
        uint32_t delay_frames {};
        bool enabled {};
        bool auto_update_sdp {true};  // When true, the receiver will connect to the RTSP server for SDP updates.
 
        static Configuration default_config() {
            return Configuration {{}, {}, 480, true, true};
        }
    };

    class Subscriber {
      public:
        virtual ~Subscriber() = default;

        virtual void ravenna_receiver_parameters_updated(const rtp::AudioReceiver::ReaderParameters& parameters) {
            std::ignore = parameters;
        }

        virtual void ravenna_receiver_configuration_updated(const RavennaReceiver& receiver, const Configuration& configuration) {
            std::ignore = receiver;
            std::ignore = configuration;
        }

        virtual void ravenna_receiver_stream_state_updated(
            const rtp::AudioReceiver::StreamInfo& stream_info, const rtp::AudioReceiver::StreamState state
        ) {
            std::ignore = stream_info;
            std::ignore = state;
        }

        virtual void ravenna_receiver_stream_stats_updated(Id receiver_id, size_t stream_index, const rtp::PacketStats::Counters& stats) {
            std::ignore = receiver_id;
            std::ignore = stream_index;
            std::ignore = stats;
        }
    };
 
    explicit RavennaReceiver(
        RavennaRtspClient& rtsp_client, rtp::AudioReceiver& rtp_audio_receiver, Id id, NetworkInterfaceConfig network_interface_config
    );
    ~RavennaReceiver() override;
 
    RavennaReceiver(const RavennaReceiver&) = delete;
    RavennaReceiver& operator=(const RavennaReceiver&) = delete;
 
    RavennaReceiver(RavennaReceiver&&) noexcept = delete;
    RavennaReceiver& operator=(RavennaReceiver&&) noexcept = delete;

    [[nodiscard]] Id get_id() const;

    [[nodiscard]] const boost::uuids::uuid& get_uuid() 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]] std::optional<sdp::SessionDescription> get_sdp() const;

    [[nodiscard]] std::optional<std::string> get_sdp_text() const;

    void set_network_interface_config(NetworkInterfaceConfig network_interface_config);

    [[nodiscard]] boost::json::object to_boost_json() const;

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

    [[nodiscard]] const nmos::ReceiverAudio& get_nmos_receiver() const;

    void do_maintenance();
 
    // ravenna_rtsp_client::subscriber overrides
    void on_announced(const RavennaRtspClient::AnnouncedEvent& event) override;
 
  private:
    RavennaRtspClient& rtsp_client_;
    rtp::AudioReceiver& rtp_audio_receiver_;
    nmos::Node* nmos_node_ {nullptr};
    const Id id_;
    Configuration configuration_;
    NetworkInterfaceConfig network_interface_config_;
    nmos::ReceiverAudio nmos_receiver_;
    SubscriberList<Subscriber> subscribers_;
    rtp::AudioReceiver::ReaderParameters reader_parameters_;
    std::array<rtp::AudioReceiver::StreamState, rtp::AudioReceiver::k_max_num_redundant_sessions> streams_states_ {};
    Throttle<void> stats_throttle_ {std::chrono::seconds(1)};
 
    void handle_announced_sdp(const sdp::SessionDescription& sdp);
    tl::expected<void, std::string> update_nmos();
    tl::expected<void, std::string> update_rtsp();
    tl::expected<void, nmos::ApiError> handle_patch_request(const boost::json::value& patch_request);
};

tl::expected<rtp::AudioReceiver::ReaderParameters, std::string> create_rtp_receiver_parameters(const sdp::SessionDescription& sdp);
 
void tag_invoke(const boost::json::value_from_tag&, boost::json::value& jv, const RavennaReceiver::Configuration& config);
 
RavennaReceiver::Configuration tag_invoke(const boost::json::value_to_tag<RavennaReceiver::Configuration>&, const boost::json::value& jv);
 
}  // namespace rav