mpd_builder.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
//
// 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 <stdint.h>

#include <list>
#include <map>
#include <set>
#include <string>

#include "packager/base/atomic_sequence_num.h"
#include "packager/base/callback.h"
#include "packager/base/gtest_prod_util.h"
#include "packager/base/time/clock.h"
#include "packager/base/time/time.h"
#include "packager/mpd/base/bandwidth_estimator.h"
#include "packager/mpd/base/content_protection_element.h"
#include "packager/mpd/base/media_info.pb.h"
#include "packager/mpd/base/mpd_options.h"
#include "packager/mpd/base/segment_info.h"
#include "packager/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 shaka {

class AdaptationSet;
class File;
class Representation;

namespace xml {

class XmlNode;
class RepresentationXmlNode;

}  // namespace xml

class MpdBuilder {
 public:
  explicit MpdBuilder(const MpdOptions& mpd_options);
  virtual ~MpdBuilder();

  void AddBaseUrl(const std::string& base_url);

  virtual AdaptationSet* AddAdaptationSet(const std::string& lang);

  // TODO(kqyang): Handle file IO in this class as in HLS media_playlist?
  virtual bool ToString(std::string* output);

  static void MakePathsRelativeToMpd(const std::string& mpd_path,
                                     MediaInfo* media_info);

  // Inject a |clock| that returns the current time.
  void InjectClockForTesting(std::unique_ptr<base::Clock> clock) {
    clock_ = std::move(clock);
  }

 private:
  // LiveMpdBuilderTest needs to set availabilityStartTime so that the test
  // doesn't need to depend on current time.
  friend class LiveMpdBuilderTest;
  template <DashProfile profile>
  friend class MpdBuilderTest;

  // 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();

  // Set MPD attributes common to all profiles. Uses non-zero |mpd_options_| to
  // set attributes for the MPD.
  void AddCommonMpdInfo(xml::XmlNode* mpd_node);

  // 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);

  // Same as AddStaticMpdInfo() but for 'dynamic' MPDs.
  void AddDynamicMpdInfo(xml::XmlNode* mpd_node);

  float GetStaticMpdDuration(xml::XmlNode* mpd_node);

  // Set MPD attributes for dynamic profile MPD. Uses non-zero |mpd_options_| as
  // well as various calculations to set attributes for the MPD.
  void SetDynamicMpdAttributes(xml::XmlNode* mpd_node);

  // Gets the earliest, normalized segment timestamp. Returns true if
  // successful, false otherwise.
  bool GetEarliestTimestamp(double* timestamp_seconds);

  MpdOptions mpd_options_;
  std::list<std::unique_ptr<AdaptationSet>> adaptation_sets_;

  std::list<std::string> base_urls_;
  std::string availability_start_time_;

  base::AtomicSequenceNumber adaptation_set_counter_;
  base::AtomicSequenceNumber representation_counter_;

  // By default, this returns the current time. This can be injected for
  // testing.
  std::unique_ptr<base::Clock> clock_;

  DISALLOW_COPY_AND_ASSIGN(MpdBuilder);
};

class AdaptationSet {
 public:
  // The role for this AdaptationSet. These values are used to add a Role
  // element to the AdaptationSet with schemeIdUri=urn:mpeg:dash:role:2011.
  // See ISO/IEC 23009-1:2012 section 5.8.5.5.
  enum Role {
    kRoleCaption,
    kRoleSubtitle,
    kRoleMain,
    kRoleAlternate,
    kRoleSupplementary,
    kRoleCommentary,
    kRoleDub
  };

  virtual ~AdaptationSet();

  virtual Representation* AddRepresentation(const MediaInfo& media_info);

  virtual void AddContentProtectionElement(
      const ContentProtectionElement& element);

  virtual void UpdateContentProtectionPssh(const std::string& drm_uuid,
                                           const std::string& pssh);

  virtual void AddRole(Role role);

  xml::scoped_xml_ptr<xmlNode> GetXml();

  virtual void ForceSetSegmentAlignment(bool segment_alignment);

  void AddAdaptationSetSwitching(uint32_t adaptation_set_id);

