MPD generation classes

- MpdBuilder, AdapatationSet, and Representation class.

Change-Id: I0dbaa5e17b7d44fec6d47f1643f15083a2c96757

mpd/base/mpd_builder.cc

@@ -0,0 +1,313 @@
+#include "mpd/base/mpd_builder.h"
+
+#include <string>
+
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/string_number_conversions.h"
+#include "mpd/base/content_protection_element.h"
+#include "mpd/base/mpd_utils.h"
+#include "mpd/base/xml/xml_node.h"
+#include "third_party/libxml/src/include/libxml/tree.h"
+
+// TODO(rkuroiwa): If performance is a problem work on fine grained locking.
+namespace dash_packager {
+
+using xml::XmlNode;
+using xml::RepresentationXmlNode;
+using xml::AdaptationSetXmlNode;
+
+MpdBuilder::MpdBuilder(MpdType type)
+    : type_(type),
+      adaptation_sets_deleter_(&adaptation_sets_) {}
+
+MpdBuilder::~MpdBuilder() {}
+
+void MpdBuilder::AddBaseUrl(const std::string& base_url) {
+  base::AutoLock scoped_lock(lock_);
+  base_urls_.push_back(base_url);
+}
+
+AdaptationSet* MpdBuilder::AddAdaptationSet() {
+  base::AutoLock scoped_lock(lock_);
+  scoped_ptr<AdaptationSet> adaptation_set(new AdaptationSet(
+      adaptation_set_counter_.GetNext(), &representation_counter_));
+
+  DCHECK(adaptation_set);
+  adaptation_sets_.push_back(adaptation_set.get());
+  return adaptation_set.release();
+}
+
+bool MpdBuilder::WriteMpd() {
+  base::AutoLock scoped_lock(lock_);
+  std::string mpd;
+  bool result = ToStringImpl(&mpd);
+
+  // TODO(rkuroiwa): Write to file, after interface change.
+  return result;
+}
+
+bool MpdBuilder::ToString(std::string* output) {
+  base::AutoLock scoped_lock(lock_);
+  return ToStringImpl(output);
+}
+
+bool MpdBuilder::ToStringImpl(std::string* output) {
+  xmlInitParser();
+  xml::ScopedXmlPtr<xmlDoc>::type doc(GenerateMpd());
+  if (!doc.get())
+    return false;
+
+  static const int kNiceFormat = 1;
+  int doc_str_size = 0;
+  xmlChar* doc_str = NULL;
+  xmlDocDumpFormatMemoryEnc(
+      doc.get(), &doc_str, &doc_str_size, "UTF-8", kNiceFormat);
+
+  output->assign(doc_str, doc_str + doc_str_size);
+  xmlFree(doc_str);
+
+  DLOG(INFO) << *output;
+
+  // Cleanup, free the doc then cleanup parser.
+  doc.reset();
+  xmlCleanupParser();
+  return true;
+}
+
+// TODO(rkuroiwa): This function is too big.
+xmlDocPtr MpdBuilder::GenerateMpd() {
+  // Setup nodes.
+  static const char kXmlVersion[] = "1.0";
+  xml::ScopedXmlPtr<xmlDoc>::type doc(xmlNewDoc(BAD_CAST kXmlVersion));
+  XmlNode mpd("MPD");
+
+  static const char kXmlSchema[] = "http://www.w3.org/2001/XMLSchema-instance";
+  mpd.SetStringAttribute("xmlns:xsi", kXmlSchema);
+
+  static const char kDashSchemaMpd2011[] =
+      "urn:mpeg:DASH:schema:MPD:2011 DASH-MPD.xsd";
+  mpd.SetStringAttribute("xsi:schemaLocation", kDashSchemaMpd2011);
+
+  static const char kMinBufferTimeTwoSeconds[] = "PT2S";
+  mpd.SetStringAttribute("minBufferTime", kMinBufferTimeTwoSeconds);
+
+  // Iterate thru AdaptationSets and add them to one big Period element.
+  XmlNode period("Period");
+  std::list<AdaptationSet*>::iterator adaptation_sets_it =
+      adaptation_sets_.begin();
+  for (; adaptation_sets_it != adaptation_sets_.end(); ++adaptation_sets_it) {
+    xml::ScopedXmlPtr<xmlNode>::type child((*adaptation_sets_it)->GetXml());
+    if (!child.get() || !period.AddChild(child.Pass()))
+      return NULL;
+  }
+
+  // Add baseurls to MPD.
+  std::list<std::string>::const_iterator base_urls_it = base_urls_.begin();
+  for (; base_urls_it != base_urls_.end(); ++base_urls_it) {
+    XmlNode base_url("BaseURL");
+    base_url.SetContent(*base_urls_it);
+
+    if (!mpd.AddChild(base_url.PassScopedPtr()))
+      return NULL;
+  }
+
+  if (!mpd.AddChild(period.PassScopedPtr()))
+    return NULL;
+
+  switch (type_) {
+    case kStatic:
+      AddStaticMpdInfo(&mpd);
+      break;
+    case kDynamic:
+      NOTIMPLEMENTED() << "MPD for live is not implemented.";
+      break;
+    default:
+      NOTREACHED() << "Unknown MPD type: " << type_;
+      break;
+  }
+
+  DCHECK(doc);
+  xmlDocSetRootElement(doc.get(), mpd.Release());
+  return doc.release();
+}
+
+void MpdBuilder::AddStaticMpdInfo(XmlNode* mpd_node) {
+  DCHECK(mpd_node);
+  DCHECK_EQ(MpdBuilder::kStatic, type_);
+
+  static const char kStaticMpdType[] = "static";
+  static const char kStaticMpdProfile[] =
+      "urn:mpeg:dash:profile:isoff-on-demand:2011";
+  mpd_node->SetStringAttribute("type", kStaticMpdType);
+  mpd_node->SetStringAttribute("profiles", kStaticMpdProfile);
+  mpd_node->SetStringAttribute(
+      "mediaPresentationDuration",
+      SecondsToXmlDuration(GetStaticMpdDuration(mpd_node)));
+}
+
+uint32 MpdBuilder::GetStaticMpdDuration(XmlNode* mpd_node) {
+  DCHECK(mpd_node);
+  DCHECK_EQ(MpdBuilder::kStatic, type_);
+
+  xmlNodePtr period_node = xmlFirstElementChild(mpd_node->GetRawPtr());
+  DCHECK(period_node);
+  DCHECK_NE(strcmp(reinterpret_cast<const char*>(period_node->name), "Period"),
+            0);
+
+  // TODO(rkuroiwa): Update this so that the duration for each Representation is
+  // (duration / timescale).
+  // Attribute mediaPresentationDuration must be present for 'static' MPD. So
+  // setting "P0S" is still required if none of the representaions had a
+  // duration attribute.
+  uint32 max_duration = 0;
+  for (xmlNodePtr adaptation_set = xmlFirstElementChild(period_node);
+       adaptation_set;
+       adaptation_set = xmlNextElementSibling(adaptation_set)) {
+    for (xmlNodePtr representation = xmlFirstElementChild(adaptation_set);
+         representation;
+         representation = xmlNextElementSibling(representation)) {
+      uint32 duration = 0;
+      if (GetDurationAttribute(representation, &duration)) {
+        max_duration = max_duration > duration ? max_duration : duration;
+
+        // 'duration' attribute is there only to help generate MPD, not
+        // necessary for MPD, remove the attribute.
+        xmlUnsetProp(representation, BAD_CAST "duration");
+      }
+    }
+  }
+
+  return max_duration;
+}
+
+AdaptationSet::AdaptationSet(uint32 adaptation_set_id,
+                             base::AtomicSequenceNumber* counter)
+    : representations_deleter_(&representations_),
+      representation_counter_(counter),
+      id_(adaptation_set_id) {
+  DCHECK(counter);
+}
+
+AdaptationSet::~AdaptationSet() {}
+
+Representation* AdaptationSet::AddRepresentation(const MediaInfo& media_info) {
+  base::AutoLock scoped_lock(lock_);
+  if (HasVODOnlyFields(media_info) && HasLiveOnlyFields(media_info)) {
+    LOG(ERROR) << "MediaInfo cannot have both VOD and Live fields.";
+    return NULL;
+  }
+
+  if (!media_info.has_bandwidth()) {
+    LOG(ERROR) << "MediaInfo missing required bandwidth field.";
+    return NULL;
+  }
+
+  scoped_ptr<Representation> representation(
+      new Representation(media_info, representation_counter_->GetNext()));
+
+  DCHECK(representation);
+  representations_.push_back(representation.get());
+  return representation.release();
+}
+
+void AdaptationSet::AddContentProtectionElement(
+    const ContentProtectionElement& content_protection_element) {
+  base::AutoLock scoped_lock(lock_);
+  content_protection_elements_.push_back(content_protection_element);
+  RemoveDuplicateAttributes(&content_protection_elements_.back());
+}
+
+// Creates a copy of <AdaptationSet> xml element, iterate thru all the
+// <Representation> (child) elements and add them to the copy.
+xml::ScopedXmlPtr<xmlNode>::type AdaptationSet::GetXml() {
+  base::AutoLock scoped_lock(lock_);
+  AdaptationSetXmlNode adaptation_set;
+
+  if (!adaptation_set.AddContentProtectionElements(
+           content_protection_elements_)) {
+    return xml::ScopedXmlPtr<xmlNode>::type();
+  }
+
+  std::list<Representation*>::iterator representation_it =
+      representations_.begin();
+
+  for (; representation_it != representations_.end(); ++representation_it) {
+    xml::ScopedXmlPtr<xmlNode>::type child((*representation_it)->GetXml());
+    if (!child.get() || !adaptation_set.AddChild(child.Pass()))
+      return xml::ScopedXmlPtr<xmlNode>::type();
+  }
+
+  adaptation_set.SetId(id_);
+  return adaptation_set.PassScopedPtr();
+}
+
+Representation::Representation(const MediaInfo& media_info, uint32 id)
+    : media_info_(media_info), id_(id) {}
+
+Representation::~Representation() {}
+
+void Representation::AddContentProtectionElement(
+    const ContentProtectionElement& content_protection_element) {
+  base::AutoLock scoped_lock(lock_);
+  content_protection_elements_.push_back(content_protection_element);
+  RemoveDuplicateAttributes(&content_protection_elements_.back());
+}
+
+bool Representation::AddNewSegment(uint64 start_time, uint64 duration) {
+  base::AutoLock scoped_lock(lock_);
+  segment_starttime_duration_pairs_.push_back(
+      std::pair<uint64, uint64>(start_time, duration));
+  return true;
+}
+
+// TODO(rkuroiwa): We don't need to create a node every single time. Make an
+// internal copy of this element.
+// Uses info in |media_info_| and |content_protection_elements_| to create a
+// "Representation" node.
+xml::ScopedXmlPtr<xmlNode>::type Representation::GetXml() {
+  base::AutoLock scoped_lock(lock_);
+  DCHECK(!(HasVODOnlyFields(media_info_) && HasLiveOnlyFields(media_info_)));
+  DCHECK(media_info_.has_bandwidth());
+
+  RepresentationXmlNode representation;
+  if (!representation.AddContentProtectionElements(
+           content_protection_elements_)) {
+    return xml::ScopedXmlPtr<xmlNode>::type();
+  }
+
+  // Two 'Mandatory' fields for Representation.
+  representation.SetId(id_);
+  representation.SetNumberAttribute("bandwidth", media_info_.bandwidth());
+
+  const bool has_video_info = media_info_.video_info_size() > 0;
+  const bool has_audio_info = media_info_.audio_info_size() > 0;
+  if (has_video_info || has_audio_info) {
+    const std::string codecs = GetCodecs(media_info_);
+    if (!codecs.empty())
+      representation.SetStringAttribute("codecs", codecs);
+
+    if (has_video_info) {
+      if (!representation.AddVideoInfo(media_info_.video_info()))
+        return xml::ScopedXmlPtr<xmlNode>::type();
+    }
+
+    if (has_audio_info) {
+      if (!representation.AddAudioInfo(media_info_.audio_info()))
+        return xml::ScopedXmlPtr<xmlNode>::type();
+    }
+  }
+
+  // TODO(rkuroiwa): Add TextInfo.
+  // TODO(rkuroiwa): Add ContentProtection info.
+  if (HasVODOnlyFields(media_info_)) {
+    if (!representation.AddVODOnlyInfo(media_info_))
+      return xml::ScopedXmlPtr<xmlNode>::type();
+  }
+
+  // TODO(rkuroiwa): Handle Live case. Handle data in
+  // segment_starttime_duration_pairs_.
+  return representation.PassScopedPtr();
+}
+
+}  // namespace dash_packager

