MBMS_RT::ServiceAnnouncement Class Reference

#include <ServiceAnnouncement.h>

Collaboration diagram for MBMS_RT::ServiceAnnouncement:

Classes
struct	Item

Public Types
typedef std::function< std::shared_ptr< Service >const std::string &service_id)>	get_service_callback_t
typedef std::function< void(const std::string &service_id, std::shared_ptr< Service >)>	set_service_callback_t

Public Member Functions
	ServiceAnnouncement (const libconfig::Config &cfg, std::string tmgi, const std::string &mcast, unsigned long long tsi, std::string iface, boost::asio::io_service &io_service, CacheManagement &cache, bool seamless_switching, get_service_callback_t get_service, set_service_callback_t set_service)
virtual	~ServiceAnnouncement ()
const std::vector< Item > &	items () const
const std::string &	content () const
uint32_t	toi () const
void	parse_bootstrap (const std::string &str)
	Parse the service announcement/bootstrap file. More...
void	start_flute_receiver (const std::string &mcast_address)
	Starts the FLUTE receiver at the specified multicast address. More...

Private Member Functions
void	_addServiceAnnouncementItems (const std::string &str)
	Iterates through the service announcement file and adds the different sections/items to the the list of _items. More...
void	_handleMbmsEnvelope (const Item &item)
	Parses the MBMS envelope. More...
void	_handleMbmbsUserServiceDescriptionBundle (const Item &item, const std::string &bootstrap_format)
	Parses the MBMS USD. More...
std::tuple< std::shared_ptr< MBMS_RT::Service >, bool >	_registerService (tinyxml2::XMLElement *usd, const std::string &service_id)
	Creates a new service or finds an existing service for the specified service id. More...
void	_handleAppService (tinyxml2::XMLElement *app_service, const std::shared_ptr< Service > &service)
	Parse the appService element Spec: Presence of the r12:appService child element of userServiceDescription indicates that the associated MBMS User Service is an application service explicitly linked to the r12:broadcastAppService and r12:unicastAppService elements under deliveryMethod. More...
bool	_setupBroadcastDelivery (tinyxml2::XMLElement *usd, std::string base, std::shared_ptr< ContentStream > cs)
void	_setupByAlternativeContentElement (tinyxml2::XMLElement *app_service, const std::shared_ptr< MBMS_RT::Service > &service, tinyxml2::XMLElement *usd)
	Setup according to original SA format with an alternativeContentElement required to indicate that the stream is available via BC and UC. More...
void	_setupBy5GMagConfig (tinyxml2::XMLElement *app_service, const std::shared_ptr< MBMS_RT::Service > &service, tinyxml2::XMLElement *usd)
void	_setupBy5GMagLegacyFormat (tinyxml2::XMLElement *app_service, const std::shared_ptr< MBMS_RT::Service > &service, tinyxml2::XMLElement *usd)
	Setup according to the format that was used for the first 5G-MAG sample recordings. More...

Private Attributes
get_service_callback_t	_get_service
set_service_callback_t	_set_service
bool	_seamless = false
std::vector< Item >	_items
const libconfig::Config &	_cfg
bool	_bootstrapped = false
uint32_t	_toi = {}
std::string	_raw_content
std::string	_iface
std::string	_tmgi
std::string	_mcast_addr
std::string	_mcast_port
std::string	_base_path
unsigned long long	_tsi = 0
std::thread	_flute_thread
std::unique_ptr< LibFlute::Receiver >	_flute_receiver
boost::asio::io_service &	_io_service
CacheManagement &	_cache

Detailed Description

Definition at line 32 of file ServiceAnnouncement.h.

Member Typedef Documentation

get_service_callback_t

typedef std::function<std::shared_ptr<Service>const std::string &service_id)> MBMS_RT::ServiceAnnouncement::get_service_callback_t

Definition at line 34 of file ServiceAnnouncement.h.

set_service_callback_t

typedef std::function<void(const std::string &service_id, std::shared_ptr<Service>)> MBMS_RT::ServiceAnnouncement::set_service_callback_t

Definition at line 35 of file ServiceAnnouncement.h.

Constructor & Destructor Documentation

ServiceAnnouncement()

