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

media/formats/mp4/track_run_iterator.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/mp4/track_run_iterator.h"
 
 #include <algorithm>
 
 #include "media/base/buffers.h"
-#include "media/base/stream_parser_buffer.h"
 #include "media/formats/mp4/rcheck.h"
 #include "media/formats/mp4/sample_to_group_iterator.h"
 
 namespace media {
 namespace mp4 {
 
 struct SampleInfo {
   int size;
   int duration;
   int cts_offset;
@@ skipping 29 matching lines @@
       timescale(-1),
       start_dts(-1),
       sample_start_offset(-1),
       is_audio(false),
       aux_info_start_offset(-1),
       aux_info_default_size(-1),
       aux_info_total_size(-1) {
 }
 TrackRunInfo::~TrackRunInfo() {}
 
-TimeDelta TimeDeltaFromRational(int64 numer, int64 denom) {
+base::TimeDelta TimeDeltaFromRational(int64 numer, int64 denom) {
   // To avoid overflow, split the following calculation:
   // (numer * base::Time::kMicrosecondsPerSecond) / denom
   // into:
   //  (numer / denom) * base::Time::kMicrosecondsPerSecond +
   // ((numer % denom) * base::Time::kMicrosecondsPerSecond) / denom
   int64 a = numer / denom;
   DCHECK_LE((a > 0 ? a : -a), kint64max / base::Time::kMicrosecondsPerSecond);
   int64 timea_in_us = a * base::Time::kMicrosecondsPerSecond;
 
   int64 b = numer % denom;
   DCHECK_LE((b > 0 ? b : -b), kint64max / base::Time::kMicrosecondsPerSecond);
   int64 timeb_in_us = (b * base::Time::kMicrosecondsPerSecond) / denom;
 
   DCHECK((timeb_in_us < 0) || (timea_in_us <= kint64max - timeb_in_us));
   DCHECK((timeb_in_us > 0) || (timea_in_us >= kint64min - timeb_in_us));
-  return TimeDelta::FromMicroseconds(timea_in_us + timeb_in_us);
+  return base::TimeDelta::FromMicroseconds(timea_in_us + timeb_in_us);
+}
+
+DecodeTimestamp DecodeTimestampFromRational(int64 numer, int64 denom) {
+  return DecodeTimestamp::FromPresentationTime(
+      TimeDeltaFromRational(numer, denom));
 }
 
 TrackRunIterator::TrackRunIterator(const Movie* moov,
                                    const LogCB& log_cb)
     : moov_(moov), log_cb_(log_cb), sample_offset_(0) {
   CHECK(moov);
 }
 
 TrackRunIterator::~TrackRunIterator() {}
 
@@ skipping 375 matching lines @@
 int64 TrackRunIterator::sample_offset() const {
   DCHECK(IsSampleValid());
   return sample_offset_;
 }
 
 int TrackRunIterator::sample_size() const {
   DCHECK(IsSampleValid());
   return sample_itr_->size;
 }
 
-TimeDelta TrackRunIterator::dts() const {
+DecodeTimestamp TrackRunIterator::dts() const {
   DCHECK(IsSampleValid());
-  return TimeDeltaFromRational(sample_dts_, run_itr_->timescale);
+  return DecodeTimestampFromRational(sample_dts_, run_itr_->timescale);
 }
 
-TimeDelta TrackRunIterator::cts() const {
+base::TimeDelta TrackRunIterator::cts() const {
   DCHECK(IsSampleValid());
   return TimeDeltaFromRational(sample_dts_ + sample_itr_->cts_offset,
                                run_itr_->timescale);
 }
 
-TimeDelta TrackRunIterator::duration() const {
+base::TimeDelta TrackRunIterator::duration() const {
   DCHECK(IsSampleValid());
   return TimeDeltaFromRational(sample_itr_->duration, run_itr_->timescale);
 }
 
 bool TrackRunIterator::is_keyframe() const {
   DCHECK(IsSampleValid());
   return sample_itr_->is_keyframe;
 }
 
 bool TrackRunIterator::is_random_access_point() const {
@@ skipping 66 matching lines @@
 }
 
 uint8 TrackRunIterator::GetIvSize(size_t sample_index) const {
   uint32 index = GetGroupDescriptionIndex(sample_index);
   return (index == 0) ? track_encryption().default_iv_size
                       : GetSampleEncryptionInfoEntry(index).iv_size;
 }
 
 }  // namespace mp4
 }  // namespace media