[Cast] Repair receiver playout time calculations and frame skip logic.

media/cast/cast_defines.h

 // Copyright 2013 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 MEDIA_CAST_CAST_DEFINES_H_
 #define MEDIA_CAST_CAST_DEFINES_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 117 matching lines @@
          ((delay_fraction & 0xFFFF0000) >> 16);
 }
 
 inline base::TimeDelta ConvertFromNtpDiff(uint32 ntp_delay) {
   uint32 delay_ms = (ntp_delay & 0x0000ffff) * 1000;
   delay_ms >>= 16;
   delay_ms += ((ntp_delay & 0xffff0000) >> 16) * 1000;
   return base::TimeDelta::FromMilliseconds(delay_ms);
 }
 
-inline void ConvertTimeToFractions(int64 time_us,
+inline void ConvertTimeToFractions(int64 ntp_time_us,
                                    uint32* seconds,
                                    uint32* fractions) {
-  DCHECK_GE(time_us, 0) << "Time must NOT be negative";
-  *seconds = static_cast<uint32>(time_us / base::Time::kMicrosecondsPerSecond);
+  DCHECK_GE(ntp_time_us, 0) << "Time must NOT be negative";
+  const int64 seconds_component =
+      ntp_time_us / base::Time::kMicrosecondsPerSecond;
+  // NTP time will overflow in the year 2036.  Also, make sure unit tests don't
+  // regress and use an origin past the year 2036.  If this overflows here, the
+  // inverse calculation fails to compute the correct TimeTicks value, throwing
+  // off the entire system.
+  DCHECK_LT(seconds_component, INT64_C(4263431296))
+      << "One year left to fix the NTP year 2036 wrap-around issue!";
+  *seconds = static_cast<uint32>(seconds_component);
   *fractions = static_cast<uint32>(
-      (time_us % base::Time::kMicrosecondsPerSecond) * kMagicFractionalUnit);
+      (ntp_time_us % base::Time::kMicrosecondsPerSecond) *
+          kMagicFractionalUnit);
 }
 
 inline void ConvertTimeTicksToNtp(const base::TimeTicks& time,
                                   uint32* ntp_seconds,
                                   uint32* ntp_fractions) {
   base::TimeDelta elapsed_since_unix_epoch =
       time - base::TimeTicks::UnixEpoch();
 
   int64 ntp_time_us =
       elapsed_since_unix_epoch.InMicroseconds() +
       (kUnixEpochInNtpSeconds * base::Time::kMicrosecondsPerSecond);
 
   ConvertTimeToFractions(ntp_time_us, ntp_seconds, ntp_fractions);
 }
 
 inline base::TimeTicks ConvertNtpToTimeTicks(uint32 ntp_seconds,
                                              uint32 ntp_fractions) {
   int64 ntp_time_us =
       static_cast<int64>(ntp_seconds) * base::Time::kMicrosecondsPerSecond +
       static_cast<int64>(ntp_fractions) / kMagicFractionalUnit;
 
   base::TimeDelta elapsed_since_unix_epoch = base::TimeDelta::FromMicroseconds(
       ntp_time_us -
       (kUnixEpochInNtpSeconds * base::Time::kMicrosecondsPerSecond));
   return base::TimeTicks::UnixEpoch() + elapsed_since_unix_epoch;
 }
 
+inline base::TimeDelta RtpDeltaToTimeDelta(int64 rtp_delta, int rtp_timebase) {
+  DCHECK_GT(rtp_timebase, 0);
+  return rtp_delta * base::TimeDelta::FromSeconds(1) / rtp_timebase;
+}
+
 inline uint32 GetVideoRtpTimestamp(const base::TimeTicks& time_ticks) {
   base::TimeTicks zero_time;
   base::TimeDelta recorded_delta = time_ticks - zero_time;
   // Timestamp is in 90 KHz for video.
   return static_cast<uint32>(recorded_delta.InMilliseconds() * 90);
 }
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_CAST_DEFINES_H_