Type conversion fixes, media/ edition.

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 160 matching lines @@
 
   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;
+  // We need to ceil() here because the calculation of |fractions| in

[wolenetz, 2014/10/21 19:15:15]

nit: fix compilation by #including std::ceil

[Peter Kasting, 2014/10/21 19:34:47]

Done.

+  // ConvertTimeToFractions() effectively does a floor().
+  int64 ntp_time_us = ntp_seconds * base::Time::kMicrosecondsPerSecond +
+      static_cast<int64>(std::ceil(ntp_fractions / kMagicFractionalUnit));

[wolenetz, 2014/10/21 19:15:15]

Though this works for the unit tests' hardcoded times, does this introduce lack
of round-tripping for other times? Would rounding solve this better (e.g.
std::floor(0.5 + ntp_fractions / kMagic..))?

[wolenetz, 2014/10/21 19:22:00]

From offline chat w/pkasting@, the behavior-invariant patch would use ceil()
here. There could be other issues with rounding vs ceil/floor/truncation
pre-existing in this code. miu@, please take a look.

[Peter Kasting, 2014/10/21 19:34:47]

More detail:

ceil() here is correct if we're trying to invert ConvertTimeToFractions().  The
question, really, is whether ConvertTimeToFractions() is correct to truncate the
calculation of |fractions|, or if instead it should round.  If it _should_
round, then we'd want to round here as well to match.

I'm happy to do either.

 
   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 int64 TimeDeltaToRtpDelta(base::TimeDelta delta, int rtp_timebase) {
   DCHECK_GT(rtp_timebase, 0);
   return delta * rtp_timebase / base::TimeDelta::FromSeconds(1);
 }
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_CAST_DEFINES_H_