/*

 * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/* ****************************************************************

 ******************************************************************

 ******************************************************************

 *** COPYRIGHT (c) Eastman Kodak Company, 1997

 *** As  an unpublished  work pursuant to Title 17 of the United

 *** States Code.  All rights reserved.

 ******************************************************************

 ******************************************************************

 ******************************************************************/

package java.awt.image;

/**

 *  This class represents image data which is stored in a band interleaved

 *  fashion and for

 *  which each sample of a pixel occupies one data element of the DataBuffer.

 *  It subclasses ComponentSampleModel but provides a more efficient

 *  implementation for accessing band interleaved image data than is provided

 *  by ComponentSampleModel.  This class should typically be used when working

 *  with images which store sample data for each band in a different bank of the

 *  DataBuffer. Accessor methods are provided so that image data can be

 *  manipulated directly. Pixel stride is the number of

 *  data array elements between two samples for the same band on the same

 *  scanline. The pixel stride for a BandedSampleModel is one.

 *  Scanline stride is the number of data array elements between

 *  a given sample and the corresponding sample in the same column of the next

 *  scanline.  Band offsets denote the number

 *  of data array elements from the first data array element of the bank

 *  of the DataBuffer holding each band to the first sample of the band.

 *  The bands are numbered from 0 to N-1.

 *  Bank indices denote the correspondence between a bank of the data buffer

 *  and a band of image data.  This class supports

 *  {@link DataBuffer#TYPE_BYTE TYPE_BYTE},

 *  {@link DataBuffer#TYPE_USHORT TYPE_USHORT},

 *  {@link DataBuffer#TYPE_SHORT TYPE_SHORT},

 *  {@link DataBuffer#TYPE_INT TYPE_INT},

 *  {@link DataBuffer#TYPE_FLOAT TYPE_FLOAT}, and

 *  {@link DataBuffer#TYPE_DOUBLE TYPE_DOUBLE} datatypes

 */

public final class BandedSampleModel extends ComponentSampleModel

{

    /**

     * Constructs a BandedSampleModel with the specified parameters.

     * The pixel stride will be one data element.  The scanline stride

     * will be the same as the width.  Each band will be stored in

     * a separate bank and all band offsets will be zero.

     * @param dataType  The data type for storing samples.

     * @param w         The width (in pixels) of the region of

     *                  image data described.

     * @param h         The height (in pixels) of the region of image

     *                  data described.

     * @param numBands  The number of bands for the image data.

     * @throws IllegalArgumentException if {@code dataType} is not

     *         one of the supported data types

     */

    public BandedSampleModel(int dataType, int w, int h, int numBands) {

        super(dataType, w, h, 1, w,

              BandedSampleModel.createIndicesArray(numBands),

              BandedSampleModel.createOffsetArray(numBands));

    }

    /**

     * Constructs a BandedSampleModel with the specified parameters.

     * The number of bands will be inferred from the lengths of the

     * bandOffsets bankIndices arrays, which must be equal.  The pixel

     * stride will be one data element.

     * @param dataType  The data type for storing samples.

     * @param w         The width (in pixels) of the region of

     *                  image data described.

     * @param h         The height (in pixels) of the region of

     *                  image data described.

     * @param scanlineStride The line stride of the of the image data.

     * @param bankIndices The bank index for each band.

     * @param bandOffsets The band offset for each band.

     * @throws IllegalArgumentException if {@code dataType} is not

     *         one of the supported data types

     */

    public BandedSampleModel(int dataType,

                             int w, int h,

                             int scanlineStride,

        super(dataType, w, h, 1,scanlineStride, bankIndices, bandOffsets);

    }

    /**

     * Creates a new BandedSampleModel with the specified

     * width and height.  The new BandedSampleModel will have the same

     * number of bands, storage data type, and bank indices

     * as this BandedSampleModel.  The band offsets will be compressed

     * such that the offset between bands will be w*pixelStride and

     * the minimum of all of the band offsets is zero.

     * @param w the width of the resulting {@code BandedSampleModel}

     * @param h the height of the resulting {@code BandedSampleModel}

     * @return a new {@code BandedSampleModel} with the specified

     *         width and height.

     * @throws IllegalArgumentException if {@code w} or

     *         {@code h} equals either

     *         {@code Integer.MAX_VALUE} or

     *         {@code Integer.MIN_VALUE}

     * @throws IllegalArgumentException if {@code dataType} is not

     *         one of the supported data types

     */

