1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define __STDC_LIMIT_MACROS 18 19 #define LOG_TAG "common_time" 20 #include <utils/Log.h> 21 22 #include <inttypes.h> 23 #include <stdint.h> 24 25 #include <utils/Errors.h> 26 #include <utils/LinearTransform.h> 27 28 #include "common_clock.h" 29 30 namespace android { 31 32 CommonClock::CommonClock() { 33 cur_slew_ = 0; 34 cur_trans_valid_ = false; 35 36 cur_trans_.a_zero = 0; 37 cur_trans_.b_zero = 0; 38 cur_trans_.a_to_b_numer = local_to_common_freq_numer_ = 1; 39 cur_trans_.a_to_b_denom = local_to_common_freq_denom_ = 1; 40 duration_trans_ = cur_trans_; 41 } 42 43 bool CommonClock::init(uint64_t local_freq) { 44 Mutex::Autolock lock(&lock_); 45 46 if (!local_freq) 47 return false; 48 49 uint64_t numer = kCommonFreq; 50 uint64_t denom = local_freq; 51 52 LinearTransform::reduce(&numer, &denom); 53 if ((numer > UINT32_MAX) || (denom > UINT32_MAX)) { 54 ALOGE("Overflow in CommonClock::init while trying to reduce %" PRIu64 "/%" PRIu64, 55 kCommonFreq, local_freq); 56 return false; 57 } 58 59 cur_trans_.a_to_b_numer = local_to_common_freq_numer_ = 60 static_cast<uint32_t>(numer); 61 cur_trans_.a_to_b_denom = local_to_common_freq_denom_ = 62 static_cast<uint32_t>(denom); 63 duration_trans_ = cur_trans_; 64 65 return true; 66 } 67 68 status_t CommonClock::localToCommon(int64_t local, int64_t *common_out) const { 69 Mutex::Autolock lock(&lock_); 70 71 if (!cur_trans_valid_) 72 return INVALID_OPERATION; 73 74 if (!cur_trans_.doForwardTransform(local, common_out)) 75 return INVALID_OPERATION; 76 77 return OK; 78 } 79 80 status_t CommonClock::commonToLocal(int64_t common, int64_t *local_out) const { 81 Mutex::Autolock lock(&lock_); 82 83 if (!cur_trans_valid_) 84 return INVALID_OPERATION; 85 86 if (!cur_trans_.doReverseTransform(common, local_out)) 87 return INVALID_OPERATION; 88 89 return OK; 90 } 91 92 int64_t CommonClock::localDurationToCommonDuration(int64_t localDur) const { 93 int64_t ret; 94 duration_trans_.doForwardTransform(localDur, &ret); 95 return ret; 96 } 97 98 void CommonClock::setBasis(int64_t local, int64_t common) { 99 Mutex::Autolock lock(&lock_); 100 101 cur_trans_.a_zero = local; 102 cur_trans_.b_zero = common; 103 cur_trans_valid_ = true; 104 } 105 106 void CommonClock::resetBasis() { 107 Mutex::Autolock lock(&lock_); 108 109 cur_trans_.a_zero = 0; 110 cur_trans_.b_zero = 0; 111 cur_trans_valid_ = false; 112 } 113 114 status_t CommonClock::setSlew(int64_t change_time, int32_t ppm) { 115 Mutex::Autolock lock(&lock_); 116 117 int64_t new_local_basis; 118 int64_t new_common_basis; 119 120 if (cur_trans_valid_) { 121 new_local_basis = change_time; 122 if (!cur_trans_.doForwardTransform(change_time, &new_common_basis)) { 123 ALOGE("Overflow when attempting to set slew rate to %d", ppm); 124 return INVALID_OPERATION; 125 } 126 } else { 127 new_local_basis = 0; 128 new_common_basis = 0; 129 } 130 131 cur_slew_ = ppm; 132 uint32_t n1 = local_to_common_freq_numer_; 133 uint32_t n2 = 1000000 + cur_slew_; 134 135 uint32_t d1 = local_to_common_freq_denom_; 136 uint32_t d2 = 1000000; 137 138 // n1/d1 has already been reduced, no need to do so here. 139 LinearTransform::reduce(&n1, &d2); 140 LinearTransform::reduce(&n2, &d1); 141 LinearTransform::reduce(&n2, &d2); 142 143 cur_trans_.a_zero = new_local_basis; 144 cur_trans_.b_zero = new_common_basis; 145 cur_trans_.a_to_b_numer = n1 * n2; 146 cur_trans_.a_to_b_denom = d1 * d2; 147 148 return OK; 149 } 150 151 } // namespace android 152