MBMS_RT::ServiceAnnouncement::ServiceAnnouncement	(	const libconfig::Config &	cfg,
		std::string	tmgi,
		const std::string &	mcast,
		unsigned long long	tsi,
		std::string	iface,
		boost::asio::io_service &	io_service,
		CacheManagement &	cache,
		bool	seamless_switching,
		get_service_callback_t	get_service,
		set_service_callback_t	set_service
	)

Definition at line 36 of file ServiceAnnouncement.cpp.

    : _cfg(cfg), _tmgi(std::move(tmgi)), _tsi(tsi), _iface(std::move(iface)), _io_service(io_service), _cache(cache),
      _flute_thread{}, _seamless(seamless_switching), _get_service(std::move(get_service)),
      _set_service(std::move(set_service)) {
}

~ServiceAnnouncement()

MBMS_RT::ServiceAnnouncement::~ServiceAnnouncement ( )

virtual

Definition at line 48 of file ServiceAnnouncement.cpp.

                                                 {
  spdlog::info("Closing service announcement session with TMGI {}", _tmgi);
  _flute_receiver.reset();
  if (_flute_thread.joinable()) {
    _flute_thread.join();
  }
}

Member Function Documentation

_addServiceAnnouncementItems()

void MBMS_RT::ServiceAnnouncement::_addServiceAnnouncementItems ( const std::string &  str )

private

Iterates through the service announcement file and adds the different sections/items to the the list of _items.

Parameters

{std::string}

str

Definition at line 121 of file ServiceAnnouncement.cpp.

                                                                                  {
  g_mime_init();
  auto stream = g_mime_stream_mem_new_with_buffer(str.c_str(), str.length());
  auto parser = g_mime_parser_new_with_stream(stream);
  g_object_unref(stream);
 
  auto mpart = g_mime_parser_construct_part(parser, nullptr);
  g_object_unref(parser);
 
  auto iter = g_mime_part_iter_new(mpart);
  do {
    GMimeObject *current = g_mime_part_iter_get_current(iter);
    GMimeObject *parent = g_mime_part_iter_get_parent(iter);
 
    if (GMIME_IS_PART (current)) {
      auto type = std::string(g_mime_content_type_get_mime_type(g_mime_object_get_content_type(current)));
      std::string location = "";
      if (g_mime_object_get_header(current, "Content-Location")) {
        location = std::string(g_mime_object_get_header(current, "Content-Location"));
      }
      auto options = g_mime_format_options_new();
      g_mime_format_options_add_hidden_header(options, "Content-Type");
      g_mime_format_options_add_hidden_header(options, "Content-Transfer-Encoding");
      g_mime_format_options_add_hidden_header(options, "Content-Location");
      std::string content = g_mime_object_to_string(current, options);
      boost::algorithm::trim_left(content);
 
      if (location != "") {
        _items.emplace_back(Item{
            type,
            location,
            0, 0, 0,
            content
        });
      }
    }
  } while (g_mime_part_iter_next(iter));
 
}

_handleAppService()

void MBMS_RT::ServiceAnnouncement::_handleAppService ( tinyxml2::XMLElement *  app_service, const std::shared_ptr< Service > &  service  )

private

Parse the appService element Spec: Presence of the r12:appService child element of userServiceDescription indicates that the associated MBMS User Service is an application service explicitly linked to the r12:broadcastAppService and r12:unicastAppService elements under deliveryMethod.

Parameters

usd
app_service
service

Definition at line 272 of file ServiceAnnouncement.cpp.

                                                                                             {
 
  service->set_delivery_protocol_from_mime_type(app_service->Attribute(ServiceAnnouncementXmlElements::MIME_TYPE));
 
  // Now search for the content that corresponds to appServiceDescriptionURI. For instance appServiceDescriptionURI="http://localhost/watchfolder/manifest.m3u8"
  // The attribute appServiceDescriptionURI of r12:appService references an Application Service Description which may be a Media Presentation Description fragment corresponding to a unified MPD.
  for (const auto &item: _items) {
    // item.uri is derived from the Content-Location of each entry in the bootstrap file. For HLS we are looking for the content of the master manifest in the bootstrap file:
    if (item.uri == app_service->Attribute(ServiceAnnouncementXmlElements::APP_SERVICE_DESCRIPTION_URI)) {
      web::uri uri(item.uri);
 
      // remove file, leave only dir
      const std::string &path = uri.path();
      size_t spos = path.rfind('/');
      auto base_path = path.substr(0, spos + 1);
 
      // make relative path: remove leading /
      if (base_path[0] == '/') {
        base_path.erase(0, 1);
      }
      service->read_master_manifest(item.content, base_path);
      _base_path = base_path;
    }
  }
}

