Transmitter.h

Go to the documentation of this file.

// libflute - FLUTE/ALC library
//
// Copyright (C) 2021 Klaus Kühnhammer (Österreichische Rundfunksender GmbH & Co KG)
//               2025 British Broadcasting Corporation (David Waring <david.waring2@bbc.co.uk>)
//
// Licensed under the License terms and conditions for use, reproduction, and
// distribution of 5G-MAG software (the “License”).  You may not use this file
// except in compliance with the License.  You may obtain a copy of the License at
// https://www.5g-mag.com/reference-tools.  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.
//
#pragma once
#include <boost/asio.hpp>
#include <boost/bind/bind.hpp>
#include <atomic>
#include <chrono>
#include <queue>
#include <string>
#include <map>
#include <mutex>
#include <optional>
//#include "File.h"
#include "AlcPacket.h"
#include "FileDeliveryTable.h"
 
namespace LibFlute {
 
  class File;
 
  class Transmitter {
    public:
      using FdtNamespace = FileDeliveryTable::FdtNamespace;
 
 
      class FileDescription {
      public:
        using date_time_type = std::chrono::system_clock::time_point;
 
        enum CompressionAlgorithm {
          COMPRESSION_NONE = 0,  //< No compression
          COMPRESSION_GZIP,      //< Use gzip compression when encoding the file
          COMPRESSION_DEFLATE    //< Use deflate compression when encoding the file
        };
 
        FileDescription() = delete;
        FileDescription(const std::string &content_location, const std::string &filename);
 
        FileDescription(const std::string &content_location, const std::vector<char> &data);
        FileDescription(const std::string &content_location, const std::vector<unsigned char> &data);
        FileDescription(const std::string &content_location, const char *data, size_t length);
 
        FileDescription(const std::string &content_location);
 
        FileDescription(const FileDescription &other);
 
        FileDescription(FileDescription &&other);
 
        virtual ~FileDescription();
 
        FileDescription &operator=(const FileDescription &other);
 
        FileDescription &operator=(FileDescription &&other);
 
        bool operator==(const FileDescription &other) const;
 
        bool has_tsi() const { return _tsi.has_value(); };
 
        uint64_t tsi() const { return _tsi?_tsi.value():0; };
 
        uint32_t toi() const { return _file_entry.toi; };
 
        const FileDeliveryTable::FileEntry &file_entry() const {
          return _file_entry;
        };
 
        const char *data();
 
        size_t data_length();
 
        FileDescription &set_compression(CompressionAlgorithm compression);
 
        FileDescription &set_content_location(const std::string &location);
 
        FileDescription &set_content(const std::string &filename);
 
        FileDescription &set_content(const char *data, size_t data_length);
 
        FileDescription &set_content(const std::vector<char> &data);
        FileDescription &set_content(const std::vector<unsigned char> &data);
        FileDescription &set_content_type(const std::string &content_type);
 
        FileDescription &set_expiry_time(const date_time_type &expiry_time);
 
        date_time_type get_expiry_time() const;
 
        FileDescription &set_etag(const std::string &etag);
 
        const std::string &get_etag() const;
 
      protected:
        friend class Transmitter;
        FileDescription &tsi(uint64_t val) { _tsi = val; return *this; };
        FileDescription &toi(uint32_t val) { _file_entry.toi = val; return *this; };
 
        uint32_t previous_toi() const { return _previous_toi; };
 
        FileDescription &reset_previous_toi() { _previous_toi = 0; return *this; };
 
        FileDescription &merge_fec_oti(const FecOti &fec_oti);
 
      private:
        void _attach_file(const std::string &filename);
        void _free_file_data();
        void _calculate_file_entry();
        void _reset_toi(); //< Zero the TOI for reassignment, remembering the old value in _previous_toi
 
        std::optional<uint64_t> _tsi; //< The last TSI this file was associated with
        FileDeliveryTable::FileEntry _file_entry; //< The FDT File entry values to use
        CompressionAlgorithm _compression_type;   //< The compression to apply to _data
        std::string _filename;                    //< The filename that _data was loaded from, empty for no local file
        int _file_handle;                         //< The file handle of the open _filename
        const char *_data;                        //< The uncompressed file contents (may be mapped file)
        size_t _data_length;                      //< The length of the uncompressed file contents
        uint32_t _previous_toi = 0;                //< TOI this description held before a content/compression
                                                    //< change zeroed it for reassignment, so the Transmitter can
                                                    //< remove that now-orphaned FDT entry; 0 once consumed
      };
 
