/*
* Copyright (C) 2010 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.
*/
/* 3DLocation implementation */
#include "sles_allinclusive.h"
static SLresult I3DLocation_SetLocationCartesian(SL3DLocationItf self, const SLVec3D *pLocation)
{
SL_ENTER_INTERFACE
if (NULL == pLocation) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
I3DLocation *thiz = (I3DLocation *) self;
SLVec3D locationCartesian = *pLocation;
interface_lock_exclusive(thiz);
thiz->mLocationCartesian = locationCartesian;
thiz->mLocationActive = CARTESIAN_SET_SPHERICAL_UNKNOWN;
interface_unlock_exclusive(thiz);
result = SL_RESULT_SUCCESS;
}
SL_LEAVE_INTERFACE
}
static SLresult I3DLocation_SetLocationSpherical(SL3DLocationItf self,
SLmillidegree azimuth, SLmillidegree elevation, SLmillimeter distance)
{
SL_ENTER_INTERFACE
if (!((-360000 <= azimuth) && (azimuth <= 360000) &&
(-90000 <= elevation) && (elevation <= 90000) &&
(0 <= distance) && (distance <= SL_MILLIMETER_MAX))) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
I3DLocation *thiz = (I3DLocation *) self;
interface_lock_exclusive(thiz);
thiz->mLocationSpherical.mAzimuth = azimuth;
thiz->mLocationSpherical.mElevation = elevation;
thiz->mLocationSpherical.mDistance = distance;
thiz->mLocationActive = CARTESIAN_UNKNOWN_SPHERICAL_SET;
interface_unlock_exclusive(thiz);
result = SL_RESULT_SUCCESS;
}
SL_LEAVE_INTERFACE
}
static SLresult I3DLocation_Move(SL3DLocationItf self, const SLVec3D *pMovement)
{
SL_ENTER_INTERFACE
if (NULL == pMovement) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
I3DLocation *thiz = (I3DLocation *) self;
SLVec3D movementCartesian = *pMovement;
interface_lock_exclusive(thiz);
for (;;) {
enum CartesianSphericalActive locationActive = thiz->mLocationActive;
switch (locationActive) {
case CARTESIAN_COMPUTED_SPHERICAL_SET:
case CARTESIAN_SET_SPHERICAL_COMPUTED: // not in 1.0.1
case CARTESIAN_SET_SPHERICAL_REQUESTED: // not in 1.0.1
case CARTESIAN_SET_SPHERICAL_UNKNOWN:
thiz->mLocationCartesian.x += movementCartesian.x;
thiz->mLocationCartesian.y += movementCartesian.y;
thiz->mLocationCartesian.z += movementCartesian.z;
thiz->mLocationActive = CARTESIAN_SET_SPHERICAL_UNKNOWN;
break;
case CARTESIAN_UNKNOWN_SPHERICAL_SET:
thiz->mLocationActive = CARTESIAN_REQUESTED_SPHERICAL_SET;
// fall through
case CARTESIAN_REQUESTED_SPHERICAL_SET:
// matched by cond_broadcast in case multiple requesters
#if 0
interface_cond_wait(thiz);
#else
thiz->mLocationActive = CARTESIAN_COMPUTED_SPHERICAL_SET;
#endif
continue;
default:
assert(SL_BOOLEAN_FALSE);
break;
}
break;
}
interface_unlock_exclusive(thiz);
result = SL_RESULT_SUCCESS;
}
SL_LEAVE_INTERFACE
}
static SLresult I3DLocation_GetLocationCartesian(SL3DLocationItf self, SLVec3D *pLocation)
{
SL_ENTER_INTERFACE
if (NULL == pLocation) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
I3DLocation *thiz = (I3DLocation *) self;
interface_lock_exclusive(thiz);
for (;;) {
enum CartesianSphericalActive locationActive = thiz->mLocationActive;
switch (locationActive) {
case CARTESIAN_COMPUTED_SPHERICAL_SET:
case CARTESIAN_SET_SPHERICAL_COMPUTED: // not in 1.0.1
case CARTESIAN_SET_SPHERICAL_REQUESTED: // not in 1.0.1
case CARTESIAN_SET_SPHERICAL_UNKNOWN:
{
SLVec3D locationCartesian = thiz->mLocationCartesian;
interface_unlock_exclusive(thiz);
*pLocation = locationCartesian;
}
break;
case CARTESIAN_UNKNOWN_SPHERICAL_SET:
thiz->mLocationActive = CARTESIAN_REQUESTED_SPHERICAL_SET;
// fall through
case CARTESIAN_REQUESTED_SPHERICAL_SET:
// matched by cond_broadcast in case multiple requesters
#if 0
interface_cond_wait(thiz);
#else
thiz->mLocationActive = CARTESIAN_COMPUTED_SPHERICAL_SET;
#endif
continue;
default:
assert(SL_BOOLEAN_FALSE);
interface_unlock_exclusive(thiz);
pLocation->x = 0;
pLocation->y = 0;
pLocation->z = 0;
break;
}
break;
}
result = SL_RESULT_SUCCESS;
}
SL_LEAVE_INTERFACE
}
static SLresult I3DLocation_SetOrientationVectors(SL3DLocationItf self,
const SLVec3D *pFront, const SLVec3D *pAbove)
{
SL_ENTER_INTERFACE
if (NULL == pFront || NULL == pAbove) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
SLVec3D front = *pFront;
SLVec3D above = *pAbove;
// NTH Check for vectors close to zero or close to parallel
I3DLocation *thiz = (I3DLocation *) self;
interface_lock_exclusive(thiz);
thiz->mOrientationVectors.mFront = front;
thiz->mOrientationVectors.mAbove = above;
thiz->mOrientationActive = ANGLES_UNKNOWN_VECTORS_SET;
thiz->mRotatePending = SL_BOOLEAN_FALSE;
interface_unlock_exclusive(thiz);
result = SL_RESULT_SUCCESS;
}
SL_LEAVE_INTERFACE
}
static SLresult I3DLocation_SetOrientationAngles(SL3DLocationItf self,
SLmillidegree heading, SLmillidegree pitch, SLmillidegree roll)
{
SL_ENTER_INTERFACE
if (!((-360000 <= heading) && (heading <= 360000) &&
(-90000 <= pitch) && (pitch <= 90000) &&
(-360000 <= roll) && (roll <= 360000))) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
I3DLocation *thiz = (I3DLocation *) self;
interface_lock_exclusive(thiz);
thiz->mOrientationAngles.mHeading = heading;
thiz->mOrientationAngles.mPitch = pitch;
thiz->mOrientationAngles.mRoll = roll;
thiz->mOrientationActive = ANGLES_SET_VECTORS_UNKNOWN;
thiz->mRotatePending = SL_BOOLEAN_FALSE;
interface_unlock_exclusive(thiz);
result = SL_RESULT_SUCCESS;
}
SL_LEAVE_INTERFACE
}
static SLresult I3DLocation_Rotate(SL3DLocationItf self, SLmillidegree theta, const SLVec3D *pAxis)
{
SL_ENTER_INTERFACE
if (!((-360000 <= theta) && (theta <= 360000)) || (NULL == pAxis)) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
SLVec3D axis = *pAxis;
// NTH Check that axis is not (close to) zero vector, length does not matter
I3DLocation *thiz = (I3DLocation *) self;
interface_lock_exclusive(thiz);
while (thiz->mRotatePending)
#if 0
interface_cond_wait(thiz);
#else
break;
#endif
thiz->mTheta = theta;
thiz->mAxis = axis;
thiz->mRotatePending = SL_BOOLEAN_TRUE;
interface_unlock_exclusive(thiz);
result = SL_RESULT_SUCCESS;
}
SL_LEAVE_INTERFACE
}
static SLresult I3DLocation_GetOrientationVectors(SL3DLocationItf self,
SLVec3D *pFront, SLVec3D *pUp)
{
SL_ENTER_INTERFACE
if (NULL == pFront || NULL == pUp) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
I3DLocation *thiz = (I3DLocation *) self;
interface_lock_shared(thiz);
SLVec3D front = thiz->mOrientationVectors.mFront;
SLVec3D up = thiz->mOrientationVectors.mUp;
interface_unlock_shared(thiz);
*pFront = front;
*pUp = up;
result = SL_RESULT_SUCCESS;
}
SL_LEAVE_INTERFACE
}
static const struct SL3DLocationItf_ I3DLocation_Itf = {
I3DLocation_SetLocationCartesian,
I3DLocation_SetLocationSpherical,
I3DLocation_Move,
I3DLocation_GetLocationCartesian,
I3DLocation_SetOrientationVectors,
I3DLocation_SetOrientationAngles,
I3DLocation_Rotate,
I3DLocation_GetOrientationVectors
};
void I3DLocation_init(void *self)
{
I3DLocation *thiz = (I3DLocation *) self;
thiz->mItf = &I3DLocation_Itf;
thiz->mLocationCartesian.x = 0;
thiz->mLocationCartesian.y = 0;
thiz->mLocationCartesian.z = 0;
memset(&thiz->mLocationSpherical, 0x55, sizeof(thiz->mLocationSpherical));
thiz->mLocationActive = CARTESIAN_SET_SPHERICAL_UNKNOWN;
thiz->mOrientationAngles.mHeading = 0;
thiz->mOrientationAngles.mPitch = 0;
thiz->mOrientationAngles.mRoll = 0;
memset(&thiz->mOrientationVectors, 0x55, sizeof(thiz->mOrientationVectors));
thiz->mOrientationActive = ANGLES_SET_VECTORS_UNKNOWN;
thiz->mTheta = 0x55555555;
thiz->mAxis.x = 0x55555555;
thiz->mAxis.y = 0x55555555;
thiz->mAxis.z = 0x55555555;
thiz->mRotatePending = SL_BOOLEAN_FALSE;
}