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

media/formats/mp2t/mp2t_stream_parser_unittest.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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
@@ skipping 19 matching lines @@
 
   StreamParser::BufferQueue::const_iterator it1 = buffers.begin();
   StreamParser::BufferQueue::const_iterator it2 = ++it1;
   for ( ; it2 != buffers.end(); ++it1, ++it2) {
     if ((*it2)->GetDecodeTimestamp() < (*it1)->GetDecodeTimestamp())
       return false;
   }
   return true;
 }
 
-bool IsAlmostEqual(base::TimeDelta t0, base::TimeDelta t1) {
+bool IsAlmostEqual(DecodeTimestamp t0, DecodeTimestamp t1) {
   base::TimeDelta kMaxDeviation = base::TimeDelta::FromMilliseconds(5);
   base::TimeDelta diff = t1 - t0;
   return (diff >= -kMaxDeviation && diff <= kMaxDeviation);
 }
 
 }  // namespace
 
 class Mp2tStreamParserTest : public testing::Test {
  public:
   Mp2tStreamParserTest()
       : segment_count_(0),
         config_count_(0),
         audio_frame_count_(0),
         video_frame_count_(0),
-        audio_min_dts_(kNoTimestamp()),
-        audio_max_dts_(kNoTimestamp()),
-        video_min_dts_(kNoTimestamp()),
-        video_max_dts_(kNoTimestamp()) {
+        audio_min_dts_(kNoDecodeTimestamp()),
+        audio_max_dts_(kNoDecodeTimestamp()),
+        video_min_dts_(kNoDecodeTimestamp()),
+        video_max_dts_(kNoDecodeTimestamp()) {
     bool has_sbr = false;
     parser_.reset(new Mp2tStreamParser(has_sbr));
   }
 
  protected:
   scoped_ptr<Mp2tStreamParser> parser_;
   int segment_count_;
   int config_count_;
   int audio_frame_count_;
   int video_frame_count_;
-  base::TimeDelta audio_min_dts_;
-  base::TimeDelta audio_max_dts_;
-  base::TimeDelta video_min_dts_;
-  base::TimeDelta video_max_dts_;
+  DecodeTimestamp audio_min_dts_;
+  DecodeTimestamp audio_max_dts_;
+  DecodeTimestamp video_min_dts_;
+  DecodeTimestamp video_max_dts_;
 
   void ResetStats() {
     segment_count_ = 0;
     config_count_ = 0;
     audio_frame_count_ = 0;
     video_frame_count_ = 0;
-    audio_min_dts_ = kNoTimestamp();
-    audio_max_dts_ = kNoTimestamp();
-    video_min_dts_ = kNoTimestamp();
-    video_max_dts_ = kNoTimestamp();
+    audio_min_dts_ = kNoDecodeTimestamp();
+    audio_max_dts_ = kNoDecodeTimestamp();
+    video_min_dts_ = kNoDecodeTimestamp();
+    video_max_dts_ = kNoDecodeTimestamp();
   }
 
   bool AppendData(const uint8* data, size_t length) {
     return parser_->Parse(data, length);
   }
 
   bool AppendDataInPieces(const uint8* data, size_t length, size_t piece_size) {
     const uint8* start = data;
     const uint8* end = data + length;
     while (start < end) {
@@ skipping 49 matching lines @@
     if (!text_map.empty())
       return false;
 
     // Verify monotonicity.
     if (!IsMonotonic(video_buffers))
       return false;
     if (!IsMonotonic(audio_buffers))
       return false;
 
     if (!video_buffers.empty()) {
-      base::TimeDelta first_dts = video_buffers.front()->GetDecodeTimestamp();
-      base::TimeDelta last_dts = video_buffers.back()->GetDecodeTimestamp();
-      if (video_max_dts_ != kNoTimestamp() && first_dts < video_max_dts_)
+      DecodeTimestamp first_dts = video_buffers.front()->GetDecodeTimestamp();
+      DecodeTimestamp last_dts = video_buffers.back()->GetDecodeTimestamp();
+      if (video_max_dts_ != kNoDecodeTimestamp() && first_dts < video_max_dts_)
         return false;
-      if (video_min_dts_ == kNoTimestamp())
+      if (video_min_dts_ == kNoDecodeTimestamp())
         video_min_dts_ = first_dts;
       video_max_dts_ = last_dts;
     }
     if (!audio_buffers.empty()) {
-      base::TimeDelta first_dts = audio_buffers.front()->GetDecodeTimestamp();
-      base::TimeDelta last_dts = audio_buffers.back()->GetDecodeTimestamp();
-      if (audio_max_dts_ != kNoTimestamp() && first_dts < audio_max_dts_)
+      DecodeTimestamp first_dts = audio_buffers.front()->GetDecodeTimestamp();
+      DecodeTimestamp last_dts = audio_buffers.back()->GetDecodeTimestamp();
+      if (audio_max_dts_ != kNoDecodeTimestamp() && first_dts < audio_max_dts_)
         return false;
-      if (audio_min_dts_ == kNoTimestamp())
+      if (audio_min_dts_ == kNoDecodeTimestamp())
         audio_min_dts_ = first_dts;
       audio_max_dts_ = last_dts;
     }
 
     audio_frame_count_ += audio_buffers.size();
     video_frame_count_ += video_buffers.size();
     return true;
   }
 
   void OnKeyNeeded(const std::string& type,
@@ skipping 79 matching lines @@
   // "bear-1280x720_ptswraparound.ts" has been transcoded
   // from bear-1280x720.mp4 by applying a time offset of 95442s
   // (close to 2^33 / 90000) which results in timestamps wrap around
   // in the Mpeg2 TS stream.
   InitializeParser();
   ParseMpeg2TsFile("bear-1280x720_ptswraparound.ts", 512);
   parser_->Flush();
   EXPECT_EQ(video_frame_count_, 82);
 
   EXPECT_TRUE(IsAlmostEqual(video_min_dts_,
-                            base::TimeDelta::FromSecondsD(95443.376)));
+                            DecodeTimestamp::FromSecondsD(95443.376)));
   EXPECT_TRUE(IsAlmostEqual(video_max_dts_,
-                            base::TimeDelta::FromSecondsD(95446.079)));
+                            DecodeTimestamp::FromSecondsD(95446.079)));
 
   // Note: for audio, AdtsStreamParser considers only the PTS (which is then
   // used as the DTS).
   // TODO(damienv): most of the time, audio streams just have PTS. Here, only
   // the first PES packet has a DTS, all the other PES packets have PTS only.
   // Reconsider the expected value for |audio_min_dts_| if DTS are used as part
   // of the ADTS stream parser.
   //
   // Note: the last pts for audio is 95445.931 but this PES packet includes
   // 9 ADTS frames with 1 AAC frame in each ADTS frame.
   // So the PTS of the last AAC frame is:
   // 95445.931 + 8 * (1024 / 44100) = 95446.117
   EXPECT_TRUE(IsAlmostEqual(audio_min_dts_,
-                            base::TimeDelta::FromSecondsD(95443.400)));
+                            DecodeTimestamp::FromSecondsD(95443.400)));
   EXPECT_TRUE(IsAlmostEqual(audio_max_dts_,
-                            base::TimeDelta::FromSecondsD(95446.117)));
+                            DecodeTimestamp::FromSecondsD(95446.117)));
 }
 
 }  // namespace mp2t
 }  // namespace media