  const std::vector<uint32_t>& adaptation_set_switching_ids() const {
    return adaptation_set_switching_ids_;
  }

  // Must be unique in the Period.
  uint32_t id() const { return id_; }

  void OnNewSegmentForRepresentation(uint32_t representation_id,
                                     uint64_t start_time,
                                     uint64_t duration);

  void OnSetFrameRateForRepresentation(uint32_t representation_id,
                                       uint32_t frame_duration,
                                       uint32_t timescale);

  virtual void AddTrickPlayReferenceId(uint32_t id);

 protected:
  AdaptationSet(uint32_t adaptation_set_id,
                const std::string& lang,
                const MpdOptions& mpd_options,
                base::AtomicSequenceNumber* representation_counter);

 private:
  friend class MpdBuilder;
  template <DashProfile profile>
  friend class MpdBuilderTest;

  // kSegmentAlignmentUnknown means that it is uncertain if the
  // (sub)segments are aligned or not.
  // kSegmentAlignmentTrue means that it is certain that the all the (current)
  // segments added to the adaptation set are aligned.
  // kSegmentAlignmentFalse means that it is it is certain that some segments
  // are not aligned. This is useful to disable the computation for
  // segment alignment, once it is certain that some segments are not aligned.
  enum SegmentAligmentStatus {
    kSegmentAlignmentUnknown,
    kSegmentAlignmentTrue,
    kSegmentAlignmentFalse
  };

  // This maps Representations (IDs) to a list of start times of the segments.
  // e.g.
  // If Representation 1 has start time 0, 100, 200 and Representation 2 has
  // start times 0, 200, 400, then the map contains:
  // 1 -> [0, 100, 200]
  // 2 -> [0, 200, 400]
  typedef std::map<uint32_t, std::list<uint64_t> > RepresentationTimeline;

  // Gets the earliest, normalized segment timestamp. Returns true if
  // successful, false otherwise.
  bool GetEarliestTimestamp(double* timestamp_seconds);

  void CheckLiveSegmentAlignment(uint32_t representation_id,
                                 uint64_t start_time,
                                 uint64_t duration);

  // Checks representation_segment_start_times_ and sets segments_aligned_.
  // Use this for VOD, do not use for Live.
  void CheckVodSegmentAlignment();

  // Records the framerate of a Representation.
  void RecordFrameRate(uint32_t frame_duration, uint32_t timescale);

  std::list<ContentProtectionElement> content_protection_elements_;
  std::list<std::unique_ptr<Representation>> representations_;

  base::AtomicSequenceNumber* const representation_counter_;

  const uint32_t id_;
  const std::string lang_;
  const MpdOptions& mpd_options_;

  // The ids of the adaptation sets this adaptation set can switch to.
  std::vector<uint32_t> adaptation_set_switching_ids_;

  // Video widths and heights of Representations. Note that this is a set; if
  // there is only 1 resolution, then @width & @height should be set, otherwise
  // @maxWidth & @maxHeight should be set for DASH IOP.
  std::set<uint32_t> video_widths_;
  std::set<uint32_t> video_heights_;

  // Video representations' frame rates.
  // The frame rate notation for MPD is <integer>/<integer> (where the
  // denominator is optional). This means the frame rate could be non-whole
  // rational value, therefore the key is of type double.
  // Value is <integer>/<integer> in string form.
  // So, key == CalculatedValue(value)
  std::map<double, std::string> video_frame_rates_;

  // contentType attribute of AdaptationSet.
  // Determined by examining the MediaInfo passed to AddRepresentation().
  std::string content_type_;

  // This does not have to be a set, it could be a list or vector because all we
  // really care is whether there is more than one entry.
  // Contains one entry if all the Representations have the same picture aspect
  // ratio (@par attribute for AdaptationSet).
  // There will be more than one entry if there are multiple picture aspect
  // ratios.
  // The @par attribute should only be set if there is exactly one entry
  // in this set.
  std::set<std::string> picture_aspect_ratio_;

  // The roles of this AdaptationSet.
  std::set<Role> roles_;

  // True iff all the segments are aligned.
  SegmentAligmentStatus segments_aligned_;
  bool force_set_segment_alignment_;

