remove LinearTransform from libutils (d4d6167f) · Commits · e / os / android_frameworks_base

libs/common_time/Android.mk

+2 −1

Original line number	Diff line number	Diff line
		@@ -15,7 +15,8 @@ LOCAL_SRC_FILES := \
		clock_recovery.cpp \
		common_clock.cpp \
		main.cpp \
		utils.cpp
		utils.cpp \
		LinearTransform.cpp

		# Uncomment to enable vesbose logging and debug service.
		#TIME_SERVICE_DEBUG=true

libs/common_time/LinearTransform.cpp

0 → 100644

+281 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2011 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#define __STDC_LIMIT_MACROS

		#include "LinearTransform.h"
		#include <assert.h>


		// disable sanitize as these functions may intentionally overflow (see comments below).
		// the ifdef can be removed when host builds use clang.
		#if defined(__clang__)
		#define ATTRIBUTE_NO_SANITIZE_INTEGER __attribute__((no_sanitize("integer")))
		#else
		#define ATTRIBUTE_NO_SANITIZE_INTEGER
		#endif

		namespace android {

		// sanitize failure with T = int32_t and x = 0x80000000
		template<class T>
		ATTRIBUTE_NO_SANITIZE_INTEGER
		static inline T ABS(T x) { return (x < 0) ? -x : x; }

		// Static math methods involving linear transformations
		// remote sanitize failure on overflow case.
		ATTRIBUTE_NO_SANITIZE_INTEGER
		static bool scale_u64_to_u64(
		uint64_t val,
		uint32_t N,
		uint32_t D,
		uint64_t* res,
		bool round_up_not_down) {
		uint64_t tmp1, tmp2;
		uint32_t r;

		assert(res);
		assert(D);

		// Let U32(X) denote a uint32_t containing the upper 32 bits of a 64 bit
		// integer X.
		// Let L32(X) denote a uint32_t containing the lower 32 bits of a 64 bit
		// integer X.
		// Let X[A, B] with A <= B denote bits A through B of the integer X.
		// Let (A \| B) denote the concatination of two 32 bit ints, A and B.
		// IOW X = (A \| B) => U32(X) == A && L32(X) == B
		//
		// compute M = val * N (a 96 bit int)
		// ---------------------------------
		// tmp2 = U32(val) * N (a 64 bit int)
		// tmp1 = L32(val) * N (a 64 bit int)
		// which means
		// M = val * N = (tmp2 << 32) + tmp1
		tmp2 = (val >> 32) * N;
		tmp1 = (val & UINT32_MAX) * N;

		// compute M[32, 95]
		// tmp2 = tmp2 + U32(tmp1)
		// = (U32(val) * N) + U32(L32(val) * N)
		// = M[32, 95]
		tmp2 += tmp1 >> 32;

		// if M[64, 95] >= D, then M/D has bits > 63 set and we have
		// an overflow.
		if ((tmp2 >> 32) >= D) {
		*res = UINT64_MAX;
		return false;
		}

		// Divide. Going in we know
		// tmp2 = M[32, 95]
		// U32(tmp2) < D
		r = tmp2 % D;
		tmp2 /= D;

		// At this point
		// tmp1 = L32(val) * N
		// tmp2 = M[32, 95] / D
		// = (M / D)[32, 95]
		// r = M[32, 95] % D
		// U32(tmp2) = 0
		//
		// compute tmp1 = (r \| M[0, 31])
		tmp1 = (tmp1 & UINT32_MAX) \| ((uint64_t)r << 32);

		// Divide again. Keep the remainder around in order to round properly.
		r = tmp1 % D;
		tmp1 /= D;

		// At this point
		// tmp2 = (M / D)[32, 95]
		// tmp1 = (M / D)[ 0, 31]
		// r = M % D
		// U32(tmp1) = 0
		// U32(tmp2) = 0

		// Pack the result and deal with the round-up case (As well as the
		// remote possiblility over overflow in such a case).
		*res = (tmp2 << 32) \| tmp1;
		if (r && round_up_not_down) {
		++(*res);
		if (!(*res)) {
		*res = UINT64_MAX;
		return false;
		}
		}

		return true;
		}

		// at least one known sanitize failure (see comment below)
		ATTRIBUTE_NO_SANITIZE_INTEGER
		static bool linear_transform_s64_to_s64(
		int64_t val,
		int64_t basis1,
		int32_t N,
		uint32_t D,
		bool invert_frac,
		int64_t basis2,
		int64_t* out) {
		uint64_t scaled, res;
		uint64_t abs_val;
		bool is_neg;

		if (!out)
		return false;

		// Compute abs(val - basis_64). Keep track of whether or not this delta
		// will be negative after the scale opertaion.
		if (val < basis1) {
		is_neg = true;
		abs_val = basis1 - val;
		} else {
		is_neg = false;
		abs_val = val - basis1;
		}

		if (N < 0)
		is_neg = !is_neg;

		if (!scale_u64_to_u64(abs_val,
		invert_frac ? D : ABS(N),
		invert_frac ? ABS(N) : D,
		&scaled,
		is_neg))
		return false; // overflow/undeflow

		// if scaled is >= 0x8000<etc>, then we are going to overflow or
		// underflow unless ABS(basis2) is large enough to pull us back into the
		// non-overflow/underflow region.
		if (scaled & INT64_MIN) {
		if (is_neg && (basis2 < 0))
		return false; // certain underflow

		if (!is_neg && (basis2 >= 0))
		return false; // certain overflow

		if (ABS(basis2) <= static_cast<int64_t>(scaled & INT64_MAX))
		return false; // not enough

		// Looks like we are OK
		*out = (is_neg ? (-scaled) : scaled) + basis2;
		} else {
		// Scaled fits within signed bounds, so we just need to check for
		// over/underflow for two signed integers. Basically, if both scaled
		// and basis2 have the same sign bit, and the result has a different
		// sign bit, then we have under/overflow. An easy way to compute this
		// is
		// (scaled_signbit XNOR basis_signbit) &&
		// (scaled_signbit XOR res_signbit)
		// ==
		// (scaled_signbit XOR basis_signbit XOR 1) &&
		// (scaled_signbit XOR res_signbit)

		if (is_neg)
		scaled = -scaled; // known sanitize failure
		res = scaled + basis2;

		if ((scaled ^ basis2 ^ INT64_MIN) & (scaled ^ res) & INT64_MIN)
		return false;

		*out = res;
		}

		return true;
		}

		bool LinearTransform::doForwardTransform(int64_t a_in, int64_t* b_out) const {
		if (0 == a_to_b_denom)
		return false;

		return linear_transform_s64_to_s64(a_in,
		a_zero,
		a_to_b_numer,
		a_to_b_denom,
		false,
		b_zero,
		b_out);
		}

		bool LinearTransform::doReverseTransform(int64_t b_in, int64_t* a_out) const {
		if (0 == a_to_b_numer)
		return false;

		return linear_transform_s64_to_s64(b_in,
		b_zero,
		a_to_b_numer,
		a_to_b_denom,
		true,
		a_zero,
		a_out);
		}

		template <class T> void LinearTransform::reduce(T* N, T* D) {
		T a, b;
		if (!N \|\| !D \|\| !(*D)) {
		assert(false);
		return;
		}

		a = *N;
		b = *D;

		if (a == 0) {
		*D = 1;
		return;
		}

		// This implements Euclid's method to find GCD.
		if (a < b) {
		T tmp = a;
		a = b;
		b = tmp;
		}

		while (1) {
		// a is now the greater of the two.
		const T remainder = a % b;
		if (remainder == 0) {
		*N /= b;
		*D /= b;
		return;
		}
		// by swapping remainder and b, we are guaranteeing that a is
		// still the greater of the two upon entrance to the loop.
		a = b;
		b = remainder;
		}
		};

		template void LinearTransform::reduce<uint64_t>(uint64_t* N, uint64_t* D);
		template void LinearTransform::reduce<uint32_t>(uint32_t* N, uint32_t* D);

		// sanitize failure if *N = 0x80000000
		ATTRIBUTE_NO_SANITIZE_INTEGER
		void LinearTransform::reduce(int32_t* N, uint32_t* D) {
		if (N && D && *D) {
		if (*N < 0) {
		N = -(N);
		reduce(reinterpret_cast<uint32_t*>(N), D);
		N = -(N);
		} else {
		reduce(reinterpret_cast<uint32_t*>(N), D);
		}
		}
		}

		} // namespace android