_handleMbmbsUserServiceDescriptionBundle()

void MBMS_RT::ServiceAnnouncement::_handleMbmbsUserServiceDescriptionBundle ( const Item &  item, const std::string &  bootstrap_format  )

private

Parses the MBMS USD.

Parameters

{MBMS_RT::ServiceAnnouncement::Item}

item

Definition at line 197 of file ServiceAnnouncement.cpp.

                                                                                                          {
  try {
    tinyxml2::XMLDocument doc;
    doc.Parse(item.content.c_str());
 
    auto bundle = doc.FirstChildElement(ServiceAnnouncementXmlElements::BUNDLE_DESCRIPTION);
    for (auto *usd = bundle->FirstChildElement(ServiceAnnouncementXmlElements::USER_SERVICE_DESCRIPTION);
         usd != nullptr;
         usd = usd->NextSiblingElement(ServiceAnnouncementXmlElements::USER_SERVICE_DESCRIPTION)) {
 
      // Create a new service
      auto service_id = usd->Attribute(ServiceAnnouncementXmlElements::SERVICE_ID);
      auto[service, is_new_service] = _registerService(usd, service_id);
 
      // Handle the app service element. Will read the master manifest as provided in the SA
      auto app_service = usd->FirstChildElement(ServiceAnnouncementXmlElements::APP_SERVICE);
      _handleAppService(app_service, service);
 
      // For the default format we need an alternativeContent attribute to setup the service
      if (bootstrap_format == ServiceAnnouncementFormatConstants::FIVEG_MAG_BC_UC) {
        _setupBy5GMagConfig(app_service, service, usd);
      } else if (bootstrap_format == ServiceAnnouncementFormatConstants::FIVEG_MAG_LEGACY) {
        _setupBy5GMagLegacyFormat(app_service, service, usd);
      } else {
        _setupByAlternativeContentElement(app_service, service, usd);
      }
 
      if (is_new_service && service->content_streams().size() > 0) {
        _set_service(service_id, service);
      }
    }
  } catch (std::exception e) {
    spdlog::warn("MBMS user service desription parsing failed: {}", e.what());
  }
}

_handleMbmsEnvelope()

void MBMS_RT::ServiceAnnouncement::_handleMbmsEnvelope ( const Item &  item )

private

Parses the MBMS envelope.

Parameters

{MBMS_RT::ServiceAnnouncement::Item}

item

Definition at line 165 of file ServiceAnnouncement.cpp.

                                                                                               {
  try {
    tinyxml2::XMLDocument doc;
    doc.Parse(item.content.c_str());
    auto envelope = doc.FirstChildElement(ServiceAnnouncementXmlElements::METADATA_ENVELOPE);
    for (auto *i = envelope->FirstChildElement(ServiceAnnouncementXmlElements::ITEM);
         i != nullptr; i = i->NextSiblingElement(ServiceAnnouncementXmlElements::ITEM)) {
      spdlog::debug("uri: {}", i->Attribute(ServiceAnnouncementXmlElements::METADATA_URI));
      for (auto &ir: _items) {
        if (ir.uri == i->Attribute(ServiceAnnouncementXmlElements::METADATA_URI)) {
          std::stringstream ss_from(i->Attribute(ServiceAnnouncementXmlElements::VALID_FROM));
          struct std::tm from;
          ss_from >> std::get_time(&from, "%Y-%m-%dT%H:%M:%S.%fZ");
          ir.valid_from = mktime(&from);
          std::stringstream ss_until(i->Attribute(ServiceAnnouncementXmlElements::VALID_UNTIL));
          struct std::tm until;
          ss_until >> std::get_time(&until, "%Y-%m-%dT%H:%M:%S.%fZ");
          ir.valid_until = mktime(&until);
          ir.version = atoi(i->Attribute(ServiceAnnouncementXmlElements::VERSION));
        }
      }
    }
  } catch (std::exception e) {
    spdlog::warn("MBMS envelope parsing failed: {}", e.what());
  }
}