  // Keeps track of segment start times of Representations.
  // For VOD, this will not be cleared, all the segment start times are
  // stored in this. This should not out-of-memory for a reasonable length
  // video and reasonable subsegment length.
  // For Live, the entries are deleted (see CheckLiveSegmentAlignment()
  // implementation comment) because storing the entire timeline is not
  // reasonable and may cause an out-of-memory problem.
  RepresentationTimeline representation_segment_start_times_;

  // Record the reference id for the original adaptation sets the trick play
  // stream belongs to. This is a set because the trick play streams may be for
  // multiple AdaptationSets (e.g. SD and HD videos in different AdaptationSets
  // can share the same trick play stream.)
  std::set<uint32_t> trick_play_reference_ids_;

  DISALLOW_COPY_AND_ASSIGN(AdaptationSet);
};

class RepresentationStateChangeListener {
 public:
  RepresentationStateChangeListener() {}
  virtual ~RepresentationStateChangeListener() {}

  virtual void OnNewSegmentForRepresentation(uint64_t start_time,
                                             uint64_t duration) = 0;

  virtual void OnSetFrameRateForRepresentation(uint32_t frame_duration,
                                               uint32_t timescale) = 0;
};

class Representation {
 public:
  enum SuppressFlag {
    kSuppressWidth = 1,
    kSuppressHeight = 2,
    kSuppressFrameRate = 4,
  };

  virtual ~Representation();

  bool Init();

  virtual void AddContentProtectionElement(
      const ContentProtectionElement& element);

  virtual void UpdateContentProtectionPssh(const std::string& drm_uuid,
                                           const std::string& pssh);

  virtual void AddNewSegment(uint64_t start_time,
                             uint64_t duration,
                             uint64_t size);

  virtual void SetSampleDuration(uint32_t sample_duration);

  xml::scoped_xml_ptr<xmlNode> GetXml();

  void SuppressOnce(SuppressFlag flag);

  uint32_t id() const { return id_; }

 protected:
  Representation(
      const MediaInfo& media_info,
      const MpdOptions& mpd_options,
      uint32_t representation_id,
      std::unique_ptr<RepresentationStateChangeListener> state_change_listener);

 private:
  friend class AdaptationSet;
  template <DashProfile profile>
  friend class MpdBuilderTest;

  bool AddLiveInfo(xml::RepresentationXmlNode* representation);

  // Returns true if |media_info_| has required fields to generate a valid
  // Representation. Otherwise returns false.
  bool HasRequiredMediaInfoFields();

  // Return false if the segment should be considered a new segment. True if the
  // segment is contiguous.
  bool IsContiguous(uint64_t start_time,
                    uint64_t duration,
                    uint64_t size) const;

  // Remove elements from |segment_infos_| for dynamic live profile. Increments
  // |start_number_| by the number of segments removed.
  void SlideWindow();

  // Note: Because 'mimeType' is a required field for a valid MPD, these return
  // strings.
  std::string GetVideoMimeType() const;
  std::string GetAudioMimeType() const;
  std::string GetTextMimeType() const;

  // Gets the earliest, normalized segment timestamp. Returns true if
  // successful, false otherwise.
  bool GetEarliestTimestamp(double* timestamp_seconds);

  // Init() checks that only one of VideoInfo, AudioInfo, or TextInfo is set. So
  // any logic using this can assume only one set.
  MediaInfo media_info_;
  std::list<ContentProtectionElement> content_protection_elements_;
  std::list<SegmentInfo> segment_infos_;

  const uint32_t id_;
  std::string mime_type_;
  std::string codecs_;
  BandwidthEstimator bandwidth_estimator_;
  const MpdOptions& mpd_options_;

  // startNumber attribute for SegmentTemplate.
  // Starts from 1.
  uint32_t start_number_;

  // If this is not null, then Representation is responsible for calling the
  // right methods at right timings.
  std::unique_ptr<RepresentationStateChangeListener> state_change_listener_;

  // Bit vector for tracking witch attributes should not be output.
  int output_suppression_flags_;

  DISALLOW_COPY_AND_ASSIGN(Representation);
};

}  // namespace shaka

#endif  // MPD_BASE_MPD_BUILDER_H_