Calculate the buffered ranges in ChunkDemuxer::GetBufferedRanges()

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 "media/base/audio_decoder_config.h"
@@ skipping 115 matching lines @@
 
   void StartWaitingForSeek();
   void Seek(base::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 a list of the buffered time ranges.
+  SourceBufferStream::TimespanList GetBufferedTime() const;
+
   // 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 93 matching lines @@
     }
     CreateReadDoneClosures_Locked(&closures);
   }
 
   for (ClosureQueue::iterator it = closures.begin(); it != closures.end(); ++it)
     it->Run();
 
   return true;
 }
 
+SourceBufferStream::TimespanList 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();
 
   bool success = (current_config.codec() == config.codec()) &&
       (current_config.bits_per_channel() == config.bits_per_channel()) &&
       (current_config.channel_layout() == config.channel_layout()) &&
@@ skipping 314 matching lines @@
     audio_->Shutdown();
 
   if (source_id_video_ == id && video_)
     video_->Shutdown();
 }
 
 bool ChunkDemuxer::GetBufferedRanges(const std::string& id,
                                      Ranges* ranges_out) 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_);
 
-  // TODO(annacc): Calculate buffered ranges (http://crbug.com/129852 ).
-  return false;
+  if (id == source_id_audio_ && id != source_id_video_) {
+    // Only include ranges that have been buffered in |audio_|
+    return CopyIntoRanges(audio_->GetBufferedTime(), ranges_out);
+  }
+
+  if (id != source_id_audio_ && id == source_id_video_) {
+    // Only include ranges that have been buffered in |video_|
+    return CopyIntoRanges(video_->GetBufferedTime(), ranges_out);
+  }
+
+  // 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;
+
+  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();
+
+    // 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;
+    }
+
+    // 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));
 }
 
 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);
@@ skipping 286 matching lines @@
   return true;
 }
 
 bool ChunkDemuxer::OnKeyNeeded(scoped_array<uint8> init_data,
                                int init_data_size) {
   client_->KeyNeeded(init_data.Pass(), init_data_size);
   return true;
 }
 
 }  // namespace media