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 181 matching lines @@
   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;
+
+  // Returns the range of buffered data in this stream, capped at |duration|.
+  Ranges<TimeDelta> GetBufferedRanges(base::TimeDelta duration) const;

[acolwell GONE FROM CHROMIUM, 2012/08/01 17:09:45]

nit: perhaps move this just below Append() so it's with similar methods called
by ChunkDemuxer?

[vrk (LEFT CHROMIUM), 2012/08/02 18:23:00]

Done.

 
  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();
+
+  Ranges<TimeDelta> valid_time_range;
+  valid_time_range.Add(base::TimeDelta(), duration);

[acolwell GONE FROM CHROMIUM, 2012/08/01 17:09:45]

I think base::TimeDelta() needs to be start_time_ or at least range.start(0)?

+  return range.IntersectionWith(valid_time_range);

[acolwell GONE FROM CHROMIUM, 2012/08/01 17:09:45]

\o/ look who's being tricky. I like it, but this deserves a comment.

[vrk (LEFT CHROMIUM), 2012/08/02 18:23:00]

haha glad you like! :) commented!

 }
 
 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 {

[vrk (LEFT CHROMIUM), 2012/08/01 00:10:06]

This CL adds this guy back again; if it's still overkill, I could make a method
to find specifically the last buffered timestamp.

[acolwell GONE FROM CHROMIUM, 2012/08/01 17:09:45]

No this is fine here. My original complaint was it being overkill for the append
case. You're only calling this on eos now which is fine.

[vrk (LEFT CHROMIUM), 2012/08/02 18:23:00]

SG!

+  if (audio_ && !video_)
+    return audio_->GetBufferedRanges(duration_);
+  else if (!audio_ && video_)
+    return video_->GetBufferedRanges(duration_);
+  return ComputeIntersection();
+}
+
 }  // namespace media