mirror of git://gcc.gnu.org/git/gcc.git
521 lines
14 KiB
Java
521 lines
14 KiB
Java
/* ZigZag.java --
|
|
Copyright (C) 2005 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package gnu.javax.imageio.jpeg;
|
|
|
|
/**
|
|
* This class implements the Zig Zag Algorithm on any array with
|
|
* the same amount of rows and columns. It takes a matrix and in turn builds an
|
|
* encoded byte array (or double array) from it. The adverse is also true, this
|
|
* will take a byte or double array and build a matrix based on the zig zag
|
|
* algorithm.
|
|
* <p>This is used exclusively in the JPEG DCT encoding.</p>
|
|
*/
|
|
public class ZigZag
|
|
{
|
|
public final static boolean ZIGZAG_FORWARD = true;
|
|
public final static boolean ZIGZAG_BACKWARD = false;
|
|
public final static int ZIGZAG_8X8_MAP[] =
|
|
{
|
|
0, 1, 8, 16, 9, 2, 3, 10,
|
|
17, 24, 32, 25, 18, 11, 4, 5,
|
|
12, 19, 26, 33, 40, 48, 41, 34,
|
|
27, 20, 13, 6, 7, 14, 21, 28,
|
|
35, 42, 49, 56, 57, 50, 43, 36,
|
|
29, 22, 15, 23, 30, 37, 44, 51,
|
|
58, 59, 52, 45, 38, 31, 39, 46,
|
|
53, 60, 61, 54, 47, 55, 62, 63
|
|
};
|
|
|
|
/**
|
|
* Encodes a matrix of equal width and height to a byte array.
|
|
*
|
|
* @param matrix
|
|
*
|
|
* @return
|
|
*/
|
|
public static byte[] encode(byte[][] matrix)
|
|
{
|
|
byte[] buffer = new byte[matrix.length ^ 2];
|
|
boolean direction = ZigZag.ZIGZAG_FORWARD;
|
|
int x = 0, y = 0, index = 0;
|
|
for (int zigIndex = 0; zigIndex < (matrix.length * 2 - 1);
|
|
zigIndex++, direction = !direction)
|
|
{
|
|
if (direction == ZigZag.ZIGZAG_FORWARD)
|
|
{
|
|
while (x >= 0 && y != matrix.length)
|
|
{
|
|
if (x == matrix.length)
|
|
{
|
|
x--;
|
|
y++;
|
|
}
|
|
buffer[index] = matrix[x][y];
|
|
y++;
|
|
x--;
|
|
index++;
|
|
}
|
|
x++;
|
|
}
|
|
else
|
|
{
|
|
while (y >= 0 && x != matrix.length)
|
|
{
|
|
if (y == matrix.length)
|
|
{
|
|
y--;
|
|
x++;
|
|
}
|
|
buffer[index] = matrix[x][y];
|
|
y--;
|
|
x++;
|
|
index++;
|
|
}
|
|
y++;
|
|
}
|
|
}
|
|
return (buffer);
|
|
}
|
|
|
|
/**
|
|
* Encodes a matrix of equal width and height to a double array
|
|
*
|
|
* @param matrix
|
|
*
|
|
* @return
|
|
*/
|
|
public static double[] encode(double[][] matrix)
|
|
{
|
|
double[] buffer = new double[matrix.length * matrix.length];
|
|
boolean direction = ZigZag.ZIGZAG_FORWARD;
|
|
int x = 0, y = 0, index = 0;
|
|
for (int zigIndex = 0; zigIndex < (matrix.length * 2 - 1);
|
|
zigIndex++, direction = !direction)
|
|
{
|
|
if (direction == ZigZag.ZIGZAG_FORWARD)
|
|
{
|
|
while (x >= 0 && y != matrix.length)
|
|
{
|
|
if (x == matrix.length)
|
|
{
|
|
x--;
|
|
y++;
|
|
}
|
|
buffer[index] = matrix[x][y];
|
|
y++;
|
|
x--;
|
|
index++;
|
|
}
|
|
x++;
|
|
}
|
|
else
|
|
{
|
|
while (y >= 0 && x != matrix.length)
|
|
{
|
|
if (y == matrix.length)
|
|
{
|
|
y--;
|
|
x++;
|
|
}
|
|
buffer[index] = matrix[x][y];
|
|
y--;
|
|
x++;
|
|
index++;
|
|
}
|
|
y++;
|
|
}
|
|
}
|
|
return (buffer);
|
|
}
|
|
|
|
/**
|
|
* Encodes a matrix of equal width and height to a float array
|
|
*
|
|
* @param matrix
|
|
*
|
|
* @return
|
|
*/
|
|
public static float[] encode(float[][] matrix)
|
|
{
|
|
float[] buffer = new float[matrix.length * matrix.length];
|
|
boolean direction = ZigZag.ZIGZAG_FORWARD;
|
|
int x = 0, y = 0, index = 0;
|
|
for (int zigIndex = 0; zigIndex < (matrix.length * 2 - 1);
|
|
zigIndex++, direction = !direction)
|
|
{
|
|
if (direction == ZigZag.ZIGZAG_FORWARD)
|
|
{
|
|
while (x >= 0 && y != matrix.length)
|
|
{
|
|
if (x == matrix.length)
|
|
{
|
|
x--;
|
|
y++;
|
|
}
|
|
buffer[index] = matrix[x][y];
|
|
y++;
|
|
x--;
|
|
index++;
|
|
}
|
|
x++;
|
|
}
|
|
else
|
|
{
|
|
while (y >= 0 && x != matrix.length)
|
|
{
|
|
if (y == matrix.length)
|
|
{
|
|
y--;
|
|
x++;
|
|
}
|
|
buffer[index] = matrix[x][y];
|
|
y--;
|
|
x++;
|
|
index++;
|
|
}
|
|
y++;
|
|
}
|
|
}
|
|
return (buffer);
|
|
}
|
|
|
|
/**
|
|
* Encodes a matrix of equal width and height to a float array
|
|
*
|
|
* @param matrix
|
|
*
|
|
* @return
|
|
*/
|
|
public static short[] encode(short[][] matrix)
|
|
{
|
|
short[] buffer = new short[matrix.length * matrix.length];
|
|
boolean direction = ZigZag.ZIGZAG_FORWARD;
|
|
int x = 0, y = 0, index = 0;
|
|
for (int zigIndex = 0; zigIndex < (matrix.length * 2 - 1);
|
|
zigIndex++, direction = !direction)
|
|
{
|
|
if (direction == ZigZag.ZIGZAG_FORWARD)
|
|
{
|
|
while (x >= 0 && y != matrix.length)
|
|
{
|
|
if (x == matrix.length)
|
|
{
|
|
x--;
|
|
y++;
|
|
}
|
|
buffer[index] = matrix[x][y];
|
|
y++;
|
|
x--;
|
|
index++;
|
|
}
|
|
x++;
|
|
}
|
|
else
|
|
{
|
|
while (y >= 0 && x != matrix.length)
|
|
{
|
|
if (y == matrix.length)
|
|
{
|
|
y--;
|
|
x++;
|
|
}
|
|
buffer[index] = matrix[x][y];
|
|
y--;
|
|
x++;
|
|
index++;
|
|
}
|
|
y++;
|
|
}
|
|
}
|
|
return (buffer);
|
|
}
|
|
|
|
/**
|
|
* Convert a double array into a matrix with the same amount of columns and
|
|
* rows with length sqrt(double array length)
|
|
*
|
|
* @param data
|
|
*
|
|
* @return
|
|
*/
|
|
public static double[][] decode(double[] data)
|
|
{
|
|
return decode(data, (int) Math.sqrt(data.length),
|
|
(int) Math.sqrt(data.length));
|
|
}
|
|
|
|
/**
|
|
* Convert a byte array into a matrix with the same amount of columns and
|
|
* rows with length sqrt(double array length)
|
|
*
|
|
* @param data
|
|
*
|
|
* @return
|
|
*/
|
|
public static byte[][] decode(byte[] data)
|
|
{
|
|
return decode(data, (int) Math.sqrt(data.length),
|
|
(int) Math.sqrt(data.length));
|
|
}
|
|
|
|
public static int[][] decode(int[] data)
|
|
{
|
|
return decode(data, (int) Math.sqrt(data.length),
|
|
(int) Math.sqrt(data.length));
|
|
}
|
|
|
|
public static byte[][] decode(byte[] data, int width, int height)
|
|
{
|
|
byte[][] buffer = new byte[height][width];
|
|
|
|
for (int v = 0; v < height; v++)
|
|
for (int z = 0; z < width; z++)
|
|
buffer[v][z] = 11;
|
|
|
|
boolean dir = ZigZag.ZIGZAG_FORWARD;
|
|
int xindex = 0, yindex = 0, dataindex = 0;
|
|
|
|
while (xindex < width && yindex < height && dataindex < data.length)
|
|
{
|
|
buffer[yindex][xindex] = data[dataindex];
|
|
dataindex++;
|
|
|
|
if (dir == ZigZag.ZIGZAG_FORWARD)
|
|
{
|
|
if (yindex == 0 || xindex == (width - 1))
|
|
{
|
|
dir = ZigZag.ZIGZAG_BACKWARD;
|
|
if (xindex == (width - 1))
|
|
yindex++;
|
|
else
|
|
xindex++;
|
|
}
|
|
else
|
|
{
|
|
yindex--;
|
|
xindex++;
|
|
}
|
|
}
|
|
else
|
|
{ /* Backwards */
|
|
if (xindex == 0 || yindex == (height - 1))
|
|
{
|
|
dir = ZigZag.ZIGZAG_FORWARD;
|
|
if (yindex == (height - 1))
|
|
xindex++;
|
|
else
|
|
yindex++;
|
|
}
|
|
else
|
|
{
|
|
yindex++;
|
|
xindex--;
|
|
}
|
|
}
|
|
}
|
|
return (buffer);
|
|
}
|
|
|
|
public static double[][] decode(double[] data, int width, int height)
|
|
{
|
|
double[][] buffer = new double[height][width];
|
|
|
|
for (int v = 0; v < height; v++)
|
|
for (int z = 0; z < width; z++)
|
|
buffer[v][z] = 11;
|
|
|
|
boolean dir = ZigZag.ZIGZAG_FORWARD;
|
|
int xindex = 0, yindex = 0, dataindex = 0;
|
|
|
|
while (xindex < width && yindex < height && dataindex < data.length)
|
|
{
|
|
buffer[yindex][xindex] = data[dataindex];
|
|
dataindex++;
|
|
System.err.println("Setting " + dataindex + " to row: " + yindex
|
|
+ " column: " + xindex + " yourval:"
|
|
+ (yindex*8+xindex));
|
|
if (dir == ZigZag.ZIGZAG_FORWARD)
|
|
{
|
|
if (yindex == 0 || xindex == (width - 1))
|
|
{
|
|
dir = ZigZag.ZIGZAG_BACKWARD;
|
|
if (xindex == (width - 1))
|
|
yindex++;
|
|
else
|
|
xindex++;
|
|
}
|
|
else
|
|
{
|
|
yindex--;
|
|
xindex++;
|
|
}
|
|
}
|
|
else
|
|
{ /* Backwards */
|
|
if (xindex == 0 || yindex == (height - 1))
|
|
{
|
|
dir = ZigZag.ZIGZAG_FORWARD;
|
|
if (yindex == (height - 1))
|
|
xindex++;
|
|
else
|
|
yindex++;
|
|
}
|
|
else
|
|
{
|
|
yindex++;
|
|
xindex--;
|
|
}
|
|
}
|
|
}
|
|
return (buffer);
|
|
}
|
|
|
|
public static float[][] decode(float[] data, int width, int height)
|
|
{
|
|
float[][] buffer = new float[height][width];
|
|
|
|
for (int v = 0; v < height; v++)
|
|
for (int z = 0; z < width; z++)
|
|
buffer[v][z] = 11;
|
|
|
|
boolean dir = ZigZag.ZIGZAG_FORWARD;
|
|
int xindex = 0, yindex = 0, dataindex = 0;
|
|
|
|
while (xindex < width && yindex < height && dataindex < data.length)
|
|
{
|
|
buffer[yindex][xindex] = data[dataindex];
|
|
dataindex++;
|
|
|
|
if (dir == ZigZag.ZIGZAG_FORWARD)
|
|
{
|
|
if (yindex == 0 || xindex == (width - 1))
|
|
{
|
|
dir = ZigZag.ZIGZAG_BACKWARD;
|
|
if (xindex == (width - 1))
|
|
yindex++;
|
|
else
|
|
xindex++;
|
|
}
|
|
else
|
|
{
|
|
yindex--;
|
|
xindex++;
|
|
}
|
|
}
|
|
else
|
|
{ /* Backwards */
|
|
if (xindex == 0 || yindex == (height - 1))
|
|
{
|
|
dir = ZigZag.ZIGZAG_FORWARD;
|
|
if (yindex == (height - 1))
|
|
xindex++;
|
|
else
|
|
yindex++;
|
|
}
|
|
else
|
|
{
|
|
yindex++;
|
|
xindex--;
|
|
}
|
|
}
|
|
}
|
|
return (buffer);
|
|
}
|
|
|
|
public static int[][] decode(int[] data, int width, int height)
|
|
{
|
|
int[][] buffer = new int[height][width];
|
|
|
|
for (int v = 0; v < height; v++)
|
|
for (int z = 0; z < width; z++)
|
|
buffer[v][z] = 11;
|
|
|
|
boolean dir = ZigZag.ZIGZAG_FORWARD;
|
|
int xindex = 0, yindex = 0, dataindex = 0;
|
|
|
|
while (xindex < width && yindex < height && dataindex < data.length)
|
|
{
|
|
buffer[yindex][xindex] = data[dataindex];
|
|
dataindex++;
|
|
|
|
if (dir == ZigZag.ZIGZAG_FORWARD)
|
|
{
|
|
if (yindex == 0 || xindex == (width - 1))
|
|
{
|
|
dir = ZigZag.ZIGZAG_BACKWARD;
|
|
if (xindex == (width - 1))
|
|
yindex++;
|
|
else
|
|
xindex++;
|
|
}
|
|
else
|
|
{
|
|
yindex--;
|
|
xindex++;
|
|
}
|
|
}
|
|
else
|
|
{ /* Backwards */
|
|
if (xindex == 0 || yindex == (height - 1))
|
|
{
|
|
dir = ZigZag.ZIGZAG_FORWARD;
|
|
if (yindex == (height - 1))
|
|
xindex++;
|
|
else
|
|
yindex++;
|
|
}
|
|
else
|
|
{
|
|
yindex++;
|
|
xindex--;
|
|
}
|
|
}
|
|
}
|
|
return (buffer);
|
|
}
|
|
|
|
public static double[][] decode8x8_map(double input[])
|
|
{
|
|
double[][] output = new double[8][8];
|
|
for(int i=0; i < 64 ; i++)
|
|
output[ZIGZAG_8X8_MAP[i]/8][ZIGZAG_8X8_MAP[i]%8] = input[i];
|
|
return (output);
|
|
}
|
|
|
|
}
|