representation.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_REPRESENTATION_H_
#define PACKAGER_MPD_BASE_REPRESENTATION_H_
 
#include <cstdint>
#include <list>
#include <memory>
#include <optional>
 
#include <packager/mpd/base/bandwidth_estimator.h>
#include <packager/mpd/base/media_info.pb.h>
#include <packager/mpd/base/segment_info.h>
#include <packager/mpd/base/xml/xml_node.h>
 
namespace shaka {
 
struct ContentProtectionElement;
struct MpdOptions;
 
class RepresentationStateChangeListener {
 public:
  RepresentationStateChangeListener() {}
  virtual ~RepresentationStateChangeListener() {}
 
  virtual void OnNewSegmentForRepresentation(int64_t start_time,
                                             int64_t duration) = 0;
 
  virtual void OnSetFrameRateForRepresentation(int32_t frame_duration,
                                               int32_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(int64_t start_time,
                             int64_t duration,
                             uint64_t size,
                             int64_t segment_number);
 
  virtual void UpdateCompletedSegment(int64_t duration, uint64_t size);
 
  virtual void SetSampleDuration(int32_t sample_duration);
 
  virtual const MediaInfo& GetMediaInfo() const;
 
  std::optional<xml::XmlNode> GetXml();
 
  void SuppressOnce(SuppressFlag flag);
 
  void SetPresentationTimeOffset(double presentation_time_offset);
 
  void SetAvailabilityTimeOffset();
 
  void SetSegmentDuration();
 
  bool GetStartAndEndTimestamps(double* start_timestamp_seconds,
                                double* end_timestamp_seconds) const;
 
  uint32_t id() const { return id_; }
 
  void set_media_info(const MediaInfo& media_info) { media_info_ = media_info; }
 
 protected:
  Representation(
      const MediaInfo& media_info,
      const MpdOptions& mpd_options,
      uint32_t representation_id,
      std::unique_ptr<RepresentationStateChangeListener> state_change_listener);
 
  Representation(
      const Representation& representation,
      std::unique_ptr<RepresentationStateChangeListener> state_change_listener);
 
 private:
  Representation(const Representation&) = delete;
  Representation& operator=(const Representation&) = delete;
 
  friend class AdaptationSet;
  friend class RepresentationTest;
 
  // Returns true if |media_info_| has required fields to generate a valid
  // Representation. Otherwise returns false.
  bool HasRequiredMediaInfoFields() const;
 
  // Add a SegmentInfo. This function may insert an adjusted SegmentInfo if
  // |allow_approximate_segment_timeline_| is set.
  void AddSegmentInfo(int64_t start_time,
                      int64_t duration,
                      int64_t segment_number);
 
  // Update the current SegmentInfo. This method is used to update the duration
  // value after a low latency segment is complete, and the full segment
  // duration is known.
  void UpdateSegmentInfo(int64_t duration);
 
  // Check if two timestamps are approximately equal if
  // |allow_approximate_segment_timeline_| is set; Otherwise check whether the
  // two times match.
  bool ApproximiatelyEqual(int64_t time1, int64_t time2) const;
 
  // Return adjusted duration if |allow_aproximate_segment_timeline_or_duration|
  // is set; otherwise duration is returned without adjustment.
  int64_t AdjustDuration(int64_t duration) const;
 
  // Remove elements from |segment_infos_| for dynamic live profile. Increments
  // |start_number_| by the number of segments removed.
  void SlideWindow();
 
  // Remove the first segment in |segment_info|.
  void RemoveOldSegment(SegmentInfo* segment_info);
 
  // 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;
 
  // Get Representation as string. For debugging.
  std::string RepresentationAsString() const;
 
  // 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_;
 
  int64_t current_buffer_depth_ = 0;
  // TODO(kqyang): Address sliding window issue with multiple periods.
  std::list<SegmentInfo> segment_infos_;
  // A list to hold the file names of the segments to be removed temporarily.
  // Once a file is actually removed, it is removed from the list.
  std::list<std::string> segments_to_be_removed_;
 
  const uint32_t id_;
  std::string mime_type_;
  std::string codecs_;
  std::string supplemental_codecs_;
  std::string supplemental_profiles_;
  BandwidthEstimator bandwidth_estimator_;
  const MpdOptions& mpd_options_;
 
  // 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_ = 0;
 
  // When set to true, allows segments to have slightly different durations (up
  // to one sample).
  const bool allow_approximate_segment_timeline_ = false;
  // Segments with duration difference less than one frame duration are
  // considered to have the same duration.
  int32_t frame_duration_ = 0;
};
 
}  // namespace shaka
 
#endif  // PACKAGER_MPD_BASE_REPRESENTATION_H_