KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > imagero > uio > buffer > arrays > FloatArrayBufferManager


1 /*
2  * Copyright (c) Andrey Kuznetsov. All Rights Reserved.
3  *
4  * http://uio.imagero.com
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * o Redistributions of source code must retain the above copyright notice,
10  * this list of conditions and the following disclaimer.
11  *
12  * o Redistributions in binary form must reproduce the above copyright notice,
13  * this list of conditions and the following disclaimer in the documentation
14  * and/or other materials provided with the distribution.
15  *
16  * o Neither the name of imagero Andrei Kouznetsov nor the names of
17  * its contributors may be used to endorse or promote products derived
18  * from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 package com.imagero.uio.buffer.arrays;
33
34 import com.imagero.uio.buffer.MemoryAccessManager;
35
36
37 /**
38  * Gives possibility to read and write an float array using RandomAccess interface
39  *
40  * @author Andrei Kouznetsov
41  * Date: 01.06.2004
42  * Time: 22:35:58
43  */
44 public class FloatArrayBufferManager extends AbstractArrayBufferManager {
45
46     float[] data;
47
48     /**
49      * Create FloatArrayBufferManager with standard tile size
50      *
51      * @param data int array
52      */
53     public FloatArrayBufferManager(float[] data) {
54         this(data, Math.min(TILE_SIZE, data.length));
55     }
56
57     /**
58      * Create FloatArrayBufferManager with specified tile size
59      *
60      * @param data int array
61      * @param size tile length (for Buffer)
62      */
63     public FloatArrayBufferManager(float[] data, int size) {
64         this(data, 0, data.length, size);
65     }
66
67     /**
68      * Create FloatArrayBufferManager with standard tile size
69      *
70      * @param data int array
71      * @param offset start offset in <code>data</code>
72      * @param length length to read
73      */
74     public FloatArrayBufferManager(float[] data, int offset, int length) {
75         this(data, offset, length, TILE_SIZE);
76     }
77
78     /**
79      * Create FloatArrayBufferManager with specified tile size
80      *
81      * @param data int array
82      * @param offset start offset in <code>data</code>
83      * @param length length to read
84      * @param size tile length (for Buffer)
85      */
86     public FloatArrayBufferManager(float[] data, int offset, int length, int size) {
87         this.data = data;
88         this.tileSize = size;
89         this.unitSize = 4;
90         this.length = length;
91         this.offset = offset;
92         accessManager = MemoryAccessManager.createMemoryAccessManager();
93     }
94
95     /**
96      * write appropriate unit (int) in LITTLE_ENDIAN order
97      *
98      * @param source source byte array
99      * @param sourceOffset offset in source array
100      * @param destOffset offset in destination array
101      *
102      * @return new offset in source array (for next writeUnitXX)
103      */
104     protected int writeUnitLE(byte[] source, int sourceOffset, int destOffset) {
105         int v = ((source[sourceOffset++] & 0xFF))
106                 | (((source[sourceOffset++] & 0xFF)) << 8)
107                 | (((source[sourceOffset++] & 0xFF)) << 16)
108                 | (((source[sourceOffset++] & 0xFF)) << 24);
109         data[destOffset] = Float.intBitsToFloat(v);
110         return sourceOffset;
111     }
112
113     /**
114      * write appropriate unit (int) in BIG_ENDIAN order
115      *
116      * @param source source byte array
117      * @param sourceOffset offset in source array
118      * @param destOffset offset in destination array
119      *
120      * @return new offset in source array (for next writeUnitXX)
121      */
122     protected int writeUnitBE(byte[] source, int sourceOffset, int destOffset) {
123         int v = ((source[sourceOffset++] & 0xFF) << 24)
124                 | ((source[sourceOffset++] & 0xFF) << 16)
125                 | ((source[sourceOffset++] & 0xFF) << 8)
126                 | (source[sourceOffset++] & 0xFF);
127         data[destOffset] = Float.intBitsToFloat(v);
128         return sourceOffset;
129     }
130
131     /**
132      * read unit (int) in BIG_ENDIAN order
133      *
134      * @param offset offset in source array
135      * @param dest byte array (destination)
136      * @param destOffset offset in destination array
137      *
138      * @return offset in destination array (updated)
139      */
140     protected int readUnitBE(int offset, byte[] dest, int destOffset) {
141         float f = data[offset];
142         int v = Float.floatToIntBits(f);
143         dest[destOffset++] = (byte) ((v >>> 24) & 0xFF);
144         dest[destOffset++] = (byte) ((v >>> 16) & 0xFF);
145         dest[destOffset++] = (byte) ((v >>> 8) & 0xFF);
146         dest[destOffset++] = (byte) (v & 0xFF);
147         return destOffset;
148     }
149
150     /**
151      * read appropriate unit (int) in LITTLE_ENDIAN order
152      *
153      * @param offset offset in source array
154      * @param dest byte array (destination)
155      * @param destOffset offset in destination array
156      *
157      * @return offset in destination array (updated)
158      */
159     protected int readUnitLE(int offset, byte[] dest, int destOffset) {
160         float f = data[offset];
161         int v = Float.floatToIntBits(f);
162         dest[destOffset++] = (byte) (v & 0xFF);
163         dest[destOffset++] = (byte) ((v >>> 8) & 0xFF);
164         dest[destOffset++] = (byte) ((v >>> 16) & 0xFF);
165         dest[destOffset++] = (byte) ((v >>> 24) & 0xFF);
166         return destOffset;
167     }
168 }
169
Popular Tags