    public SampleModel createCompatibleSampleModel(int w, int h) {

        int[] bandOffs;

        if (numBanks == 1) {

            bandOffs = orderBands(bandOffsets, w*h);

        }

        else {

            bandOffs = new int[bandOffsets.length];

        }

        SampleModel sampleModel =

            new BandedSampleModel(dataType, w, h, w, bankIndices, bandOffs);

        return sampleModel;

    }

    /**

     * Creates a new BandedSampleModel with a subset of the bands of this

     * BandedSampleModel.  The new BandedSampleModel can be

     * used with any DataBuffer that the existing BandedSampleModel

     * can be used with.  The new BandedSampleModel/DataBuffer

     * combination will represent an image with a subset of the bands

     * of the original BandedSampleModel/DataBuffer combination.

     * @throws RasterFormatException if the number of bands is greater than

     *                               the number of banks in this sample model.

     * @throws IllegalArgumentException if {@code dataType} is not

     *         one of the supported data types

     */

        if (bands.length > bankIndices.length)

            throw new RasterFormatException("There are only " +

                                            bankIndices.length +

                                            " bands");

        for (int i=0; i<bands.length; i++) {

            newBankIndices[i] = bankIndices[bands[i]];

            newBandOffsets[i] = bandOffsets[bands[i]];

        }

