Fix ChunkDemuxer so it properly outputs buffered ranges.

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"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/chunk_demuxer_client.h"
 #include "media/mp4/mp4_stream_parser.h"
 #include "media/webm/webm_stream_parser.h"
 
+using base::TimeDelta;
+
 namespace media {
 
 struct CodecInfo {
   const char* pattern;
   DemuxerStream::Type type;
 };
 
 typedef StreamParser* (*ParserFactoryFunction)();
 
 struct SupportedTypeInfo {
@@ skipping 38 matching lines @@
   return new mp4::MP4StreamParser();
 }
 
 static const SupportedTypeInfo kSupportedTypeInfo[] = {
   { "video/webm", &BuildWebMParser, kVideoWebMCodecs },
   { "audio/webm", &BuildWebMParser, kAudioWebMCodecs },
   { "video/mp4", &BuildMP4Parser, kVideoMP4Codecs },
   { "audio/mp4", &BuildMP4Parser, kAudioMP4Codecs },
 };
 
+
+// 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 54 matching lines @@
 class ChunkDemuxerStream : public DemuxerStream {
  public:
   typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
   typedef std::deque<ReadCB> ReadCBQueue;
   typedef std::deque<base::Closure> ClosureQueue;
 
   explicit ChunkDemuxerStream(const AudioDecoderConfig& audio_config);
   explicit ChunkDemuxerStream(const VideoDecoderConfig& video_config);
 
   void StartWaitingForSeek();
-  void Seek(base::TimeDelta time);
+  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.
-  SourceBufferStream::TimespanList GetBufferedTime() const;
+  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(base::TimeDelta 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();
@@ skipping 30 matching lines @@
   Type type_;
 
   scoped_ptr<SourceBufferStream> stream_;
 
   mutable base::Lock lock_;
   State state_;
   ReadCBQueue read_cbs_;
 
   // The timestamp of the current media segment being parsed by
   // |stream_parser_|.
-  base::TimeDelta media_segment_start_time_;
+  TimeDelta media_segment_start_time_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 };
 
 ChunkDemuxerStream::ChunkDemuxerStream(const AudioDecoderConfig& audio_config)
     : type_(AUDIO),
       state_(RETURNING_DATA_FOR_READS),
       media_segment_start_time_(kNoTimestamp()) {
   stream_.reset(new SourceBufferStream(audio_config));
 }
@@ skipping 11 matching lines @@
     base::AutoLock auto_lock(lock_);
     ChangeState_Locked(WAITING_FOR_SEEK);
 
     std::swap(read_cbs_, read_cbs);
   }
 
   for (ReadCBQueue::iterator it = read_cbs.begin(); it != read_cbs.end(); ++it)
     it->Run(NULL);
 }
 
