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