        return new BandedSampleModel(this.dataType, width, height,

                                     this.scanlineStride,

                                     newBankIndices, newBandOffsets);

    }

    /**

     * Creates a DataBuffer that corresponds to this BandedSampleModel,

     * The DataBuffer's data type, number of banks, and size

     * will be consistent with this BandedSampleModel.

     * @throws IllegalArgumentException if {@code dataType} is not

     *         one of the supported types.

     */

    public DataBuffer createDataBuffer() {

        DataBuffer dataBuffer = null;

        // The minimum size required to store samples of one band

        int size = scanlineStride * height;

        if (numBanks == 1) {

            /*

             * The sample model contains a single bank of data buffer. Hence

             * we need to compute the size required to store samples of all

             * bands including the respective offsets.

             */

            int sizePerBand = size;

            size += bandOffsets[0];

            for (int index = 1; index < bandOffsets.length; index++) {

                size += (bandOffsets[index] - size) + sizePerBand;

            }

        } else {

            /*

             * The sample model contains multiple banks of data buffer where

             * each bank would correspond to a particular band. Hence we need

             * to compute only the additional space required for band offsets.

             */

            int maxBandOffset = bandOffsets[0];

            for (int index = 1; index < bandOffsets.length; index++) {

                maxBandOffset = Math.max(maxBandOffset, bandOffsets[index]);

            }

            size += maxBandOffset;

        }

        switch (dataType) {

        case DataBuffer.TYPE_BYTE:

            dataBuffer = new DataBufferByte(size, numBanks);

            break;

        case DataBuffer.TYPE_USHORT:

            dataBuffer = new DataBufferUShort(size, numBanks);

            break;

        case DataBuffer.TYPE_SHORT:

            dataBuffer = new DataBufferShort(size, numBanks);

            break;

        case DataBuffer.TYPE_INT:

            dataBuffer = new DataBufferInt(size, numBanks);

            break;

        case DataBuffer.TYPE_FLOAT:

            dataBuffer = new DataBufferFloat(size, numBanks);

            break;

        case DataBuffer.TYPE_DOUBLE:

            dataBuffer = new DataBufferDouble(size, numBanks);

            break;

        default:

            throw new IllegalArgumentException("dataType is not one " +

                "of the supported types.");

        }

        return dataBuffer;

    }

    /**

     * Returns data for a single pixel in a primitive array of type

     * TransferType.  For a BandedSampleModel, this will be the same

     * as the data type, and samples will be returned one per array

     * element.  Generally, obj

     * should be passed in as null, so that the Object will be created

     * automatically and will be of the right primitive data type.

     * <p>

     * The following code illustrates transferring data for one pixel from

     * DataBuffer {@code db1}, whose storage layout is described by

     * BandedSampleModel {@code bsm1}, to DataBuffer {@code db2},

     * whose storage layout is described by

     * BandedSampleModel {@code bsm2}.

     * The transfer will generally be more efficient than using

     * getPixel/setPixel.

     * <pre>

     *       BandedSampleModel bsm1, bsm2;

     *       DataBufferInt db1, db2;

     *       bsm2.setDataElements(x, y, bsm1.getDataElements(x, y, null, db1),

     *                            db2);

     * </pre>

     * Using getDataElements/setDataElements to transfer between two

     * DataBuffer/SampleModel pairs is legitimate if the SampleModels have

     * the same number of bands, corresponding bands have the same number of

     * bits per sample, and the TransferTypes are the same.

     * <p>

     * If obj is non-null, it should be a primitive array of type TransferType.

     * Otherwise, a ClassCastException is thrown.  An

     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are

     * not in bounds, or if obj is non-null and is not large enough to hold

     * the pixel data.

     * @param x         The X coordinate of the pixel location

     * @param y         The Y coordinate of the pixel location

     * @param obj       If non-null, a primitive array in which to return

     *                  the pixel data.

     * @param data      The DataBuffer containing the image data.

     * @return the data for the specified pixel.

     * @see #setDataElements(int, int, Object, DataBuffer)

     */

    public Object getDataElements(int x, int y, Object obj, DataBuffer data) {

        if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {

            throw new ArrayIndexOutOfBoundsException

                ("Coordinate out of bounds!");

        }

        int type = getTransferType();

        int numDataElems = getNumDataElements();

        int pixelOffset = y*scanlineStride + x;

        switch(type) {

        case DataBuffer.TYPE_BYTE:

            byte[] bdata;

            if (obj == null) {

                bdata = new byte[numDataElems];

            } else {

                bdata = (byte[])obj;

            }

            for (int i=0; i<numDataElems; i++) {

                bdata[i] = (byte)data.getElem(bankIndices[i],

                                              pixelOffset + bandOffsets[i]);

            }

            obj = (Object)bdata;

            break;

        case DataBuffer.TYPE_USHORT:

        case DataBuffer.TYPE_SHORT:

            short[] sdata;

            if (obj == null) {

                sdata = new short[numDataElems];

            } else {

                sdata = (short[])obj;

            }

            for (int i=0; i<numDataElems; i++) {

                sdata[i] = (short)data.getElem(bankIndices[i],

                                               pixelOffset + bandOffsets[i]);

            }

            obj = (Object)sdata;

            break;

        case DataBuffer.TYPE_INT:

            int[] idata;

            if (obj == null) {

                idata = new int[numDataElems];

            } else {

                idata = (int[])obj;

            }

            for (int i=0; i<numDataElems; i++) {

                idata[i] = data.getElem(bankIndices[i],

                                        pixelOffset + bandOffsets[i]);

            }

            obj = (Object)idata;

            break;

        case DataBuffer.TYPE_FLOAT:

            float[] fdata;

            if (obj == null) {

                fdata = new float[numDataElems];

            } else {

                fdata = (float[])obj;

            }

            for (int i=0; i<numDataElems; i++) {

                fdata[i] = data.getElemFloat(bankIndices[i],

                                             pixelOffset + bandOffsets[i]);

            }

            obj = (Object)fdata;

            break;

        case DataBuffer.TYPE_DOUBLE:

            double[] ddata;

            if (obj == null) {

                ddata = new double[numDataElems];

            } else {

                ddata = (double[])obj;

            }

            for (int i=0; i<numDataElems; i++) {

                ddata[i] = data.getElemDouble(bankIndices[i],

                                              pixelOffset + bandOffsets[i]);

            }

            obj = (Object)ddata;

            break;

        }

        return obj;

    }

    /**

     * Returns all samples for the specified pixel in an int array.

     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are

     * not in bounds.

     * @param x         The X coordinate of the pixel location

     * @param y         The Y coordinate of the pixel location

     * @param iArray    If non-null, returns the samples in this array

     * @param data      The DataBuffer containing the image data

     * @return the samples for the specified pixel.

     * @see #setPixel(int, int, int[], DataBuffer)

     */

        if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {

            throw new ArrayIndexOutOfBoundsException

                ("Coordinate out of bounds!");

        }

        int[] pixels;

        if (iArray != null) {

           pixels = iArray;

        } else {

           pixels = new int [numBands];

        }

        int pixelOffset = y*scanlineStride + x;

        for (int i=0; i<numBands; i++) {

            pixels[i] = data.getElem(bankIndices[i],

                                     pixelOffset + bandOffsets[i]);

        }

        return pixels;

    }

    /**

     * Returns all samples for the specified rectangle of pixels in

     * an int array, one sample per data array element.

     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are

     * not in bounds.

     * @param x         The X coordinate of the upper left pixel location

     * @param y         The Y coordinate of the upper left pixel location

     * @param w         The width of the pixel rectangle

     * @param h         The height of the pixel rectangle

     * @param iArray    If non-null, returns the samples in this array

     * @param data      The DataBuffer containing the image data

     * @return the samples for the pixels within the specified region.

     * @see #setPixels(int, int, int, int, int[], DataBuffer)

     */

    public int[] getPixels(int x, int y, int w, int h,

        int x1 = x + w;

        int y1 = y + h;

        if (x < 0 || x >= width || w > width || x1 < 0 || x1 > width ||

            y < 0 || y >= height || h > height || y1 < 0 || y1 >  height)

        {

            throw new ArrayIndexOutOfBoundsException

                ("Coordinate out of bounds!");

        }

        int[] pixels;

        if (iArray != null) {

           pixels = iArray;

        } else {

           pixels = new int[w*h*numBands];

        }

        for (int k = 0; k < numBands; k++) {

            int lineOffset = y*scanlineStride + x + bandOffsets[k];

            int srcOffset = k;

            int bank = bankIndices[k];

            for (int i = 0; i < h; i++) {

                int pixelOffset = lineOffset;

                for (int j = 0; j < w; j++) {

                    pixels[srcOffset] = data.getElem(bank, pixelOffset++);

                    srcOffset += numBands;

                }

                lineOffset += scanlineStride;

            }

        }

        return pixels;

    }

    /**

     * Returns as int the sample in a specified band for the pixel

     * located at (x,y).

     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are

     * not in bounds.

     * @param x         The X coordinate of the pixel location

     * @param y         The Y coordinate of the pixel location

     * @param b         The band to return

     * @param data      The DataBuffer containing the image data

     * @return the sample in the specified band for the specified pixel.

     * @see #setSample(int, int, int, int, DataBuffer)

     */

    public int getSample(int x, int y, int b, DataBuffer data) {

        // Bounds check for 'b' will be performed automatically

        if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {

            throw new ArrayIndexOutOfBoundsException

                ("Coordinate out of bounds!");

        }

        int sample =

            data.getElem(bankIndices[b],

                         y*scanlineStride + x + bandOffsets[b]);

        return sample;

    }

    /**

     * Returns the sample in a specified band

     * for the pixel located at (x,y) as a float.

     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are

     * not in bounds.

     * @param x         The X coordinate of the pixel location

     * @param y         The Y coordinate of the pixel location

     * @param b         The band to return

     * @param data      The DataBuffer containing the image data

     * @return a float value that represents the sample in the specified

     * band for the specified pixel.

     */

    public float getSampleFloat(int x, int y, int b, DataBuffer data) {

        // Bounds check for 'b' will be performed automatically

        if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {

            throw new ArrayIndexOutOfBoundsException

                ("Coordinate out of bounds!");

        }

        float sample = data.getElemFloat(bankIndices[b],

                                    y*scanlineStride + x + bandOffsets[b]);

        return sample;

    }

    /**

     * Returns the sample in a specified band

     * for a pixel located at (x,y) as a double.

     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are