Remove lingering frames of old data when appending a new segment

media/filters/source_buffer_stream.cc

 // 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.
 
 #include "media/filters/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 135 matching lines @@
   // Returns true if the end of this range contains buffers that overlaps with
   // the beginning of |range|.
   bool EndOverlaps(const SourceBufferRange& range) const;
 
   // Returns true if |timestamp| is the timestamp of the next buffer in
   // sequence after |buffer|, false otherwise.
   bool IsNextInSequence(
       const scoped_refptr<media::StreamParserBuffer>& buffer,
       base::TimeDelta timestamp) const;
 
+  // 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;
+
   int size_in_bytes() const { return size_in_bytes_; }
 
  private:
   typedef std::map<base::TimeDelta, size_t> KeyframeMap;
 
   // Seeks the range to the next keyframe after |timestamp|. If
   // |skip_given_timestamp| is true, the seek will go to a keyframe with a
   // timestamp strictly greater than |timestamp|.
   void SeekAhead(base::TimeDelta timestamp, bool skip_given_timestamp);
 
@@ skipping 146 matching lines @@
     ranges_.pop_front();
   }
 
   STLDeleteElements(&audio_configs_);
   STLDeleteElements(&video_configs_);
 }
 
 void SourceBufferStream::OnNewMediaSegment(
     base::TimeDelta media_segment_start_time) {
   media_segment_start_time_ = media_segment_start_time;
+  new_media_segment_ = true;
 
-  // Find the range that will house the buffers appended through the next
-  // Append() call.
+  RangeList::iterator last_range = range_for_next_append_;
   range_for_next_append_ = FindExistingRangeFor(media_segment_start_time);
-  new_media_segment_ = true;
-  last_buffer_timestamp_ = kNoTimestamp();
+
+  // Only reset |last_buffer_timestamp_| if this new media segment is not
+  // adjacent to the previous media segment appended to the stream.
+  if (range_for_next_append_ == ranges_.end() ||
+      !(*range_for_next_append_)->AreAdjacentInSequence(

[acolwell GONE FROM CHROMIUM, 2012/09/19 23:15:51]

This is a little awkward because it calls into the range just so the range can
call back into this class for the approximate duration value. I think making
this a helper method on SourceBufferStream would be better and just keep
SourceBufferRange::IsNextInSequence() as is for now.

You could create a static TimeDelta GetFudge(TimeDelta approximate_duration)
helper to avoid SourceBufferStream & SourceBufferRange getting out of sync.

[vrk (LEFT CHROMIUM), 2012/09/20 00:00:59]

Done.

+          last_buffer_timestamp_, media_segment_start_time)) {
+    last_buffer_timestamp_ = kNoTimestamp();
+  } else {
+    DCHECK(last_range == range_for_next_append_);
+  }
 }
 
 bool SourceBufferStream::Append(
     const SourceBufferStream::BufferQueue& buffers) {
   DCHECK(!buffers.empty());
   DCHECK(media_segment_start_time_ != kNoTimestamp());
 
   // New media segments must begin with a keyframe.
   if (new_media_segment_ && !buffers.front()->IsKeyframe()) {
     DVLOG(1) << "Media segment did not begin with keyframe.";
@@ skipping 1061 matching lines @@
   DCHECK(!buffers_.empty());
   base::TimeDelta duration = buffers_.back()->GetDuration();
   if (duration == kNoTimestamp() || duration == base::TimeDelta())
     duration = GetApproximateDuration();
   return GetEndTimestamp() + duration;
 }
 
 bool SourceBufferRange::IsNextInSequence(
     const scoped_refptr<media::StreamParserBuffer>& buffer,
     base::TimeDelta timestamp) const {
-  return buffer->GetDecodeTimestamp() < timestamp &&
-      timestamp <= buffer->GetDecodeTimestamp() + GetFudgeRoom();
+  return AreAdjacentInSequence(buffer->GetDecodeTimestamp(), timestamp);
+}
+
+bool SourceBufferRange::AreAdjacentInSequence(
+    base::TimeDelta first_timestamp, base::TimeDelta second_timestamp) const {
+  return first_timestamp < second_timestamp &&
+      second_timestamp <= first_timestamp + GetFudgeRoom();
 }
 
 base::TimeDelta SourceBufferRange::GetFudgeRoom() const {
   // Because we do not know exactly when is the next timestamp, any buffer
   // that starts within 2x the approximate duration of a buffer is considered
   // within this range.
   return 2 * GetApproximateDuration();
 }
 
 base::TimeDelta SourceBufferRange::GetApproximateDuration() const {
   base::TimeDelta max_interbuffer_distance = interbuffer_distance_cb_.Run();
   DCHECK(max_interbuffer_distance != kNoTimestamp());
   return max_interbuffer_distance;
 }
 
 }  // namespace media