_registerService()

auto MBMS_RT::ServiceAnnouncement::_registerService ( tinyxml2::XMLElement *  usd, const std::string &  service_id  )

private

Creates a new service or finds an existing service for the specified service id.

Parameters

usd
service_id

Returns

Definition at line 241 of file ServiceAnnouncement.cpp.

                                                                                                                                                  {
  // Register a new service if we have not seen this service id before
 
  bool is_new_service = false;
  auto service = _get_service(service_id);
  if (service == nullptr) {
    service = std::make_shared<Service>(_cache);
    is_new_service = true;
  }
 
  // read the names
  for (auto *name = usd->FirstChildElement(ServiceAnnouncementXmlElements::NAME);
       name != nullptr; name = name->NextSiblingElement(ServiceAnnouncementXmlElements::NAME)) {
    auto lang = name->Attribute(ServiceAnnouncementXmlElements::LANG);
    auto namestr = name->GetText();
    if (lang && namestr) {
      service->add_name(namestr, lang);
    }
  }
 
  return {service, is_new_service};
}

_setupBroadcastDelivery()

bool MBMS_RT::ServiceAnnouncement::_setupBroadcastDelivery ( tinyxml2::XMLElement *  usd, std::string  base, std::shared_ptr< ContentStream >  cs  )

private

_setupBy5GMagConfig()

void MBMS_RT::ServiceAnnouncement::_setupBy5GMagConfig ( tinyxml2::XMLElement *  app_service, const std::shared_ptr< MBMS_RT::Service > &  service, tinyxml2::XMLElement *  usd  )

private

