Ensure media's buffered ranges always have a range that includes currentTime.

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/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 63 matching lines @@
 
 static const SupportedTypeInfo kSupportedTypeInfo[] = {
   { "video/webm", &BuildWebMParser, kVideoWebMCodecs },
   { "audio/webm", &BuildWebMParser, kAudioWebMCodecs },
 #if defined(USE_PROPRIETARY_CODECS)
   { "video/mp4", &BuildMP4Parser, kVideoMP4Codecs },
   { "audio/mp4", &BuildMP4Parser, kAudioMP4Codecs },
 #endif
 };
 
-
-// The fake total size we use for converting times to bytes
-// for AddBufferedByteRange() calls.
-// TODO(acolwell): Remove this once Pipeline accepts buffered times
-// instead of only buffered bytes.
-enum { kFakeTotalBytes = 1000000 };
-
 // Checks to see if the specified |type| and |codecs| list are supported.
 // Returns true if |type| and all codecs listed in |codecs| are supported.
 //         |factory_function| contains a function that can build a StreamParser
 //                            for this type.
 //         |has_audio| is true if an audio codec was specified.
 //         |has_video| is true if a video codec was specified.
 // Returns false otherwise. The values of |factory_function|, |has_audio|,
 //         and |has_video| are undefined.
 static bool IsSupported(const std::string& type,
                         std::vector<std::string>& codecs,
@@ skipping 63 matching lines @@
   void StartWaitingForSeek();
   void Seek(TimeDelta time);
   bool IsSeekPending() const;
   void Flush();
 
   // 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 a list of the buffered time ranges.
-  Ranges<TimeDelta> GetBufferedTime() 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);
 
   // 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 91 matching lines @@
     }
     CreateReadDoneClosures_Locked(&closures);
   }
 
   for (ClosureQueue::iterator it = closures.begin(); it != closures.end(); ++it)
     it->Run();
 
   return true;
 }
 
-Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedTime() const {
+Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedRanges() {
   base::AutoLock auto_lock(lock_);
   return stream_->GetBufferedTime();
 }
 
 bool ChunkDemuxerStream::UpdateAudioConfig(const AudioDecoderConfig& config) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, AUDIO);
 
   const AudioDecoderConfig& current_config =
       stream_->GetCurrentAudioDecoderConfig();
@@ skipping 324 matching lines @@
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const {
   DCHECK(!id.empty());
   DCHECK_GT(stream_parser_map_.count(id), 0u);
   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_->GetBufferedTime() : Ranges<TimeDelta>();
+    return audio_ ? audio_->GetBufferedRanges() : Ranges<TimeDelta>();
   }
 
   if (id != source_id_audio_ && id == source_id_video_) {
     // Only include ranges that have been buffered in |video_|
-    return video_ ? video_->GetBufferedTime() : Ranges<TimeDelta>();
+    return video_ ? video_->GetBufferedRanges() : 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_->GetBufferedTime();
-  Ranges<TimeDelta> video_ranges = video_->GetBufferedTime();
+  Ranges<TimeDelta> audio_ranges = audio_->GetBufferedRanges();
+  Ranges<TimeDelta> video_ranges = video_->GetBufferedRanges();
   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 54 matching lines @@
     }
 
     // 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 (duration_ > TimeDelta() && duration_ != kInfiniteDuration()) {
       if (audio_ && !video_) {
-        ranges = audio_->GetBufferedTime();
+        ranges = audio_->GetBufferedRanges();
       } else if (!audio_ && video_) {
-        ranges = video_->GetBufferedTime();
+        ranges = video_->GetBufferedRanges();
       } else {
         ranges = ComputeIntersection();
       }
     }
   }
 
-  DCHECK(!ranges.size() || duration_ > TimeDelta());
-  for (size_t i = 0; i < ranges.size(); ++i) {
-    // Notify the host of 'network activity' because we got data.
-    int64 start =
-        kFakeTotalBytes * ranges.start(i).InSecondsF() / duration_.InSecondsF();
-    int64 end =
-        kFakeTotalBytes * ranges.end(i).InSecondsF() / duration_.InSecondsF();
-    host_->AddBufferedByteRange(start, end);
-  }
+  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;
 }
 
 void ChunkDemuxer::Abort(const std::string& id) {
   DVLOG(1) << "Abort(" << id << ")";
   DCHECK(!id.empty());
@@ skipping 147 matching lines @@
   }
 
   if (duration > duration_)
     duration_ = duration;
 
   // Wait until all streams have initialized.
   if ((!source_id_audio_.empty() && !audio_) ||
       (!source_id_video_.empty() && !video_))
     return;
 
-  if (duration_ > TimeDelta() && duration_ != kInfiniteDuration())
-    host_->SetTotalBytes(kFakeTotalBytes);
   host_->SetDuration(duration_);
 
   ChangeState_Locked(INITIALIZED);
   PipelineStatusCB cb;
   std::swap(cb, init_cb_);
   cb.Run(PIPELINE_OK);
 }
 
 bool ChunkDemuxer::OnNewConfigs(bool has_audio, bool has_video,
                                 const AudioDecoderConfig& audio_config,
@@ skipping 68 matching lines @@
   // TODO(vrk): There should be a special case for the first appends where all
   // streams (for both demuxed and muxed case) begin at the earliest stream
   // timestamp. (crbug.com/132815)
   if (audio_ && source_id == source_id_audio_)
     audio_->OnNewMediaSegment(start_timestamp);
   if (video_ && source_id == source_id_video_)
     video_->OnNewMediaSegment(start_timestamp);
 }
 
 }  // namespace media