blob: e4a3ecc7192b67d340f5acfaf884bb13a061a953 [file] [log] [blame]
// Copyright 2015 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.
#ifndef COBALT_MEDIA_CAST_COMMON_RTP_TIME_H_
#define COBALT_MEDIA_CAST_COMMON_RTP_TIME_H_
#include <limits>
#include <sstream>
#include "base/time/time.h"
#include "media/cast/common/expanded_value_base.h"
#include "starboard/types.h"
namespace cobalt {
namespace media {
namespace cast {
// Forward declarations (see below).
class RtpTimeDelta;
class RtpTimeTicks;
// Convenience operator overloads for logging.
std::ostream& operator<<(std::ostream& out, const RtpTimeDelta rhs);
std::ostream& operator<<(std::ostream& out, const RtpTimeTicks rhs);
// The difference between two RtpTimeTicks values. This data type is modeled
// off of base::TimeDelta, and used for performing compiler-checked arithmetic
// with RtpTimeTicks.
//
// This data type wraps a value, providing only the meaningful set of math
// operations that may be performed on the value. RtpTimeDeltas may be
// added/subtracted with other RtpTimeDeltas to produce a RtpTimeDelta holding
// the sum/difference. RtpTimeDeltas may also be multiplied or divided by
// integer amounts. Finally, RtpTimeDeltas may be divided by other
// RtpTimeDeltas to compute a number of periods (floor'ed to an integer), or
// modulo each other to determine a time period remainder.
//
// The base class provides bit truncation/extension features for
// wire-formatting, and also the comparison operators.
//
// Usage example:
//
// // Time math.
// RtpTimeDelta zero;
// RtpTimeDelta one_second_later =
// zero + RtpTimeDelta::FromTicks(kAudioSamplingRate);
// RtpTimeDelta ten_seconds_later = one_second_later * 10;
// int64_t ten_periods = ten_seconds_later / one_second_later;
//
// // Logging convenience.
// DLOG(INFO) << "The RTP time offset is " << ten_seconds_later;
//
// // Convert (approximately!) between RTP timebase and microsecond timebase:
// base::TimeDelta nine_seconds_offset =
// (ten_seconds_later - one_second_later).ToTimeDelta(kAudioSamplingRate);
// RtpTimeDelta nine_seconds_rtp =
// RtpTimeDelta::FromTimeDelta(nine_seconds_offset, kAudioSamplingRate);
class RtpTimeDelta : public ExpandedValueBase<int64_t, RtpTimeDelta> {
public:
RtpTimeDelta() : ExpandedValueBase(0) {}
// Arithmetic operators (with other deltas).
RtpTimeDelta operator+(RtpTimeDelta rhs) const {
return RtpTimeDelta(value_ + rhs.value_);
}
RtpTimeDelta operator-(RtpTimeDelta rhs) const {
return RtpTimeDelta(value_ - rhs.value_);
}
RtpTimeDelta& operator+=(RtpTimeDelta rhs) { return (*this = (*this + rhs)); }
RtpTimeDelta& operator-=(RtpTimeDelta rhs) { return (*this = (*this - rhs)); }
RtpTimeDelta operator-() const { return RtpTimeDelta(-value_); }
// Multiplicative operators (with other deltas).
int64_t operator/(RtpTimeDelta rhs) const { return value_ / rhs.value_; }
RtpTimeDelta operator%(RtpTimeDelta rhs) const {
return RtpTimeDelta(value_ % rhs.value_);
}
RtpTimeDelta& operator%=(RtpTimeDelta rhs) { return (*this = (*this % rhs)); }
// Multiplicative operators (with integer types).
template <typename IntType>
RtpTimeDelta operator*(IntType rhs) const {
static_assert(std::numeric_limits<IntType>::is_integer,
"|rhs| must be a POD integer type");
return RtpTimeDelta(value_ * rhs);
}
template <typename IntType>
RtpTimeDelta operator/(IntType rhs) const {
static_assert(std::numeric_limits<IntType>::is_integer,
"|rhs| must be a POD integer type");
return RtpTimeDelta(value_ / rhs);
}
template <typename IntType>
RtpTimeDelta& operator*=(IntType rhs) {
return (*this = (*this * rhs));
}
template <typename IntType>
RtpTimeDelta& operator/=(IntType rhs) {
return (*this = (*this / rhs));
}
// Maps this RtpTimeDelta to an approximate TimeDelta using the given
// RTP timebase. Assumes a zero-valued TimeDelta corresponds to a zero-valued
// RtpTimeDelta.
base::TimeDelta ToTimeDelta(int rtp_timebase) const;
// Maps the TimeDelta to an approximate RtpTimeDelta using the given RTP
// timebase. Assumes a zero-valued TimeDelta corresponds to a zero-valued
// RtpTimeDelta.
static RtpTimeDelta FromTimeDelta(base::TimeDelta delta, int rtp_timebase);
// Construct a RtpTimeDelta from an exact number of ticks.
static RtpTimeDelta FromTicks(int64_t ticks);
private:
friend class ExpandedValueBase<int64_t, RtpTimeDelta>;
friend class RtpTimeTicks;
friend std::ostream& operator<<(std::ostream& out, const RtpTimeDelta rhs);
explicit RtpTimeDelta(int64_t ticks) : ExpandedValueBase(ticks) {}
int64_t value() const { return value_; }
};
// A media timestamp whose timebase matches the periodicity of the content
// (e.g., for audio, the timebase would be the sampling frequency). This data
// type is modeled off of base::TimeTicks.
//
// This data type wraps a value, providing only the meaningful set of math
// operations that may be performed on the value. The difference between two
// RtpTimeTicks is a RtpTimeDelta. Likewise, adding or subtracting a
// RtpTimeTicks with a RtpTimeDelta produces an off-set RtpTimeTicks.
//
// The base class provides bit truncation/extension features for
// wire-formatting, and also the comparison operators.
//
// Usage example:
//
// // Time math.
// RtpTimeTicks origin;
// RtpTimeTicks at_one_second =
// origin + RtpTimeDelta::FromTicks(kAudioSamplingRate);
// RtpTimeTicks at_two_seconds =
// at_one_second + RtpTimeDelta::FromTicks(kAudioSamplingRate);
// RtpTimeDelta elasped_in_between = at_two_seconds - at_one_second;
// RtpTimeDelta thrice_as_much_elasped = elasped_in_between * 3;
// RtpTimeTicks at_four_seconds = at_one_second + thrice_as_much_elasped;
//
// // Logging convenience.
// DLOG(INFO) << "The RTP timestamp is " << at_four_seconds;
//
// // Convert (approximately!) between RTP timebase and media timestamps in
// // microsecond timebase:
// base::TimeDelta four_seconds_timestamp =
// at_four_seconds.ToTimeDelta(kAudioSamplingRate);
// video_frame->set_timestamp(four_seconds_timestamp);
// RtpTimeTicks four_seconds_rtp = RtpTimeDelta::FromTimeDelta(
// video_frame->timestamp(), kAudioSamplingRate);
class RtpTimeTicks : public ExpandedValueBase<int64_t, RtpTimeTicks> {
public:
RtpTimeTicks() : ExpandedValueBase(0) {}
// Compute the difference between two RtpTimeTickses.
RtpTimeDelta operator-(RtpTimeTicks rhs) const {
return RtpTimeDelta(value_ - rhs.value_);
}
// Return a new RtpTimeTicks before or after this one.
RtpTimeTicks operator+(RtpTimeDelta rhs) const {
return RtpTimeTicks(value_ + rhs.value());
}
RtpTimeTicks operator-(RtpTimeDelta rhs) const {
return RtpTimeTicks(value_ - rhs.value());
}
RtpTimeTicks& operator+=(RtpTimeDelta rhs) { return (*this = (*this + rhs)); }
RtpTimeTicks& operator-=(RtpTimeDelta rhs) { return (*this = (*this - rhs)); }
// Maps this RtpTimeTicks to an approximate TimeDelta using the given
// RTP timebase. Assumes a zero-valued TimeDelta corresponds to a zero-valued
// RtpTimeTicks.
base::TimeDelta ToTimeDelta(int rtp_timebase) const;
// Maps the TimeDelta to an approximate RtpTimeTicks using the given RTP
// timebase. Assumes a zero-valued TimeDelta corresponds to a zero-valued
// RtpTimeTicks.
static RtpTimeTicks FromTimeDelta(base::TimeDelta delta, int rtp_timebase);
private:
friend class ExpandedValueBase<int64_t, RtpTimeTicks>;
friend std::ostream& operator<<(std::ostream& out, const RtpTimeTicks rhs);
explicit RtpTimeTicks(int64_t value) : ExpandedValueBase(value) {}
int64_t value() const { return value_; }
};
} // namespace cast
} // namespace media
} // namespace cobalt
#endif // COBALT_MEDIA_CAST_COMMON_RTP_TIME_H_