xml_node.h

// Copyright 2014 Google Inc. 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 <libxml/tree.h>
#include <stdint.h>

#include <list>

#include "packager/base/macros.h"
#include "packager/mpd/base/content_protection_element.h"
#include "packager/mpd/base/media_info.pb.h"
#include "packager/mpd/base/xml/scoped_xml_ptr.h"

namespace shaka {

struct SegmentInfo;

namespace xml {

class XmlNode {
 public:
  explicit XmlNode(const char* name);
  virtual ~XmlNode();

  bool AddChild(scoped_xml_ptr<xmlNode> child);

  bool AddElements(const std::vector<Element>& elements);

  void SetStringAttribute(const char* attribute_name,
                          const std::string& attribute);

  void SetIntegerAttribute(const char* attribute_name, uint64_t number);

  void SetFloatingPointAttribute(const char* attribute_name, double number);

  void SetId(uint32_t id);

  void SetContent(const std::string& content);

  scoped_xml_ptr<xmlNode> PassScopedPtr();

  xmlNodePtr Release();

  xmlNodePtr GetRawPtr();

 private:
  scoped_xml_ptr<xmlNode> node_;

  DISALLOW_COPY_AND_ASSIGN(XmlNode);
};

class RepresentationBaseXmlNode : public XmlNode {
 public:
  ~RepresentationBaseXmlNode() override;
  bool AddContentProtectionElements(
      const std::list<ContentProtectionElement>& content_protection_elements);

  void AddSupplementalProperty(const std::string& scheme_id_uri,
                               const std::string& value);

 protected:
  explicit RepresentationBaseXmlNode(const char* name);

 private:
  bool AddContentProtectionElement(
      const ContentProtectionElement& content_protection_element);

  DISALLOW_COPY_AND_ASSIGN(RepresentationBaseXmlNode);
};

class AdaptationSetXmlNode : public RepresentationBaseXmlNode {
 public:
  AdaptationSetXmlNode();
  ~AdaptationSetXmlNode() override;

  void AddRoleElement(const std::string& scheme_id_uri,
                      const std::string& value);

 private:
  DISALLOW_COPY_AND_ASSIGN(AdaptationSetXmlNode);
};

class RepresentationXmlNode : public RepresentationBaseXmlNode {
 public:
  RepresentationXmlNode();
  ~RepresentationXmlNode() override;

  bool AddVideoInfo(const MediaInfo::VideoInfo& video_info,
                    bool set_width,
                    bool set_height,
                    bool set_frame_rate);

  bool AddAudioInfo(const MediaInfo::AudioInfo& audio_info);

  bool AddVODOnlyInfo(const MediaInfo& media_info);

  bool AddLiveOnlyInfo(const MediaInfo& media_info,
                       const std::list<SegmentInfo>& segment_infos,
                       uint32_t start_number);

 private:
  // Add AudioChannelConfiguration element. Note that it is a required element
  // for audio Representations.
  bool AddAudioChannelInfo(const MediaInfo::AudioInfo& audio_info);

  // Add audioSamplingRate attribute to this element, if present.
  void AddAudioSamplingRateInfo(const MediaInfo::AudioInfo& audio_info);

  DISALLOW_COPY_AND_ASSIGN(RepresentationXmlNode);
};

}  // namespace xml
}  // namespace shaka
#endif  // MPD_BASE_XML_XML_NODE_H_