Definition at line 299 of file ServiceAnnouncement.cpp.

                                                                                {
 
  std::vector<std::shared_ptr<ContentStream>> broadcastContentStreams;
  std::vector<std::shared_ptr<SeamlessContentStream>> unicastContentStreams;
// Create content stream objects for each broadcastAppService::basePattern element.
  for (auto *delivery_method = usd->FirstChildElement(ServiceAnnouncementXmlElements::DELIVERY_METHOD);
       delivery_method != nullptr;
       delivery_method = delivery_method->NextSiblingElement(ServiceAnnouncementXmlElements::DELIVERY_METHOD)) {
    auto sdp_uri = delivery_method->Attribute(ServiceAnnouncementXmlElements::SESSION_DESCRIPTION_URI);
    // We assume that the master manifest is signaled in the SA and that we can simply replace the .sdp ending with .m3u8 to find the element with the right Content-Location
    auto manifest_url = std::regex_replace(sdp_uri, std::regex(".sdp"), ".m3u8");
    auto broadcast_app_service = delivery_method->FirstChildElement(
        ServiceAnnouncementXmlElements::BROADCAST_APP_SERVICE);
 
    if (broadcast_app_service != nullptr) {
      for (auto *base_pattern = broadcast_app_service->FirstChildElement(ServiceAnnouncementXmlElements::BASE_PATTERN);
           base_pattern != nullptr;
           base_pattern = base_pattern->NextSiblingElement(ServiceAnnouncementXmlElements::BASE_PATTERN)) {
 
        std::string broadcast_url = base_pattern->GetText();
 
        // create a content stream
        std::shared_ptr<ContentStream> cs;
        if (_seamless) {
          cs = std::make_shared<SeamlessContentStream>(broadcast_url, _iface, _io_service, _cache,
                                                       service->delivery_protocol(), _cfg);
        } else {
          cs = std::make_shared<ContentStream>(broadcast_url, _iface, _io_service, _cache, service->delivery_protocol(),
                                               _cfg);
        }
 
        for (const auto &item: _items) {
          if (item.uri == manifest_url) {
            cs->read_master_manifest(item.content);
          }
          if (item.content_type == ContentTypeConstants::SDP &&
              item.uri == sdp_uri) {
            cs->configure_5gbc_delivery_from_sdp(item.content);
          }
        }
 
        broadcastContentStreams.push_back(cs);
      }
    }
 
    if (_seamless) {
      // Iterate through unicastAppService elements. If we find a match in identical content we add the CDN information to the existing broadcast content stream
      // If not we create a new content stream object pointing to the CDN url
      auto unicast_app_service = delivery_method->FirstChildElement(
          ServiceAnnouncementXmlElements::UNICAST_APP_SERVICE);
      if (unicast_app_service != nullptr) {
        for (auto *base_pattern = unicast_app_service->FirstChildElement(
            ServiceAnnouncementXmlElements::BASE_PATTERN);
             base_pattern != nullptr;
             base_pattern = base_pattern->NextSiblingElement(ServiceAnnouncementXmlElements::BASE_PATTERN)) {
          // For HLS streams base_pattern now holds the url to the media manifest
          std::string unicast_url = base_pattern->GetText();
          // Check for identical content entries that contain this base pattern.
          for (auto *identical_content = app_service->FirstChildElement(
              ServiceAnnouncementXmlElements::IDENTICAL_CONTENT);
               identical_content != nullptr;
               identical_content = identical_content->NextSiblingElement(
                   ServiceAnnouncementXmlElements::IDENTICAL_CONTENT)) {
            std::shared_ptr<SeamlessContentStream> broadcast_content_stream;
            bool found_identical_element = false;
            for (auto *base_pattern_ic = identical_content->FirstChildElement(
                ServiceAnnouncementXmlElements::BASE_PATTERN);
                 base_pattern_ic != nullptr;
                 base_pattern_ic = base_pattern_ic->NextSiblingElement(ServiceAnnouncementXmlElements::BASE_PATTERN)) {
              // For HLS streams base_pattern_ic now holds either an url that points to a BC media playlist or to a UC playlist
              std::string identical_content_url = base_pattern_ic->GetText();
              // Check if we have a match of our current unicast url with the url in the identical content element
              // Otherwise check if the current identical content url points to an existing BC element
              if (unicast_url == identical_content_url) {
                found_identical_element = true;
              } else {
                for (auto &element: broadcastContentStreams) {
                  if (element->base() == identical_content_url) {
                    broadcast_content_stream = std::dynamic_pointer_cast<SeamlessContentStream>(element);
                  }
                }
              }
            }
            // If we found a matching broadcast stream we add the CDN url to this one. Otherwise, we create a new SeamlessContentStream element
            if (broadcast_content_stream != nullptr && found_identical_element) {
              broadcast_content_stream->set_cdn_endpoint(unicast_url);
            } else {
              std::shared_ptr<SeamlessContentStream> cs = std::make_shared<SeamlessContentStream>(manifest_url, _iface,
                                                                                                  _io_service, _cache,
                                                                                                  service->delivery_protocol(),
                                                                                                  _cfg);
              cs->set_cdn_endpoint(unicast_url);
              unicastContentStreams.push_back(cs);
            }
          }
        }
      }
    }
 
    for (auto &element: unicastContentStreams) {
      service->add_and_start_content_stream(element);
    }
 
    for (auto &element: broadcastContentStreams) {
      service->add_and_start_content_stream(element);
    }
 
    spdlog::info("Finished SA setup with 5G-MAG Format");
  }
 
}

_setupBy5GMagLegacyFormat()

void MBMS_RT::ServiceAnnouncement::_setupBy5GMagLegacyFormat ( tinyxml2::XMLElement *  app_service, const std::shared_ptr< MBMS_RT::Service > &  service, tinyxml2::XMLElement *  usd  )

private

Setup according to the format that was used for the first 5G-MAG sample recordings.

Parameters

app_service
service
usd