mpd/base/mpd_builder.h

@@ -0,0 +1,156 @@
+// This file contains the MpdBuilder, AdaptationSet, and Representation class
+// declarations.
+// http://goo.gl/UrsSlF
+
+#ifndef MPD_BASE_MPD_BUILDER_H_
+#define MPD_BASE_MPD_BUILDER_H_
+
+#include <list>
+#include <string>
+
+#include "base/atomic_sequence_num.h"
+#include "base/basictypes.h"
+#include "base/stl_util.h"
+#include "base/synchronization/lock.h"
+#include "mpd/base/content_protection_element.h"
+#include "mpd/base/media_info.pb.h"
+#include "mpd/base/mpd_utils.h"
+#include "mpd/base/xml/scoped_xml_ptr.h"
+
+// TODO(rkuroiwa): For classes with |id_|, consider removing the field and let
+// the MPD (XML) generation functions take care of assigning an ID to each
+// element.
+namespace dash_packager {
+
+class AdaptationSet;
+class Representation;
+
+namespace xml {
+
+class XmlNode;
+
+}  // namespace xml
+
+class MpdBuilder {
+ public:
+  enum MpdType {
+    kStatic = 0,
+    kDynamic
+  };
+
+  explicit MpdBuilder(MpdType type);
+  ~MpdBuilder();
+
+  void AddBaseUrl(const std::string& base_url);
+
+  // The returned pointer is owned by this object.
+  AdaptationSet* AddAdaptationSet();
+
+  // TODO(rkuroiwa): Once File interface is defined, make this method take a
+  // pointer to a File.
+  // This will write to stdout until File interface is defined.
+  bool WriteMpd();
+  bool ToString(std::string* output);
+
+ private:
+  bool ToStringImpl(std::string* output);
+
+  // Returns the document pointer to the MPD. This must be freed by the caller
+  // using appropriate xmlDocPtr freeing function.
+  // On failure, this returns NULL.
+  xmlDocPtr GenerateMpd();
+
+  // Adds 'static' MPD attributes and elements to |mpd_node|. This assumes that
+  // the first child element is a Period element.
+  void AddStaticMpdInfo(xml::XmlNode* mpd_node);
+  uint32 GetStaticMpdDuration(xml::XmlNode* mpd_node);
+
+  MpdType type_;
+  std::list<AdaptationSet*> adaptation_sets_;
+  ::STLElementDeleter<std::list<AdaptationSet*> > adaptation_sets_deleter_;
+
+  std::list<std::string> base_urls_;
+
+  // TODO(rkuroiwa): I don't like locks.
+  base::Lock lock_;
+  base::AtomicSequenceNumber adaptation_set_counter_;
+  base::AtomicSequenceNumber representation_counter_;
+
+  DISALLOW_COPY_AND_ASSIGN(MpdBuilder);
+};
+
+class AdaptationSet {
+ public:
+  AdaptationSet(uint32 adaptation_set_id,
+                base::AtomicSequenceNumber* representation_counter);
+  ~AdaptationSet();
+
+  // The returned pointer is owned by this object.
+  Representation* AddRepresentation(const MediaInfo& media_info);
+
+  // If |element| has {value, schemeIdUri} set and has
+  // {“value”, “schemeIdUri”} as key for additional_attributes,
+  // then the former is used.
+  void AddContentProtectionElement(const ContentProtectionElement& element);
+
+  // Makes a copy of AdaptationSet xml element with its child elements, which
+  // are Representation elements. On success this returns non-NULL ScopedXmlPtr,
+  // otherwise returns NULL ScopedXmlPtr.
+  xml::ScopedXmlPtr<xmlNode>::type GetXml();
+
+  // Must be unique in the Period.
+  uint32 id() const {
+    return id_;
+  }
+
+ private:
+  std::list<ContentProtectionElement> content_protection_elements_;
+  std::list<Representation*> representations_;
+  ::STLElementDeleter<std::list<Representation*> > representations_deleter_;
+
+  base::Lock lock_;
+
+  base::AtomicSequenceNumber* const representation_counter_;
+
+  const uint32 id_;
+
+  DISALLOW_COPY_AND_ASSIGN(AdaptationSet);
+};
+
+class Representation {
+ public:
+  Representation(const MediaInfo& media_info, uint32 representation_id);
+  ~Representation();
+
+  // If |element| has {value, schemeIdUri} set and has
+  // {“value”, “schemeIdUri”} as key for additional_attributes,
+  // then the former is used.
+  void AddContentProtectionElement(const ContentProtectionElement& element);
+
+  bool AddNewSegment(uint64 start_time, uint64 duration);
+
+  // Makes a copy of the current XML. Note that this is a copy. The caller is
+  // responsible for cleaning up the allocated resource.
+  xml::ScopedXmlPtr<xmlNode>::type GetXml();
+
+  // Must be unique amongst other Representations in the MPD file.
+  // As the MPD spec says.
+  uint32 id() const {
+    return id_;
+  }
+
+ private:
+  MediaInfo media_info_;
+  std::list<ContentProtectionElement> content_protection_elements_;
+  std::list<std::pair<uint64, uint64> > segment_starttime_duration_pairs_;
+
+  base::Lock lock_;
+
+  const uint32 id_;
+
+  DISALLOW_COPY_AND_ASSIGN(Representation);
+};
+
+}  // namespace dash_packager
+
+#endif  // MPD_BASE_MPD_BUILDER_H_

mpd/mpd.gyp

@@ -15,5 +15,27 @@
       },
       'includes': ['../build/protoc.gypi'],
     },
+    {
+      'target_name': 'mpd_builder',
+      'type': 'static_library',
+      'sources': [
+        'base/content_protection_element.h',
+        'base/mpd_builder.cc',
+        'base/mpd_builder.h',
+        'base/mpd_utils.cc',
+        'base/mpd_utils.h',
+        'base/xml/scoped_xml_ptr.h',
+        'base/xml/xml_node.cc',
+        'base/xml/xml_node.h',
+      ],
+      'include_dirs': [
+        '..',
+      ],
+      'dependencies': [
+        '../base/base.gyp:base',
+        '../third_party/libxml/libxml.gyp:libxml',
+        'media_info_proto',
+      ],
+    },
   ],
 }