KickJava   Java API By Example, From Geeks To Geeks.

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


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
35 import com.imagero.uio.buffer.MemoryAccessManager;
36
37 /**
38  * Gives possibility to read and write a short array using RandomAccess interface
39  *
40  * @author Andrei Kouznetsov
41  * Date: 01.06.2004
42  * Time: 22:35:58
43  */
44 public class ShortArrayBufferManager extends AbstractArrayBufferManager {
45
46     short[] data;
47
48     /**
49      * Create ShortArrayBufferManager with standard tile size
50      *
51      * @param data int array
52      */
53     public ShortArrayBufferManager(short[] data) {
54         this(data, Math.min(TILE_SIZE, data.length));
55     }
56
57     /**
58      * @param data int array
59      * @param size tile length (for Buffer)
60      */
61     public ShortArrayBufferManager(short[] data, int size) {
62         this(data, 0, data.length, size);
63     }
64
65     /**
66      * @param data int array
67      * @param offset start offset in <code>data</code>
68      * @param length length to read
69      */
70     public ShortArrayBufferManager(short[] data, int offset, int length) {
71         this(data, offset, length, TILE_SIZE);
72     }
73
74     /**
75      * @param data int array
76      * @param offset start offset in <code>data</code>
77      * @param length length to read
78      * @param size tile length (for Buffer)
79      */
80     public ShortArrayBufferManager(short[] data, int offset, int length, int size) {
81         this.data = data;
82         this.tileSize = size;
83         this.unitSize = 2;
84         this.length = length;
85         this.offset = offset;
86         accessManager = MemoryAccessManager.createMemoryAccessManager();
87     }
88
89     /**
90      * write appropriate unit (int) in LITTLE_ENDIAN order
91      *
92      * @param source source byte array
93      * @param sourceOffset offset in source array
94      * @param destOffset offset in destination array
95      *
96      * @return new offset in source array (for next writeUnitXX)
97      */
98     protected int writeUnitLE(byte[] source, int sourceOffset, int destOffset) {
99         int v = ((source[sourceOffset++] & 0xFF))
100                 | (((source[sourceOffset++] & 0xFF)) << 8);
101         data[destOffset] = (short) v;
102         return sourceOffset;
103     }
104
105     /**
106      * write appropriate unit (int) in BIG_ENDIAN order
107      *
108      * @param source source byte array
109      * @param sourceOffset offset in source array
110      * @param destOffset offset in destination array
111      *
112      * @return new offset in source array (for next writeUnitXX)
113      */
114     protected int writeUnitBE(byte[] source, int sourceOffset, int destOffset) {
115         int v = ((source[sourceOffset++] & 0xFF) << 8)
116                 | (source[sourceOffset++] & 0xFF);
117         data[destOffset] = (short) v;
118         return sourceOffset;
119     }
120
121     /**
122      * read unit (short) in BIG_ENDIAN order
123      *
124      * @param offset offset in source array
125      * @param dest byte array (destination)
126      * @param destOffset offset in destination array
127      *
128      * @return offset in destination array (updated)
129      */
130     protected int readUnitBE(int offset, byte[] dest, int destOffset) {
131         int v = data[offset];
132         dest[destOffset++] = (byte) ((v >>> 8) & 0xFF);
133         dest[destOffset++] = (byte) (v & 0xFF);
134         return destOffset;
135     }
136
137     /**
138      * read appropriate unit (short) in LITTLE_ENDIAN order
139      *
140      * @param offset offset in source array
141      * @param dest byte array (destination)
142      * @param destOffset offset in destination array
143      *
144      * @return offset in destination array (updated)
145      */
146     protected int readUnitLE(int offset, byte[] dest, int destOffset) {
147         int v = data[offset];
148         dest[destOffset++] = (byte) (v & 0xFF);
149         dest[destOffset++] = (byte) ((v >>> 8) & 0xFF);
150         return destOffset;
151     }
152
153 // public static void main(String[] args) throws IOException {
154 // int unitSize = 2;
155 // short[] a = new short[4];
156 // byte[] b = new byte[]{(byte) 0xEE, (byte) 0xDD, (byte) 0xCC, (byte) 0xBB, (byte) 0xAA, (byte) 0x99, (byte) 0x88, 0x77};
157 //
158 // DataInputStream dis = new DataInputStream(new ByteArrayInputStream(b));
159 // for(int i = 0; i < a.length; i++) {
160 // a[i] = dis.readShort();
161 // }
162 //
163 // Sys.out.println("b");
164 // AbstractArrayBufferManager.printHex(b);
165 //
166 // Sys.out.println("a");
167 // AbstractArrayBufferManager.printHex(a);
168 //
169 // ShortArrayBufferManager iadsm = new ShortArrayBufferManager(a, a.length);
170 //
171 // byte[] bLE = new byte[unitSize * a.length];
172 // iadsm.readLE(bLE, 0);
173 // Sys.out.println("bLE");
174 // AbstractArrayBufferManager.printHex(bLE);
175 //
176 // RandomAccessRO r0 = new RandomAccessByteArray(bLE, RandomAccessFactory.LITTLE_ENDIAN);
177 // short[] aLE = new short[a.length];
178 // r0.readFully(aLE);
179 //
180 // Sys.out.println("aLE");
181 // AbstractArrayBufferManager.printHex(aLE);
182 //
183 //
184 // byte[] bBE = new byte[unitSize * a.length];
185 // iadsm.readBE(bBE, 0);
186 //
187 // Sys.out.println("bBE");
188 // AbstractArrayBufferManager.printHex(bBE);
189 //
190 // RandomAccessRO r1 = new RandomAccessByteArray(bBE, RandomAccessFactory.BIG_ENDIAN);
191 // short[] aBE = new short[a.length];
192 // r1.readFully(aBE);
193 //
194 // Sys.out.println("aBE");
195 // AbstractArrayBufferManager.printHex(aBE);
196 // }
197 }
198
Popular Tags