1/*
2 * Copyright (C) 2008 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
17package android.renderscript;
18
19/**
20 * Only intended for use by generated reflected code.
21 *
22 **/
23public class AllocationAdapter extends Allocation {
24    Type mWindow;
25
26    AllocationAdapter(long id, RenderScript rs, Allocation alloc, Type t) {
27        super(id, rs, alloc.mType, alloc.mUsage);
28        mAdaptedAllocation = alloc;
29        mWindow = t;
30    }
31
32    /*
33    long getID(RenderScript rs) {
34        throw new RSInvalidStateException(
35            "This operation is not supported with adapters at this time.");
36    }
37    */
38
39    void initLOD(int lod) {
40        if (lod < 0) {
41            throw new RSIllegalArgumentException("Attempting to set negative lod (" + lod + ").");
42        }
43
44        int tx = mAdaptedAllocation.mType.getX();
45        int ty = mAdaptedAllocation.mType.getY();
46        int tz = mAdaptedAllocation.mType.getZ();
47
48        for (int ct=0; ct < lod; ct++) {
49            if ((tx==1) && (ty == 1) && (tz == 1)) {
50                throw new RSIllegalArgumentException("Attempting to set lod (" + lod + ") out of range.");
51            }
52
53            if (tx > 1) tx >>= 1;
54            if (ty > 1) ty >>= 1;
55            if (tz > 1) tz >>= 1;
56        }
57
58        mCurrentDimX = tx;
59        mCurrentDimY = ty;
60        mCurrentDimZ = tz;
61        mCurrentCount = mCurrentDimX;
62        if (mCurrentDimY > 1) {
63            mCurrentCount *= mCurrentDimY;
64        }
65        if (mCurrentDimZ > 1) {
66            mCurrentCount *= mCurrentDimZ;
67        }
68        mSelectedY = 0;
69        mSelectedZ = 0;
70    }
71
72    private void updateOffsets() {
73        int a1 = 0, a2 = 0, a3 = 0, a4 = 0;
74
75        if (mSelectedArray != null) {
76            if (mSelectedArray.length > 0) {
77                a1 = mSelectedArray[0];
78            }
79            if (mSelectedArray.length > 1) {
80                a2 = mSelectedArray[2];
81            }
82            if (mSelectedArray.length > 2) {
83                a3 = mSelectedArray[2];
84            }
85            if (mSelectedArray.length > 3) {
86                a4 = mSelectedArray[3];
87            }
88        }
89        mRS.nAllocationAdapterOffset(getID(mRS), mSelectedX, mSelectedY, mSelectedZ,
90                                     mSelectedLOD, mSelectedFace.mID, a1, a2, a3, a4);
91
92    }
93
94    /**
95     * Set the active LOD.  The LOD must be within the range for the
96     * type being adapted.  The base allocation must have mipmaps.
97     *
98     * Because this changes the dimensions of the adapter the
99     * current Y and Z will be reset.
100     *
101     * @param lod The LOD to make active.
102     */
103    public void setLOD(int lod) {
104        if (!mAdaptedAllocation.getType().hasMipmaps()) {
105            throw new RSInvalidStateException("Cannot set LOD when the allocation type does not include mipmaps.");
106        }
107        if (mWindow.hasMipmaps()) {
108            throw new RSInvalidStateException("Cannot set LOD when the adapter includes mipmaps.");
109        }
110
111        initLOD(lod);
112        mSelectedLOD = lod;
113        updateOffsets();
114    }
115
116    /**
117     * Set the active Face.  The base allocation must be of a type
118     * that includes faces.
119     *
120     * @param cf The face to make active.
121     */
122    public void setFace(Type.CubemapFace cf) {
123        if (!mAdaptedAllocation.getType().hasFaces()) {
124            throw new RSInvalidStateException("Cannot set Face when the allocation type does not include faces.");
125        }
126        if (mWindow.hasFaces()) {
127            throw new RSInvalidStateException("Cannot set face when the adapter includes faces.");
128        }
129        if (cf == null) {
130            throw new RSIllegalArgumentException("Cannot set null face.");
131        }
132
133        mSelectedFace = cf;
134        updateOffsets();
135    }
136
137
138    /**
139     *
140     * Set the active X.  The x value must be within the range for
141     * the allocation being adapted.
142     *
143     * @param x The x to make active.
144     */
145    public void setX(int x) {
146        if (mAdaptedAllocation.getType().getX() <= x) {
147            throw new RSInvalidStateException("Cannot set X greater than dimension of allocation.");
148        }
149        if (mWindow.getX() == mAdaptedAllocation.getType().getX()) {
150            throw new RSInvalidStateException("Cannot set X when the adapter includes X.");
151        }
152        if ((mWindow.getX() + x) >= mAdaptedAllocation.getType().getX()) {
153            throw new RSInvalidStateException("Cannot set (X + window) which would be larger than dimension of allocation.");
154        }
155
156        mSelectedX = x;
157        updateOffsets();
158    }
159
160    /**
161     * Set the active Y.  The y value must be within the range for
162     * the allocation being adapted.  The base allocation must
163     * contain the Y dimension.
164     *
165     * @param y The y to make active.
166     */
167    public void setY(int y) {
168        if (mAdaptedAllocation.getType().getY() == 0) {
169            throw new RSInvalidStateException("Cannot set Y when the allocation type does not include Y dim.");
170        }
171        if (mAdaptedAllocation.getType().getY() <= y) {
172            throw new RSInvalidStateException("Cannot set Y greater than dimension of allocation.");
173        }
174        if (mWindow.getY() == mAdaptedAllocation.getType().getY()) {
175            throw new RSInvalidStateException("Cannot set Y when the adapter includes Y.");
176        }
177        if ((mWindow.getY() + y) >= mAdaptedAllocation.getType().getY()) {
178            throw new RSInvalidStateException("Cannot set (Y + window) which would be larger than dimension of allocation.");
179        }
180
181        mSelectedY = y;
182        updateOffsets();
183    }
184
185    /**
186     * Set the active Z.  The z value must be within the range for
187     * the allocation being adapted.  The base allocation must
188     * contain the Z dimension.
189     *
190     * @param z The z to make active.
191     */
192    public void setZ(int z) {
193        if (mAdaptedAllocation.getType().getZ() == 0) {
194            throw new RSInvalidStateException("Cannot set Z when the allocation type does not include Z dim.");
195        }
196        if (mAdaptedAllocation.getType().getZ() <= z) {
197            throw new RSInvalidStateException("Cannot set Z greater than dimension of allocation.");
198        }
199        if (mWindow.getZ() == mAdaptedAllocation.getType().getZ()) {
200            throw new RSInvalidStateException("Cannot set Z when the adapter includes Z.");
201        }
202        if ((mWindow.getZ() + z) >= mAdaptedAllocation.getType().getZ()) {
203            throw new RSInvalidStateException("Cannot set (Z + window) which would be larger than dimension of allocation.");
204        }
205
206        mSelectedZ = z;
207        updateOffsets();
208    }
209
210    /**
211     * @hide
212     */
213    public void setArray(int arrayNum, int arrayVal) {
214        if (mAdaptedAllocation.getType().getArray(arrayNum) == 0) {
215            throw new RSInvalidStateException("Cannot set arrayNum when the allocation type does not include arrayNum dim.");
216        }
217        if (mAdaptedAllocation.getType().getArray(arrayNum) <= arrayVal) {
218            throw new RSInvalidStateException("Cannot set arrayNum greater than dimension of allocation.");
219        }
220        if (mWindow.getArray(arrayNum) == mAdaptedAllocation.getType().getArray(arrayNum)) {
221            throw new RSInvalidStateException("Cannot set arrayNum when the adapter includes arrayNum.");
222        }
223        if ((mWindow.getArray(arrayNum) + arrayVal) >= mAdaptedAllocation.getType().getArray(arrayNum)) {
224            throw new RSInvalidStateException("Cannot set (arrayNum + window) which would be larger than dimension of allocation.");
225        }
226
227        mSelectedArray[arrayNum] = arrayVal;
228        updateOffsets();
229    }
230
231    static public AllocationAdapter create1D(RenderScript rs, Allocation a) {
232        rs.validate();
233        Type t = Type.createX(rs, a.getElement(), a.getType().getX());
234        return createTyped(rs, a, t);
235    }
236
237
238    static public AllocationAdapter create2D(RenderScript rs, Allocation a) {
239        rs.validate();
240        Type t = Type.createXY(rs, a.getElement(), a.getType().getX(), a.getType().getY());
241        return createTyped(rs, a, t);
242    }
243
244    /**
245     *
246     *
247     * Create an arbitrary window into the base allocation.
248     * The type describes the shape of the window.
249     *
250     * Any dimensions present in the type must be equal or smaller
251     * to the dimensions in the source allocation.  A dimension
252     * present in the allocation that is not present in the type
253     * will be constrained away with the selectors.
254     *
255     * If a dimension is present in both the type and allocation, one of
256     * two things will happen.
257     *
258     * If the type is smaller than the allocation, a window will be
259     * created, the selected value in the adapter for that dimension
260     * will act as the base address, and the type will describe the
261     * size of the view starting at that point.
262     *
263     * If the type and allocation dimension are of the same size,
264     * then setting the selector for the dimension will be an error.
265     */
266    static public AllocationAdapter createTyped(RenderScript rs, Allocation a, Type t) {
267        rs.validate();
268
269        if (a.mAdaptedAllocation != null) {
270            throw new RSInvalidStateException("Adapters cannot be nested.");
271        }
272
273        if (!a.getType().getElement().equals(t.getElement())) {
274            throw new RSInvalidStateException("Element must match Allocation type.");
275        }
276
277        if (t.hasFaces() || t.hasMipmaps()) {
278            throw new RSInvalidStateException("Adapters do not support window types with Mipmaps or Faces.");
279        }
280
281        Type at = a.getType();
282        if ((t.getX() > at.getX()) ||
283            (t.getY() > at.getY()) ||
284            (t.getZ() > at.getZ()) ||
285            (t.getArrayCount() > at.getArrayCount())) {
286
287            throw new RSInvalidStateException("Type cannot have dimension larger than the source allocation.");
288        }
289
290        if (t.getArrayCount() > 0) {
291            for (int i = 0; i < t.getArray(i); i++) {
292                if (t.getArray(i) > at.getArray(i)) {
293                    throw new RSInvalidStateException("Type cannot have dimension larger than the source allocation.");
294                }
295            }
296        }
297
298        // Create the object
299        long id = rs.nAllocationAdapterCreate(a.getID(rs), t.getID(rs));
300        if (id == 0) {
301            throw new RSRuntimeException("AllocationAdapter creation failed.");
302        }
303        return new AllocationAdapter(id, rs, a, t);
304    }
305
306    /**
307     * Override the Allocation resize.  Resizing adapters is not
308     * allowed and will throw a RSInvalidStateException.
309     *
310     * @param dimX ignored.
311     */
312    public synchronized void resize(int dimX) {
313        throw new RSInvalidStateException("Resize not allowed for Adapters.");
314    }
315
316}
317
318
319