cmsBool CMSEXPORT _cmsMAT3isIdentity(const cmsMAT3* a)
{
cmsMAT3 Identity;
int i, j;
_cmsMAT3identity(&Identity);
for (i=0; i < 3; i++)
for (j=0; j < 3; j++)
if (!CloseEnough(a ->v[i].n[j], Identity.v[i].n[j])) return FALSE;
return TRUE;
}
bool
Curve::approxPolylineMatch(
std::vector<QPointF> const& polyline1, std::vector<QPointF> const& polyline2)
{
if (polyline1.size() != polyline2.size()) {
return false;
}
if (!std::equal(polyline1.begin(), polyline1.end(), polyline2.begin(), CloseEnough())) {
return false;
}
return true;
}
// ---------------------------------------------------------------------- //
// Prop setup functions (for building tables).
// ---------------------------------------------------------------------- //
float AssignRangeMultiplier( int nBits, double range )
{
unsigned long iHighValue;
if ( nBits == 32 )
iHighValue = 0xFFFFFFFE;
else
iHighValue = ((1 << (unsigned long)nBits) - 1);
float fHighLowMul = iHighValue / range;
if ( CloseEnough( range, 0 ) )
fHighLowMul = iHighValue;
// If the precision is messing us up, then adjust it so it won't.
if ( (unsigned long)(fHighLowMul * range) > iHighValue ||
(fHighLowMul * range) > (double)iHighValue )
{
// Squeeze it down smaller and smaller until it's going to produce an integer
// in the valid range when given the highest value.
float multipliers[] = { 0.9999, 0.99, 0.9, 0.8, 0.7 };
int i;
for ( i=0; i < ARRAYSIZE( multipliers ); i++ )
{
fHighLowMul = (float)( iHighValue / range ) * multipliers[i];
if ( (unsigned long)(fHighLowMul * range) > iHighValue ||
(fHighLowMul * range) > (double)iHighValue )
{
}
else
{
break;
}
}
if ( i == ARRAYSIZE( multipliers ) )
{
// Doh! We seem to be unable to represent this range.
Assert( false );
return 0;
}
}
return fHighLowMul;
}
status_t Harness::testSeek(
const char *componentName, const char *componentRole) {
bool isEncoder =
!strncmp(componentRole, "audio_encoder.", 14)
|| !strncmp(componentRole, "video_encoder.", 14);
if (isEncoder) {
// Not testing seek behaviour for encoders.
printf(" * Not testing seek functionality for encoders.\n");
return OK;
}
const char *mime = GetMimeFromComponentRole(componentRole);
if (!mime) {
LOGI("Cannot perform seek test with this componentRole (%s)",
componentRole);
return OK;
}
sp<MediaSource> source = CreateSourceForMime(mime);
sp<MediaSource> seekSource = CreateSourceForMime(mime);
if (source == NULL || seekSource == NULL) {
return UNKNOWN_ERROR;
}
CHECK_EQ(seekSource->start(), OK);
sp<MediaSource> codec = OMXCodec::Create(
mOMX, source->getFormat(), false /* createEncoder */,
source, componentName);
CHECK(codec != NULL);
CHECK_EQ(codec->start(), OK);
int64_t durationUs;
CHECK(source->getFormat()->findInt64(kKeyDuration, &durationUs));
LOGI("stream duration is %lld us (%.2f secs)",
durationUs, durationUs / 1E6);
static const int32_t kNumIterations = 5000;
// We are always going to seek beyond EOS in the first iteration (i == 0)
// followed by a linear read for the second iteration (i == 1).
// After that it's all random.
for (int32_t i = 0; i < kNumIterations; ++i) {
int64_t requestedSeekTimeUs;
int64_t actualSeekTimeUs;
MediaSource::ReadOptions options;
double r = uniform_rand();
if ((i == 1) || (i > 0 && r < 0.5)) {
// 50% chance of just continuing to decode from last position.
requestedSeekTimeUs = -1;
LOGI("requesting linear read");
} else {
if (i == 0 || r < 0.55) {
// 5% chance of seeking beyond end of stream.
requestedSeekTimeUs = durationUs;
LOGI("requesting seek beyond EOF");
} else {
requestedSeekTimeUs =
(int64_t)(uniform_rand() * durationUs);
LOGI("requesting seek to %lld us (%.2f secs)",
requestedSeekTimeUs, requestedSeekTimeUs / 1E6);
}
MediaBuffer *buffer = NULL;
options.setSeekTo(
requestedSeekTimeUs, MediaSource::ReadOptions::SEEK_NEXT_SYNC);
if (seekSource->read(&buffer, &options) != OK) {
CHECK_EQ(buffer, NULL);
actualSeekTimeUs = -1;
} else {
CHECK(buffer != NULL);
CHECK(buffer->meta_data()->findInt64(kKeyTime, &actualSeekTimeUs));
CHECK(actualSeekTimeUs >= 0);
buffer->release();
buffer = NULL;
}
LOGI("nearest keyframe is at %lld us (%.2f secs)",
actualSeekTimeUs, actualSeekTimeUs / 1E6);
}
status_t err;
MediaBuffer *buffer;
for (;;) {
err = codec->read(&buffer, &options);
options.clearSeekTo();
if (err == INFO_FORMAT_CHANGED) {
CHECK_EQ(buffer, NULL);
continue;
}
if (err == OK) {
CHECK(buffer != NULL);
if (buffer->range_length() == 0) {
buffer->release();
buffer = NULL;
continue;
}
} else {
CHECK_EQ(buffer, NULL);
}
break;
}
if (requestedSeekTimeUs < 0) {
// Linear read.
if (err != OK) {
CHECK_EQ(buffer, NULL);
} else {
CHECK(buffer != NULL);
buffer->release();
buffer = NULL;
}
} else if (actualSeekTimeUs < 0) {
EXPECT(err != OK,
"We attempted to seek beyond EOS and expected "
"ERROR_END_OF_STREAM to be returned, but instead "
"we got a valid buffer.");
EXPECT(err == ERROR_END_OF_STREAM,
"We attempted to seek beyond EOS and expected "
"ERROR_END_OF_STREAM to be returned, but instead "
"we found some other error.");
CHECK_EQ(err, ERROR_END_OF_STREAM);
CHECK_EQ(buffer, NULL);
} else {
EXPECT(err == OK,
"Expected a valid buffer to be returned from "
"OMXCodec::read.");
CHECK(buffer != NULL);
int64_t bufferTimeUs;
CHECK(buffer->meta_data()->findInt64(kKeyTime, &bufferTimeUs));
if (!CloseEnough(bufferTimeUs, actualSeekTimeUs)) {
printf("\n * Attempted seeking to %lld us (%.2f secs)",
requestedSeekTimeUs, requestedSeekTimeUs / 1E6);
printf("\n * Nearest keyframe is at %lld us (%.2f secs)",
actualSeekTimeUs, actualSeekTimeUs / 1E6);
printf("\n * Returned buffer was at %lld us (%.2f secs)\n\n",
bufferTimeUs, bufferTimeUs / 1E6);
buffer->release();
buffer = NULL;
CHECK_EQ(codec->stop(), OK);
return UNKNOWN_ERROR;
}
buffer->release();
buffer = NULL;
}
}
CHECK_EQ(codec->stop(), OK);
return OK;
}
void Quaternion::Slerp(const Quaternion& a, const Quaternion& b, float t, Quaternion& outQuat)
{
// The folowing copyright and licence applies to the contents of this Quaternion::Slerp method
// Copyright 2013 BlackBerry Inc.
// 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.
// Original file from GamePlay3D: http://gameplay3d.org
// Modified by Jared Thomson in 2016:
// - removed assertions
// - made compatable with xo-math
// Fast slerp implementation by kwhatmough:
// It contains no division operations, no trig, no inverse trig
// and no sqrt. Not only does this code tolerate small constraint
// errors in the input quaternions, it actually corrects for them.
if (CloseEnough(t, 0.0f))
{
outQuat = a;
return;
}
else if (CloseEnough(t, 1.0f))
{
outQuat = b;
return;
}
else if (a == b)
{
outQuat = a;
}
else
{
float halfY, alpha, beta;
float u, f1, f2a, f2b;
float ratio1, ratio2;
float halfSecHalfTheta, versHalfTheta;
float sqNotU, sqU;
Vector4 * va = (Vector4*)&a;
Vector4 * vb = (Vector4*)&b;
float cosTheta = ((*va) * (*vb)).Sum();
// As usual in all slerp implementations, we fold theta.
alpha = cosTheta >= 0 ? 1.0f : -1.0f;
halfY = 1.0f + alpha * cosTheta;
// Here we bisect the interval, so we need to fold t as well.
f2b = t - 0.5f;
u = f2b >= 0 ? f2b : -f2b;
f2a = u - f2b;
f2b += u;
u += u;
f1 = 1.0f - u;
// One iteration of Newton to get 1-cos(theta / 2) to good accuracy.
halfSecHalfTheta = 1.09f - (0.476537f - 0.0903321f * halfY) * halfY;
halfSecHalfTheta *= 1.5f - halfY * halfSecHalfTheta * halfSecHalfTheta;
versHalfTheta = 1.0f - halfY * halfSecHalfTheta;
// Evaluate series expansions of the coefficients.
sqNotU = f1 * f1;
ratio2 = 0.0000440917108f * versHalfTheta;
ratio1 = -0.00158730159f + (sqNotU - 16.0f) * ratio2;
ratio1 = 0.0333333333f + ratio1 * (sqNotU - 9.0f) * versHalfTheta;
ratio1 = -0.333333333f + ratio1 * (sqNotU - 4.0f) * versHalfTheta;
ratio1 = 1.0f + ratio1 * (sqNotU - 1.0f) * versHalfTheta;
sqU = u * u;
ratio2 = -0.00158730159f + (sqU - 16.0f) * ratio2;
ratio2 = 0.0333333333f + ratio2 * (sqU - 9.0f) * versHalfTheta;
ratio2 = -0.333333333f + ratio2 * (sqU - 4.0f) * versHalfTheta;
ratio2 = 1.0f + ratio2 * (sqU - 1.0f) * versHalfTheta;
// Perform the bisection and resolve the folding done earlier.
f1 *= ratio1 * halfSecHalfTheta;
f2a *= ratio2;
f2b *= ratio2;
alpha *= f1 + f2a;
beta = f1 + f2b;
// Apply final coefficients to a and b as usual.
float w = alpha * a.w + beta * b.w;
float x = alpha * a.x + beta * b.x;
float y = alpha * a.y + beta * b.y;
float z = alpha * a.z + beta * b.z;
// This final adjustment to the quaternion's length corrects for
// any small constraint error in the inputs q1 and q2 But as you
// can see, it comes at the cost of 9 additional multiplication
// operations. If this error-correcting feature is not required,
// the following code may be removed.
f1 = 1.5f - 0.5f * (w * w + x * x + y * y + z * z);
_XO_ASSIGN_QUAT_Q(outQuat, w * f1, x * f1, y * f1, z * f1);
}
}
Quaternion::Quaternion(float x, float y, float z, float w) :
#if defined(XO_SSE)
xmm(_mm_set_ps(w, z, y, x))
#else
x(x), y(y), z(z), w(w)
#endif
{
}
Quaternion Quaternion::Inverse() const
{
return Quaternion(*this).MakeInverse();
}
Quaternion& Quaternion::MakeInverse()
{
float magnitude = xo_internal::QuaternionSquareSum(*this);
if (CloseEnough(magnitude, 1.0f, Epsilon))
{
return MakeConjugate();
}
if (CloseEnough(magnitude, 0.0f, Epsilon))
{
return *this;
}
MakeConjugate();
(*(Vector4*)this) /= magnitude;
return *this;
}
Quaternion Quaternion::Normalized() const
{
return Quaternion(*this).Normalize();
}
Quaternion& Quaternion::Normalize()
{
float magnitude = xo_internal::QuaternionSquareSum(*this);
if (CloseEnough(magnitude, 1.0f, Epsilon))
{
return *this;
}
magnitude = Sqrt(magnitude);
if (CloseEnough(magnitude, 0.0f, Epsilon))
{
return *this;
}
(*(Vector4*)this) /= magnitude;
return *this;
}
Quaternion Quaternion::Conjugate() const
{
return Quaternion(*this).MakeConjugate();
}
Quaternion& Quaternion::MakeConjugate()
{
_XO_ASSIGN_QUAT(w, -x, -y, -z);
return *this;
}
void Quaternion::GetAxisAngleRadians(Vector3& axis, float& radians) const
{
Quaternion q = Normalized();
#if defined(XO_SSE)
// todo: don't we need to normalize axis in sse too?
axis.xmm = q.xmm;
#else
axis.x = q.x;
axis.y = q.y;
axis.z = q.z;
axis.Normalize();
#endif
radians = (2.0f * ACos(q.w));
}
