Cap sourceBuffered() on duration and truncate duration on EoS

media/filters/chunk_demuxer.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/chunk_demuxer.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 158 matching lines @@
 
   void StartWaitingForSeek();
   void Seek(TimeDelta time);
   bool IsSeekPending() const;
 
   // Add buffers to this stream.  Buffers are stored in SourceBufferStreams,
   // which handle ordering and overlap resolution.
   // Returns true if buffers were successfully added.
   bool Append(const StreamParser::BufferQueue& buffers);
 
+  // Returns the range of buffered data in this stream, capped at |duration|.
+  Ranges<TimeDelta> GetBufferedRanges(base::TimeDelta duration) const;
+
   // Signal to the stream that buffers handed in through subsequent calls to
   // Append() belong to a media segment that starts at |start_timestamp|.
   void OnNewMediaSegment(TimeDelta start_timestamp);
 
   // Notifies the stream that it begins at |start_time|.
   void SetStartTime(TimeDelta start_time);
 
   // Called when mid-stream config updates occur.
   // Returns true if the new config is accepted.
   // Returns false if the new config should trigger an error.
   bool UpdateAudioConfig(const AudioDecoderConfig& config);
   bool UpdateVideoConfig(const VideoDecoderConfig& config);
 
   void EndOfStream();
   bool CanEndOfStream() const;
   void Shutdown();
 
   // DemuxerStream methods.
   virtual void Read(const ReadCB& read_cb) OVERRIDE;
   virtual Type type() OVERRIDE;
   virtual void EnableBitstreamConverter() OVERRIDE;
   virtual const AudioDecoderConfig& audio_decoder_config() OVERRIDE;
   virtual const VideoDecoderConfig& video_decoder_config() OVERRIDE;
-  virtual Ranges<TimeDelta> GetBufferedRanges() OVERRIDE;
 
  protected:
   virtual ~ChunkDemuxerStream();
 
  private:
   enum State {
     RETURNING_DATA_FOR_READS,
     WAITING_FOR_SEEK,
     SHUTDOWN,
   };
@@ skipping 98 matching lines @@
     }
     CreateReadDoneClosures_Locked(&closures);
   }
 
   for (ClosureQueue::iterator it = closures.begin(); it != closures.end(); ++it)
     it->Run();
 
   return true;
 }
 
-Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedRanges() {
+Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedRanges(
+    base::TimeDelta duration) const {
   base::AutoLock auto_lock(lock_);
-  return stream_->GetBufferedTime();
+  Ranges<TimeDelta> range = stream_->GetBufferedTime();
+
+  if (range.size() == 0u)
+    return range;
+
+  // Clamp the end of the stream's buffered ranges to fit within the duration.
+  // This can be done by intersecting the stream's range with the valid time
+  // range.
+  Ranges<TimeDelta> valid_time_range;
+  valid_time_range.Add(range.start(0), duration);
+  return range.IntersectionWith(valid_time_range);
 }
 
 bool ChunkDemuxerStream::UpdateAudioConfig(const AudioDecoderConfig& config) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, AUDIO);
   return stream_->UpdateAudioConfig(config);
 }
 
 bool ChunkDemuxerStream::UpdateVideoConfig(const VideoDecoderConfig& config) {
   DCHECK(config.IsValidConfig());
@@ skipping 330 matching lines @@
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const {
   DCHECK(!id.empty());
   DCHECK(IsValidId(id));
   DCHECK(id == source_id_audio_ || id == source_id_video_);
 
   base::AutoLock auto_lock(lock_);
 
   if (id == source_id_audio_ && id != source_id_video_) {
     // Only include ranges that have been buffered in |audio_|
-    return audio_ ? audio_->GetBufferedRanges() : Ranges<TimeDelta>();
+    return audio_ ? audio_->GetBufferedRanges(duration_) : Ranges<TimeDelta>();
   }
 
   if (id != source_id_audio_ && id == source_id_video_) {
     // Only include ranges that have been buffered in |video_|
-    return video_ ? video_->GetBufferedRanges() : Ranges<TimeDelta>();
+    return video_ ? video_->GetBufferedRanges(duration_) : Ranges<TimeDelta>();
   }
 
   return ComputeIntersection();
 }
 
 Ranges<TimeDelta> ChunkDemuxer::ComputeIntersection() const {
   lock_.AssertAcquired();
 
   if (!audio_ || !video_)
     return Ranges<TimeDelta>();
 
   // Include ranges that have been buffered in both |audio_| and |video_|.
-  Ranges<TimeDelta> audio_ranges = audio_->GetBufferedRanges();
-  Ranges<TimeDelta> video_ranges = video_->GetBufferedRanges();
+  Ranges<TimeDelta> audio_ranges = audio_->GetBufferedRanges(duration_);
+  Ranges<TimeDelta> video_ranges = video_->GetBufferedRanges(duration_);
   Ranges<TimeDelta> result = audio_ranges.IntersectionWith(video_ranges);
 
   if (state_ == ENDED && result.size() > 0) {
     // If appending has ended, extend the last intersection range to include the
     // max end time of the last audio/video range. This allows the buffered
     // information to match the actual time range that will get played out if
     // the streams have slightly different lengths.
     TimeDelta audio_start = audio_ranges.start(audio_ranges.size() - 1);
     TimeDelta audio_end = audio_ranges.end(audio_ranges.size() - 1);
     TimeDelta video_start = video_ranges.start(video_ranges.size() - 1);
@@ skipping 52 matching lines @@
         DVLOG(1) << "AppendData(): called in unexpected state " << state_;
         return false;
     }
 
     // Check to see if data was appended at the pending seek point. This
     // indicates we have parsed enough data to complete the seek.
     if (old_seek_pending && !IsSeekPending_Locked() && !seek_cb_.is_null()) {
       std::swap(cb, seek_cb_);
     }
 
-    if (audio_ && !video_) {
-      ranges = audio_->GetBufferedRanges();
-    } else if (!audio_ && video_) {
-      ranges = video_->GetBufferedRanges();
-    } else {
-      ranges = ComputeIntersection();
-    }
+    ranges = GetBufferedRanges();
   }
 
   for (size_t i = 0; i < ranges.size(); ++i)
     host_->AddBufferedTimeRange(ranges.start(i), ranges.end(i));
 
   if (!cb.is_null())
     cb.Run(PIPELINE_OK);
 
   return true;
 }
@@ skipping 35 matching lines @@
 
   if (!CanEndOfStream_Locked() && status == PIPELINE_OK)
     return false;
 
   if (audio_)
     audio_->EndOfStream();
 
   if (video_)
     video_->EndOfStream();
 
-  if (status != PIPELINE_OK)
+  if (status != PIPELINE_OK) {
     ReportError_Locked(status);
-  else
+  } else {
     ChangeState_Locked(ENDED);
+    DecreaseDurationIfNecessary();
+  }
 
   return true;
 }
 
 void ChunkDemuxer::Shutdown() {
   DVLOG(1) << "Shutdown()";
   PipelineStatusCB cb;
   {
     base::AutoLock auto_lock(lock_);
 
@@ skipping 272 matching lines @@
   host_->SetDuration(new_duration);
 }
 
 void ChunkDemuxer::IncreaseDurationIfNecessary(
     const StreamParser::BufferQueue& buffers,
     const scoped_refptr<ChunkDemuxerStream>& stream) {
   DCHECK(!buffers.empty());
   if (buffers.back()->GetTimestamp() <= duration_)
     return;
 
-  Ranges<TimeDelta> ranges = stream->GetBufferedRanges();
+  Ranges<TimeDelta> ranges = stream->GetBufferedRanges(kInfiniteDuration());
   DCHECK_GT(ranges.size(), 0u);
 
   base::TimeDelta last_timestamp_buffered = ranges.end(ranges.size() - 1);
   if (last_timestamp_buffered > duration_)
     UpdateDuration(last_timestamp_buffered);
 }
 
+void ChunkDemuxer::DecreaseDurationIfNecessary() {
+  Ranges<TimeDelta> ranges = GetBufferedRanges();
+  if (ranges.size() == 0u)
+    return;
+
+  base::TimeDelta last_timestamp_buffered = ranges.end(ranges.size() - 1);
+  if (last_timestamp_buffered < duration_)
+    UpdateDuration(last_timestamp_buffered);
+}
+
+Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
+  if (audio_ && !video_)
+    return audio_->GetBufferedRanges(duration_);
+  else if (!audio_ && video_)
+    return video_->GetBufferedRanges(duration_);
+  return ComputeIntersection();
+}
+
 }  // namespace media