Fix WebM parser not to wait for a next frame when DefaultDuration is specified.

media/formats/webm/webm_cluster_parser.cc

 // Copyright 2014 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/formats/webm/webm_cluster_parser.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/sys_byteorder.h"
@@ skipping 95 matching lines @@
 
     last_block_timecode_ = -1;
     cluster_timecode_ = -1;
   }
 
   return result;
 }
 
 const WebMClusterParser::BufferQueue& WebMClusterParser::GetAudioBuffers() {
   if (cluster_ended_)
-    audio_.ApplyDurationDefaultOrEstimateIfNeeded();
+    audio_.ApplyDurationEstimateIfNeeded();
   return audio_.buffers();
 }
 
 const WebMClusterParser::BufferQueue& WebMClusterParser::GetVideoBuffers() {
   if (cluster_ended_)
-    video_.ApplyDurationDefaultOrEstimateIfNeeded();
+    video_.ApplyDurationEstimateIfNeeded();
   return video_.buffers();
 }
 
 const WebMClusterParser::TextBufferQueueMap&
 WebMClusterParser::GetTextBuffers() {
   // Translate our |text_track_map_| into |text_buffers_map_|, inserting rows in
   // the output only for non-empty text buffer queues in |text_track_map_|.
   text_buffers_map_.clear();
   for (TextTrackMap::const_iterator itr = text_track_map_.begin();
        itr != text_track_map_.end();
        ++itr) {
     // Per OnBlock(), all text buffers should already have valid durations, so
     // there is no need to call
-    // itr->second.ApplyDurationDefaultOrEstimateIfNeeded() here.
+    // itr->second.ApplyDurationEstimateIfNeeded() here.
     const BufferQueue& text_buffers = itr->second.buffers();
     if (!text_buffers.empty())
       text_buffers_map_.insert(std::make_pair(itr->first, text_buffers));
   }
 
   return text_buffers_map_;
 }
 
 WebMParserClient* WebMClusterParser::OnListStart(int id) {
   if (id == kWebMIdCluster) {
@@ skipping 253 matching lines @@
         true, buffer_type, track_num);
   }
 
   buffer->set_timestamp(timestamp);
   if (cluster_start_time_ == kNoTimestamp())
     cluster_start_time_ = timestamp;
 
   if (block_duration >= 0) {
     buffer->set_duration(base::TimeDelta::FromMicroseconds(
         block_duration * timecode_multiplier_));
+  } else {
+    DCHECK_NE(buffer_type, DemuxerStream::TEXT);
+    buffer->set_duration(track->default_duration());
   }
 
   if (discard_padding != 0) {
     buffer->set_discard_padding(base::TimeDelta::FromMicroseconds(
                                     discard_padding / 1000));
   }
 
   return track->AddBuffer(buffer);
 }
 
@@ skipping 38 matching lines @@
 
   if (buffer->duration() == kNoTimestamp()) {
     last_added_buffer_missing_duration_ = buffer;
     DVLOG(2) << "AddBuffer() : holding back buffer that is missing duration";
     return true;
   }
 
   return QueueBuffer(buffer);
 }
 
-void WebMClusterParser::Track::ApplyDurationDefaultOrEstimateIfNeeded() {
+void WebMClusterParser::Track::ApplyDurationEstimateIfNeeded() {
   if (!last_added_buffer_missing_duration_)
     return;
 
-  last_added_buffer_missing_duration_->set_duration(
-      GetDurationDefaultOrEstimate());
+  last_added_buffer_missing_duration_->set_duration(GetDurationEstimate());
 
-  DVLOG(2) << "ApplyDurationDefaultOrEstimateIfNeeded() : new dur : "
+  DVLOG(2) << "ApplyDurationEstimateIfNeeded() : new dur : "
            << " ts "
            << last_added_buffer_missing_duration_->timestamp().InSecondsF()
            << " dur "
            << last_added_buffer_missing_duration_->duration().InSecondsF()
            << " kf " << last_added_buffer_missing_duration_->IsKeyframe()
            << " size " << last_added_buffer_missing_duration_->data_size();
 
   // Don't use the applied duration as a future estimation (don't use
   // QueueBuffer() here.)
   buffers_.push_back(last_added_buffer_missing_duration_);
@@ skipping 43 matching lines @@
              << duration.InSecondsF();
     return false;
   }
 
   estimated_next_frame_duration_ = std::max(duration,
                                             estimated_next_frame_duration_);
   buffers_.push_back(buffer);
   return true;
 }
 
-base::TimeDelta WebMClusterParser::Track::GetDurationDefaultOrEstimate() {
-  base::TimeDelta duration = default_duration_;
+base::TimeDelta WebMClusterParser::Track::GetDurationEstimate() {
+  base::TimeDelta duration = estimated_next_frame_duration_;
   if (duration != kNoTimestamp()) {
-    DVLOG(3) << __FUNCTION__ << " : using TrackEntry DefaultDuration";
-  } else if (estimated_next_frame_duration_ != kNoTimestamp()) {
     DVLOG(3) << __FUNCTION__ << " : using estimated duration";
-    duration = estimated_next_frame_duration_;
   } else {
     DVLOG(3) << __FUNCTION__ << " : using hardcoded default duration";
     if (is_video_) {
       duration = base::TimeDelta::FromMilliseconds(
           kDefaultVideoBufferDurationInMs);
     } else {
       duration = base::TimeDelta::FromMilliseconds(
           kDefaultAudioBufferDurationInMs);
     }
   }
@@ skipping 16 matching lines @@
 WebMClusterParser::FindTextTrack(int track_num) {
   const TextTrackMap::iterator it = text_track_map_.find(track_num);
 
   if (it == text_track_map_.end())
     return NULL;
 
   return &it->second;
 }
 
 }  // namespace media