Introduce DecodeTimestamp class to make it easier to distiguish presentation and decode timestamps.

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 26 matching lines @@
       block_data_size_(-1),
       block_duration_(-1),
       block_add_id_(-1),
       block_additional_data_size_(-1),
       discard_padding_(-1),
       cluster_timecode_(-1),
       cluster_start_time_(kNoTimestamp()),
       cluster_ended_(false),
       audio_(audio_track_num, false, audio_default_duration, log_cb),
       video_(video_track_num, true, video_default_duration, log_cb),
-      ready_buffer_upper_bound_(kNoTimestamp()),
+      ready_buffer_upper_bound_(kNoDecodeTimestamp()),
       log_cb_(log_cb) {
   for (WebMTracksParser::TextTracks::const_iterator it = text_tracks.begin();
        it != text_tracks.end();
        ++it) {
     text_track_map_.insert(std::make_pair(
         it->first, Track(it->first, false, kNoTimestamp(), log_cb_)));
   }
 }
 
 WebMClusterParser::~WebMClusterParser() {}
 
 void WebMClusterParser::Reset() {
   last_block_timecode_ = -1;
   cluster_timecode_ = -1;
   cluster_start_time_ = kNoTimestamp();
   cluster_ended_ = false;
   parser_.Reset();
   audio_.Reset();
   video_.Reset();
   ResetTextTracks();
-  ready_buffer_upper_bound_ = kNoTimestamp();
+  ready_buffer_upper_bound_ = kNoDecodeTimestamp();
 }
 
 int WebMClusterParser::Parse(const uint8* buf, int size) {
   audio_.ClearReadyBuffers();
   video_.ClearReadyBuffers();
   ClearTextTrackReadyBuffers();
-  ready_buffer_upper_bound_ = kNoTimestamp();
+  ready_buffer_upper_bound_ = kNoDecodeTimestamp();
 
   int result = parser_.Parse(buf, size);
 
   if (result < 0) {
     cluster_ended_ = false;
     return result;
   }
 
   cluster_ended_ = parser_.IsParsingComplete();
   if (cluster_ended_) {
@@ skipping 15 matching lines @@
     parser_.Reset();
 
     last_block_timecode_ = -1;
     cluster_timecode_ = -1;
   }
 
   return result;
 }
 
 const WebMClusterParser::BufferQueue& WebMClusterParser::GetAudioBuffers() {
-  if (ready_buffer_upper_bound_ == kNoTimestamp())
+  if (ready_buffer_upper_bound_ == kNoDecodeTimestamp())
     UpdateReadyBuffers();
 
   return audio_.ready_buffers();
 }
 
 const WebMClusterParser::BufferQueue& WebMClusterParser::GetVideoBuffers() {
-  if (ready_buffer_upper_bound_ == kNoTimestamp())
+  if (ready_buffer_upper_bound_ == kNoDecodeTimestamp())
     UpdateReadyBuffers();
 
   return video_.ready_buffers();
 }
 
 const WebMClusterParser::TextBufferQueueMap&
 WebMClusterParser::GetTextBuffers() {
-  if (ready_buffer_upper_bound_ == kNoTimestamp())
+  if (ready_buffer_upper_bound_ == kNoDecodeTimestamp())
     UpdateReadyBuffers();
 
   // Translate our |text_track_map_| into |text_buffers_map_|, inserting rows in
   // the output only for non-empty ready_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) {
     const BufferQueue& text_buffers = itr->second.ready_buffers();
     if (!text_buffers.empty())
@@ skipping 295 matching lines @@
       is_video_(is_video),
       default_duration_(default_duration),
       estimated_next_frame_duration_(kNoTimestamp()),
       log_cb_(log_cb) {
   DCHECK(default_duration_ == kNoTimestamp() ||
          default_duration_ > base::TimeDelta());
 }
 
 WebMClusterParser::Track::~Track() {}
 
-base::TimeDelta WebMClusterParser::Track::GetReadyUpperBound() {
+DecodeTimestamp WebMClusterParser::Track::GetReadyUpperBound() {
   DCHECK(ready_buffers_.empty());
   if (last_added_buffer_missing_duration_)
     return last_added_buffer_missing_duration_->GetDecodeTimestamp();
 
-  return kInfiniteDuration();
+  return DecodeTimestamp::FromPresentationTime(kInfiniteDuration());

[wolenetz, 2014/08/08 21:30:05]

nit: We have an explicit kNoDecodeTimestamp(). Does an explicit
kInfiniteDecodeTimestamp() make sense for consistency?

[acolwell GONE FROM CHROMIUM, 2014/08/11 17:05:06]

I don't think it is worth it since I'm pretty sure this is the only usage. I've
changed the code to explicitly use base::TimeDelta::Max() since really that is
what this code cares about and it doesn't really have anything to do with
duration.

[wolenetz, 2014/08/12 00:09:00]

Acknowledged.

 }
 
 void WebMClusterParser::Track::ExtractReadyBuffers(
-    const base::TimeDelta before_timestamp) {
+    const DecodeTimestamp before_timestamp) {
   DCHECK(ready_buffers_.empty());
-  DCHECK(base::TimeDelta() <= before_timestamp);
-  DCHECK(kNoTimestamp() != before_timestamp);
+  DCHECK(DecodeTimestamp() <= before_timestamp);
+  DCHECK(kNoDecodeTimestamp() != before_timestamp);
 
   if (buffers_.empty())
     return;
 
   if (buffers_.back()->GetDecodeTimestamp() < before_timestamp) {
     // All of |buffers_| are ready.
     ready_buffers_.swap(buffers_);
     DVLOG(3) << __FUNCTION__ << " : " << track_num_ << " All "
              << ready_buffers_.size() << " are ready: before upper bound ts "
              << before_timestamp.InSecondsF();
@@ skipping 107 matching lines @@
   return true;
 }
 
 bool WebMClusterParser::Track::QueueBuffer(
     const scoped_refptr<StreamParserBuffer>& buffer) {
   DCHECK(!last_added_buffer_missing_duration_);
 
   // WebMClusterParser::OnBlock() gives MEDIA_LOG and parse error on decreasing
   // block timecode detection within a cluster. Therefore, we should not see
   // those here.
-  base::TimeDelta previous_buffers_timestamp = buffers_.empty() ?
-      base::TimeDelta() : buffers_.back()->GetDecodeTimestamp();
+  DecodeTimestamp previous_buffers_timestamp = buffers_.empty() ?
+      DecodeTimestamp() : buffers_.back()->GetDecodeTimestamp();
   CHECK(previous_buffers_timestamp <= buffer->GetDecodeTimestamp());
 
   base::TimeDelta duration = buffer->duration();
   if (duration < base::TimeDelta() || duration == kNoTimestamp()) {
     MEDIA_LOG(log_cb_) << "Invalid buffer duration: " << duration.InSecondsF();
     return false;
   }
 
   // The estimated frame duration is the minimum non-zero duration since the
   // last initialization segment.  The minimum is used to ensure frame durations
@@ skipping 43 matching lines @@
 void WebMClusterParser::ResetTextTracks() {
   ClearTextTrackReadyBuffers();
   for (TextTrackMap::iterator it = text_track_map_.begin();
        it != text_track_map_.end();
        ++it) {
     it->second.Reset();
   }
 }
 
 void WebMClusterParser::UpdateReadyBuffers() {
-  DCHECK(ready_buffer_upper_bound_ == kNoTimestamp());
+  DCHECK(ready_buffer_upper_bound_ == kNoDecodeTimestamp());
   DCHECK(text_buffers_map_.empty());
 
   if (cluster_ended_) {
     audio_.ApplyDurationEstimateIfNeeded();
     video_.ApplyDurationEstimateIfNeeded();
     // Per OnBlock(), all text buffers should already have valid durations, so
     // there is no need to call ApplyDurationEstimateIfNeeded() on text tracks
     // here.
-    ready_buffer_upper_bound_ = kInfiniteDuration();
+    ready_buffer_upper_bound_ =
+        DecodeTimestamp::FromPresentationTime(kInfiniteDuration());
     DCHECK(ready_buffer_upper_bound_ == audio_.GetReadyUpperBound());
     DCHECK(ready_buffer_upper_bound_ == video_.GetReadyUpperBound());
   } else {
     ready_buffer_upper_bound_ = std::min(audio_.GetReadyUpperBound(),
                                          video_.GetReadyUpperBound());
-    DCHECK(base::TimeDelta() <= ready_buffer_upper_bound_);
-    DCHECK(kNoTimestamp() != ready_buffer_upper_bound_);
+    DCHECK(DecodeTimestamp() <= ready_buffer_upper_bound_);
+    DCHECK(kNoDecodeTimestamp() != ready_buffer_upper_bound_);
   }
 
   // Prepare each track's ready buffers for retrieval.
   audio_.ExtractReadyBuffers(ready_buffer_upper_bound_);
   video_.ExtractReadyBuffers(ready_buffer_upper_bound_);
   for (TextTrackMap::iterator itr = text_track_map_.begin();
        itr != text_track_map_.end();
        ++itr) {
     itr->second.ExtractReadyBuffers(ready_buffer_upper_bound_);
   }
 }
 
 WebMClusterParser::Track*
 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