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 

    26 package java.awt.image;

    27 

    28 import 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 

    52 public 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 }