      typedef std::function<void(uint32_t)> completion_callback_t;
 
      Transmitter( const std::string& destination_address,
          short port, uint64_t tsi, unsigned short mtu,
          uint32_t rate_limit,
          boost::asio::io_context& io_context,
          const std::optional<boost::asio::ip::udp::endpoint>& tunnel_endpoint = std::nullopt,
          FdtNamespace fdt_namespace = FileDeliveryTable::FDT_NS_NONE,
          bool active = true,
          const std::optional<std::string>& source_address = std::nullopt);
 
      virtual ~Transmitter();
 
      const std::optional<boost::asio::ip::udp::endpoint> &udp_tunnel_address() const { return _tunnel_endpoint; };
 
      Transmitter &udp_tunnel_address(const boost::asio::ip::udp::endpoint &new_tunnel_endpoint);
 
      Transmitter &udp_tunnel_address(boost::asio::ip::udp::endpoint &&new_tunnel_endpoint);
 
      Transmitter &udp_tunnel_address(const std::optional<boost::asio::ip::udp::endpoint> &new_tunnel_endpoint);
 
      Transmitter &udp_tunnel_address(std::optional<boost::asio::ip::udp::endpoint> &&new_tunnel_endpoint);
 
      Transmitter &udp_tunnel_address(const std::nullopt_t&);
 
      uint32_t rate_limit() const { return _rate_limit; };
 
      Transmitter &rate_limit(uint32_t limit) { _rate_limit = limit; return *this; };
 
      const boost::asio::ip::udp::endpoint &endpoint() const { return _endpoint; };
 
      Transmitter &endpoint(const std::string &address, uint32_t port);
 
      Transmitter &endpoint(const boost::asio::ip::udp::endpoint &destination);
      Transmitter &endpoint(boost::asio::ip::udp::endpoint &&destination);
      const std::optional<boost::asio::ip::address> &source_address() const { return _source_address; };
 
      Transmitter &source_address(const std::optional<boost::asio::ip::address> &source);
      Transmitter &source_address(std::optional<boost::asio::ip::address> &&source);
      void enable_ipsec( uint32_t spi, const std::string& aes_key);
 
      uint16_t send(const std::string& content_location,
          const std::string& content_type,
          uint32_t expires,
          char* data,
          size_t length);
 
      uint16_t send(const std::shared_ptr<FileDescription> &file_description);
 
      uint64_t seconds_since_epoch();
 
      void register_completion_callback(completion_callback_t cb) { _completion_cb = cb; };
 
      void activate();
 
      void deactivate(bool finish_file_transmissions = false);
 
      size_t number_of_files() { std::lock_guard<std::mutex> guard(_files_mutex); return _files.size(); };
 
    private:
      void send_fdt();
      void send_next_packet();
      void fdt_send_tick(const boost::system::error_code& error);
      void start_fdt_repeat_timer();
 
      void _complete_deactivation();
 
      void file_transmitted(uint32_t toi);
 
      void handle_send_to(const boost::system::error_code& error);
      boost::asio::ip::udp::endpoint _endpoint;
      std::optional<boost::asio::ip::address> _source_address;
      boost::asio::ip::udp::socket _socket;
      boost::asio::io_context& _io_context;
      boost::asio::steady_timer _send_timer;
      boost::asio::steady_timer _fdt_timer;
 
      uint64_t _tsi;
      uint16_t _mtu;
 
      std::unique_ptr<FileDeliveryTable> _fdt;
      std::map<uint32_t, std::shared_ptr<File>> _files;
      std::mutex _files_mutex;
 
      unsigned _fdt_repeat_interval = 5;
      uint16_t _toi = 1;
 
      uint32_t _max_payload;
      FecOti _fec_oti;
 
      completion_callback_t _completion_cb = nullptr;
      std::string _mcast_address;
 
      uint32_t _rate_limit = 0;
      std::optional<boost::asio::ip::udp::endpoint> _tunnel_endpoint = std::nullopt;
      boost::asio::ip::address _tunnel_local_address;
 
      std::atomic<bool> _active;
      std::atomic<bool> _deactivate_when_all_files_sent = false;
  };
 
} // end namespace LibFlute