mirror of
https://git.huckle.dev/Huckles-Minecraft-Archive/jpexs-decompiler.git
synced 2026-05-24 18:54:34 +00:00
473 lines
15 KiB
Java
473 lines
15 KiB
Java
/*
|
|
* $Id: PDFImage.java,v 1.2 2007/08/26 18:56:35 gil1 Exp $
|
|
*
|
|
* $Date: 2007/08/26 18:56:35 $
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
package gnu.jpdf;
|
|
|
|
import java.awt.Image;
|
|
import java.awt.image.*;
|
|
import java.io.*;
|
|
import java.util.*;
|
|
import java.util.zip.*;
|
|
|
|
/**
|
|
* <p>
|
|
* This implements the Image XObject. Calling one of the <code>drawImage</code>
|
|
* methods of <code>PDFGraphics</code> will put all the necessary code into the
|
|
* pdf file, and the image will be encoded in ascii base 85, then deflated in
|
|
* zip format.</p>
|
|
*
|
|
* @author Eric Z. Beard (original version by Peter Mount)
|
|
* @author Matthew Hreljac, mhreljac@hotmail.com
|
|
* @version $Revision: 1.2 $, $Date: 2007/08/26 18:56:35 $
|
|
*/
|
|
public class PDFImage extends PDFStream implements ImageObserver, Serializable {
|
|
|
|
/*
|
|
* NOTE: The original class is the work of Peter T. Mount, who released it
|
|
* in the uk.org.retep.pdf package. It was modified by Eric Z. Beard as
|
|
* follows:
|
|
* The package name was changed to gnu.jpdf.
|
|
* The formatting was changed a little bit.
|
|
* Images were not yet implemented, so the core of this
|
|
* class was mostly rewritten
|
|
* It is still licensed under the LGPL.
|
|
* Got some help with base85 methods from Mathew Hreljac
|
|
*/
|
|
// Dimensions of the object.
|
|
private int objwidth;
|
|
private int objheight;
|
|
|
|
// Dimensions of the image.
|
|
private int width;
|
|
private int height;
|
|
private Image img;
|
|
private byte[] jpegImageData;
|
|
private String name;
|
|
|
|
private String mask;
|
|
|
|
private boolean interpolate;
|
|
|
|
/**
|
|
* Creates a new <code>PDFImage</code> instance.
|
|
*
|
|
*/
|
|
public PDFImage() {
|
|
super("/XObject");
|
|
}
|
|
|
|
/**
|
|
* Creates a new <code>PDFImage</code> instance.
|
|
*
|
|
* @param img an <code>Image</code> value
|
|
*/
|
|
public PDFImage(Image img, String mask, boolean interpolate) {
|
|
this();
|
|
this.mask = mask;
|
|
this.interpolate = interpolate;
|
|
setImage(img, 0, 0, img.getWidth(this), img.getHeight(this), this);
|
|
}
|
|
|
|
public PDFImage(Image img) {
|
|
this(img, null, false);
|
|
}
|
|
|
|
public boolean isInterpolate() {
|
|
return interpolate;
|
|
}
|
|
|
|
/**
|
|
* Creates a new <code>PDFImage</code> instance.
|
|
*
|
|
* @param img an <code>Image</code> value
|
|
* @param x an <code>int</code> value
|
|
* @param y an <code>int</code> value
|
|
* @param w an <code>int</code> value
|
|
* @param h an <code>int</code> value
|
|
* @param obs an <code>ImageObserver</code> value
|
|
*/
|
|
public PDFImage(Image img, int x, int y, int w, int h, ImageObserver obs, String mask, boolean interpolate) {
|
|
this();
|
|
objwidth = w;
|
|
objheight = h;
|
|
this.mask = mask;
|
|
this.interpolate = interpolate;
|
|
setImage(img, x, y, img.getWidth(this), img.getHeight(this), obs);
|
|
}
|
|
|
|
public PDFImage(byte jpegImageData[], int x, int y, int w, int h, ImageObserver obs, String mask, boolean interpolate) {
|
|
this();
|
|
objwidth = w;
|
|
objheight = h;
|
|
this.mask = mask;
|
|
this.interpolate = interpolate;
|
|
setJpegImageData(jpegImageData, w, h);
|
|
}
|
|
|
|
public PDFImage(Image img, int x, int y, int w, int h, ImageObserver obs) {
|
|
this(img, x, y, w, h, obs, null, false);
|
|
}
|
|
|
|
public PDFImage(byte jpegImageData[], int x, int y, int w, int h, ImageObserver obs) {
|
|
this(jpegImageData, x, y, w, h, obs, null, false);
|
|
}
|
|
|
|
/**
|
|
* Get the value of width.
|
|
*
|
|
* @return value of width.
|
|
*/
|
|
public int getWidth() {
|
|
return width;
|
|
}
|
|
|
|
/**
|
|
* Set the value of width.
|
|
*
|
|
* @param v Value to assign to width.
|
|
*/
|
|
public void setWidth(int v) {
|
|
this.width = v;
|
|
}
|
|
|
|
/**
|
|
* Get the value of height.
|
|
*
|
|
* @return value of height.
|
|
*/
|
|
public int getHeight() {
|
|
return height;
|
|
}
|
|
|
|
/**
|
|
* Set the value of height.
|
|
*
|
|
* @param v Value to assign to height.
|
|
*/
|
|
public void setHeight(int v) {
|
|
this.height = v;
|
|
}
|
|
|
|
/**
|
|
* Set the name
|
|
*
|
|
* @param n a <code>String</code> value
|
|
*/
|
|
public void setName(String n) {
|
|
name = n;
|
|
}
|
|
|
|
/**
|
|
* Get the name
|
|
*
|
|
* @return a <code>String</code> value
|
|
*/
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* Set the image
|
|
*
|
|
* @param img an <code>Image</code> value
|
|
* @param x an <code>int</code> value
|
|
* @param y an <code>int</code> value
|
|
* @param w an <code>int</code> value
|
|
* @param h an <code>int</code> value
|
|
* @param obs an <code>ImageObserver</code> value
|
|
*/
|
|
public void setImage(Image img, int x, int y, int w, int h, ImageObserver obs) {
|
|
this.img = img;
|
|
this.jpegImageData = null;
|
|
width = w;
|
|
height = h;
|
|
}
|
|
|
|
public void setJpegImageData(byte[] jpegImageData, int w, int h) {
|
|
this.jpegImageData = jpegImageData;
|
|
this.img = null;
|
|
width = w;
|
|
height = h;
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Adobe's base 85 does not follow the format used by ipv6 addresses. It
|
|
* simply starts with 33 and goes straight up without skipping any
|
|
* characters</p>
|
|
*
|
|
* <p>
|
|
* Parts of this method contributed by Mathew Hreljac</p>
|
|
*
|
|
* @param stringToEncode a <code>String</code> value
|
|
* @return a <code>String</code> value
|
|
*/
|
|
private String base85Encoding(String stringToEncode)
|
|
throws NumberFormatException {
|
|
if ((stringToEncode == null) || (stringToEncode.length() == 0)) {
|
|
//System.out.println("PDFImage.base85Encoding() null or blank String");
|
|
return "";
|
|
}
|
|
if ((stringToEncode.length() > 8)
|
|
|| ((stringToEncode.length() % 2) != 0)) {
|
|
System.out.println("PDFImage.base85Encoding, Incorrect tuple length: "
|
|
+ stringToEncode.length());
|
|
return "";
|
|
}
|
|
//System.out.println("str: " + stringToEncode);
|
|
// String buffer to use to return the String encoding
|
|
StringBuffer sb = new StringBuffer();
|
|
|
|
// Deal with a partial tuple (less than 8 hex digits)
|
|
// From Adobe's docs:
|
|
// "Given n (1, 2 or 3) bytes of binary data, the encoding first
|
|
// appends 4 - n zero bytes to make a complete 4-tuple. This 4-tuple
|
|
// is encoded in the usual way, but without applying the special
|
|
// z-case. Finally, only the first n+1 characters of the resulting
|
|
// 5-tuple are written out. Those characters are immediately followed
|
|
// by the EOD marker, ~>"
|
|
int numHexDigits = stringToEncode.length() / 2;
|
|
int numAppendBytes = 4 - numHexDigits;
|
|
for (int i = 0; i < numAppendBytes; i++) {
|
|
stringToEncode += "00";
|
|
}
|
|
Vector<Integer> digitVector = new Vector<Integer>();
|
|
long number = Long.parseLong(stringToEncode, 16);
|
|
int remainder = 0;
|
|
|
|
while (number >= 85) {
|
|
remainder = (int) (number % 85);
|
|
number = number / 85;
|
|
digitVector.add(0, new Integer(remainder));
|
|
}
|
|
digitVector.add(0, new Integer((int) number));
|
|
|
|
for (int i = 0; i < digitVector.size(); i++) {
|
|
char c = (char) (((Integer) digitVector.elementAt(i)).intValue() + 33);
|
|
sb.append(c);
|
|
}
|
|
String tuple = sb.toString();
|
|
int len = tuple.length();
|
|
switch (len) {
|
|
case 1:
|
|
tuple = "!!!!" + tuple;
|
|
break;
|
|
case 2:
|
|
tuple = "!!!" + tuple;
|
|
break;
|
|
case 3:
|
|
tuple = "!!" + tuple;
|
|
break;
|
|
case 4:
|
|
tuple = "!" + tuple;
|
|
break;
|
|
default:
|
|
break;
|
|
} // end switch
|
|
//System.out.println("enc tuple: " + tuple);
|
|
|
|
return (tuple);
|
|
} // end base85encoding
|
|
|
|
/**
|
|
* Writes the image to the stream
|
|
*
|
|
* @param os an <code>OutputStream</code> value
|
|
* @exception IOException if an error occurs
|
|
*/
|
|
@Override
|
|
public void writeStream(OutputStream os) throws IOException {
|
|
// This is a non-deflated stream
|
|
/*
|
|
os.write("/Length ".getBytes("UTF-8"));
|
|
// Account for stream\n ... >\nendstream
|
|
os.write(Integer.toString(buf.size() + 18).getBytes("UTF-8"));
|
|
os.write("\n/Filter /ASCII85Decode".getBytes("UTF-8"));
|
|
os.write("\n>>\nstream\n".getBytes("UTF-8"));
|
|
buf.writeTo(os);
|
|
os.write(">\nendstream\nendobj\n\n".getBytes("UTF-8"));
|
|
*/
|
|
ByteArrayOutputStream b = new ByteArrayOutputStream();
|
|
|
|
if (jpegImageData == null) {
|
|
DeflaterOutputStream dos = new DeflaterOutputStream(b);
|
|
buf.writeTo(dos);
|
|
dos.finish();
|
|
dos.close();
|
|
} else {
|
|
buf.writeTo(b);
|
|
}
|
|
|
|
// FlatDecode is compatible with the java.util.zip.Deflater class
|
|
//os.write("/Filter [/FlateDecode /ASCIIHexDecode]\n".getBytes("UTF-8"));
|
|
if (jpegImageData != null) {
|
|
os.write("/Filter /DCTDecode\n".getBytes("UTF-8"));
|
|
} else {
|
|
os.write("/Filter [/FlateDecode /ASCII85Decode]\n".getBytes("UTF-8"));
|
|
}
|
|
os.write("/Length ".getBytes("UTF-8"));
|
|
os.write(Integer.toString(b.size()).getBytes("UTF-8"));
|
|
os.write("\n>>\nstream\n".getBytes("UTF-8"));
|
|
b.writeTo(os);
|
|
os.write("\nendstream\nendobj\n".getBytes("UTF-8"));
|
|
|
|
} // end writeStream
|
|
|
|
/**
|
|
* <p>
|
|
* Compression needs to be improved here</p>
|
|
*
|
|
* @param os OutputStream to send the object to
|
|
* @exception IOException on error
|
|
*/
|
|
@Override
|
|
public void write(OutputStream os) throws IOException {
|
|
writeStart(os);
|
|
|
|
// write the extra details
|
|
os.write("/Subtype /Image\n/Name ".getBytes("UTF-8"));
|
|
os.write(name.getBytes("UTF-8"));
|
|
os.write("\n/Width ".getBytes("UTF-8"));
|
|
os.write(Integer.toString(width).getBytes("UTF-8"));
|
|
os.write("\n/Height ".getBytes("UTF-8"));
|
|
os.write(Integer.toString(height).getBytes("UTF-8"));
|
|
os.write("\n/BitsPerComponent 8\n/ColorSpace /DeviceRGB\n".getBytes("UTF-8"));
|
|
if (mask != null) {
|
|
os.write(("/SMask " + mask + "\n").getBytes("UTF-8"));
|
|
}
|
|
if (interpolate) {
|
|
os.write("/Interpolate true\n".getBytes("UTF-8"));
|
|
}
|
|
|
|
// write the pixels to the stream
|
|
//System.err.println("Processing image "+width+"x"+height+" pixels");
|
|
ByteArrayOutputStream bos = getStream();
|
|
|
|
if (jpegImageData != null) {
|
|
bos.write(jpegImageData);
|
|
} else {
|
|
int w = width;
|
|
int h = height;
|
|
int x = 0;
|
|
int y = 0;
|
|
int[] pixels = new int[w * h];
|
|
PixelGrabber pg = new PixelGrabber(img, x, y, w, h, pixels, 0, w);
|
|
try {
|
|
pg.grabPixels();
|
|
} catch (InterruptedException e) {
|
|
System.err.println("interrupted waiting for pixels!");
|
|
return;
|
|
}
|
|
if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
|
|
System.err.println("image fetch aborted or errored");
|
|
return;
|
|
}
|
|
StringBuffer out = new StringBuffer();
|
|
for (int j = 0; j < h; j++) {
|
|
for (int i = 0; i < w; i++) {
|
|
//System.out.print("p[" + j * w + i+ "]=" + pixels[j * w + i] + ".");
|
|
out.append(handlePixel(x + i, y + j, pixels[j * w + i]));
|
|
if (out.toString().length() >= 8) {
|
|
String tuple = out.substring(0, 8);
|
|
out.delete(0, 8);
|
|
// Convert !!!!! to 'z'
|
|
String encTuple = base85Encoding(tuple);
|
|
if (encTuple.equals("!!!!!")) {
|
|
encTuple = "z";
|
|
}
|
|
bos.write(encTuple.getBytes("UTF-8"));
|
|
}
|
|
}
|
|
}
|
|
// This should be the only partial tuple case,
|
|
|
|
String lastTuple = base85Encoding(out.toString());
|
|
//System.out.println("lastTuple: " + lastTuple);
|
|
bos.write(lastTuple.getBytes("UTF-8"));
|
|
bos.write("~".getBytes("UTF-8"));
|
|
}
|
|
|
|
//System.out.println("Processing done");
|
|
// this will write the actual stream
|
|
setDeflate(false);
|
|
|
|
writeStream(os);
|
|
|
|
// Note: we do not call writeEnd() on streams!
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Converts a pixel to a hex string</p>
|
|
*
|
|
* @param x an <code>int</code> value
|
|
* @param y an <code>int</code> value
|
|
* @param p an <code>int</code> value
|
|
* @return a <code>String</code> value
|
|
*/
|
|
public static String handlePixel(int x, int y, int p) {
|
|
int alpha = (p >> 24) & 0xff;
|
|
int red = (p >> 16) & 0xff;
|
|
int green = (p >> 8) & 0xff;
|
|
int blue = (p) & 0xff;
|
|
String redHex = Integer.toHexString(red);
|
|
String greenHex = Integer.toHexString(green);
|
|
String blueHex = Integer.toHexString(blue);
|
|
if (redHex.length() == 1) {
|
|
redHex = "0" + redHex;
|
|
}
|
|
if (greenHex.length() == 1) {
|
|
greenHex = "0" + greenHex;
|
|
}
|
|
if (blueHex.length() == 1) {
|
|
blueHex = "0" + blueHex;
|
|
}
|
|
return redHex + greenHex + blueHex;
|
|
} // end handlePixel
|
|
|
|
/**
|
|
* Describe <code>imageUpdate</code> method here.
|
|
*
|
|
* @param img an <code>Image</code> value
|
|
* @param infoflags an <code>int</code> value
|
|
* @param x an <code>int</code> value
|
|
* @param y an <code>int</code> value
|
|
* @param w an <code>int</code> value
|
|
* @param h an <code>int</code> value
|
|
* @return a <code>boolean</code> value
|
|
*/
|
|
@Override
|
|
public boolean imageUpdate(Image img, int infoflags, int x, int y, int w, int h) {
|
|
System.err.println("img=" + img + "\ninfoflags=" + infoflags
|
|
+ "\nx=" + x + " y=" + y + " w=" + w + " h=" + h);
|
|
//if(img == this.img) {
|
|
if (infoflags == ImageObserver.WIDTH) {
|
|
width = w;
|
|
}
|
|
if (infoflags == ImageObserver.HEIGHT) {
|
|
height = h;
|
|
}
|
|
|
|
//return true;
|
|
//}
|
|
return false;
|
|
}
|
|
|
|
} // end class PDFImage
|