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_);
+  bool success = false;
 
-  // 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_|

[acolwell GONE FROM CHROMIUM, 2012/06/12 22:48:13]

Move this to a helper method so we don't have duplicate code below. Something
along the lines of bool CopyIntoRanges(const SourceBufferStream::TimespanList&
timespans, Ranges* ranges_out);

[annacc, 2012/06/13 00:00:01]

Done.

+    SourceBufferStream::TimespanList audio_ranges = audio_->GetBufferedTime();
+    for (SourceBufferStream::TimespanList::iterator itr = audio_ranges.begin();
+         itr != audio_ranges.end(); ++itr) {
+      ranges_out->push_back(*itr);
+      success = true;
+    }
+    return success;
+  }
+
+  if (id != source_id_audio_ && id == source_id_video_) {
+    // Only include ranges that have been buffered in |video_|
+    SourceBufferStream::TimespanList video_ranges = video_->GetBufferedTime();
+    for (SourceBufferStream::TimespanList::iterator itr = video_ranges.begin();
+         itr != video_ranges.end(); ++itr) {
+      ranges_out->push_back(*itr);
+      success = true;
+    }
+    return success;
+  }
+
+  // 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();
+
+  while (audio_ranges_itr != audio_ranges.end() &&
+         video_ranges_itr != video_ranges.end()) {
+

[acolwell GONE FROM CHROMIUM, 2012/06/12 22:48:13]

Precompute the "last ranges" condition into a bool here instead of in
AddIntersectionRange() & use (itr + 1) instead of next(). Pass this bool into
the AddIntersectionRange() instead of the iterators. I think that will make
things easier to read.

[annacc, 2012/06/13 00:00:01]

Done.

+    // 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,

[acolwell GONE FROM CHROMIUM, 2012/06/12 22:48:13]

How about passing in *xxx_itr instead of the iterator itself and moving the
iterator increment outside of   AddIntersectionRange()? I think it would make
the body of  AddIntersectionRange() easier to read.

[annacc, 2012/06/13 00:00:01]

I think I've realized your suggestion here, but you should check :)

+                           audio_ranges.end(), video_ranges.end(),
+                           ranges_out);
+      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,
+                           video_ranges.end(), audio_ranges.end(),
+                           ranges_out);
+      success = true;
+      continue;
+    }
+
+    // No overlap was found.  Increment the smallest one and keep looking.

[acolwell GONE FROM CHROMIUM, 2012/06/12 22:48:13]

nit: smallest -> earliest?

[annacc, 2012/06/13 00:00:01]

Done.

+    if ((*audio_ranges_itr).first < (*video_ranges_itr).first)
+      audio_ranges_itr++;
+    else
+      video_ranges_itr++;
+  }
+
+  return success;
+}
+
+void ChunkDemuxer::AddIntersectionRange(
+    SourceBufferStream::TimespanList::const_iterator& itr_a,
+    SourceBufferStream::TimespanList::const_iterator& itr_b,
+    SourceBufferStream::TimespanList::const_iterator itr_a_end,
+    SourceBufferStream::TimespanList::const_iterator itr_b_end,
+    Ranges* ranges_out) const {
+  base::TimeDelta start = (*itr_a).first;
+
+  // 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.
+  base::TimeDelta end;
+  if (state_ == ENDED &&
+      next(itr_a) == itr_a_end &&

[acolwell GONE FROM CHROMIUM, 2012/06/12 22:48:13]

nit: Use (itr_a + 1) instead.

[annacc, 2012/06/13 00:00:01]

Done.

+      next(itr_b) == itr_b_end) {
+    end = std::max((*itr_a).second, (*itr_b).second);
+  } else {
+    end = std::min((*itr_a).second, (*itr_b).second);
+  }
+
+  ranges_out->push_back(std::make_pair(start, end));
+
+  itr_a++;
+}
+
+SourceBufferStream::TimespanList::const_iterator ChunkDemuxer::next(

[acolwell GONE FROM CHROMIUM, 2012/06/12 22:48:13]

nit: I'd prefer you use (itr + 1) instead of defining this method.

[annacc, 2012/06/13 00:00:01]

Done.

+      SourceBufferStream::TimespanList::const_iterator itr) const {
+  return ++itr;
 }
 
 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