Motown: Use new TimelineTransform and related definitions

mojo/services/media/common/cpp/timeline_rate.h

 // Copyright 2016 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 MOJO_SERVICES_MEDIA_COMMON_CPP_TIMELINE_RATE_H_
 #define MOJO_SERVICES_MEDIA_COMMON_CPP_TIMELINE_RATE_H_
 
 #include <stdint.h>
 
 #include <limits>
@@ skipping 44 matching lines @@
             b.reference_delta(), &result_subject_delta, &result_reference_delta,
             exact);
     return TimelineRate(result_subject_delta, result_reference_delta);
   }
 
   TimelineRate() : subject_delta_(0), reference_delta_(1) {}
 
   explicit TimelineRate(uint32_t subject_delta)
       : subject_delta_(subject_delta), reference_delta_(1) {}
 
+  explicit TimelineRate(float rate_as_float)
+      : subject_delta_(
+            rate_as_float > 1.0f
+                ? kFloatFactor
+                : static_cast<uint32_t>(kFloatFactor * rate_as_float)),
+        reference_delta_(
+            rate_as_float > 1.0f
+                ? static_cast<uint32_t>(kFloatFactor / rate_as_float)
+                : kFloatFactor) {
+    // The expressions above are intended to provide good precision for
+    // 'reasonable' playback rate values (say in the range 0.0 to 4.0). The
+    // expressions always produce a ratio of kFloatFactor and a number smaller
+    // than kFloatFactor. kFloatFactor's value was chosen because floats have
+    // a 23-bit mantissa, and operations with a larger factor would sacrifice
+    // precision.
+    MOJO_DCHECK(rate_as_float >= 0.0f);
+    Reduce(&subject_delta_, &reference_delta_);
+  }
+
   TimelineRate(uint32_t subject_delta, uint32_t reference_delta)
       : subject_delta_(subject_delta), reference_delta_(reference_delta) {
     MOJO_DCHECK(reference_delta != 0);
     Reduce(&subject_delta_, &reference_delta_);
   }
 
   // Returns the inverse of the rate. DCHECKs if the subject_delta of this
   // rate is zero.
   TimelineRate Inverse() const {
     MOJO_DCHECK(subject_delta_ != 0);
     return TimelineRate(reference_delta_, subject_delta_);
   }
 
   // Scales the value by this rate. Returns kOverflow on overflow.
   int64_t Scale(int64_t value) const {
     return Scale(value, subject_delta_, reference_delta_);
   }
 
   uint32_t subject_delta() const { return subject_delta_; }
   uint32_t reference_delta() const { return reference_delta_; }
 
  private:
+  // A multiplier for float-to-TimelineRate conversions chosen because floats
+  // have a 23-bit mantissa.
+  static constexpr uint32_t kFloatFactor = 1ul << 23;
+
   uint32_t subject_delta_;
   uint32_t reference_delta_;
 };
 
 // Tests two rates for equality.
 inline bool operator==(const TimelineRate& a, const TimelineRate& b) {
   return a.subject_delta() == b.subject_delta() &&
          a.reference_delta() == b.reference_delta();
 }
 
@@ skipping 22 matching lines @@
 // Returns the the int64_t divided by the rate. Returns kOverflow on
 // overflow.
 inline int64_t operator/(int64_t a, const TimelineRate& b) {
   return b.Inverse().Scale(a);
 }
 
 }  // namespace media
 }  // namespace mojo
 
 #endif  // MOJO_SERVICES_MEDIA_COMMON_CPP_TIMELINE_RATE_H_