Introduce DecodeTimestamp class to make it easier to distiguish presentation and decode timestamps.

media/filters/source_buffer_stream.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // SourceBufferStream is a data structure that stores media Buffers in ranges.
 // Buffers can be appended out of presentation order. Buffers are retrieved by
 // seeking to the desired start point and calling GetNextBuffer(). Buffers are
 // returned in sequential presentation order.
 
 #ifndef MEDIA_FILTERS_SOURCE_BUFFER_STREAM_H_
@@ skipping 48 matching lines @@
                      const LogCB& log_cb,
                      bool splice_frames_enabled);
   SourceBufferStream(const TextTrackConfig& text_config,
                      const LogCB& log_cb,
                      bool splice_frames_enabled);
 
   ~SourceBufferStream();
 
   // Signals that the next buffers appended are part of a new media segment
   // starting at |media_segment_start_time|.
-  void OnNewMediaSegment(base::TimeDelta media_segment_start_time);
+  void OnNewMediaSegment(DecodeTimestamp media_segment_start_time);

[wolenetz, 2014/08/08 21:30:05]

Here and below, is the eventual intent to signal DTS or PTS? If the latter, ISTM
we should keep base::TimeDelta here and put FromPTS hacks in the implementation,
not this interface.

[acolwell GONE FROM CHROMIUM, 2014/08/11 17:05:06]

But the ultimate caller (frame_processor.cc) is passing a DTS into this code.
For now this change is intended to document the flow of DTS through the
different layers of code. Ultimately this should be PTS, but I think this
interface should reflect what is actually being passed in right now. I've filed
http://crbug.com/402502 to track changing this code and added a comment
referring to this bug.

[wolenetz, 2014/08/12 00:09:00]

Acknowledged.

 
   // Add the |buffers| to the SourceBufferStream. Buffers within the queue are
   // expected to be in order, but multiple calls to Append() may add buffers out
   // of order or overlapping. Assumes all buffers within |buffers| are in
   // presentation order and are non-overlapping.
   // Returns true if Append() was successful, false if |buffers| are not added.
   // TODO(vrk): Implement garbage collection. (crbug.com/125070)
   bool Append(const BufferQueue& buffers);
 
   // Removes buffers between |start| and |end| according to the steps
@@ skipping 80 matching lines @@
   // Attempts to delete approximately |total_bytes_to_free| amount of data from
   // |ranges_|, starting after the last appended buffer before the current
   // playback position.
   int FreeBuffersAfterLastAppended(int total_bytes_to_free);
 
   // Gets the removal range to secure |byte_to_free| from
   // [|start_timestamp|, |end_timestamp|).
   // Returns the size of buffers to secure if future
   // Remove(|start_timestamp|, |removal_end_timestamp|, duration) is called.
   // Will not update |removal_end_timestamp| if the returned size is 0.
-  int GetRemovalRange(base::TimeDelta start_timestamp,
-      base::TimeDelta end_timestamp, int byte_to_free,
-      base::TimeDelta* removal_end_timestamp);
+  int GetRemovalRange(DecodeTimestamp start_timestamp,
+      DecodeTimestamp end_timestamp, int byte_to_free,
+      DecodeTimestamp* removal_end_timestamp);
 
   // Prepares |range_for_next_append_| so |new_buffers| can be appended.
   // This involves removing buffers between the end of the previous append
   // and any buffers covered by the time range in |new_buffers|.
   // |deleted_buffers| is an output parameter containing candidates for
   // |track_buffer_| if this method ends up removing the current playback
   // position from the range.
   void PrepareRangesForNextAppend(const BufferQueue& new_buffers,
                                   BufferQueue* deleted_buffers);
 
   // Removes buffers, from the |track_buffer_|, that come after |timestamp|.
-  void PruneTrackBuffer(const base::TimeDelta timestamp);
+  void PruneTrackBuffer(const DecodeTimestamp timestamp);
 
   // Checks to see if |range_with_new_buffers_itr| can be merged with the range
   // next to it, and merges them if so.
   void MergeWithAdjacentRangeIfNecessary(
       const RangeList::iterator& range_with_new_buffers_itr);
 
   // Returns true if |second_timestamp| is the timestamp of the next buffer in
   // sequence after |first_timestamp|, false otherwise.
   bool AreAdjacentInSequence(
-      base::TimeDelta first_timestamp, base::TimeDelta second_timestamp) const;
+      DecodeTimestamp first_timestamp, DecodeTimestamp second_timestamp) const;
 
   // Helper method that returns the timestamp for the next buffer that
   // |selected_range_| will return from GetNextBuffer() call, or kNoTimestamp()
   // if in between seeking (i.e. |selected_range_| is null).