Definition at line 419 of file ServiceAnnouncement.cpp.

                                                                                      {
 
  std::vector<std::shared_ptr<ContentStream>> broadcastContentStreams;
// Create content stream objects for each broadcastAppService::basePattern element.
  for (auto *delivery_method = usd->FirstChildElement(ServiceAnnouncementXmlElements::DELIVERY_METHOD);
       delivery_method != nullptr;
       delivery_method = delivery_method->NextSiblingElement(ServiceAnnouncementXmlElements::DELIVERY_METHOD)) {
    auto sdp_uri = delivery_method->Attribute(ServiceAnnouncementXmlElements::SESSION_DESCRIPTION_URI);
    // We assume that the master manifest is signaled in the SA and that we can simply replace the .sdp ending with .m3u8 or .mpd to find the element with the right Content-Location
    std::string manifest_type = service->delivery_protocol() == DeliveryProtocol::HLS ? ContentTypeConstants::HLS_MANIFEST : ContentTypeConstants::DASH_MANIFEST;
    auto manifest_url = std::regex_replace(sdp_uri, std::regex(".sdp"), "." + manifest_type);
    auto broadcast_app_service = delivery_method->FirstChildElement(
        ServiceAnnouncementXmlElements::BROADCAST_APP_SERVICE);
 
    if (broadcast_app_service != nullptr) {
      for (auto *base_pattern = broadcast_app_service->FirstChildElement(ServiceAnnouncementXmlElements::BASE_PATTERN);
           base_pattern != nullptr;
           base_pattern = base_pattern->NextSiblingElement(ServiceAnnouncementXmlElements::BASE_PATTERN)) {
 
        std::string broadcast_url = base_pattern->GetText();
 
        // create a content stream if this is not a base pattern that points to file://
        if (service->delivery_protocol() == DeliveryProtocol::DASH || (service->delivery_protocol() == DeliveryProtocol::HLS && broadcast_url.find("file://") == std::string::npos)) {
 
          std::shared_ptr<ContentStream> cs;
          cs = std::make_shared<ContentStream>(broadcast_url, _iface, _io_service, _cache, service->delivery_protocol(),
                                               _cfg);
 
          cs->set_base_path(_base_path);
          for (const auto &item: _items) {
            if (item.uri == manifest_url && service->delivery_protocol() == DeliveryProtocol::HLS) {
              cs->read_master_manifest(item.content);
            }
            if (item.content_type == ContentTypeConstants::SDP &&
                item.uri == sdp_uri) {
              cs->configure_5gbc_delivery_from_sdp(item.content);
            }
          }
 
          broadcastContentStreams.push_back(cs);
        }
      }
    }
 
    for (auto &element: broadcastContentStreams) {
      service->add_and_start_content_stream(element);
    }
 
    spdlog::info("Finished SA setup with 5G-MAG Legacy Format");
 
  }
}

_setupByAlternativeContentElement()

void MBMS_RT::ServiceAnnouncement::_setupByAlternativeContentElement ( tinyxml2::XMLElement *  app_service, const std::shared_ptr< MBMS_RT::Service > &  service, tinyxml2::XMLElement *  usd  )

private

Setup according to original SA format with an alternativeContentElement required to indicate that the stream is available via BC and UC.

Parameters

app_service
service
usd

