xml_node.h

// Copyright 2014 Google LLC. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
//
// Classes to wrap XML operations. XmlNode is a generic wrapper class for
// XmlNode in libxml2. There are also MPD XML specific classes as well.
 
#ifndef MPD_BASE_XML_XML_NODE_H_
#define MPD_BASE_XML_XML_NODE_H_
 
#include <cstdint>
#include <list>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
#include <packager/macros/classes.h>
#include <packager/mpd/base/content_protection_element.h>
#include <packager/mpd/base/media_info.pb.h>
 
typedef struct _xmlNode xmlNode;
 
namespace shaka {
 
class MpdBuilder;
struct SegmentInfo;
 
namespace xml {
class XmlNode;
}  // namespace xml
 
// Defined in tests under mpd/test/xml_compare.h
bool XmlEqual(const std::string& xml1, const xml::XmlNode& xml2);
 
namespace xml {
 
class XmlNode {
 public:
  explicit XmlNode(const std::string& name);
  XmlNode(XmlNode&&);
  virtual ~XmlNode();
 
  XmlNode& operator=(XmlNode&&);
 
  [[nodiscard]] bool AddChild(XmlNode child);
 
  [[nodiscard]] bool AddElements(const std::vector<Element>& elements);
 
  [[nodiscard]] bool SetStringAttribute(const std::string& attribute_name,
                                        const std::string& attribute);
 
  [[nodiscard]] bool SetIntegerAttribute(const std::string& attribute_name,
                                         uint64_t number);
 
  [[nodiscard]] bool SetFloatingPointAttribute(
      const std::string& attribute_name,
      double number);
 
  [[nodiscard]] bool SetId(uint32_t id);
 
  void AddContent(const std::string& content);
 
  void AddUrlEncodedContent(const std::string& content);
 
  void SetContent(const std::string& content);
 
  void SetUrlEncodedContent(const std::string& content);
 
  std::set<std::string> ExtractReferencedNamespaces() const;
 
  std::string ToString(const std::string& comment) const;
 
  bool GetAttribute(const std::string& name, std::string* value) const;
 
 private:
  friend bool shaka::XmlEqual(const std::string& xml1,
                              const xml::XmlNode& xml2);
  xmlNode* GetRawPtr() const;
 
  // Don't use xmlNode directly so we don't have to forward-declare a bunch of
  // libxml types to define the scoped_xml_ptr type.  This allows us to only
  // include libxml headers in a few source files.
  class Impl;
  std::unique_ptr<Impl> impl_;
 
  DISALLOW_COPY_AND_ASSIGN(XmlNode);
};
 
class RepresentationBaseXmlNode : public XmlNode {
 public:
  ~RepresentationBaseXmlNode() override;
  [[nodiscard]] bool AddContentProtectionElements(
      const std::list<ContentProtectionElement>& content_protection_elements);
 
  [[nodiscard]] bool AddSupplementalProperty(const std::string& scheme_id_uri,
                                             const std::string& value);
 
  [[nodiscard]] bool AddEssentialProperty(const std::string& scheme_id_uri,
                                          const std::string& value);
 
 protected:
  explicit RepresentationBaseXmlNode(const std::string& name);
 
  [[nodiscard]] bool AddDescriptor(const std::string& descriptor_name,
                                   const std::string& scheme_id_uri,
                                   const std::string& value);
 
 private:
  [[nodiscard]] bool AddContentProtectionElement(
      const ContentProtectionElement& content_protection_element);
 
  DISALLOW_COPY_AND_ASSIGN(RepresentationBaseXmlNode);
};
 
class AdaptationSetXmlNode : public RepresentationBaseXmlNode {
 public:
  AdaptationSetXmlNode();
  ~AdaptationSetXmlNode() override;
 
  [[nodiscard]] bool AddAccessibilityElement(const std::string& scheme_id_uri,
                                             const std::string& value);
 
  [[nodiscard]] bool AddRoleElement(const std::string& scheme_id_uri,
                                    const std::string& value);
 
  [[nodiscard]] bool AddLabelElement(const std::string& value);
 
 private:
  DISALLOW_COPY_AND_ASSIGN(AdaptationSetXmlNode);
};
 
class RepresentationXmlNode : public RepresentationBaseXmlNode {
 public:
  RepresentationXmlNode();
  ~RepresentationXmlNode() override;
 
  [[nodiscard]] bool AddVideoInfo(const MediaInfo::VideoInfo& video_info,
                                  bool set_width,
                                  bool set_height,
                                  bool set_frame_rate);
 
  [[nodiscard]] bool AddAudioInfo(const MediaInfo::AudioInfo& audio_info);
 
  //         duration of media segments. This is only used when use_segment_list
  //         is true.
  [[nodiscard]] bool AddVODOnlyInfo(const MediaInfo& media_info,
                                    bool use_segment_list,
                                    double target_segment_duration);
 
  [[nodiscard]] bool AddLiveOnlyInfo(
      const MediaInfo& media_info,
      const std::list<SegmentInfo>& segment_infos,
      bool low_latency_dash_mode);
 
 private:
  // Add AudioChannelConfiguration element. Note that it is a required element
  // for audio Representations.
  [[nodiscard]] bool AddAudioChannelInfo(
      const MediaInfo::AudioInfo& audio_info);
 
  // Add audioSamplingRate attribute to this element, if present.
  [[nodiscard]] bool AddAudioSamplingRateInfo(
      const MediaInfo::AudioInfo& audio_info);
 
  DISALLOW_COPY_AND_ASSIGN(RepresentationXmlNode);
};
 
}  // namespace xml
}  // namespace shaka
#endif  // MPD_BASE_XML_XML_NODE_H_