Update media duration if data is appended after the previous duration

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/callback_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 481 matching lines @@
 }
 
 ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
     : state_(WAITING_FOR_INIT),
       host_(NULL),
       client_(client),
       start_time_(kNoTimestamp()) {
   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_);
     DCHECK_EQ(state_, WAITING_FOR_INIT);
     host_ = host;
 
     ChangeState_Locked(INITIALIZING);
     init_cb_ = cb;
   }
 
@@ skipping 416 matching lines @@
 void ChunkDemuxer::OnStreamParserInitDone(bool success, TimeDelta duration) {
   DVLOG(1) << "OnStreamParserInitDone(" << 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;
+  if (duration != base::TimeDelta() && duration_ == base::TimeDelta())
+    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);
 }
 
 bool ChunkDemuxer::OnNewConfigs(bool has_audio, bool has_video,
                                 const AudioDecoderConfig& audio_config,
                                 const VideoDecoderConfig& video_config) {
   DVLOG(1) << "OnNewConfigs(" << has_audio << ", " << has_video
            << ", " << audio_config.IsValidConfig()
            << ", " << video_config.IsValidConfig() << ")";
   CHECK(audio_config.IsValidConfig() || video_config.IsValidConfig());
@@ skipping 38 matching lines @@
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
 
   if (!audio_)
     return false;
 
   CHECK(IsValidId(source_id_audio_));
   AdjustBufferTimestamps(
       buffers, source_info_map_[source_id_audio_].timestamp_offset);
 
-  return audio_->Append(buffers);
+  if (!audio_->Append(buffers))
+    return false;
+
+  IncreaseDurationIfNecessary(buffers, audio_);
+  return true;
 }
 
 bool ChunkDemuxer::OnVideoBuffers(const StreamParser::BufferQueue& buffers) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
 
   if (!video_)
     return false;
 
   CHECK(IsValidId(source_id_video_));
   AdjustBufferTimestamps(
       buffers, source_info_map_[source_id_video_].timestamp_offset);
 
-  return video_->Append(buffers);
+  if (!video_->Append(buffers))
+    return false;
+
+  IncreaseDurationIfNecessary(buffers, video_);
+  return true;
 }
 
 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,
                                      TimeDelta timestamp) {
   DVLOG(2) << "OnNewMediaSegment(" << source_id << ", "
            << timestamp.InSecondsF() << ")";
   lock_.AssertAcquired();
 
   CHECK(IsValidId(source_id));
   source_info_map_[source_id].can_update_offset = false;
   base::TimeDelta start_timestamp =
       timestamp + source_info_map_[source_id].timestamp_offset;
 
   if (start_time_ == kNoTimestamp()) {
     DCHECK(state_ == INITIALIZING || state_ == WAITING_FOR_START_TIME);
     // Use the first reported media segment start time as the |start_time_|
     // for the demuxer.
     start_time_ = start_timestamp;
+
+    // Ensure |duration_| is never before |start_time_|.
+    // TODO(vrk): We have to do this because there are places in the code that
+    // assumes the media duration is the same as the end time of the media
+    // stream. Fix this once crbug.com/137275 is addressed.
+    if (start_time_ > duration_)
+      UpdateDuration(start_time_);
   }
 
   if (audio_ && source_id == source_id_audio_)
     audio_->OnNewMediaSegment(start_timestamp);
   if (video_ && source_id == source_id_video_)
     video_->OnNewMediaSegment(start_timestamp);
 
   if (state_ != WAITING_FOR_START_TIME)
     return;
 
   if (audio_) {
     audio_->SetStartTime(start_time_);
     audio_->Seek(start_time_);
   }
   if (video_) {
     video_->SetStartTime(start_time_);
     video_->Seek(start_time_);
   }
 
+  if (duration_ == base::TimeDelta())
+    duration_ = kInfiniteDuration();
+
   // The demuxer is now initialized after the |start_timestamp_| was set.
   ChangeState_Locked(INITIALIZED);
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 void ChunkDemuxer::OnEndOfMediaSegment(const std::string& source_id) {
   DVLOG(2) << "OnEndOfMediaSegment(" << source_id << ")";
   CHECK(IsValidId(source_id));
   source_info_map_[source_id].can_update_offset = true;
 }
@@ skipping 10 matching lines @@
         (*itr)->GetDecodeTimestamp() + timestamp_offset);
     (*itr)->SetTimestamp((*itr)->GetTimestamp() + timestamp_offset);
   }
 }
 
 bool ChunkDemuxer::IsValidId(const std::string& source_id) const {
   return source_info_map_.count(source_id) > 0u &&
       stream_parser_map_.count(source_id) > 0u;
 }
 
+void ChunkDemuxer::UpdateDuration(base::TimeDelta new_duration) {
+  DCHECK(duration_ != new_duration);
+  duration_ = new_duration;
+  host_->SetDuration(new_duration);
+}
+
+void ChunkDemuxer::IncreaseDurationIfNecessary(
+    const StreamParser::BufferQueue& buffers,
+    const scoped_refptr<ChunkDemuxerStream>& stream) {
+  DCHECK(!buffers.empty());
+  if (buffers.back()->GetTimestamp() <= duration_)
+    return;
+
+  Ranges<TimeDelta> ranges = stream->GetBufferedRanges();
+  DCHECK_GT(ranges.size(), 0u);
+
+  base::TimeDelta last_timestamp_buffered = ranges.end(ranges.size() - 1);
+  if (last_timestamp_buffered > duration_)
+    UpdateDuration(last_timestamp_buffered);
+}
+
 }  // namespace media