Definition at line 481 of file ServiceAnnouncement.cpp.

                                                                                              {
  auto alternative_content = app_service->FirstChildElement(ServiceAnnouncementXmlElements::ALTERNATIVE_CONTENT);
  if (alternative_content != nullptr) {
    for (auto *base_pattern = alternative_content->FirstChildElement(ServiceAnnouncementXmlElements::BASE_PATTERN);
         base_pattern != nullptr;
         base_pattern = base_pattern->NextSiblingElement(ServiceAnnouncementXmlElements::BASE_PATTERN)) {
      std::string base = base_pattern->GetText();
 
      // create a content stream
      std::shared_ptr<ContentStream> cs;
      if (_seamless) {
        cs = std::make_shared<SeamlessContentStream>(base, _iface, _io_service, _cache,
                                                     service->delivery_protocol(), _cfg);
      } else {
        cs = std::make_shared<ContentStream>(base, _iface, _io_service, _cache, service->delivery_protocol(),
                                             _cfg);
      }
 
 
      // Check for 5GBC delivery method elements
      bool broadcast_delivery_available = false;
      for (auto *delivery_method = usd->FirstChildElement(ServiceAnnouncementXmlElements::DELIVERY_METHOD);
           delivery_method != nullptr;
           delivery_method = delivery_method->NextSiblingElement(ServiceAnnouncementXmlElements::DELIVERY_METHOD)) {
        auto sdp_uri = delivery_method->Attribute(ServiceAnnouncementXmlElements::SESSION_DESCRIPTION_URI);
        auto broadcast_app_service = delivery_method->FirstChildElement(
            ServiceAnnouncementXmlElements::BROADCAST_APP_SERVICE);
        std::string broadcast_base_pattern = broadcast_app_service->FirstChildElement(
            ServiceAnnouncementXmlElements::BASE_PATTERN)->GetText();
 
        if (broadcast_base_pattern == base) {
          for (const auto &item: _items) {
            if (item.uri == broadcast_base_pattern) {
              cs->read_master_manifest(item.content);
            }
            if (item.content_type == ContentTypeConstants::SDP &&
                item.uri == sdp_uri) {
              broadcast_delivery_available = cs->configure_5gbc_delivery_from_sdp(item.content);
            }
          }
        }
      }
      bool unicast_delivery_available = false;
 
      // When seamless switching is enabled we check for unicast endpoints as well
      if (_seamless) {
        if (!broadcast_delivery_available) {
          // No 5G broadcast available. Assume the base pattern is a CDN endpoint.
          std::dynamic_pointer_cast<SeamlessContentStream>(cs)->set_cdn_endpoint(base);
          unicast_delivery_available = true;
        } else {
          // Check for identical content entries to find a CDN base pattern
          for (auto *identical_content = app_service->FirstChildElement(
              ServiceAnnouncementXmlElements::IDENTICAL_CONTENT);
               identical_content != nullptr;
               identical_content = identical_content->NextSiblingElement(
                   ServiceAnnouncementXmlElements::IDENTICAL_CONTENT)) {
 
            bool base_matched = false;
            std::string found_identical_base;
            for (auto *base_pattern = identical_content->FirstChildElement(
                ServiceAnnouncementXmlElements::BASE_PATTERN);
                 base_pattern != nullptr;
                 base_pattern = base_pattern->NextSiblingElement(ServiceAnnouncementXmlElements::BASE_PATTERN)) {
              std::string identical_base = base_pattern->GetText();
              if (base == identical_base) {
                base_matched = true;
              } else {
                found_identical_base = identical_base;
              }
            }
 
            if (base_matched && found_identical_base.length()) {
              std::dynamic_pointer_cast<SeamlessContentStream>(cs)->set_cdn_endpoint(found_identical_base);
            }
          }
        }
      }
 
      if (unicast_delivery_available || broadcast_delivery_available) {
        service->add_and_start_content_stream(cs);
      }
    }
  }
}

content()

const std::string& MBMS_RT::ServiceAnnouncement::content ( ) const

inline

Definition at line 56 of file ServiceAnnouncement.h.

{ return _raw_content; };

items()

const std::vector<Item>& MBMS_RT::ServiceAnnouncement::items ( ) const

inline

Definition at line 54 of file ServiceAnnouncement.h.

{ return _items; };

parse_bootstrap()

auto MBMS_RT::ServiceAnnouncement::parse_bootstrap

(

const std::string &

str

)

Parse the service announcement/bootstrap file.

Parameters

str

Definition at line 95 of file ServiceAnnouncement.cpp.

                                                                        {
  std::string bootstrap_format = ServiceAnnouncementFormatConstants::DEFAULT;
  _cfg.lookupValue("mw.bootstrap_format", bootstrap_format);
 
  // Add all the SA items including their content to _items
  _addServiceAnnouncementItems(str);
 
  // Parse MBMS envelope: <metadataEnvelope>
  for (const auto &item: _items) {
    if (item.content_type == ContentTypeConstants::MBMS_ENVELOPE) {
      _handleMbmsEnvelope(item);
    }
  }
 
  // Parse MBMS user service description bundle
  for (const auto &item: _items) {
    if (item.content_type == ContentTypeConstants::MBMS_USER_SERVICE_DESCRIPTION) {
      _handleMbmbsUserServiceDescriptionBundle(item, bootstrap_format);
    }
  }
}

start_flute_receiver()

auto MBMS_RT::ServiceAnnouncement::start_flute_receiver

(

const std::string &

mcast_address

)

Starts the FLUTE receiver at the specified multicast address.

Includes a callback function that is called once a file has been received via multicast Used for receiving a service announcement file via multicast

Parameters

mcast_address

