1 /* Copyright (C) 2000, 2002, 2005 Free Software Foundation 2 3 This file is part of GNU Classpath. 4 5 GNU Classpath is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 2, or (at your option) 8 any later version. 9 10 GNU Classpath is distributed in the hope that it will be useful, but 11 WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with GNU Classpath; see the file COPYING. If not, write to the 17 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 18 02110-1301 USA. 19 20 Linking this library statically or dynamically with other modules is 21 making a combined work based on this library. Thus, the terms and 22 conditions of the GNU General Public License cover the whole 23 combination. 24 25 As a special exception, the copyright holders of this library give you 26 permission to link this library with independent modules to produce an 27 executable, regardless of the license terms of these independent 28 modules, and to copy and distribute the resulting executable under 29 terms of your choice, provided that you also meet, for each linked 30 independent module, the terms and conditions of the license of that 31 module. An independent module is a module which is not derived from 32 or based on this library. If you modify this library, you may extend 33 this exception to your version of the library, but you are not 34 obligated to do so. If you do not wish to do so, delete this 35 exception statement from your version. */ 36 37 package java.awt.image; 38 39 /** 40 * Class that manages arrays of data elements. A data buffer consists 41 * of one or more banks. A bank is a continuous region of data 42 * elements. 43 * 44 * @author Rolf W. Rasmussen (rolfwr@ii.uib.no) 45 */ 46 public abstract class DataBuffer 47 { 48 /** 49 * A constant representing a data type that uses <code>byte</code> primitives 50 * as the storage unit. 51 */ 52 public static final int TYPE_BYTE = 0; 53 54 /** 55 * A constant representing a data type that uses <code>short</code> 56 * primitives as the storage unit. 57 */ 58 public static final int TYPE_USHORT = 1; 59 60 /** 61 * A constant representing a data type that uses <code>short</code> 62 * primitives as the storage unit. 63 */ 64 public static final int TYPE_SHORT = 2; 65 66 /** 67 * A constant representing a data type that uses <code>int</code> 68 * primitives as the storage unit. 69 */ 70 public static final int TYPE_INT = 3; 71 72 /** 73 * A constant representing a data type that uses <code>float</code> 74 * primitives as the storage unit. 75 */ 76 public static final int TYPE_FLOAT = 4; 77 78 /** 79 * A constant representing a data type that uses <code>double</code> 80 * primitives as the storage unit. 81 */ 82 public static final int TYPE_DOUBLE = 5; 83 84 /** 85 * A constant representing an undefined data type. 86 */ 87 public static final int TYPE_UNDEFINED = 32; 88 89 /** The type of the data elements stored in the data buffer. */ 90 protected int dataType; 91 92 /** The number of banks in this buffer. */ 93 protected int banks = 1; 94 95 /** Offset into the default (0'th) bank). */ 96 protected int offset; // FIXME: Is offsets[0] always mirrored in offset? 97 98 /** The size of the banks. */ 99 protected int size; 100 101 /** Offset into each bank. */ 102 protected int[] offsets; 103 104 /** 105 * Creates a new <code>DataBuffer</code> with the specified data type and 106 * size. The <code>dataType</code> should be one of the constants 107 * {@link #TYPE_BYTE}, {@link #TYPE_SHORT}, {@link #TYPE_USHORT}, 108 * {@link #TYPE_INT}, {@link #TYPE_FLOAT} and {@link #TYPE_DOUBLE}. 109 * <p> 110 * The physical (array-based) storage is allocated by a subclass. 111 * 112 * @param dataType the data type. 113 * @param size the number of elements in the buffer. 114 */ DataBuffer(int dataType, int size)115 protected DataBuffer(int dataType, int size) 116 { 117 this(dataType, size, 1); 118 } 119 120 /** 121 * Creates a new <code>DataBuffer</code> with the specified data type, 122 * size and number of banks. The <code>dataType</code> should be one of 123 * the constants {@link #TYPE_BYTE}, {@link #TYPE_SHORT}, 124 * {@link #TYPE_USHORT}, {@link #TYPE_INT}, {@link #TYPE_FLOAT} and 125 * {@link #TYPE_DOUBLE}. 126 * <p> 127 * The physical (array-based) storage is allocated by a subclass. 128 * 129 * @param dataType the data type. 130 * @param size the number of elements in the buffer. 131 * @param numBanks the number of data banks. 132 */ DataBuffer(int dataType, int size, int numBanks)133 protected DataBuffer(int dataType, int size, int numBanks) { 134 this(dataType, size, numBanks, 0); 135 } 136 137 /** 138 * Creates a new <code>DataBuffer</code> with the specified data type, 139 * size and number of banks. An offset (which applies to all banks) is 140 * also specified. The <code>dataType</code> should be one of 141 * the constants {@link #TYPE_BYTE}, {@link #TYPE_SHORT}, 142 * {@link #TYPE_USHORT}, {@link #TYPE_INT}, {@link #TYPE_FLOAT} and 143 * {@link #TYPE_DOUBLE}. 144 * <p> 145 * The physical (array-based) storage is allocated by a subclass. 146 * 147 * @param dataType the data type. 148 * @param size the number of elements in the buffer. 149 * @param numBanks the number of data banks. 150 * @param offset the offset to the first element for all banks. 151 */ DataBuffer(int dataType, int size, int numBanks, int offset)152 protected DataBuffer(int dataType, int size, int numBanks, int offset) { 153 banks = numBanks; 154 this.dataType = dataType; 155 this.size = size; 156 this.offset = offset; 157 158 offsets = new int[ numBanks ]; 159 for(int i = 0; i < numBanks; i++ ) 160 offsets[i] = offset; 161 } 162 163 /** 164 * Creates a new <code>DataBuffer</code> with the specified data type, 165 * size and number of banks. An offset (which applies to all banks) is 166 * also specified. The <code>dataType</code> should be one of 167 * the constants {@link #TYPE_BYTE}, {@link #TYPE_SHORT}, 168 * {@link #TYPE_USHORT}, {@link #TYPE_INT}, {@link #TYPE_FLOAT} and 169 * {@link #TYPE_DOUBLE}. 170 * <p> 171 * The physical (array-based) storage is allocated by a subclass. 172 * 173 * @param dataType the data type. 174 * @param size the number of elements in the buffer. 175 * @param numBanks the number of data banks. 176 * @param offsets the offsets to the first element for all banks. 177 * 178 * @throws ArrayIndexOutOfBoundsException if 179 * <code>numBanks != offsets.length</code>. 180 */ DataBuffer(int dataType, int size, int numBanks, int[] offsets)181 protected DataBuffer(int dataType, int size, int numBanks, int[] offsets) { 182 if (numBanks != offsets.length) 183 throw new ArrayIndexOutOfBoundsException(); 184 185 this.dataType = dataType; 186 this.size = size; 187 banks = numBanks; 188 this.offsets = offsets; 189 190 offset = offsets[0]; 191 } 192 193 /** 194 * Returns the size (number of bits) of the specified data type. Valid types 195 * are defined by the constants {@link #TYPE_BYTE}, {@link #TYPE_SHORT}, 196 * {@link #TYPE_USHORT}, {@link #TYPE_INT}, {@link #TYPE_FLOAT} and 197 * {@link #TYPE_DOUBLE}. 198 * 199 * @param dataType the data type. 200 * @return The number of bits for the specified data type. 201 * @throws IllegalArgumentException if <code>dataType < 0</code> or 202 * <code>dataType > TYPE_DOUBLE</code>. 203 */ getDataTypeSize(int dataType)204 public static int getDataTypeSize(int dataType) { 205 // Maybe this should be a lookup table instead. 206 switch (dataType) 207 { 208 case TYPE_BYTE: 209 return 8; 210 case TYPE_USHORT: 211 case TYPE_SHORT: 212 return 16; 213 case TYPE_INT: 214 case TYPE_FLOAT: 215 return 32; 216 case TYPE_DOUBLE: 217 return 64; 218 default: 219 throw new IllegalArgumentException(); 220 } 221 } 222 223 /** 224 * Returns the type of the data elements in the data buffer. Valid types 225 * are defined by the constants {@link #TYPE_BYTE}, {@link #TYPE_SHORT}, 226 * {@link #TYPE_USHORT}, {@link #TYPE_INT}, {@link #TYPE_FLOAT} and 227 * {@link #TYPE_DOUBLE}. 228 * 229 * @return The type. 230 */ getDataType()231 public int getDataType() 232 { 233 return dataType; 234 } 235 236 /** 237 * Returns the size of the data buffer. 238 * 239 * @return The size. 240 */ getSize()241 public int getSize() 242 { 243 return size; 244 } 245 246 /** 247 * Returns the element offset for the first data bank. 248 * 249 * @return The element offset. 250 */ getOffset()251 public int getOffset() 252 { 253 return offset; 254 } 255 256 /** 257 * Returns the offsets for all the data banks used by this 258 * <code>DataBuffer</code>. 259 * 260 * @return The offsets. 261 */ getOffsets()262 public int[] getOffsets() 263 { 264 if (offsets == null) 265 { 266 // is this necessary? 267 offsets = new int[1]; 268 offsets[0] = offset; 269 } 270 return offsets; 271 } 272 273 /** 274 * Returns the number of data banks for this <code>DataBuffer</code>. 275 * @return The number of data banks. 276 */ getNumBanks()277 public int getNumBanks() 278 { 279 return banks; 280 } 281 282 /** 283 * Returns an element from the first data bank. The offset (specified in 284 * the constructor) is added to <code>i</code> before accessing the 285 * underlying data array. 286 * 287 * @param i the element index. 288 * @return The element. 289 */ getElem(int i)290 public int getElem(int i) 291 { 292 return getElem(0, i); 293 } 294 295 /** 296 * Returns an element from a particular data bank. The offset (specified in 297 * the constructor) is added to <code>i</code> before accessing the 298 * underlying data array. 299 * 300 * @param bank the bank index. 301 * @param i the element index. 302 * @return The element. 303 */ getElem(int bank, int i)304 public abstract int getElem(int bank, int i); 305 306 /** 307 * Sets an element in the first data bank. The offset (specified in the 308 * constructor) is added to <code>i</code> before updating the underlying 309 * data array. 310 * 311 * @param i the element index. 312 * @param val the new element value. 313 */ setElem(int i, int val)314 public void setElem(int i, int val) 315 { 316 setElem(0, i, val); 317 } 318 319 /** 320 * Sets an element in a particular data bank. The offset (specified in the 321 * constructor) is added to <code>i</code> before updating the underlying 322 * data array. 323 * 324 * @param bank the data bank index. 325 * @param i the element index. 326 * @param val the new element value. 327 */ setElem(int bank, int i, int val)328 public abstract void setElem(int bank, int i, int val); 329 330 /** 331 * Returns an element from the first data bank, converted to a 332 * <code>float</code>. The offset (specified in the constructor) is added 333 * to <code>i</code> before accessing the underlying data array. 334 * 335 * @param i the element index. 336 * @return The element. 337 */ getElemFloat(int i)338 public float getElemFloat(int i) 339 { 340 return getElem(i); 341 } 342 343 /** 344 * Returns an element from a particular data bank, converted to a 345 * <code>float</code>. The offset (specified in the constructor) is 346 * added to <code>i</code> before accessing the underlying data array. 347 * 348 * @param bank the bank index. 349 * @param i the element index. 350 * @return The element. 351 */ getElemFloat(int bank, int i)352 public float getElemFloat(int bank, int i) 353 { 354 return getElem(bank, i); 355 } 356 357 /** 358 * Sets an element in the first data bank. The offset (specified in the 359 * constructor) is added to <code>i</code> before updating the underlying 360 * data array. 361 * 362 * @param i the element index. 363 * @param val the new element value. 364 */ setElemFloat(int i, float val)365 public void setElemFloat(int i, float val) 366 { 367 setElem(i, (int) val); 368 } 369 370 /** 371 * Sets an element in a particular data bank. The offset (specified in the 372 * constructor) is added to <code>i</code> before updating the underlying 373 * data array. 374 * 375 * @param bank the data bank index. 376 * @param i the element index. 377 * @param val the new element value. 378 */ setElemFloat(int bank, int i, float val)379 public void setElemFloat(int bank, int i, float val) 380 { 381 setElem(bank, i, (int) val); 382 } 383 384 /** 385 * Returns an element from the first data bank, converted to a 386 * <code>double</code>. The offset (specified in the constructor) is added 387 * to <code>i</code> before accessing the underlying data array. 388 * 389 * @param i the element index. 390 * @return The element. 391 */ getElemDouble(int i)392 public double getElemDouble(int i) 393 { 394 return getElem(i); 395 } 396 397 /** 398 * Returns an element from a particular data bank, converted to a 399 * <code>double</code>. The offset (specified in the constructor) is 400 * added to <code>i</code> before accessing the underlying data array. 401 * 402 * @param bank the bank index. 403 * @param i the element index. 404 * @return The element. 405 */ getElemDouble(int bank, int i)406 public double getElemDouble(int bank, int i) 407 { 408 return getElem(bank, i); 409 } 410 411 /** 412 * Sets an element in the first data bank. The offset (specified in the 413 * constructor) is added to <code>i</code> before updating the underlying 414 * data array. 415 * 416 * @param i the element index. 417 * @param val the new element value. 418 */ setElemDouble(int i, double val)419 public void setElemDouble(int i, double val) 420 { 421 setElem(i, (int) val); 422 } 423 424 /** 425 * Sets an element in a particular data bank. The offset (specified in the 426 * constructor) is added to <code>i</code> before updating the underlying 427 * data array. 428 * 429 * @param bank the data bank index. 430 * @param i the element index. 431 * @param val the new element value. 432 */ setElemDouble(int bank, int i, double val)433 public void setElemDouble(int bank, int i, double val) 434 { 435 setElem(bank, i, (int) val); 436 } 437 } 438