1/*
2 * Copyright (C) 2010 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/* 3DMacroscopic implementation */
18
19#include "sles_allinclusive.h"
20
21
22static SLresult I3DMacroscopic_SetSize(SL3DMacroscopicItf self,
23    SLmillimeter width, SLmillimeter height, SLmillimeter depth)
24{
25    SL_ENTER_INTERFACE
26
27    if (!((0 <= width) && (width <= SL_MILLIMETER_MAX) &&
28        (0 <= height) && (height <= SL_MILLIMETER_MAX) &&
29        (0 <= depth) && (depth <= SL_MILLIMETER_MAX))) {
30        result = SL_RESULT_PARAMETER_INVALID;
31    } else {
32        I3DMacroscopic *thiz = (I3DMacroscopic *) self;
33        interface_lock_exclusive(thiz);
34        thiz->mSize.mWidth = width;
35        thiz->mSize.mHeight = height;
36        thiz->mSize.mDepth = depth;
37        interface_unlock_exclusive(thiz);
38        result = SL_RESULT_SUCCESS;
39    }
40
41    SL_LEAVE_INTERFACE
42}
43
44
45static SLresult I3DMacroscopic_GetSize(SL3DMacroscopicItf self,
46    SLmillimeter *pWidth, SLmillimeter *pHeight, SLmillimeter *pDepth)
47{
48    SL_ENTER_INTERFACE
49
50    if (NULL == pWidth || NULL == pHeight || NULL == pDepth) {
51        result = SL_RESULT_PARAMETER_INVALID;
52    } else {
53        I3DMacroscopic *thiz = (I3DMacroscopic *) self;
54        interface_lock_shared(thiz);
55        SLmillimeter width = thiz->mSize.mWidth;
56        SLmillimeter height = thiz->mSize.mHeight;
57        SLmillimeter depth = thiz->mSize.mDepth;
58        interface_unlock_shared(thiz);
59        *pWidth = width;
60        *pHeight = height;
61        *pDepth = depth;
62        result = SL_RESULT_SUCCESS;
63    }
64
65    SL_LEAVE_INTERFACE
66}
67
68
69static SLresult I3DMacroscopic_SetOrientationAngles(SL3DMacroscopicItf self,
70    SLmillidegree heading, SLmillidegree pitch, SLmillidegree roll)
71{
72    SL_ENTER_INTERFACE
73
74    if (!((-360000 <= heading) && (heading <= 360000) &&
75        (-90000 <= pitch) && (pitch <= 90000) &&
76        (-360000 <= roll) && (roll <= 360000))) {
77        result = SL_RESULT_PARAMETER_INVALID;
78    } else {
79        I3DMacroscopic *thiz = (I3DMacroscopic *) self;
80        interface_lock_exclusive(thiz);
81        thiz->mOrientationAngles.mHeading = heading;
82        thiz->mOrientationAngles.mPitch = pitch;
83        thiz->mOrientationAngles.mRoll = roll;
84        thiz->mOrientationActive = ANGLES_SET_VECTORS_UNKNOWN;
85        thiz->mRotatePending = SL_BOOLEAN_FALSE;
86        // ++thiz->mGeneration;
87        interface_unlock_exclusive(thiz);
88        result = SL_RESULT_SUCCESS;
89    }
90
91    SL_LEAVE_INTERFACE
92}
93
94
95static SLresult I3DMacroscopic_SetOrientationVectors(SL3DMacroscopicItf self,
96    const SLVec3D *pFront, const SLVec3D *pAbove)
97{
98    SL_ENTER_INTERFACE
99
100    if (NULL == pFront || NULL == pAbove) {
101        result = SL_RESULT_PARAMETER_INVALID;
102    } else {
103        I3DMacroscopic *thiz = (I3DMacroscopic *) self;
104        SLVec3D front = *pFront;
105        SLVec3D above = *pAbove;
106        // NTH Check for vectors close to zero or close to parallel
107        interface_lock_exclusive(thiz);
108        thiz->mOrientationVectors.mFront = front;
109        thiz->mOrientationVectors.mAbove = above;
110        thiz->mOrientationVectors.mUp = above; // wrong
111        thiz->mOrientationActive = ANGLES_UNKNOWN_VECTORS_SET;
112        thiz->mRotatePending = SL_BOOLEAN_FALSE;
113        interface_unlock_exclusive(thiz);
114        result = SL_RESULT_SUCCESS;
115    }
116
117    SL_LEAVE_INTERFACE
118}
119
120
121static SLresult I3DMacroscopic_Rotate(SL3DMacroscopicItf self,
122    SLmillidegree theta, const SLVec3D *pAxis)
123{
124    SL_ENTER_INTERFACE
125
126    if (!((-360000 <= theta) && (theta <= 360000)) || NULL == pAxis) {
127        result = SL_RESULT_PARAMETER_INVALID;
128    } else {
129        SLVec3D axis = *pAxis;
130        // NTH Check that axis is not (close to) zero vector, length does not matter
131        I3DMacroscopic *thiz = (I3DMacroscopic *) self;
132        interface_lock_exclusive(thiz);
133        while (thiz->mRotatePending)
134            interface_cond_wait(thiz);
135        thiz->mTheta = theta;
136        thiz->mAxis = axis;
137        thiz->mRotatePending = SL_BOOLEAN_TRUE;
138        interface_unlock_exclusive(thiz);
139        result = SL_RESULT_SUCCESS;
140    }
141
142    SL_LEAVE_INTERFACE
143}
144
145
146static SLresult I3DMacroscopic_GetOrientationVectors(SL3DMacroscopicItf self,
147    SLVec3D *pFront, SLVec3D *pUp)
148{
149    SL_ENTER_INTERFACE
150
151    if (NULL == pFront || NULL == pUp) {
152        result = SL_RESULT_PARAMETER_INVALID;
153    } else {
154        I3DMacroscopic *thiz = (I3DMacroscopic *) self;
155        interface_lock_exclusive(thiz);
156        for (;;) {
157            enum AnglesVectorsActive orientationActive = thiz->mOrientationActive;
158            switch (orientationActive) {
159            case ANGLES_COMPUTED_VECTORS_SET:    // not in 1.0.1
160            case ANGLES_REQUESTED_VECTORS_SET:   // not in 1.0.1
161            case ANGLES_UNKNOWN_VECTORS_SET:
162            case ANGLES_SET_VECTORS_COMPUTED:
163                {
164                SLVec3D front = thiz->mOrientationVectors.mFront;
165                SLVec3D up = thiz->mOrientationVectors.mUp;
166                interface_unlock_exclusive(thiz);
167                *pFront = front;
168                *pUp = up;
169                }
170                break;
171            case ANGLES_SET_VECTORS_UNKNOWN:
172                thiz->mOrientationActive = ANGLES_SET_VECTORS_REQUESTED;
173                // fall through
174            case ANGLES_SET_VECTORS_REQUESTED:
175                // matched by cond_broadcast in case multiple requesters
176#if 0
177                interface_cond_wait(thiz);
178#else
179                thiz->mOrientationActive = ANGLES_SET_VECTORS_COMPUTED;
180#endif
181                continue;
182            default:
183                interface_unlock_exclusive(thiz);
184                assert(SL_BOOLEAN_FALSE);
185                pFront->x = 0;
186                pFront->y = 0;
187                pFront->z = 0;
188                pUp->x = 0;
189                pUp->y = 0;
190                pUp->z = 0;
191                break;
192            }
193            break;
194        }
195        result = SL_RESULT_SUCCESS;
196    }
197
198    SL_LEAVE_INTERFACE
199}
200
201
202static const struct SL3DMacroscopicItf_ I3DMacroscopic_Itf = {
203    I3DMacroscopic_SetSize,
204    I3DMacroscopic_GetSize,
205    I3DMacroscopic_SetOrientationAngles,
206    I3DMacroscopic_SetOrientationVectors,
207    I3DMacroscopic_Rotate,
208    I3DMacroscopic_GetOrientationVectors
209};
210
211void I3DMacroscopic_init(void *self)
212{
213    I3DMacroscopic *thiz = (I3DMacroscopic *) self;
214    thiz->mItf = &I3DMacroscopic_Itf;
215    thiz->mSize.mWidth = 0;
216    thiz->mSize.mHeight = 0;
217    thiz->mSize.mDepth = 0;
218    thiz->mOrientationAngles.mHeading = 0;
219    thiz->mOrientationAngles.mPitch = 0;
220    thiz->mOrientationAngles.mRoll = 0;
221    memset(&thiz->mOrientationVectors, 0x55, sizeof(thiz->mOrientationVectors));
222    thiz->mOrientationVectors.mFront.x = 0;
223    thiz->mOrientationVectors.mFront.y = 0;
224    thiz->mOrientationVectors.mFront.z = -1000;
225    thiz->mOrientationVectors.mUp.x = 0;
226    thiz->mOrientationVectors.mUp.y = 1000;
227    thiz->mOrientationVectors.mUp.z = 0;
228    thiz->mOrientationVectors.mAbove.x = 0;
229    thiz->mOrientationVectors.mAbove.y = 0;
230    thiz->mOrientationVectors.mAbove.z = 0;
231    thiz->mOrientationActive = ANGLES_SET_VECTORS_COMPUTED;
232    thiz->mTheta = 0x55555555;
233    thiz->mAxis.x = 0x55555555;
234    thiz->mAxis.y = 0x55555555;
235    thiz->mAxis.z = 0x55555555;
236    thiz->mRotatePending = SL_BOOLEAN_FALSE;
237}
238