Definition at line 61 of file ServiceAnnouncement.cpp.

                                                                                            {
  size_t delim = mcast_address.find(':');
  if (delim == std::string::npos) {
    spdlog::error("Invalid multicast address {}", mcast_address);
    return;
  }
  _mcast_addr = mcast_address.substr(0, delim);
  _mcast_port = mcast_address.substr(delim + 1);
  spdlog::info("Starting FLUTE receiver on {}:{} for TSI {}", _mcast_addr, _mcast_port, _tsi);
  _flute_thread = std::thread{[&]() {
    _flute_receiver = std::make_unique<LibFlute::Receiver>(_iface, _mcast_addr, atoi(_mcast_port.c_str()), _tsi,
                                                           _io_service);
    _flute_receiver->register_completion_callback(
        [&](std::shared_ptr<LibFlute::File> file) { //NOLINT
          spdlog::info("{} (TOI {}) has been received",
                       file->meta().content_location, file->meta().toi);
          if (!_bootstrapped || _toi != file->meta().toi) {
            _toi = file->meta().toi;
            if (file->meta().content_type == "application/x-gzip") {
              _raw_content = gzip::decompress(file->buffer(), file->length());
            } else {
              _raw_content = std::string(file->buffer());
            }
            parse_bootstrap(file->buffer());
          }
        });
  }};
}

toi()

uint32_t MBMS_RT::ServiceAnnouncement::toi ( ) const

inline

Definition at line 58 of file ServiceAnnouncement.h.

{ return _toi; };

Member Data Documentation

_base_path

std::string MBMS_RT::ServiceAnnouncement::_base_path

private

Definition at line 83 of file ServiceAnnouncement.h.

_bootstrapped

bool MBMS_RT::ServiceAnnouncement::_bootstrapped = false

private

Definition at line 75 of file ServiceAnnouncement.h.

_cache

CacheManagement& MBMS_RT::ServiceAnnouncement::_cache

private

Definition at line 89 of file ServiceAnnouncement.h.

_cfg

const libconfig::Config& MBMS_RT::ServiceAnnouncement::_cfg

private

Definition at line 73 of file ServiceAnnouncement.h.

_flute_receiver

std::unique_ptr<LibFlute::Receiver> MBMS_RT::ServiceAnnouncement::_flute_receiver

private

Definition at line 86 of file ServiceAnnouncement.h.

_flute_thread

std::thread MBMS_RT::ServiceAnnouncement::_flute_thread

private

Definition at line 85 of file ServiceAnnouncement.h.

_get_service

get_service_callback_t MBMS_RT::ServiceAnnouncement::_get_service

private

Definition at line 66 of file ServiceAnnouncement.h.

_iface

std::string MBMS_RT::ServiceAnnouncement::_iface

private

Definition at line 79 of file ServiceAnnouncement.h.

_io_service

boost::asio::io_service& MBMS_RT::ServiceAnnouncement::_io_service

private

Definition at line 88 of file ServiceAnnouncement.h.

_items

std::vector<Item> MBMS_RT::ServiceAnnouncement::_items

private

Definition at line 71 of file ServiceAnnouncement.h.

_mcast_addr

std::string MBMS_RT::ServiceAnnouncement::_mcast_addr

private

Definition at line 81 of file ServiceAnnouncement.h.

_mcast_port

std::string MBMS_RT::ServiceAnnouncement::_mcast_port

private

Definition at line 82 of file ServiceAnnouncement.h.

_raw_content

std::string MBMS_RT::ServiceAnnouncement::_raw_content

private

Definition at line 78 of file ServiceAnnouncement.h.

_seamless

bool MBMS_RT::ServiceAnnouncement::_seamless = false

private

Definition at line 69 of file ServiceAnnouncement.h.

_set_service

set_service_callback_t MBMS_RT::ServiceAnnouncement::_set_service

private

Definition at line 67 of file ServiceAnnouncement.h.

_tmgi

std::string MBMS_RT::ServiceAnnouncement::_tmgi

private

Definition at line 80 of file ServiceAnnouncement.h.

_toi

uint32_t MBMS_RT::ServiceAnnouncement::_toi = {}

private

Definition at line 77 of file ServiceAnnouncement.h.

_tsi

unsigned long long MBMS_RT::ServiceAnnouncement::_tsi = 0

private

Definition at line 84 of file ServiceAnnouncement.h.

---

The documentation for this class was generated from the following files:

• src/ServiceAnnouncement.h
• src/ServiceAnnouncement.cpp