-  base::TimeDelta GetNextBufferTimestamp();
-
-  // Returns the timestamp of the last buffer in the |selected_range_| or
-  // kNoTimestamp() if |selected_range_| is null.
-  base::TimeDelta GetEndBufferTimestamp();
+  DecodeTimestamp GetNextBufferTimestamp();
 
   // Finds the range that should contain a media segment that begins with
   // |start_timestamp| and returns the iterator pointing to it. Returns
   // |ranges_.end()| if there's no such existing range.
-  RangeList::iterator FindExistingRangeFor(base::TimeDelta start_timestamp);
+  RangeList::iterator FindExistingRangeFor(DecodeTimestamp start_timestamp);
 
   // Inserts |new_range| into |ranges_| preserving sorted order. Returns an
   // iterator in |ranges_| that points to |new_range|.
   RangeList::iterator AddToRanges(SourceBufferRange* new_range);
 
   // Returns an iterator that points to the place in |ranges_| where
   // |selected_range_| lives.
   RangeList::iterator GetSelectedRangeItr();
 
   // Sets the |selected_range_| to |range| and resets the next buffer position
   // for the previous |selected_range_|.
   void SetSelectedRange(SourceBufferRange* range);
 
   // Seeks |range| to |seek_timestamp| and then calls SetSelectedRange() with
   // |range|.
   void SeekAndSetSelectedRange(SourceBufferRange* range,
-                               base::TimeDelta seek_timestamp);
+                               DecodeTimestamp seek_timestamp);
 
   // Resets this stream back to an unseeked state.
   void ResetSeekState();
 
   // Returns true if |seek_timestamp| refers to the beginning of the first range
   // in |ranges_|, false otherwise or if |ranges_| is empty.
   bool ShouldSeekToStartOfBuffered(base::TimeDelta seek_timestamp) const;
 
   // Returns true if the timestamps of |buffers| are monotonically increasing
   // since the previous append to the media segment, false otherwise.
   bool IsMonotonicallyIncreasing(const BufferQueue& buffers) const;
 
   // Returns true if |next_timestamp| and |next_is_keyframe| are valid for
   // the first buffer after the previous append.
