FieldPacker.java revision eeb3042428fbe3a3cace554d3aca43b324904ad1 
1/*
2 * Copyright (C) 2012 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.support.v8.renderscript;
18
19import android.os.SystemProperties;
20import android.support.v8.renderscript.RenderScript;
21
22/**
23 * Utility class for packing arguments and structures from Android system objects to
24 * RenderScript objects.
25 *
26 * This class is only intended to be used to support the
27 * reflected code generated by the RS tool chain.  It should not
28 * be called directly.
29 *
30 **/
31public class FieldPacker {
32    private FieldPackerThunker mN;
33
34    public FieldPacker(int len) {
35        mPos = 0;
36        mLen = len;
37        mData = new byte[len];
38        if (RenderScript.shouldThunk()) {
39            mN = new FieldPackerThunker(len);
40        }
41    }
42
43    public void align(int v) {
44        if (RenderScript.shouldThunk()) {
45            mN.align(v);
46            return;
47        }
48        if ((v <= 0) || ((v & (v - 1)) != 0)) {
49            throw new RSIllegalArgumentException("argument must be a non-negative non-zero power of 2: " + v);
50        }
51
52        while ((mPos & (v - 1)) != 0) {
53            mData[mPos++] = 0;
54        }
55    }
56
57    public void reset() {
58        if (RenderScript.shouldThunk()) {
59            mN.reset();
60            return;
61        }
62        mPos = 0;
63    }
64    public void reset(int i) {
65        if (RenderScript.shouldThunk()) {
66            mN.reset(i);
67            return;
68        }
69        if ((i < 0) || (i >= mLen)) {
70            throw new RSIllegalArgumentException("out of range argument: " + i);
71        }
72        mPos = i;
73    }
74
75    public void skip(int i) {
76        if (RenderScript.shouldThunk()) {
77            mN.skip(i);
78            return;
79        }
80        int res = mPos + i;
81        if ((res < 0) || (res > mLen)) {
82            throw new RSIllegalArgumentException("out of range argument: " + i);
83        }
84        mPos = res;
85    }
86
87    public void addI8(byte v) {
88        if (RenderScript.shouldThunk()) {
89            mN.addI8(v);
90            return;
91        }
92        mData[mPos++] = v;
93    }
94
95    public void addI16(short v) {
96        if (RenderScript.shouldThunk()) {
97            mN.addI16(v);
98            return;
99        }
100        align(2);
101        mData[mPos++] = (byte)(v & 0xff);
102        mData[mPos++] = (byte)(v >> 8);
103    }
104
105    public void addI32(int v) {
106        if (RenderScript.shouldThunk()) {
107            mN.addI32(v);
108            return;
109        }
110        align(4);
111        mData[mPos++] = (byte)(v & 0xff);
112        mData[mPos++] = (byte)((v >> 8) & 0xff);
113        mData[mPos++] = (byte)((v >> 16) & 0xff);
114        mData[mPos++] = (byte)((v >> 24) & 0xff);
115    }
116
117    public void addI64(long v) {
118        if (RenderScript.shouldThunk()) {
119            mN.addI64(v);
120            return;
121        }
122        align(8);
123        mData[mPos++] = (byte)(v & 0xff);
124        mData[mPos++] = (byte)((v >> 8) & 0xff);
125        mData[mPos++] = (byte)((v >> 16) & 0xff);
126        mData[mPos++] = (byte)((v >> 24) & 0xff);
127        mData[mPos++] = (byte)((v >> 32) & 0xff);
128        mData[mPos++] = (byte)((v >> 40) & 0xff);
129        mData[mPos++] = (byte)((v >> 48) & 0xff);
130        mData[mPos++] = (byte)((v >> 56) & 0xff);
131    }
132
133    public void addU8(short v) {
134        if (RenderScript.shouldThunk()) {
135            mN.addU8(v);
136            return;
137        }
138        if ((v < 0) || (v > 0xff)) {
139            throw new IllegalArgumentException("Saving value out of range for type");
140        }
141        mData[mPos++] = (byte)v;
142    }
143
144    public void addU16(int v) {
145        if (RenderScript.shouldThunk()) {
146            mN.addU16(v);
147            return;
148        }
149        if ((v < 0) || (v > 0xffff)) {
150            android.util.Log.e("rs", "FieldPacker.addU16( " + v + " )");
151            throw new IllegalArgumentException("Saving value out of range for type");
152        }
153        align(2);
154        mData[mPos++] = (byte)(v & 0xff);
155        mData[mPos++] = (byte)(v >> 8);
156    }
157
158    public void addU32(long v) {
159        if (RenderScript.shouldThunk()) {
160            mN.addU32(v);
161            return;
162        }
163        if ((v < 0) || (v > 0xffffffffL)) {
164            android.util.Log.e("rs", "FieldPacker.addU32( " + v + " )");
165            throw new IllegalArgumentException("Saving value out of range for type");
166        }
167        align(4);
168        mData[mPos++] = (byte)(v & 0xff);
169        mData[mPos++] = (byte)((v >> 8) & 0xff);
170        mData[mPos++] = (byte)((v >> 16) & 0xff);
171        mData[mPos++] = (byte)((v >> 24) & 0xff);
172    }
173
174    public void addU64(long v) {
175        if (RenderScript.shouldThunk()) {
176            mN.addU64(v);
177            return;
178        }
179        if (v < 0) {
180            android.util.Log.e("rs", "FieldPacker.addU64( " + v + " )");
181            throw new IllegalArgumentException("Saving value out of range for type");
182        }
183        align(8);
184        mData[mPos++] = (byte)(v & 0xff);
185        mData[mPos++] = (byte)((v >> 8) & 0xff);
186        mData[mPos++] = (byte)((v >> 16) & 0xff);
187        mData[mPos++] = (byte)((v >> 24) & 0xff);
188        mData[mPos++] = (byte)((v >> 32) & 0xff);
189        mData[mPos++] = (byte)((v >> 40) & 0xff);
190        mData[mPos++] = (byte)((v >> 48) & 0xff);
191        mData[mPos++] = (byte)((v >> 56) & 0xff);
192    }
193
194    public void addF32(float v) {
195        if (RenderScript.shouldThunk()) {
196            mN.addF32(v);
197            return;
198        }
199        addI32(Float.floatToRawIntBits(v));
200    }
201
202    public void addF64(double v) {
203        if (RenderScript.shouldThunk()) {
204            mN.addF64(v);
205            return;
206        }
207        addI64(Double.doubleToRawLongBits(v));
208    }
209
210    public void addObj(BaseObj obj) {
211        if (RenderScript.shouldThunk()) {
212            mN.addObj(obj);
213            return;
214        }
215        if (obj != null) {
216            addI32(obj.getID(null));
217        } else {
218            addI32(0);
219        }
220    }
221
222    public void addF32(Float2 v) {
223        if (RenderScript.shouldThunk()) {
224            mN.addF32(v);
225            return;
226        }
227        addF32(v.x);
228        addF32(v.y);
229    }
230    public void addF32(Float3 v) {
231        if (RenderScript.shouldThunk()) {
232            mN.addF32(v);
233            return;
234        }
235        addF32(v.x);
236        addF32(v.y);
237        addF32(v.z);
238    }
239    public void addF32(Float4 v) {
240        if (RenderScript.shouldThunk()) {
241            mN.addF32(v);
242            return;
243        }
244        addF32(v.x);
245        addF32(v.y);
246        addF32(v.z);
247        addF32(v.w);
248    }
249
250    public void addF64(Double2 v) {
251        if (RenderScript.shouldThunk()) {
252            mN.addF64(v);
253            return;
254        }
255        addF64(v.x);
256        addF64(v.y);
257    }
258    public void addF64(Double3 v) {
259        if (RenderScript.shouldThunk()) {
260            mN.addF64(v);
261            return;
262        }
263        addF64(v.x);
264        addF64(v.y);
265        addF64(v.z);
266    }
267    public void addF64(Double4 v) {
268        if (RenderScript.shouldThunk()) {
269            mN.addF64(v);
270            return;
271        }
272        addF64(v.x);
273        addF64(v.y);
274        addF64(v.z);
275        addF64(v.w);
276    }
277
278    public void addI8(Byte2 v) {
279        if (RenderScript.shouldThunk()) {
280            mN.addI8(v);
281            return;
282        }
283        addI8(v.x);
284        addI8(v.y);
285    }
286    public void addI8(Byte3 v) {
287        if (RenderScript.shouldThunk()) {
288            mN.addI8(v);
289            return;
290        }
291        addI8(v.x);
292        addI8(v.y);
293        addI8(v.z);
294    }
295    public void addI8(Byte4 v) {
296        if (RenderScript.shouldThunk()) {
297            mN.addI8(v);
298            return;
299        }
300        addI8(v.x);
301        addI8(v.y);
302        addI8(v.z);
303        addI8(v.w);
304    }
305
306    public void addU8(Short2 v) {
307        if (RenderScript.shouldThunk()) {
308            mN.addU8(v);
309            return;
310        }
311        addU8(v.x);
312        addU8(v.y);
313    }
314    public void addU8(Short3 v) {
315        if (RenderScript.shouldThunk()) {
316            mN.addU8(v);
317            return;
318        }
319        addU8(v.x);
320        addU8(v.y);
321        addU8(v.z);
322    }
323    public void addU8(Short4 v) {
324        if (RenderScript.shouldThunk()) {
325            mN.addU8(v);
326            return;
327        }
328        addU8(v.x);
329        addU8(v.y);
330        addU8(v.z);
331        addU8(v.w);
332    }
333
334    public void addI16(Short2 v) {
335        if (RenderScript.shouldThunk()) {
336            mN.addI16(v);
337            return;
338        }
339        addI16(v.x);
340        addI16(v.y);
341    }
342    public void addI16(Short3 v) {
343        if (RenderScript.shouldThunk()) {
344            mN.addI16(v);
345            return;
346        }
347        addI16(v.x);
348        addI16(v.y);
349        addI16(v.z);
350    }
351    public void addI16(Short4 v) {
352        if (RenderScript.shouldThunk()) {
353            mN.addI16(v);
354            return;
355        }
356        addI16(v.x);
357        addI16(v.y);
358        addI16(v.z);
359        addI16(v.w);
360    }
361
362    public void addU16(Int2 v) {
363        if (RenderScript.shouldThunk()) {
364            mN.addU16(v);
365            return;
366        }
367        addU16(v.x);
368        addU16(v.y);
369    }
370    public void addU16(Int3 v) {
371        if (RenderScript.shouldThunk()) {
372            mN.addU16(v);
373            return;
374        }
375        addU16(v.x);
376        addU16(v.y);
377        addU16(v.z);
378    }
379    public void addU16(Int4 v) {
380        if (RenderScript.shouldThunk()) {
381            mN.addU16(v);
382            return;
383        }
384        addU16(v.x);
385        addU16(v.y);
386        addU16(v.z);
387        addU16(v.w);
388    }
389
390    public void addI32(Int2 v) {
391        if (RenderScript.shouldThunk()) {
392            mN.addI32(v);
393            return;
394        }
395        addI32(v.x);
396        addI32(v.y);
397    }
398    public void addI32(Int3 v) {
399        if (RenderScript.shouldThunk()) {
400            mN.addI32(v);
401            return;
402        }
403        addI32(v.x);
404        addI32(v.y);
405        addI32(v.z);
406    }
407    public void addI32(Int4 v) {
408        if (RenderScript.shouldThunk()) {
409            mN.addI32(v);
410            return;
411        }
412        addI32(v.x);
413        addI32(v.y);
414        addI32(v.z);
415        addI32(v.w);
416    }
417
418    public void addU32(Long2 v) {
419        if (RenderScript.shouldThunk()) {
420            mN.addU32(v);
421            return;
422        }
423        addU32(v.x);
424        addU32(v.y);
425    }
426    public void addU32(Long3 v) {
427        if (RenderScript.shouldThunk()) {
428            mN.addU32(v);
429            return;
430        }
431        addU32(v.x);
432        addU32(v.y);
433        addU32(v.z);
434    }
435    public void addU32(Long4 v) {
436        if (RenderScript.shouldThunk()) {
437            mN.addU32(v);
438            return;
439        }
440        addU32(v.x);
441        addU32(v.y);
442        addU32(v.z);
443        addU32(v.w);
444    }
445
446    public void addI64(Long2 v) {
447        if (RenderScript.shouldThunk()) {
448            mN.addI64(v);
449            return;
450        }
451        addI64(v.x);
452        addI64(v.y);
453    }
454    public void addI64(Long3 v) {
455        if (RenderScript.shouldThunk()) {
456            mN.addI64(v);
457            return;
458        }
459        addI64(v.x);
460        addI64(v.y);
461        addI64(v.z);
462    }
463    public void addI64(Long4 v) {
464        if (RenderScript.shouldThunk()) {
465            mN.addI64(v);
466            return;
467        }
468        addI64(v.x);
469        addI64(v.y);
470        addI64(v.z);
471        addI64(v.w);
472    }
473
474    public void addU64(Long2 v) {
475        if (RenderScript.shouldThunk()) {
476            mN.addU64(v);
477            return;
478        }
479        addU64(v.x);
480        addU64(v.y);
481    }
482    public void addU64(Long3 v) {
483        if (RenderScript.shouldThunk()) {
484            mN.addU64(v);
485            return;
486        }
487        addU64(v.x);
488        addU64(v.y);
489        addU64(v.z);
490    }
491    public void addU64(Long4 v) {
492        if (RenderScript.shouldThunk()) {
493            mN.addU64(v);
494            return;
495        }
496        addU64(v.x);
497        addU64(v.y);
498        addU64(v.z);
499        addU64(v.w);
500    }
501
502    public void addMatrix(Matrix4f v) {
503        if (RenderScript.shouldThunk()) {
504            mN.addMatrix(v);
505            return;
506        }
507        for (int i=0; i < v.mMat.length; i++) {
508            addF32(v.mMat[i]);
509        }
510    }
511
512    public void addMatrix(Matrix3f v) {
513        if (RenderScript.shouldThunk()) {
514            mN.addMatrix(v);
515            return;
516        }
517        for (int i=0; i < v.mMat.length; i++) {
518            addF32(v.mMat[i]);
519        }
520    }
521
522    public void addMatrix(Matrix2f v) {
523        if (RenderScript.shouldThunk()) {
524            mN.addMatrix(v);
525            return;
526        }
527        for (int i=0; i < v.mMat.length; i++) {
528            addF32(v.mMat[i]);
529        }
530    }
531
532    public void addBoolean(boolean v) {
533        if (RenderScript.shouldThunk()) {
534            mN.addBoolean(v);
535            return;
536        }
537        addI8((byte)(v ? 1 : 0));
538    }
539
540    public final byte[] getData() {
541        if (RenderScript.shouldThunk()) {
542            return mN.getData();
543        }
544        return mData;
545    }
546
547    private final byte mData[];
548    private int mPos;
549    private int mLen;
550
551}
552
553
554