mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
119 lines
3.6 KiB
C++
119 lines
3.6 KiB
C++
// Copyright 2015 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.
|
|
|
|
/*
|
|
* 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 MOJO_SERVICES_MEDIA_COMMON_CPP_LINEAR_TRANSFORM_H_
|
|
#define MOJO_SERVICES_MEDIA_COMMON_CPP_LINEAR_TRANSFORM_H_
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <iosfwd>
|
|
|
|
namespace mojo {
|
|
namespace media {
|
|
|
|
// 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) * scale.numerator) / scale.denominator) + b_zero;
|
|
//
|
|
// and
|
|
//
|
|
// F(b) = (((b - b_zero) * scale.denominator) / scale.numerator) + a_zero;
|
|
//
|
|
struct LinearTransform {
|
|
struct Ratio {
|
|
Ratio() { }
|
|
Ratio(int32_t _numerator, uint32_t _denominator)
|
|
: numerator(_numerator),
|
|
denominator(_denominator) {
|
|
Reduce();
|
|
}
|
|
|
|
// Helper which will reduce the fraction numerator/denominator using
|
|
// Euclid's method.
|
|
static void Reduce(int32_t* numerator, uint32_t* denominator);
|
|
|
|
// Reduce the internal scaling rational.
|
|
void Reduce() { Reduce(&numerator, &denominator); }
|
|
|
|
// Compute a * b, reduce and store in out.
|
|
//
|
|
// Returns true if the composition was computed and stored with no loss of
|
|
// precision. Returns false if the reduced form of the composition could
|
|
// not be stored as a 32 bit ratio and had to be shifted in order to be
|
|
// stored.
|
|
static bool Compose(const Ratio& a, const Ratio& b, Ratio* out);
|
|
|
|
int32_t numerator = 1;
|
|
uint32_t denominator = 1;
|
|
};
|
|
|
|
LinearTransform() { }
|
|
|
|
LinearTransform(int32_t numerator, uint32_t denominator)
|
|
: scale(numerator, denominator) {}
|
|
|
|
explicit LinearTransform(const Ratio& s) : scale(s) {}
|
|
|
|
LinearTransform(int64_t az,
|
|
int32_t numerator,
|
|
uint32_t denominator,
|
|
int64_t bz)
|
|
: scale(numerator, denominator),
|
|
a_zero(az),
|
|
b_zero(bz) {}
|
|
|
|
LinearTransform(int64_t az, const Ratio& s, int64_t bz)
|
|
: scale(s),
|
|
a_zero(az),
|
|
b_zero(bz) {}
|
|
|
|
// 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;
|
|
|
|
Ratio scale;
|
|
int64_t a_zero = 0;
|
|
int64_t b_zero = 0;
|
|
};
|
|
|
|
std::ostream& operator<<(std::ostream& os,
|
|
const LinearTransform::Ratio& r);
|
|
std::ostream& operator<<(std::ostream& os,
|
|
const LinearTransform& lt);
|
|
|
|
} // namespace media
|
|
} // namespace mojo
|
|
|
|
#endif // MOJO_SERVICES_MEDIA_COMMON_CPP_LINEAR_TRANSFORM_H_
|