-  bool IsNextTimestampValid(base::TimeDelta next_timestamp,
+  bool IsNextTimestampValid(DecodeTimestamp next_timestamp,
                             bool next_is_keyframe) const;
 
   // Returns true if |selected_range_| is the only range in |ranges_| that
   // HasNextBufferPosition().
   bool OnlySelectedRangeIsSeeked() const;
 
   // Measures the distances between buffer timestamps and tracks the max.
   void UpdateMaxInterbufferDistance(const BufferQueue& buffers);
 
   // Sets the config ID for each buffer to |append_config_index_|.
   void SetConfigIds(const BufferQueue& buffers);
 
   // Called to complete a config change. Updates |current_config_index_| to
   // match the index of the next buffer. Calling this method causes
   // GetNextBuffer() to stop returning kConfigChange and start returning
   // kSuccess.
   void CompleteConfigChange();
 
   // Sets |selected_range_| and seeks to the nearest keyframe after
   // |timestamp| if necessary and possible. This method only attempts to
   // set |selected_range_| if |seleted_range_| is null and |track_buffer_|
   // is empty.
-  void SetSelectedRangeIfNeeded(const base::TimeDelta timestamp);
+  void SetSelectedRangeIfNeeded(const DecodeTimestamp timestamp);
 
   // Find a keyframe timestamp that is >= |start_timestamp| and can be used to
   // find a new selected range.
   // Returns kNoTimestamp() if an appropriate keyframe timestamp could not be
   // found.
-  base::TimeDelta FindNewSelectedRangeSeekTimestamp(
-      const base::TimeDelta start_timestamp);
+  DecodeTimestamp FindNewSelectedRangeSeekTimestamp(
+      const DecodeTimestamp start_timestamp);
 
   // Searches |ranges_| for the first keyframe timestamp that is >= |timestamp|.
   // If |ranges_| doesn't contain a GOP that covers |timestamp| or doesn't
   // have a keyframe after |timestamp| then kNoTimestamp() is returned.
-  base::TimeDelta FindKeyframeAfterTimestamp(const base::TimeDelta timestamp);
+  DecodeTimestamp FindKeyframeAfterTimestamp(const DecodeTimestamp timestamp);
 
   // Returns "VIDEO" for a video SourceBufferStream, "AUDIO" for an audio
   // stream, and "TEXT" for a text stream.
   std::string GetStreamTypeName() const;
 
   // Returns true if we don't have any ranges or the last range is selected
   // or there is a pending seek beyond any existing ranges.
   bool IsEndSelected() const;
 
   // Deletes the range pointed to by |*itr| and removes it from |ranges_|.
   // If |*itr| points to |selected_range_|, then |selected_range_| is set to
   // NULL. After the range is removed, |*itr| is to the range after the one that
   // was removed or to |ranges_.end()| if the last range was removed.
   void DeleteAndRemoveRange(RangeList::iterator* itr);
 
   // Helper function used by Remove() and PrepareRangesForNextAppend() to
   // remove buffers and ranges between |start| and |end|.
   // |is_exclusive| - If set to true, buffers with timestamps that
   // match |start| are not removed. If set to false, buffers with
   // timestamps that match |start| will be removed.
   // |*deleted_buffers| - Filled with buffers for the current playback position
   // if the removal range included the current playback position. These buffers
   // can be used as candidates for placing in the |track_buffer_|.
   void RemoveInternal(
-      base::TimeDelta start, base::TimeDelta end, bool is_exclusive,
+      DecodeTimestamp start, DecodeTimestamp end, bool is_exclusive,
       BufferQueue* deleted_buffers);
 
   Type GetType() const;
 
   // See GetNextBuffer() for additional details.  This method handles splice
   // frame processing.
   Status HandleNextBufferWithSplice(
       scoped_refptr<StreamParserBuffer>* out_buffer);
 
   // See GetNextBuffer() for additional details.  This method handles preroll
@@ skipping 55 matching lines @@
   // Pointer to the seeked-to Range. This is the range from which
   // GetNextBuffer() calls are fulfilled after the |track_buffer_| has been
   // emptied.
   SourceBufferRange* selected_range_;
 
   // Queue of the next buffers to be returned from calls to GetNextBuffer(). If
   // |track_buffer_| is empty, return buffers from |selected_range_|.
   BufferQueue track_buffer_;
 
   // The start time of the current media segment being appended.
-  base::TimeDelta media_segment_start_time_;
+  DecodeTimestamp media_segment_start_time_;
 
   // Points to the range containing the current media segment being appended.
   RangeList::iterator range_for_next_append_;
 
   // True when the next call to Append() begins a new media segment.
   bool new_media_segment_;
 
   // The timestamp of the last buffer appended to the media segment, set to
-  // kNoTimestamp() if the beginning of the segment.
-  base::TimeDelta last_appended_buffer_timestamp_;
+  // kNoDecodeTimestamp() if the beginning of the segment.
+  DecodeTimestamp last_appended_buffer_timestamp_;
   bool last_appended_buffer_is_keyframe_;
 
   // The decode timestamp on the last buffer returned by the most recent
   // GetNextBuffer() call. Set to kNoTimestamp() if GetNextBuffer() hasn't been
   // called yet or a seek has happened since the last GetNextBuffer() call.
-  base::TimeDelta last_output_buffer_timestamp_;
+  DecodeTimestamp last_output_buffer_timestamp_;
 
   // Stores the largest distance between two adjacent buffers in this stream.
   base::TimeDelta max_interbuffer_distance_;
 
   // The maximum amount of data in bytes the stream will keep in memory.
   int memory_limit_;
 
   // Indicates that a kConfigChanged status has been reported by GetNextBuffer()
   // and GetCurrentXXXDecoderConfig() must be called to update the current
   // config. GetNextBuffer() must not be called again until
@@ skipping 14 matching lines @@
 
   // Indicates that splice frame generation is enabled.
   const bool splice_frames_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceBufferStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_SOURCE_BUFFER_STREAM_H_