imageinfo.java

struts spring ibatis

		int bitSize = (int) readUBits(5);
		int minX = readSBits(bitSize);
		int maxX = readSBits(bitSize);
		int minY = readSBits(bitSize);
		int maxY = readSBits(bitSize);
		width = maxX / 20;
		height = maxY / 20;
		if (width < 0)
			width = -width;
		if (height < 0)
			height = -height;
		setPhysicalWidthDpi(72);
		setPhysicalHeightDpi(72);
		return width > 0 && height > 0;
	}

	private static boolean determineVerbosity(String args[]) {
		if (args != null && args.length > 0) {
			for (int i = 0; i < args.length; i++)
				if ("-c".equals(args[i]))
					return false;
		}
		return true;
	}

	private boolean equals(byte a1[], int offs1, byte a2[], int offs2, int num) {
		while (num-- > 0)
			if (a1[offs1++] != a2[offs2++])
				return false;
		return true;
	}

	public int getBitsPerPixel() {
		return bitsPerPixel;
	}

	public String getComment(int index) {
		if (comments == null || index < 0 || index >= comments.size())
			throw new IllegalArgumentException("Not a valid comment index: "
					+ index);
		else
			return (String) comments.elementAt(index);
	}

	public int getFormat() {
		return format;
	}

	public String getFormatName() {
		if (format >= 0 && format < FORMAT_NAMES.length)
			return FORMAT_NAMES[format];
		else
			return "?";
	}

	public int getHeight() {
		return height;
	}

	private int getIntBigEndian(byte a[], int offs) {
		return (a[offs] & 0xff) << 24 | (a[offs + 1] & 0xff) << 16
				| (a[offs + 2] & 0xff) << 8 | a[offs + 3] & 0xff;
	}

	private int getIntLittleEndian(byte a[], int offs) {
		return (a[offs + 3] & 0xff) << 24 | (a[offs + 2] & 0xff) << 16
				| (a[offs + 1] & 0xff) << 8 | a[offs] & 0xff;
	}

	public String getMimeType() {
		if (format >= 0 && format < MIME_TYPE_STRINGS.length)
			return MIME_TYPE_STRINGS[format];
		else
			return null;
	}

	public int getNumberOfComments() {
		if (comments == null)
			return 0;
		else
			return comments.size();
	}

	public int getNumberOfImages() {
		return numberOfImages;
	}

	public int getPhysicalHeightDpi() {
		return physicalHeightDpi;
	}

	public float getPhysicalHeightInch() {
		int h = getHeight();
		int ph = getPhysicalHeightDpi();
		if (h > 0 && ph > 0)
			return (float) h / (float) ph;
		else
			return -1F;
	}

	public int getPhysicalWidthDpi() {
		return physicalWidthDpi;
	}

	public float getPhysicalWidthInch() {
		int w = getWidth();
		int pw = getPhysicalWidthDpi();
		if (w > 0 && pw > 0)
			return (float) w / (float) pw;
		else
			return -1F;
	}

	private int getShortBigEndian(byte a[], int offs) {
		return (a[offs] & 0xff) << 8 | a[offs + 1] & 0xff;
	}

	private int getShortLittleEndian(byte a[], int offs) {
		return a[offs] & 0xff | (a[offs + 1] & 0xff) << 8;
	}

	public int getWidth() {
		return width;
	}

	public static void main(String args[]) {
		ImageInfo imageInfo = new ImageInfo();
		boolean verbose = determineVerbosity(args);
		if (args.length == 0) {
			run(null, System.in, imageInfo, verbose);
		} else {
			for (int index = 0; index < args.length;) {
				FileInputStream in = null;
				try {
					String filename = args[index++];
					System.out.print(filename + ";");
					in = new FileInputStream(filename);
					run(filename, in, imageInfo, verbose);
					in.close();
				} catch (Exception e) {
					System.out.println(e);
					try {
						in.close();
					} catch (Exception exception) {
					}
				}
			}
		}
	}

	private static void print(String sourceName, ImageInfo ii, boolean verbose) {
		if (verbose)
			printVerbose(sourceName, ii);
		else
			printCompact(sourceName, ii);
	}

	private static void printCompact(String sourceName, ImageInfo imageInfo) {
		System.out.println(imageInfo.getFormatName() + ";"
				+ imageInfo.getMimeType() + ";" + imageInfo.getWidth() + ";"
				+ imageInfo.getHeight() + ";" + imageInfo.getBitsPerPixel()
				+ ";" + imageInfo.getNumberOfImages() + ";"
				+ imageInfo.getPhysicalWidthDpi() + ";"
				+ imageInfo.getPhysicalHeightDpi() + ";"
				+ imageInfo.getPhysicalWidthInch() + ";"
				+ imageInfo.getPhysicalHeightInch());
	}

	private static void printLine(int indentLevels, String text, float value,
			float minValidValue) {
		if (value < minValidValue) {
			return;
		} else {
			printLine(indentLevels, text, Float.toString(value));
			return;
		}
	}

	private static void printLine(int indentLevels, String text, int value,
			int minValidValue) {
		if (value >= minValidValue)
			printLine(indentLevels, text, Integer.toString(value));
	}

	private static void printLine(int indentLevels, String text, String value) {
		if (value == null || value.length() == 0)
			return;
		while (indentLevels-- > 0)
			System.out.print("\t");
		if (text != null && text.length() > 0) {
			System.out.print(text);
			System.out.print(" ");
		}
		System.out.println(value);
	}

	private static void printVerbose(String sourceName, ImageInfo ii) {
		printLine(0, null, sourceName);
		printLine(1, "File format: ", ii.getFormatName());
		printLine(1, "MIME type: ", ii.getMimeType());
		printLine(1, "Width (pixels): ", ii.getWidth(), 1);
		printLine(1, "Height (pixels): ", ii.getHeight(), 1);
		printLine(1, "Bits per pixel: ", ii.getBitsPerPixel(), 1);
		printLine(1, "Number of images: ", ii.getNumberOfImages(), 1);
		printLine(1, "Physical width (dpi): ", ii.getPhysicalWidthDpi(), 1);
		printLine(1, "Physical height (dpi): ", ii.getPhysicalHeightDpi(), 1);
		printLine(1, "Physical width (inches): ", ii.getPhysicalWidthInch(),
				1.0F);
		printLine(1, "Physical height (inches): ", ii.getPhysicalHeightInch(),
				1.0F);
		int numComments = ii.getNumberOfComments();
		printLine(1, "Number of textual comments: ", numComments, 1);
		if (numComments > 0) {
			for (int i = 0; i < numComments; i++)
				printLine(2, null, ii.getComment(i));
		}
	}

	private int read() throws IOException {
		if (in != null)
			return in.read();
		else
			return din.readByte();
	}

	private int read(byte a[]) throws IOException {
		if (in != null) {
			return in.read(a);
		} else {
			din.readFully(a);
			return a.length;
		}
	}

	private int read(byte a[], int offset, int num) throws IOException {
		if (in != null) {
			return in.read(a, offset, num);
		} else {
			din.readFully(a, offset, num);
			return num;
		}
	}

	private String readLine() throws IOException {
		return readLine(new StringBuffer());
	}

	private String readLine(StringBuffer sb) throws IOException {
		boolean finished;
		do {
			int value = read();
			finished = value == -1 || value == 10;
			if (!finished)
				sb.append((char) value);
		} while (!finished);
		return sb.toString();
	}

	public long readUBits(int numBits) throws IOException {
		if (numBits == 0)
			return 0L;
		int bitsLeft = numBits;
		long result = 0L;
		if (bitPos == 0) {
			if (in != null)
				bitBuf = in.read();
			else
				bitBuf = din.readByte();
			bitPos = 8;
		}
		do {
			int shift = bitsLeft - bitPos;
			if (shift > 0) {
				result |= bitBuf << shift;
				bitsLeft -= bitPos;
				if (in != null)
					bitBuf = in.read();
				else
					bitBuf = din.readByte();
				bitPos = 8;
			} else {
				result |= bitBuf >> -shift;
				bitPos -= bitsLeft;
				bitBuf &= 255 >> 8 - bitPos;
				return result;
			}
		} while (true);
	}

	private int readSBits(int numBits) throws IOException {
		long uBits = readUBits(numBits);
		if ((uBits & 1L << numBits - 1) != 0L)
			uBits |= -1L << numBits;
		return (int) uBits;
	}

	public void synchBits() {
		bitBuf = 0;
		bitPos = 0;
	}

	private String readLine(int firstChar) throws IOException {
		StringBuffer result = new StringBuffer();
		result.append((char) firstChar);
		return readLine(result);
	}

	private static void run(String sourceName, InputStream in,
			ImageInfo imageInfo, boolean verbose) {
		imageInfo.setInput(in);
		imageInfo.setDetermineImageNumber(true);
		imageInfo.setCollectComments(verbose);
		if (imageInfo.check())
			print(sourceName, imageInfo, verbose);
	}

	public void setCollectComments(boolean newValue) {
		collectComments = newValue;
	}

	public void setDetermineImageNumber(boolean newValue) {
		determineNumberOfImages = newValue;
	}

	public void setInput(DataInput dataInput) {
		din = dataInput;
		in = null;
	}

	public void setInput(InputStream inputStream) {
		in = inputStream;
		din = null;
	}

	private void setPhysicalHeightDpi(int newValue) {
		physicalWidthDpi = newValue;
	}

	private void setPhysicalWidthDpi(int newValue) {
		physicalHeightDpi = newValue;
	}

	private void skip(int num) throws IOException {
		if (in != null)
			in.skip(num);
		else
			din.skipBytes(num);
	}

	public ImageInfo() {
		collectComments = true;
	}

	public static final int FORMAT_JPEG = 0;

	public static final int FORMAT_GIF = 1;

	public static final int FORMAT_PNG = 2;

	public static final int FORMAT_BMP = 3;

	public static final int FORMAT_PCX = 4;

	public static final int FORMAT_IFF = 5;

	public static final int FORMAT_RAS = 6;

	public static final int FORMAT_PBM = 7;

	public static final int FORMAT_PGM = 8;

	public static final int FORMAT_PPM = 9;

	public static final int FORMAT_PSD = 10;

	public static final int FORMAT_SWF = 11;

	private static final String FORMAT_NAMES[] = { "JPEG", "GIF", "PNG", "BMP",
			"PCX", "IFF", "RAS", "PBM", "PGM", "PPM", "PSD", "SWF" };

	private static final String MIME_TYPE_STRINGS[] = { "image/jpeg",
			"image/gif", "image/png", "image/bmp", "image/pcx", "image/iff",
			"image/ras", "image/x-portable-bitmap", "image/x-portable-graymap",
			"image/x-portable-pixmap", "image/psd",
			"application/x-shockwave-flash" };

	private int width;

	private int height;

	private int bitsPerPixel;

	private int format;

	private InputStream in;

	private DataInput din;

	private boolean collectComments;

	private Vector comments;

	private boolean determineNumberOfImages;

	private int numberOfImages;

	private int physicalHeightDpi;

	private int physicalWidthDpi;

	private int bitBuf;

	private int bitPos;
}