libs/common_time/LinearTransform.h

0 → 100644

+64 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2011 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef _LINEAR_TRANSFORM_H
		#define _LINEAR_TRANSFORM_H

		#include <stdint.h>

		namespace android {

		// LinearTransform defines a structure which hold the definition of a
		// transformation from single dimensional coordinate system A into coordinate
		// system B (and back again). Values in A and in B are 64 bit, the linear
		// scale factor is expressed as a rational number using two 32 bit values.
		//
		// Specifically, let
		// f(a) = b
		// F(b) = f^-1(b) = a
		// then
		//
		// f(a) = (((a - a_zero) * a_to_b_numer) / a_to_b_denom) + b_zero;
		//
		// and
		//
		// F(b) = (((b - b_zero) * a_to_b_denom) / a_to_b_numer) + a_zero;
		//
		struct LinearTransform {
		int64_t a_zero;
		int64_t b_zero;
		int32_t a_to_b_numer;
		uint32_t a_to_b_denom;

		// Transform from A->B
		// Returns true on success, or false in the case of a singularity or an
		// overflow.
		bool doForwardTransform(int64_t a_in, int64_t* b_out) const;

		// Transform from B->A
		// Returns true on success, or false in the case of a singularity or an
		// overflow.
		bool doReverseTransform(int64_t b_in, int64_t* a_out) const;

		// Helpers which will reduce the fraction N/D using Euclid's method.
		template <class T> static void reduce(T* N, T* D);
		static void reduce(int32_t* N, uint32_t* D);
		};


		}

		#endif // _LINEAR_TRANSFORM_H

libs/common_time/clock_recovery.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -19,9 +19,10 @@

		#include <stdint.h>
		#include <common_time/ICommonClock.h>
		#include <utils/LinearTransform.h>
		#include <utils/threads.h>

		#include "LinearTransform.h"

		#ifdef TIME_SERVICE_DEBUG
		#include "diag_thread.h"
		#endif

libs/common_time/common_clock.cpp

+0 −1

Original line number	Diff line number	Diff line
		@@ -23,7 +23,6 @@
		#include <stdint.h>

		#include <utils/Errors.h>
		#include <utils/LinearTransform.h>

		#include "common_clock.h"