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