Update media duration if data is appended after the previous duration

media/filters/chunk_demuxer.cc

Index: media/filters/chunk_demuxer.cc
diff --git a/media/filters/chunk_demuxer.cc b/media/filters/chunk_demuxer.cc
index 067fc0eeea75ac72196934ee7e283f6ab01c6dd5..eeaf56748f4f50fcbc9edbe326c9c3067f2dfa90 100644
--- a/media/filters/chunk_demuxer.cc
+++ b/media/filters/chunk_demuxer.cc
@@ -523,8 +523,7 @@ ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
   DCHECK(client);
 }
 
-void ChunkDemuxer::Initialize(DemuxerHost* host,
-                              const PipelineStatusCB& cb) {
+void ChunkDemuxer::Initialize(DemuxerHost* host, const PipelineStatusCB& cb) {
   DVLOG(1) << "Init()";
   {
     base::AutoLock auto_lock(lock_);
@@ -788,13 +787,7 @@ bool ChunkDemuxer::AppendData(const std::string& id,
       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)
@@ -968,15 +961,13 @@ void ChunkDemuxer::OnStreamParserInitDone(bool success, TimeDelta duration) {
   }
 
   if (duration > duration_)
-    duration_ = duration;
+    UpdateDuration(duration);
 
   // Wait until all streams have initialized.
   if ((!source_id_audio_.empty() && !audio_) ||
       (!source_id_video_.empty() && !video_))
     return;
 
-  host_->SetDuration(duration_);
-
   ChangeState_Locked(WAITING_FOR_START_TIME);
 }
 
@@ -1035,12 +1026,15 @@ bool ChunkDemuxer::OnAudioBuffers(const StreamParser::BufferQueue& buffers) {
   AdjustBufferTimestamps(
       buffers, source_info_map_[source_id_audio_].timestamp_offset);
 
+  IncreaseDurationIfNecessary(buffers);
+
   return audio_->Append(buffers);
 }
 
 bool ChunkDemuxer::OnVideoBuffers(const StreamParser::BufferQueue& buffers) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
+  DCHECK(!buffers.empty());
 
   if (!video_)
     return false;
@@ -1049,6 +1043,8 @@ bool ChunkDemuxer::OnVideoBuffers(const StreamParser::BufferQueue& buffers) {
   AdjustBufferTimestamps(
       buffers, source_info_map_[source_id_video_].timestamp_offset);
 
+  IncreaseDurationIfNecessary(buffers);
+
   return video_->Append(buffers);
 }
 
@@ -1093,6 +1089,9 @@ void ChunkDemuxer::OnNewMediaSegment(const std::string& source_id,
     video_->Seek(start_time_);
   }
 
+  if (start_time_ > duration_)
+    UpdateDuration(start_time_);
+
   // The demuxer is now initialized after the |start_timestamp_| was set.
   ChangeState_Locked(INITIALIZED);
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
@@ -1123,4 +1122,31 @@ bool ChunkDemuxer::IsValidId(const std::string& source_id) const {
       stream_parser_map_.count(source_id) > 0u;
 }
 
+void ChunkDemuxer::UpdateDuration(base::TimeDelta new_duration) {
+  duration_ = new_duration;
+  host_->SetDuration(new_duration);
+}
+
+void ChunkDemuxer::IncreaseDurationIfNecessary(
+    const StreamParser::BufferQueue& buffers) {

[vrk (LEFT CHROMIUM), 2012/07/26 22:27:27]

This function was added to fix that problem we were discussing yesterday, where
the fudge room would push the last buffer over |duration_|, even though it's the
last buffer before end of stream. The way I'm fixing the problem is I'm only
updating the duration_ if the buffer's timestamp is greater than duration_, but
I use the buffered time (i.e. timestamp+fudge) as the value for the |duration_|
... if that makes sense!

+  if (buffers.back()->GetTimestamp() <= duration_)
+    return;
+
+  Ranges<TimeDelta> ranges = GetBufferedRanges();
+  base::TimeDelta last_timestamp_buffered = ranges.end(ranges.size() - 1);
+  DCHECK(last_timestamp_buffered > duration_);
+  UpdateDuration(last_timestamp_buffered);
+}
+
+Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
+  lock_.AssertAcquired();
+
+  if (audio_ && !video_)
+    return audio_->GetBufferedRanges();
+  else if (!audio_ && video_)
+    return video_->GetBufferedRanges();
+
+  return ComputeIntersection();
+}
+
 }  // namespace media