adaptation_set.h

// Copyright 2017 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
//
 
#ifndef PACKAGER_MPD_BASE_ADAPTATION_SET_H_
#define PACKAGER_MPD_BASE_ADAPTATION_SET_H_
 
#include <cstdint>
#include <list>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
#include <packager/mpd/base/media_info.pb.h>
#include <packager/mpd/base/xml/xml_node.h>
 
namespace shaka {
 
class MediaInfo;
class Representation;
 
struct ContentProtectionElement;
struct MpdOptions;
 
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 {
    kRoleUnknown,
    kRoleCaption,
    kRoleSubtitle,
    kRoleMain,
    kRoleAlternate,
    kRoleSupplementary,
    kRoleCommentary,
    kRoleDub,
    kRoleDescription,
    kRoleSign,
    kRoleMetadata,
    kRoleEnhancedAudioIntelligibility,
    kRoleEmergency,
    kRoleForcedSubtitle,
    kRoleEasyreader,
    kRoleKaraoke,
  };
 
  virtual ~AdaptationSet();
 
  virtual Representation* AddRepresentation(const MediaInfo& media_info);
 
  virtual Representation* CopyRepresentation(
      const Representation& representation);
 
  virtual void AddContentProtectionElement(
      const ContentProtectionElement& element);
 
  virtual void UpdateContentProtectionPssh(const std::string& drm_uuid,
                                           const std::string& pssh);
 
  virtual void AddAccessibility(const std::string& scheme,
                                const std::string& value);
 
  virtual void AddRole(Role role);
 
  std::optional<xml::XmlNode> GetXml();
 
  virtual void ForceSetSegmentAlignment(bool segment_alignment);
 
  virtual void ForceSubsegmentStartswithSAP(uint32_t sap_value);
 
  virtual void ForceStartwithSAP(uint32_t sap_value);
 
  virtual void AddAdaptationSetSwitching(const AdaptationSet* adaptation_set);
 
  bool has_id() const { return static_cast<bool>(id_); }
 
  std::optional<uint32_t> SortIndex() const {
    return index_.has_value() ? index_ : id_;
  }
 
  // Must be unique in the Period.
  uint32_t id() const { return id_.value(); }
 
  void set_id(uint32_t id) { id_ = id; }
 
  void OnNewSegmentForRepresentation(uint32_t representation_id,
                                     int64_t start_time,
                                     int64_t duration);
 
  void OnSetFrameRateForRepresentation(uint32_t representation_id,
                                       int32_t frame_duration,
                                       int32_t timescale);
 
  virtual void AddTrickPlayReference(const AdaptationSet* adaptation_set);
 
  // Return the list of Representations in this AdaptationSet.
  const std::list<Representation*> GetRepresentations() const;
 
  bool IsVideo() const;
 
  const std::string& codec() const { return codec_; }
 
  void set_codec(const std::string& codec) { codec_ = codec; };
 
  uint32_t matrix_coefficients() const { return matrix_coefficients_; }
 
  void set_matrix_coefficients(const uint32_t& matrix_coefficients) {
    matrix_coefficients_ = matrix_coefficients;
  };
 
  uint32_t color_primaries() const { return color_primaries_; }
 
  void set_color_primaries(const uint32_t& color_primaries) {
    color_primaries_ = color_primaries;
  };
 
  uint32_t transfer_characteristics() const {
    return transfer_characteristics_;
  }
 
  void set_transfer_characteristics(const uint32_t& transfer_characteristics) {
    transfer_characteristics_ = transfer_characteristics;
  };
 
  const MediaInfo::ProtectedContent* protected_content() const {
    return protected_content_;
  };
 
  void set_protected_content(const MediaInfo& media_info);
 
  bool MatchAdaptationSet(const MediaInfo& media_info,
                          bool content_protection_in_adaptation_set);
 
  bool SwitchableAdaptationSet(const AdaptationSet& adaptation_set);
 
 protected:
  AdaptationSet(const std::string& language,
                const MpdOptions& mpd_options,
                uint32_t* representation_counter);
 
 private:
  AdaptationSet(const AdaptationSet&) = delete;
  AdaptationSet& operator=(const AdaptationSet&) = delete;
 
  friend class Period;
  friend class AdaptationSetTest;
 
  // 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<int64_t>> RepresentationTimeline;
 
  // Update AdaptationSet attributes for new MediaInfo.
  void UpdateFromMediaInfo(const MediaInfo& media_info);
 
  void CheckDynamicSegmentAlignment(uint32_t representation_id,
                                    int64_t start_time,
                                    int64_t duration);
 
  // Checks representation_segment_start_times_ and sets segments_aligned_.
  // Use this for static MPD, do not use for dynamic MPD.
  void CheckStaticSegmentAlignment();
 
  // Records the framerate of a Representation.
  void RecordFrameRate(int32_t frame_duration, int32_t timescale);
 
  std::list<ContentProtectionElement> content_protection_elements_;
  // representation_id => Representation map. It also keeps the representations_
  // sorted by default.
  std::map<uint32_t, std::unique_ptr<Representation>> representation_map_;
 
  uint32_t* const representation_counter_;
 
  std::optional<uint32_t> id_;
  const std::string language_;
  const MpdOptions& mpd_options_;
 
  // An array of adaptation sets this adaptation set can switch to.
  std::vector<const AdaptationSet*> switchable_adaptation_sets_;
 
  // 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_;
 
  // Codec of AdaptationSet.
  std::string codec_;
 
  // 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_;
 
  // accessibilities of this AdaptationSet.
  struct Accessibility {
    std::string scheme;
    std::string value;
  };
  std::vector<Accessibility> accessibilities_;
 
  // The roles of this AdaptationSet.
  std::set<Role> roles_;
 
  // True iff all the segments are aligned.
  SegmentAligmentStatus segments_aligned_ = kSegmentAlignmentUnknown;
  bool force_set_segment_alignment_ = false;
 
  // The stream access point for subsegment
  uint8_t subsegment_start_with_sap_ = 0;
 
  // The stream access point for segment
  uint8_t start_with_sap_ = 0;
 
  // Keeps track of segment start times of Representations.
  // For static MPD, 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 dynamic MPD, the entries are deleted (see
  // CheckDynamicSegmentAlignment() 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 original AdaptationSets the trick play stream belongs to. There
  // can be more than one reference AdaptationSets as multiple streams e.g. SD
  // and HD videos in different AdaptationSets can share the same trick play
  // stream.
  std::vector<const AdaptationSet*> trick_play_references_;
 
  // Matrix Coefficients.
  uint32_t matrix_coefficients_ = 0;
  // Colour Primaries.
  uint32_t color_primaries_ = 0;
 
  // Transfer characteristics.
  uint32_t transfer_characteristics_ = 0;
 
  // the command-line index for this AdaptationSet
  std::optional<uint32_t> index_;
 
  // The label of this AdaptationSet.
  std::string label_;
 
  // ProtectedContent of this AdaptationSet.
  MediaInfo::ProtectedContent* protected_content_;
};
 
}  // namespace shaka
 
#endif  // PACKAGER_MPD_BASE_ADAPTATION_SET_H_