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

media/formats/mp4/track_run_iterator_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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "media/formats/mp4/box_definitions.h"
 #include "media/formats/mp4/rcheck.h"
@@ skipping 273 matching lines @@
   MovieFragment moof = CreateFragment();
 
   // Test that runs are sorted correctly, and that properties of the initial
   // sample of the first run are correct
   ASSERT_TRUE(iter_->Init(moof));
   EXPECT_TRUE(iter_->IsRunValid());
   EXPECT_FALSE(iter_->is_encrypted());
   EXPECT_EQ(iter_->track_id(), 1u);
   EXPECT_EQ(iter_->sample_offset(), 100);
   EXPECT_EQ(iter_->sample_size(), 1);
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(0, kAudioScale));
+  EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(0, kAudioScale));
   EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(0, kAudioScale));
   EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(1024, kAudioScale));
   EXPECT_TRUE(iter_->is_keyframe());
 
   // Advance to the last sample in the current run, and test its properties
   for (int i = 0; i < 9; i++) iter_->AdvanceSample();
   EXPECT_EQ(iter_->track_id(), 1u);
   EXPECT_EQ(iter_->sample_offset(), 100 + kSumAscending1);
   EXPECT_EQ(iter_->sample_size(), 10);
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(1024 * 9, kAudioScale));
+  EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(1024 * 9, kAudioScale));
   EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(1024, kAudioScale));
   EXPECT_TRUE(iter_->is_keyframe());
 
   // Test end-of-run
   iter_->AdvanceSample();
   EXPECT_FALSE(iter_->IsSampleValid());
 
   // Test last sample of next run
   iter_->AdvanceRun();
   EXPECT_TRUE(iter_->is_keyframe());
   for (int i = 0; i < 9; i++) iter_->AdvanceSample();
   EXPECT_EQ(iter_->track_id(), 2u);
   EXPECT_EQ(iter_->sample_offset(), 200 + kSumAscending1);
   EXPECT_EQ(iter_->sample_size(), 10);
   int64 base_dts = kSumAscending1 + moof.tracks[1].decode_time.decode_time;
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(base_dts, kVideoScale));
+  EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(base_dts, kVideoScale));
   EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(10, kVideoScale));
   EXPECT_FALSE(iter_->is_keyframe());
 
   // Test final run
   iter_->AdvanceRun();
   EXPECT_EQ(iter_->track_id(), 1u);
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(1024 * 10, kAudioScale));
+  EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(1024 * 10, kAudioScale));
   iter_->AdvanceSample();
   EXPECT_EQ(moof.tracks[0].runs[1].data_offset +
             moof.tracks[0].header.default_sample_size,
             iter_->sample_offset());
   iter_->AdvanceRun();
   EXPECT_FALSE(iter_->IsRunValid());
 }
 
 TEST_F(TrackRunIteratorTest, TrackExtendsDefaultsTest) {
   moov_.extends.tracks[0].default_sample_duration = 50;
   moov_.extends.tracks[0].default_sample_size = 3;
   moov_.extends.tracks[0].default_sample_flags = ToSampleFlags("UN");
   iter_.reset(new TrackRunIterator(&moov_, log_cb_));
   MovieFragment moof = CreateFragment();
   moof.tracks[0].header.has_default_sample_flags = false;
   moof.tracks[0].header.default_sample_size = 0;
   moof.tracks[0].header.default_sample_duration = 0;
   moof.tracks[0].runs[0].sample_sizes.clear();
   ASSERT_TRUE(iter_->Init(moof));
   iter_->AdvanceSample();
   EXPECT_FALSE(iter_->is_keyframe());
   EXPECT_EQ(iter_->sample_size(), 3);
   EXPECT_EQ(iter_->sample_offset(), moof.tracks[0].runs[0].data_offset + 3);
   EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(50, kAudioScale));
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(50, kAudioScale));
+  EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(50, kAudioScale));
 }
 
 TEST_F(TrackRunIteratorTest, FirstSampleFlagTest) {
   // Ensure that keyframes are flagged correctly in the face of BMFF boxes which
   // explicitly specify the flags for the first sample in a run and rely on
   // defaults for all subsequent samples
   iter_.reset(new TrackRunIterator(&moov_, log_cb_));
   MovieFragment moof = CreateFragment();
   moof.tracks[1].header.has_default_sample_flags = true;
   moof.tracks[1].header.default_sample_flags = ToSampleFlags("UN");
@@ skipping 38 matching lines @@
   std::vector<int32>& cts_offsets =
     moof.tracks[1].runs[0].sample_composition_time_offsets;
   cts_offsets.resize(10);
   cts_offsets[0] = 2;
   cts_offsets[1] = 5;
   cts_offsets[2] = 0;
   moof.tracks[1].decode_time.decode_time = 0;
 
   ASSERT_TRUE(iter_->Init(moof));
   iter_->AdvanceRun();
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(0, kVideoScale));
+  EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(0, kVideoScale));
   EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(0, kVideoScale));
   EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(1, kVideoScale));
   iter_->AdvanceSample();
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(1, kVideoScale));
+  EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(1, kVideoScale));
   EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(4, kVideoScale));
   EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(2, kVideoScale));
   iter_->AdvanceSample();
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(3, kVideoScale));
+  EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(3, kVideoScale));
   EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(1, kVideoScale));
   EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(3, kVideoScale));
 }
 
 TEST_F(TrackRunIteratorTest, IgnoreUnknownAuxInfoTest) {
   iter_.reset(new TrackRunIterator(&moov_, log_cb_));
   MovieFragment moof = CreateFragment();
   moof.tracks[1].auxiliary_offset.offsets.push_back(50);
   moof.tracks[1].auxiliary_size.default_sample_info_size = 2;
   moof.tracks[1].auxiliary_size.sample_count = 2;
@@ skipping 227 matching lines @@
 
   iter_->AdvanceRun();
 
   // Verify that nothing is marked as a random access point.
   EXPECT_EQ("2 KR P PR P KR K", KeyframeAndRAPInfo(iter_.get()));
 }
 
 
 }  // namespace mp4
 }  // namespace media