-void ChunkDemuxerStream::Seek(base::TimeDelta time) {
+void ChunkDemuxerStream::Seek(TimeDelta time) {
   base::AutoLock auto_lock(lock_);
 
   DCHECK(read_cbs_.empty());
 
   stream_->Seek(time);
 
   if (state_ == WAITING_FOR_SEEK)
     ChangeState_Locked(RETURNING_DATA_FOR_READS);
 }
 
 bool ChunkDemuxerStream::IsSeekPending() const {
   base::AutoLock auto_lock(lock_);
   return stream_->IsSeekPending();
 }
 
 void ChunkDemuxerStream::Flush() {
   media_segment_start_time_ = kNoTimestamp();
 }
 
-void ChunkDemuxerStream::OnNewMediaSegment(base::TimeDelta start_timestamp) {
+void ChunkDemuxerStream::OnNewMediaSegment(TimeDelta start_timestamp) {
   media_segment_start_time_ = start_timestamp;
 }
 
 bool ChunkDemuxerStream::Append(const StreamParser::BufferQueue& buffers) {
   if (buffers.empty())
     return false;
 
   ClosureQueue closures;
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_NE(state_, SHUTDOWN);
     DCHECK(media_segment_start_time_ != kNoTimestamp());
     if (!stream_->Append(buffers, media_segment_start_time_)) {
       DVLOG(1) << "ChunkDemuxerStream::Append() : stream append failed";
       return false;
     }
     CreateReadDoneClosures_Locked(&closures);
   }
 
   for (ClosureQueue::iterator it = closures.begin(); it != closures.end(); ++it)
     it->Run();
 
   return true;
 }
 
-SourceBufferStream::TimespanList ChunkDemuxerStream::GetBufferedTime() const {
+Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedTime() const {
   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 152 matching lines @@
     if (!stream_->GetNextBuffer(&buffer))
       return;
     closures->push_back(base::Bind(read_cbs_.front(), buffer));
     read_cbs_.pop_front();
   }
 }
 
 ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
     : state_(WAITING_FOR_INIT),
       host_(NULL),
-      client_(client),
-      buffered_bytes_(0) {
+      client_(client) {
   DCHECK(client);
 }
 
 void ChunkDemuxer::Initialize(DemuxerHost* host,
                               const PipelineStatusCB& cb) {
   DVLOG(1) << "Init()";
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(state_, WAITING_FOR_INIT);
     host_ = host;
 
     ChangeState_Locked(INITIALIZING);
     init_cb_ = cb;
   }
 
   client_->DemuxerOpened(this);
 }
 
 void ChunkDemuxer::Stop(const base::Closure& callback) {
   DVLOG(1) << "Stop()";
   Shutdown();
   callback.Run();
 }
 
-void ChunkDemuxer::Seek(base::TimeDelta time, const PipelineStatusCB& cb) {
+void ChunkDemuxer::Seek(TimeDelta time, const PipelineStatusCB& cb) {
   DVLOG(1) << "Seek(" << time.InSecondsF() << ")";
 
   PipelineStatus status = PIPELINE_ERROR_INVALID_STATE;
   {
     base::AutoLock auto_lock(lock_);
 
     if (state_ == INITIALIZED || state_ == ENDED) {
       if (audio_)
         audio_->Seek(time);
 
@@ skipping 28 matching lines @@
     DemuxerStream::Type type) {
   if (type == DemuxerStream::VIDEO)
     return video_;
 
   if (type == DemuxerStream::AUDIO)
     return audio_;
 
   return NULL;
 }
 
-base::TimeDelta ChunkDemuxer::GetStartTime() const {
+TimeDelta ChunkDemuxer::GetStartTime() const {
   DVLOG(1) << "GetStartTime()";
   // TODO(acolwell) : Fix this so it uses the time on the first packet.
   // (crbug.com/132815)
-  return base::TimeDelta();
+  return TimeDelta();
 }
 
 void ChunkDemuxer::StartWaitingForSeek() {
   DVLOG(1) << "StartWaitingForSeek()";
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ == INITIALIZED || state_ == ENDED || state_ == SHUTDOWN);
 
   if (state_ == SHUTDOWN)
     return;
 
@@ skipping 64 matching lines @@
   delete stream_parser_map_[id];
   stream_parser_map_.erase(id);
 
   if (source_id_audio_ == id && audio_)
     audio_->Shutdown();
 
   if (source_id_video_ == id && video_)
     video_->Shutdown();
 }
 
-bool ChunkDemuxer::GetBufferedRanges(const std::string& id,
-                                     Ranges* ranges_out) const {
+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_);
-  DCHECK(ranges_out);
 
   base::AutoLock auto_lock(lock_);
 
   if (id == source_id_audio_ && id != source_id_video_) {
     // Only include ranges that have been buffered in |audio_|
-    return CopyIntoRanges(audio_->GetBufferedTime(), ranges_out);
+    return audio_->GetBufferedTime();
   }
 
   if (id != source_id_audio_ && id == source_id_video_) {
     // Only include ranges that have been buffered in |video_|
-    return CopyIntoRanges(video_->GetBufferedTime(), ranges_out);
+    return video_->GetBufferedTime();
   }
 
+  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_|.
-  SourceBufferStream::TimespanList audio_ranges = audio_->GetBufferedTime();
-  SourceBufferStream::TimespanList video_ranges = video_->GetBufferedTime();
-  SourceBufferStream::TimespanList::const_iterator video_ranges_itr =
-      video_ranges.begin();
-  SourceBufferStream::TimespanList::const_iterator audio_ranges_itr =
-      audio_ranges.begin();
-  bool success = false;
+  Ranges<TimeDelta> audio_ranges = audio_->GetBufferedTime();
+  Ranges<TimeDelta> video_ranges = video_->GetBufferedTime();
+  Ranges<TimeDelta> result = audio_ranges.IntersectionWith(video_ranges);
 
-  while (audio_ranges_itr != audio_ranges.end() &&
-         video_ranges_itr != video_ranges.end()) {
-    // If this is the last range and EndOfStream() was called (i.e. all data
-    // has been appended), choose the max end point of the ranges.
-    bool last_range_after_ended =
-        state_ == ENDED &&
-        (audio_ranges_itr + 1) == audio_ranges.end() &&
-        (video_ranges_itr + 1) == video_ranges.end();
+  if (state_ == ENDED) {
+    // If appending has ended, extend the intersection to include all of the
+    // data from the last ranges for each stream. This allows the buffered

[Ami GONE FROM CHROMIUM, 2012/06/19 20:23:38]

So then this is not completely correct, as you say in your last response.  This
should say what it actually does (extend the last intersection buffer to the max
of the last audio/video buffers).

[acolwell GONE FROM CHROMIUM, 2012/06/19 22:39:36]

Done.

+    // information to match the actual time range that will get played out if
+    // the streams have slightly different lengths. We only do this if the
+    // final ranges overlap because this indicates there is actually a location

[Ami GONE FROM CHROMIUM, 2012/06/19 20:23:38]

The final ranges must overlap b/c you don't allow the transition to ENDED
otherwise.  So this comment needs to be reworded...

[acolwell GONE FROM CHROMIUM, 2012/06/19 22:39:36]

Done.

+    // you can seek to, near the end, where we have data for both streams.
+    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);
+    TimeDelta video_end = video_ranges.end(video_ranges.size() - 1);
 
-    // Audio range start time is within the video range.
-    if ((*audio_ranges_itr).first >= (*video_ranges_itr).first &&
-        (*audio_ranges_itr).first <= (*video_ranges_itr).second) {
-      AddIntersectionRange(*audio_ranges_itr, *video_ranges_itr,
-                           last_range_after_ended, ranges_out);
-      audio_ranges_itr++;
-      success = true;
-      continue;
+    if ((audio_start <= video_start && video_start <= audio_end) ||

[Ami GONE FROM CHROMIUM, 2012/06/19 20:23:38]

...and this if needs to turn into a DCHECK.

[acolwell GONE FROM CHROMIUM, 2012/06/19 22:39:36]

Done.

+        (video_start <= audio_start && audio_start <= video_end)) {
+      result.Add(std::max(audio_start, video_start),

[Ami GONE FROM CHROMIUM, 2012/06/19 20:23:38]

Once you DCHECK, this Add can be
result.Add(result.end(result.size()-1), std::max(audio_end, video_end))
to emph the "extending" nature of the operation.

[acolwell GONE FROM CHROMIUM, 2012/06/19 22:39:36]

Done.

+                 std::max(audio_end, video_end));
     }
-
-    // Video range start time is within the audio range.
-    if ((*video_ranges_itr).first >= (*audio_ranges_itr).first &&
-        (*video_ranges_itr).first <= (*audio_ranges_itr).second) {
-      AddIntersectionRange(*video_ranges_itr, *audio_ranges_itr,
-                           last_range_after_ended, ranges_out);
-      video_ranges_itr++;
-      success = true;
-      continue;
-    }
-
-    // No overlap was found.  Increment the earliest one and keep looking.
-    if ((*audio_ranges_itr).first < (*video_ranges_itr).first)
-      audio_ranges_itr++;
-    else
-      video_ranges_itr++;
   }
 
-  return success;
-}
-
-bool ChunkDemuxer::CopyIntoRanges(
-    const SourceBufferStream::TimespanList& timespans,
-    Ranges* ranges_out) const {
-  for (SourceBufferStream::TimespanList::const_iterator itr = timespans.begin();
-       itr != timespans.end(); ++itr) {
-    ranges_out->push_back(*itr);
-  }
-  return !timespans.empty();
-}
-
-void ChunkDemuxer::AddIntersectionRange(
-    SourceBufferStream::Timespan timespan_a,
-    SourceBufferStream::Timespan timespan_b,
-    bool last_range_after_ended,
-    Ranges* ranges_out) const {
-  base::TimeDelta start = timespan_a.first;
-
-  // If this is the last range after EndOfStream() was called, choose the later
-  // end point of the ranges, otherwise choose the earlier.
-  base::TimeDelta end;
-  if (last_range_after_ended)
-    end = std::max(timespan_a.second, timespan_b.second);
-  else
-    end = std::min(timespan_a.second, timespan_b.second);
-
-  ranges_out->push_back(std::make_pair(start, end));
+  return result;
 }
 
 bool ChunkDemuxer::AppendData(const std::string& id,
                               const uint8* data,
                               size_t length) {
   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
 
   DCHECK(!id.empty());
   DCHECK(data);
   DCHECK_GT(length, 0u);
 
-  int64 buffered_bytes = 0;
+  Ranges<TimeDelta> ranges;
 
   PipelineStatusCB cb;
   {
     base::AutoLock auto_lock(lock_);
 
     // Capture if the SourceBuffer has a pending seek before we start parsing.
     bool old_seek_pending = IsSeekPending_Locked();
 
     switch (state_) {
       case INITIALIZING:
@@ skipping 20 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_);
     }
 
-    buffered_bytes_ += length;
-    buffered_bytes = buffered_bytes_;
+    if (duration_ > TimeDelta() && duration_ != kInfiniteDuration()) {
+      if (audio_ && !video_) {
+        ranges = audio_->GetBufferedTime();
+      } else if (!audio_ && video_) {
+        ranges = video_->GetBufferedTime();
+      } else {
+        ranges = ComputeIntersection();
+      }
+    }
   }
 
-  // Notify the host of 'network activity' because we got data, using a bogus
-  // range.
-  host_->AddBufferedByteRange(0, buffered_bytes);
+  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);
+  }
 
   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 129 matching lines @@
 
   return seek_pending;
 }
 
 bool ChunkDemuxer::CanEndOfStream_Locked() const {
   lock_.AssertAcquired();
   return (!audio_ || audio_->CanEndOfStream()) &&
          (!video_ || video_->CanEndOfStream());
 }
 
-void ChunkDemuxer::OnStreamParserInitDone(bool success,
-                                          base::TimeDelta duration) {
+void ChunkDemuxer::OnStreamParserInitDone(bool success, TimeDelta duration) {
   DVLOG(1) << "OnSourceBufferInitDone(" << success << ", "
            << duration.InSecondsF() << ")";
   lock_.AssertAcquired();
   DCHECK_EQ(state_, INITIALIZING);
   if (!success || (!audio_ && !video_)) {
     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   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 57 matching lines @@
   return video_->Append(buffers);
 }
 
 bool ChunkDemuxer::OnNeedKey(scoped_array<uint8> init_data,
                              int init_data_size) {
   client_->DemuxerNeedKey(init_data.Pass(), init_data_size);
   return true;
 }
 
 void ChunkDemuxer::OnNewMediaSegment(const std::string& source_id,
-                                     base::TimeDelta start_timestamp) {
+                                     TimeDelta start_timestamp) {
   // 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