1/* 2 * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26package java.awt.image; 27 28import static sun.java2d.StateTrackable.State.*; 29 30/** 31 * This class extends {@code DataBuffer} and stores data internally 32 * in {@code float} form. 33 * <p> 34 * <a id="optimizations"> 35 * Note that some implementations may function more efficiently 36 * if they can maintain control over how the data for an image is 37 * stored. 38 * For example, optimizations such as caching an image in video 39 * memory require that the implementation track all modifications 40 * to that data. 41 * Other implementations may operate better if they can store the 42 * data in locations other than a Java array. 43 * To maintain optimum compatibility with various optimizations 44 * it is best to avoid constructors and methods which expose the 45 * underlying storage as a Java array as noted below in the 46 * documentation for those methods. 47 * </a> 48 * 49 * @since 1.4 50 */ 51 52public final class DataBufferFloat extends DataBuffer { 53 54 /** The array of data banks. */ 55 float bankdata[][]; 56 57 /** A reference to the default data bank. */ 58 float data[]; 59 60 /** 61 * Constructs a {@code float}-based {@code DataBuffer} 62 * with a specified size. 63 * 64 * @param size The number of elements in the DataBuffer. 65 */ 66 public DataBufferFloat(int size) { 67 super(STABLE, TYPE_FLOAT, size); 68 data = new float[size]; 69 bankdata = new float[1][]; 70 bankdata[0] = data; 71 } 72 73 /** 74 * Constructs a {@code float}-based {@code DataBuffer} 75 * with a specified number of banks, all of which are of a 76 * specified size. 77 * 78 * @param size The number of elements in each bank of the 79 * {@code DataBuffer}. 80 * @param numBanks The number of banks in the 81 * {@code DataBuffer}. 82 */ 83 public DataBufferFloat(int size, int numBanks) { 84 super(STABLE, TYPE_FLOAT, size, numBanks); 85 bankdata = new float[numBanks][]; 86 for (int i= 0; i < numBanks; i++) { 87 bankdata[i] = new float[size]; 88 } 89 data = bankdata[0]; 90 } 91 92 /** 93 * Constructs a {@code float}-based {@code DataBuffer} 94 * with the specified data array. Only the first 95 * {@code size} elements are available for use by this 96 * {@code DataBuffer}. The array must be large enough to 97 * hold {@code size} elements. 98 * <p> 99 * Note that {@code DataBuffer} objects created by this constructor 100 * may be incompatible with <a href="#optimizations">performance 101 * optimizations</a> used by some implementations (such as caching 102 * an associated image in video memory). 103 * 104 * @param dataArray An array of {@code float}s to be used as the 105 * first and only bank of this {@code DataBuffer}. 106 * @param size The number of elements of the array to be used. 107 */ 108 public DataBufferFloat(float dataArray[], int size) { 109 super(UNTRACKABLE, TYPE_FLOAT, size); 110 data = dataArray; 111 bankdata = new float[1][]; 112 bankdata[0] = data; 113 } 114 115 /** 116 * Constructs a {@code float}-based {@code DataBuffer} 117 * with the specified data array. Only the elements between 118 * {@code offset} and {@code offset + size - 1} are 119 * available for use by this {@code DataBuffer}. The array 120 * must be large enough to hold {@code offset + size} 121 * elements. 122 * <p> 123 * Note that {@code DataBuffer} objects created by this constructor 124 * may be incompatible with <a href="#optimizations">performance 125 * optimizations</a> used by some implementations (such as caching 126 * an associated image in video memory). 127 * 128 * @param dataArray An array of {@code float}s to be used as the 129 * first and only bank of this {@code DataBuffer}. 130 * @param size The number of elements of the array to be used. 131 * @param offset The offset of the first element of the array 132 * that will be used. 133 */ 134 public DataBufferFloat(float dataArray[], int size, int offset) { 135 super(UNTRACKABLE, TYPE_FLOAT, size, 1, offset); 136 data = dataArray; 137 bankdata = new float[1][]; 138 bankdata[0] = data; 139 } 140 141 /** 142 * Constructs a {@code float}-based {@code DataBuffer} 143 * with the specified data arrays. Only the first 144 * {@code size} elements of each array are available for use 145 * by this {@code DataBuffer}. The number of banks will be 146 * equal to {@code dataArray.length}. 147 * <p> 148 * Note that {@code DataBuffer} objects created by this constructor 149 * may be incompatible with <a href="#optimizations">performance 150 * optimizations</a> used by some implementations (such as caching 151 * an associated image in video memory). 152 * 153 * @param dataArray An array of arrays of {@code float}s to be 154 * used as the banks of this {@code DataBuffer}. 155 * @param size The number of elements of each array to be used. 156 */ 157 public DataBufferFloat(float dataArray[][], int size) { 158 super(UNTRACKABLE, TYPE_FLOAT, size, dataArray.length); 159 bankdata = dataArray.clone(); 160 data = bankdata[0]; 161 } 162 163 /** 164 * Constructs a {@code float}-based {@code DataBuffer} 165 * with the specified data arrays, size, and per-bank offsets. 166 * The number of banks is equal to {@code dataArray.length}. 167 * Each array must be at least as large as {@code size} plus the 168 * corresponding offset. There must be an entry in the offsets 169 * array for each data array. 170 * <p> 171 * Note that {@code DataBuffer} objects created by this constructor 172 * may be incompatible with <a href="#optimizations">performance 173 * optimizations</a> used by some implementations (such as caching 174 * an associated image in video memory). 175 * 176 * @param dataArray An array of arrays of {@code float}s to be 177 * used as the banks of this {@code DataBuffer}. 178 * @param size The number of elements of each array to be used. 179 * @param offsets An array of integer offsets, one for each bank. 180 */ 181 public DataBufferFloat(float dataArray[][], int size, int offsets[]) { 182 super(UNTRACKABLE, TYPE_FLOAT, size,dataArray.length, offsets); 183 bankdata = dataArray.clone(); 184 data = bankdata[0]; 185 } 186 187 /** 188 * Returns the default (first) {@code float} data array. 189 * <p> 190 * Note that calling this method may cause this {@code DataBuffer} 191 * object to be incompatible with <a href="#optimizations">performance 192 * optimizations</a> used by some implementations (such as caching 193 * an associated image in video memory). 194 * 195 * @return the first float data array. 196 */ 197 public float[] getData() { 198 theTrackable.setUntrackable(); 199 return data; 200 } 201 202 /** 203 * Returns the data array for the specified bank. 204 * <p> 205 * Note that calling this method may cause this {@code DataBuffer} 206 * object to be incompatible with <a href="#optimizations">performance 207 * optimizations</a> used by some implementations (such as caching 208 * an associated image in video memory). 209 * 210 * @param bank the data array 211 * @return the data array specified by {@code bank}. 212 */ 213 public float[] getData(int bank) { 214 theTrackable.setUntrackable(); 215 return bankdata[bank]; 216 } 217 218 /** 219 * Returns the data array for all banks. 220 * <p> 221 * Note that calling this method may cause this {@code DataBuffer} 222 * object to be incompatible with <a href="#optimizations">performance 223 * optimizations</a> used by some implementations (such as caching 224 * an associated image in video memory). 225 * 226 * @return all data arrays for this data buffer. 227 */ 228 public float[][] getBankData() { 229 theTrackable.setUntrackable(); 230 return bankdata.clone(); 231 } 232 233 /** 234 * Returns the requested data array element from the first 235 * (default) bank as an {@code int}. 236 * 237 * @param i The desired data array element. 238 * 239 * @return The data entry as an {@code int}. 240 * @see #setElem(int, int) 241 * @see #setElem(int, int, int) 242 */ 243 public int getElem(int i) { 244 return (int)(data[i+offset]); 245 } 246 247 /** 248 * Returns the requested data array element from the specified 249 * bank as an {@code int}. 250 * 251 * @param bank The bank number. 252 * @param i The desired data array element. 253 * 254 * @return The data entry as an {@code int}. 255 * @see #setElem(int, int) 256 * @see #setElem(int, int, int) 257 */ 258 public int getElem(int bank, int i) { 259 return (int)(bankdata[bank][i+offsets[bank]]); 260 } 261 262 /** 263 * Sets the requested data array element in the first (default) 264 * bank to the given {@code int}. 265 * 266 * @param i The desired data array element. 267 * @param val The value to be set. 268 * @see #getElem(int) 269 * @see #getElem(int, int) 270 */ 271 public void setElem(int i, int val) { 272 data[i+offset] = (float)val; 273 theTrackable.markDirty(); 274 } 275 276 /** 277 * Sets the requested data array element in the specified bank to 278 * the given {@code int}. 279 * 280 * @param bank The bank number. 281 * @param i The desired data array element. 282 * @param val The value to be set. 283 * @see #getElem(int) 284 * @see #getElem(int, int) 285 */ 286 public void setElem(int bank, int i, int val) { 287 bankdata[bank][i+offsets[bank]] = (float)val; 288 theTrackable.markDirty(); 289 } 290 291 /** 292 * Returns the requested data array element from the first 293 * (default) bank as a {@code float}. 294 * 295 * @param i The desired data array element. 296 * 297 * @return The data entry as a {@code float}. 298 * @see #setElemFloat(int, float) 299 * @see #setElemFloat(int, int, float) 300 */ 301 public float getElemFloat(int i) { 302 return data[i+offset]; 303 } 304 305 /** 306 * Returns the requested data array element from the specified 307 * bank as a {@code float}. 308 * 309 * @param bank The bank number. 310 * @param i The desired data array element. 311 * 312 * @return The data entry as a {@code float}. 313 * @see #setElemFloat(int, float) 314 * @see #setElemFloat(int, int, float) 315 */ 316 public float getElemFloat(int bank, int i) { 317 return bankdata[bank][i+offsets[bank]]; 318 } 319 320 /** 321 * Sets the requested data array element in the first (default) 322 * bank to the given {@code float}. 323 * 324 * @param i The desired data array element. 325 * @param val The value to be set. 326 * @see #getElemFloat(int) 327 * @see #getElemFloat(int, int) 328 */ 329 public void setElemFloat(int i, float val) { 330 data[i+offset] = val; 331 theTrackable.markDirty(); 332 } 333 334 /** 335 * Sets the requested data array element in the specified bank to 336 * the given {@code float}. 337 * 338 * @param bank The bank number. 339 * @param i The desired data array element. 340 * @param val The value to be set. 341 * @see #getElemFloat(int) 342 * @see #getElemFloat(int, int) 343 */ 344 public void setElemFloat(int bank, int i, float val) { 345 bankdata[bank][i+offsets[bank]] = val; 346 theTrackable.markDirty(); 347 } 348 349 /** 350 * Returns the requested data array element from the first 351 * (default) bank as a {@code double}. 352 * 353 * @param i The desired data array element. 354 * 355 * @return The data entry as a {@code double}. 356 * @see #setElemDouble(int, double) 357 * @see #setElemDouble(int, int, double) 358 */ 359 public double getElemDouble(int i) { 360 return (double)data[i+offset]; 361 } 362 363 /** 364 * Returns the requested data array element from the specified 365 * bank as a {@code double}. 366 * 367 * @param bank The bank number. 368 * @param i The desired data array element. 369 * 370 * @return The data entry as a {@code double}. 371 * @see #setElemDouble(int, double) 372 * @see #setElemDouble(int, int, double) 373 */ 374 public double getElemDouble(int bank, int i) { 375 return (double)bankdata[bank][i+offsets[bank]]; 376 } 377 378 /** 379 * Sets the requested data array element in the first (default) 380 * bank to the given {@code double}. 381 * 382 * @param i The desired data array element. 383 * @param val The value to be set. 384 * @see #getElemDouble(int) 385 * @see #getElemDouble(int, int) 386 */ 387 public void setElemDouble(int i, double val) { 388 data[i+offset] = (float)val; 389 theTrackable.markDirty(); 390 } 391 392 /** 393 * Sets the requested data array element in the specified bank to 394 * the given {@code double}. 395 * 396 * @param bank The bank number. 397 * @param i The desired data array element. 398 * @param val The value to be set. 399 * @see #getElemDouble(int) 400 * @see #getElemDouble(int, int) 401 */ 402 public void setElemDouble(int bank, int i, double val) { 403 bankdata[bank][i+offsets[bank]] = (float)val; 404 theTrackable.markDirty(); 405 } 406} 407