| /* |
| * Copyright (c) 2000, 2013, 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. |
| */ |
| |
| package com.sun.imageio.plugins.png; |
| |
| import java.awt.image.ColorModel; |
| import java.awt.image.IndexColorModel; |
| import java.awt.image.SampleModel; |
| import java.util.ArrayList; |
| import java.util.StringTokenizer; |
| import javax.imageio.ImageTypeSpecifier; |
| import javax.imageio.metadata.IIOInvalidTreeException; |
| import javax.imageio.metadata.IIOMetadata; |
| import javax.imageio.metadata.IIOMetadataFormatImpl; |
| import javax.imageio.metadata.IIOMetadataNode; |
| import org.w3c.dom.Node; |
| |
| public class PNGMetadata extends IIOMetadata implements Cloneable { |
| |
| // package scope |
| public static final String |
| nativeMetadataFormatName = "javax_imageio_png_1.0"; |
| |
| protected static final String nativeMetadataFormatClassName |
| = "com.sun.imageio.plugins.png.PNGMetadataFormat"; |
| |
| // Color types for IHDR chunk |
| static final String[] IHDR_colorTypeNames = { |
| "Grayscale", null, "RGB", "Palette", |
| "GrayAlpha", null, "RGBAlpha" |
| }; |
| |
| static final int[] IHDR_numChannels = { |
| 1, 0, 3, 3, 2, 0, 4 |
| }; |
| |
| // Bit depths for IHDR chunk |
| static final String[] IHDR_bitDepths = { |
| "1", "2", "4", "8", "16" |
| }; |
| |
| // Compression methods for IHDR chunk |
| static final String[] IHDR_compressionMethodNames = { |
| "deflate" |
| }; |
| |
| // Filter methods for IHDR chunk |
| static final String[] IHDR_filterMethodNames = { |
| "adaptive" |
| }; |
| |
| // Interlace methods for IHDR chunk |
| static final String[] IHDR_interlaceMethodNames = { |
| "none", "adam7" |
| }; |
| |
| // Compression methods for iCCP chunk |
| static final String[] iCCP_compressionMethodNames = { |
| "deflate" |
| }; |
| |
| // Compression methods for zTXt chunk |
| static final String[] zTXt_compressionMethodNames = { |
| "deflate" |
| }; |
| |
| // "Unknown" unit for pHYs chunk |
| public static final int PHYS_UNIT_UNKNOWN = 0; |
| |
| // "Meter" unit for pHYs chunk |
| public static final int PHYS_UNIT_METER = 1; |
| |
| // Unit specifiers for pHYs chunk |
| static final String[] unitSpecifierNames = { |
| "unknown", "meter" |
| }; |
| |
| // Rendering intents for sRGB chunk |
| static final String[] renderingIntentNames = { |
| "Perceptual", // 0 |
| "Relative colorimetric", // 1 |
| "Saturation", // 2 |
| "Absolute colorimetric" // 3 |
| |
| }; |
| |
| // Color space types for Chroma->ColorSpaceType node |
| static final String[] colorSpaceTypeNames = { |
| "GRAY", null, "RGB", "RGB", |
| "GRAY", null, "RGB" |
| }; |
| |
| // IHDR chunk |
| public boolean IHDR_present; |
| public int IHDR_width; |
| public int IHDR_height; |
| public int IHDR_bitDepth; |
| public int IHDR_colorType; |
| public int IHDR_compressionMethod; |
| public int IHDR_filterMethod; |
| public int IHDR_interlaceMethod; // 0 == none, 1 == adam7 |
| |
| // PLTE chunk |
| public boolean PLTE_present; |
| public byte[] PLTE_red; |
| public byte[] PLTE_green; |
| public byte[] PLTE_blue; |
| |
| // If non-null, used to reorder palette entries during encoding in |
| // order to minimize the size of the tRNS chunk. Thus an index of |
| // 'i' in the source should be encoded as index 'PLTE_order[i]'. |
| // PLTE_order will be null unless 'initialize' is called with an |
| // IndexColorModel image type. |
| public int[] PLTE_order = null; |
| |
| // bKGD chunk |
| // If external (non-PNG sourced) data has red = green = blue, |
| // always store it as gray and promote when writing |
| public boolean bKGD_present; |
| public int bKGD_colorType; // PNG_COLOR_GRAY, _RGB, or _PALETTE |
| public int bKGD_index; |
| public int bKGD_gray; |
| public int bKGD_red; |
| public int bKGD_green; |
| public int bKGD_blue; |
| |
| // cHRM chunk |
| public boolean cHRM_present; |
| public int cHRM_whitePointX; |
| public int cHRM_whitePointY; |
| public int cHRM_redX; |
| public int cHRM_redY; |
| public int cHRM_greenX; |
| public int cHRM_greenY; |
| public int cHRM_blueX; |
| public int cHRM_blueY; |
| |
| // gAMA chunk |
| public boolean gAMA_present; |
| public int gAMA_gamma; |
| |
| // hIST chunk |
| public boolean hIST_present; |
| public char[] hIST_histogram; |
| |
| // iCCP chunk |
| public boolean iCCP_present; |
| public String iCCP_profileName; |
| public int iCCP_compressionMethod; |
| public byte[] iCCP_compressedProfile; |
| |
| // iTXt chunk |
| public ArrayList<String> iTXt_keyword = new ArrayList<String>(); |
| public ArrayList<Boolean> iTXt_compressionFlag = new ArrayList<Boolean>(); |
| public ArrayList<Integer> iTXt_compressionMethod = new ArrayList<Integer>(); |
| public ArrayList<String> iTXt_languageTag = new ArrayList<String>(); |
| public ArrayList<String> iTXt_translatedKeyword = new ArrayList<String>(); |
| public ArrayList<String> iTXt_text = new ArrayList<String>(); |
| |
| // pHYs chunk |
| public boolean pHYs_present; |
| public int pHYs_pixelsPerUnitXAxis; |
| public int pHYs_pixelsPerUnitYAxis; |
| public int pHYs_unitSpecifier; // 0 == unknown, 1 == meter |
| |
| // sBIT chunk |
| public boolean sBIT_present; |
| public int sBIT_colorType; // PNG_COLOR_GRAY, _GRAY_ALPHA, _RGB, _RGB_ALPHA |
| public int sBIT_grayBits; |
| public int sBIT_redBits; |
| public int sBIT_greenBits; |
| public int sBIT_blueBits; |
| public int sBIT_alphaBits; |
| |
| // sPLT chunk |
| public boolean sPLT_present; |
| public String sPLT_paletteName; // 1-79 characters |
| public int sPLT_sampleDepth; // 8 or 16 |
| public int[] sPLT_red; |
| public int[] sPLT_green; |
| public int[] sPLT_blue; |
| public int[] sPLT_alpha; |
| public int[] sPLT_frequency; |
| |
| // sRGB chunk |
| public boolean sRGB_present; |
| public int sRGB_renderingIntent; |
| |
| // tEXt chunk |
| public ArrayList<String> tEXt_keyword = new ArrayList<String>(); // 1-79 characters |
| public ArrayList<String> tEXt_text = new ArrayList<String>(); |
| |
| // tIME chunk |
| public boolean tIME_present; |
| public int tIME_year; |
| public int tIME_month; |
| public int tIME_day; |
| public int tIME_hour; |
| public int tIME_minute; |
| public int tIME_second; |
| |
| // tRNS chunk |
| // If external (non-PNG sourced) data has red = green = blue, |
| // always store it as gray and promote when writing |
| public boolean tRNS_present; |
| public int tRNS_colorType; // PNG_COLOR_GRAY, _RGB, or _PALETTE |
| public byte[] tRNS_alpha; // May have fewer entries than PLTE_red, etc. |
| public int tRNS_gray; |
| public int tRNS_red; |
| public int tRNS_green; |
| public int tRNS_blue; |
| |
| // zTXt chunk |
| public ArrayList<String> zTXt_keyword = new ArrayList<String>(); |
| public ArrayList<Integer> zTXt_compressionMethod = new ArrayList<Integer>(); |
| public ArrayList<String> zTXt_text = new ArrayList<String>(); |
| |
| // Unknown chunks |
| public ArrayList<String> unknownChunkType = new ArrayList<String>(); |
| public ArrayList<byte[]> unknownChunkData = new ArrayList<byte[]>(); |
| |
| public PNGMetadata() { |
| super(true, |
| nativeMetadataFormatName, |
| nativeMetadataFormatClassName, |
| null, null); |
| } |
| |
| public PNGMetadata(IIOMetadata metadata) { |
| // TODO -- implement |
| } |
| |
| /** |
| * Sets the IHDR_bitDepth and IHDR_colorType variables. |
| * The <code>numBands</code> parameter is necessary since |
| * we may only be writing a subset of the image bands. |
| */ |
| public void initialize(ImageTypeSpecifier imageType, int numBands) { |
| ColorModel colorModel = imageType.getColorModel(); |
| SampleModel sampleModel = imageType.getSampleModel(); |
| |
| // Initialize IHDR_bitDepth |
| int[] sampleSize = sampleModel.getSampleSize(); |
| int bitDepth = sampleSize[0]; |
| // Choose max bit depth over all channels |
| // Fixes bug 4413109 |
| for (int i = 1; i < sampleSize.length; i++) { |
| if (sampleSize[i] > bitDepth) { |
| bitDepth = sampleSize[i]; |
| } |
| } |
| // Multi-channel images must have a bit depth of 8 or 16 |
| if (sampleSize.length > 1 && bitDepth < 8) { |
| bitDepth = 8; |
| } |
| |
| // Round bit depth up to a power of 2 |
| if (bitDepth > 2 && bitDepth < 4) { |
| bitDepth = 4; |
| } else if (bitDepth > 4 && bitDepth < 8) { |
| bitDepth = 8; |
| } else if (bitDepth > 8 && bitDepth < 16) { |
| bitDepth = 16; |
| } else if (bitDepth > 16) { |
| throw new RuntimeException("bitDepth > 16!"); |
| } |
| IHDR_bitDepth = bitDepth; |
| |
| // Initialize IHDR_colorType |
| if (colorModel instanceof IndexColorModel) { |
| IndexColorModel icm = (IndexColorModel)colorModel; |
| int size = icm.getMapSize(); |
| |
| byte[] reds = new byte[size]; |
| icm.getReds(reds); |
| byte[] greens = new byte[size]; |
| icm.getGreens(greens); |
| byte[] blues = new byte[size]; |
| icm.getBlues(blues); |
| |
| // Determine whether the color tables are actually a gray ramp |
| // if the color type has not been set previously |
| boolean isGray = false; |
| if (!IHDR_present || |
| (IHDR_colorType != PNGImageReader.PNG_COLOR_PALETTE)) { |
| isGray = true; |
| int scale = 255/((1 << IHDR_bitDepth) - 1); |
| for (int i = 0; i < size; i++) { |
| byte red = reds[i]; |
| if ((red != (byte)(i*scale)) || |
| (red != greens[i]) || |
| (red != blues[i])) { |
| isGray = false; |
| break; |
| } |
| } |
| } |
| |
| // Determine whether transparency exists |
| boolean hasAlpha = colorModel.hasAlpha(); |
| |
| byte[] alpha = null; |
| if (hasAlpha) { |
| alpha = new byte[size]; |
| icm.getAlphas(alpha); |
| } |
| |
| /* |
| * NB: PNG_COLOR_GRAY_ALPHA color type may be not optimal for images |
| * contained more than 1024 pixels (or even than 768 pixels in case of |
| * single transparent pixel in palette). |
| * For such images alpha samples in raster will occupy more space than |
| * it is required to store palette so it could be reasonable to |
| * use PNG_COLOR_PALETTE color type for large images. |
| */ |
| |
| if (isGray && hasAlpha && (bitDepth == 8 || bitDepth == 16)) { |
| IHDR_colorType = PNGImageReader.PNG_COLOR_GRAY_ALPHA; |
| } else if (isGray && !hasAlpha) { |
| IHDR_colorType = PNGImageReader.PNG_COLOR_GRAY; |
| } else { |
| IHDR_colorType = PNGImageReader.PNG_COLOR_PALETTE; |
| PLTE_present = true; |
| PLTE_order = null; |
| PLTE_red = (byte[])reds.clone(); |
| PLTE_green = (byte[])greens.clone(); |
| PLTE_blue = (byte[])blues.clone(); |
| |
| if (hasAlpha) { |
| tRNS_present = true; |
| tRNS_colorType = PNGImageReader.PNG_COLOR_PALETTE; |
| |
| PLTE_order = new int[alpha.length]; |
| |
| // Reorder the palette so that non-opaque entries |
| // come first. Since the tRNS chunk does not have |
| // to store trailing 255's, this can save a |
| // considerable amount of space when encoding |
| // images with only one transparent pixel value, |
| // e.g., images from GIF sources. |
| |
| byte[] newAlpha = new byte[alpha.length]; |
| |
| // Scan for non-opaque entries and assign them |
| // positions starting at 0. |
| int newIndex = 0; |
| for (int i = 0; i < alpha.length; i++) { |
| if (alpha[i] != (byte)255) { |
| PLTE_order[i] = newIndex; |
| newAlpha[newIndex] = alpha[i]; |
| ++newIndex; |
| } |
| } |
| int numTransparent = newIndex; |
| |
| // Scan for opaque entries and assign them |
| // positions following the non-opaque entries. |
| for (int i = 0; i < alpha.length; i++) { |
| if (alpha[i] == (byte)255) { |
| PLTE_order[i] = newIndex++; |
| } |
| } |
| |
| // Reorder the palettes |
| byte[] oldRed = PLTE_red; |
| byte[] oldGreen = PLTE_green; |
| byte[] oldBlue = PLTE_blue; |
| int len = oldRed.length; // All have the same length |
| PLTE_red = new byte[len]; |
| PLTE_green = new byte[len]; |
| PLTE_blue = new byte[len]; |
| for (int i = 0; i < len; i++) { |
| PLTE_red[PLTE_order[i]] = oldRed[i]; |
| PLTE_green[PLTE_order[i]] = oldGreen[i]; |
| PLTE_blue[PLTE_order[i]] = oldBlue[i]; |
| } |
| |
| // Copy only the transparent entries into tRNS_alpha |
| tRNS_alpha = new byte[numTransparent]; |
| System.arraycopy(newAlpha, 0, |
| tRNS_alpha, 0, numTransparent); |
| } |
| } |
| } else { |
| if (numBands == 1) { |
| IHDR_colorType = PNGImageReader.PNG_COLOR_GRAY; |
| } else if (numBands == 2) { |
| IHDR_colorType = PNGImageReader.PNG_COLOR_GRAY_ALPHA; |
| } else if (numBands == 3) { |
| IHDR_colorType = PNGImageReader.PNG_COLOR_RGB; |
| } else if (numBands == 4) { |
| IHDR_colorType = PNGImageReader.PNG_COLOR_RGB_ALPHA; |
| } else { |
| throw new RuntimeException("Number of bands not 1-4!"); |
| } |
| } |
| |
| IHDR_present = true; |
| } |
| |
| public boolean isReadOnly() { |
| return false; |
| } |
| |
| private ArrayList<byte[]> cloneBytesArrayList(ArrayList<byte[]> in) { |
| if (in == null) { |
| return null; |
| } else { |
| ArrayList<byte[]> list = new ArrayList<byte[]>(in.size()); |
| for (byte[] b: in) { |
| list.add((b == null) ? null : (byte[])b.clone()); |
| } |
| return list; |
| } |
| } |
| |
| // Deep clone |
| public Object clone() { |
| PNGMetadata metadata; |
| try { |
| metadata = (PNGMetadata)super.clone(); |
| } catch (CloneNotSupportedException e) { |
| return null; |
| } |
| |
| // unknownChunkData needs deep clone |
| metadata.unknownChunkData = |
| cloneBytesArrayList(this.unknownChunkData); |
| |
| return metadata; |
| } |
| |
| public Node getAsTree(String formatName) { |
| if (formatName.equals(nativeMetadataFormatName)) { |
| return getNativeTree(); |
| } else if (formatName.equals |
| (IIOMetadataFormatImpl.standardMetadataFormatName)) { |
| return getStandardTree(); |
| } else { |
| throw new IllegalArgumentException("Not a recognized format!"); |
| } |
| } |
| |
| private Node getNativeTree() { |
| IIOMetadataNode node = null; // scratch node |
| IIOMetadataNode root = new IIOMetadataNode(nativeMetadataFormatName); |
| |
| // IHDR |
| if (IHDR_present) { |
| IIOMetadataNode IHDR_node = new IIOMetadataNode("IHDR"); |
| IHDR_node.setAttribute("width", Integer.toString(IHDR_width)); |
| IHDR_node.setAttribute("height", Integer.toString(IHDR_height)); |
| IHDR_node.setAttribute("bitDepth", |
| Integer.toString(IHDR_bitDepth)); |
| IHDR_node.setAttribute("colorType", |
| IHDR_colorTypeNames[IHDR_colorType]); |
| // IHDR_compressionMethod must be 0 in PNG 1.1 |
| IHDR_node.setAttribute("compressionMethod", |
| IHDR_compressionMethodNames[IHDR_compressionMethod]); |
| // IHDR_filterMethod must be 0 in PNG 1.1 |
| IHDR_node.setAttribute("filterMethod", |
| IHDR_filterMethodNames[IHDR_filterMethod]); |
| IHDR_node.setAttribute("interlaceMethod", |
| IHDR_interlaceMethodNames[IHDR_interlaceMethod]); |
| root.appendChild(IHDR_node); |
| } |
| |
| // PLTE |
| if (PLTE_present) { |
| IIOMetadataNode PLTE_node = new IIOMetadataNode("PLTE"); |
| int numEntries = PLTE_red.length; |
| for (int i = 0; i < numEntries; i++) { |
| IIOMetadataNode entry = new IIOMetadataNode("PLTEEntry"); |
| entry.setAttribute("index", Integer.toString(i)); |
| entry.setAttribute("red", |
| Integer.toString(PLTE_red[i] & 0xff)); |
| entry.setAttribute("green", |
| Integer.toString(PLTE_green[i] & 0xff)); |
| entry.setAttribute("blue", |
| Integer.toString(PLTE_blue[i] & 0xff)); |
| PLTE_node.appendChild(entry); |
| } |
| |
| root.appendChild(PLTE_node); |
| } |
| |
| // bKGD |
| if (bKGD_present) { |
| IIOMetadataNode bKGD_node = new IIOMetadataNode("bKGD"); |
| |
| if (bKGD_colorType == PNGImageReader.PNG_COLOR_PALETTE) { |
| node = new IIOMetadataNode("bKGD_Palette"); |
| node.setAttribute("index", Integer.toString(bKGD_index)); |
| } else if (bKGD_colorType == PNGImageReader.PNG_COLOR_GRAY) { |
| node = new IIOMetadataNode("bKGD_Grayscale"); |
| node.setAttribute("gray", Integer.toString(bKGD_gray)); |
| } else if (bKGD_colorType == PNGImageReader.PNG_COLOR_RGB) { |
| node = new IIOMetadataNode("bKGD_RGB"); |
| node.setAttribute("red", Integer.toString(bKGD_red)); |
| node.setAttribute("green", Integer.toString(bKGD_green)); |
| node.setAttribute("blue", Integer.toString(bKGD_blue)); |
| } |
| bKGD_node.appendChild(node); |
| |
| root.appendChild(bKGD_node); |
| } |
| |
| // cHRM |
| if (cHRM_present) { |
| IIOMetadataNode cHRM_node = new IIOMetadataNode("cHRM"); |
| cHRM_node.setAttribute("whitePointX", |
| Integer.toString(cHRM_whitePointX)); |
| cHRM_node.setAttribute("whitePointY", |
| Integer.toString(cHRM_whitePointY)); |
| cHRM_node.setAttribute("redX", Integer.toString(cHRM_redX)); |
| cHRM_node.setAttribute("redY", Integer.toString(cHRM_redY)); |
| cHRM_node.setAttribute("greenX", Integer.toString(cHRM_greenX)); |
| cHRM_node.setAttribute("greenY", Integer.toString(cHRM_greenY)); |
| cHRM_node.setAttribute("blueX", Integer.toString(cHRM_blueX)); |
| cHRM_node.setAttribute("blueY", Integer.toString(cHRM_blueY)); |
| |
| root.appendChild(cHRM_node); |
| } |
| |
| // gAMA |
| if (gAMA_present) { |
| IIOMetadataNode gAMA_node = new IIOMetadataNode("gAMA"); |
| gAMA_node.setAttribute("value", Integer.toString(gAMA_gamma)); |
| |
| root.appendChild(gAMA_node); |
| } |
| |
| // hIST |
| if (hIST_present) { |
| IIOMetadataNode hIST_node = new IIOMetadataNode("hIST"); |
| |
| for (int i = 0; i < hIST_histogram.length; i++) { |
| IIOMetadataNode hist = |
| new IIOMetadataNode("hISTEntry"); |
| hist.setAttribute("index", Integer.toString(i)); |
| hist.setAttribute("value", |
| Integer.toString(hIST_histogram[i])); |
| hIST_node.appendChild(hist); |
| } |
| |
| root.appendChild(hIST_node); |
| } |
| |
| // iCCP |
| if (iCCP_present) { |
| IIOMetadataNode iCCP_node = new IIOMetadataNode("iCCP"); |
| iCCP_node.setAttribute("profileName", iCCP_profileName); |
| iCCP_node.setAttribute("compressionMethod", |
| iCCP_compressionMethodNames[iCCP_compressionMethod]); |
| |
| Object profile = iCCP_compressedProfile; |
| if (profile != null) { |
| profile = ((byte[])profile).clone(); |
| } |
| iCCP_node.setUserObject(profile); |
| |
| root.appendChild(iCCP_node); |
| } |
| |
| // iTXt |
| if (iTXt_keyword.size() > 0) { |
| IIOMetadataNode iTXt_parent = new IIOMetadataNode("iTXt"); |
| for (int i = 0; i < iTXt_keyword.size(); i++) { |
| IIOMetadataNode iTXt_node = new IIOMetadataNode("iTXtEntry"); |
| iTXt_node.setAttribute("keyword", iTXt_keyword.get(i)); |
| iTXt_node.setAttribute("compressionFlag", |
| iTXt_compressionFlag.get(i) ? "TRUE" : "FALSE"); |
| iTXt_node.setAttribute("compressionMethod", |
| iTXt_compressionMethod.get(i).toString()); |
| iTXt_node.setAttribute("languageTag", |
| iTXt_languageTag.get(i)); |
| iTXt_node.setAttribute("translatedKeyword", |
| iTXt_translatedKeyword.get(i)); |
| iTXt_node.setAttribute("text", iTXt_text.get(i)); |
| |
| iTXt_parent.appendChild(iTXt_node); |
| } |
| |
| root.appendChild(iTXt_parent); |
| } |
| |
| // pHYs |
| if (pHYs_present) { |
| IIOMetadataNode pHYs_node = new IIOMetadataNode("pHYs"); |
| pHYs_node.setAttribute("pixelsPerUnitXAxis", |
| Integer.toString(pHYs_pixelsPerUnitXAxis)); |
| pHYs_node.setAttribute("pixelsPerUnitYAxis", |
| Integer.toString(pHYs_pixelsPerUnitYAxis)); |
| pHYs_node.setAttribute("unitSpecifier", |
| unitSpecifierNames[pHYs_unitSpecifier]); |
| |
| root.appendChild(pHYs_node); |
| } |
| |
| // sBIT |
| if (sBIT_present) { |
| IIOMetadataNode sBIT_node = new IIOMetadataNode("sBIT"); |
| |
| if (sBIT_colorType == PNGImageReader.PNG_COLOR_GRAY) { |
| node = new IIOMetadataNode("sBIT_Grayscale"); |
| node.setAttribute("gray", |
| Integer.toString(sBIT_grayBits)); |
| } else if (sBIT_colorType == PNGImageReader.PNG_COLOR_GRAY_ALPHA) { |
| node = new IIOMetadataNode("sBIT_GrayAlpha"); |
| node.setAttribute("gray", |
| Integer.toString(sBIT_grayBits)); |
| node.setAttribute("alpha", |
| Integer.toString(sBIT_alphaBits)); |
| } else if (sBIT_colorType == PNGImageReader.PNG_COLOR_RGB) { |
| node = new IIOMetadataNode("sBIT_RGB"); |
| node.setAttribute("red", |
| Integer.toString(sBIT_redBits)); |
| node.setAttribute("green", |
| Integer.toString(sBIT_greenBits)); |
| node.setAttribute("blue", |
| Integer.toString(sBIT_blueBits)); |
| } else if (sBIT_colorType == PNGImageReader.PNG_COLOR_RGB_ALPHA) { |
| node = new IIOMetadataNode("sBIT_RGBAlpha"); |
| node.setAttribute("red", |
| Integer.toString(sBIT_redBits)); |
| node.setAttribute("green", |
| Integer.toString(sBIT_greenBits)); |
| node.setAttribute("blue", |
| Integer.toString(sBIT_blueBits)); |
| node.setAttribute("alpha", |
| Integer.toString(sBIT_alphaBits)); |
| } else if (sBIT_colorType == PNGImageReader.PNG_COLOR_PALETTE) { |
| node = new IIOMetadataNode("sBIT_Palette"); |
| node.setAttribute("red", |
| Integer.toString(sBIT_redBits)); |
| node.setAttribute("green", |
| Integer.toString(sBIT_greenBits)); |
| node.setAttribute("blue", |
| Integer.toString(sBIT_blueBits)); |
| } |
| sBIT_node.appendChild(node); |
| |
| root.appendChild(sBIT_node); |
| } |
| |
| // sPLT |
| if (sPLT_present) { |
| IIOMetadataNode sPLT_node = new IIOMetadataNode("sPLT"); |
| |
| sPLT_node.setAttribute("name", sPLT_paletteName); |
| sPLT_node.setAttribute("sampleDepth", |
| Integer.toString(sPLT_sampleDepth)); |
| |
| int numEntries = sPLT_red.length; |
| for (int i = 0; i < numEntries; i++) { |
| IIOMetadataNode entry = new IIOMetadataNode("sPLTEntry"); |
| entry.setAttribute("index", Integer.toString(i)); |
| entry.setAttribute("red", Integer.toString(sPLT_red[i])); |
| entry.setAttribute("green", Integer.toString(sPLT_green[i])); |
| entry.setAttribute("blue", Integer.toString(sPLT_blue[i])); |
| entry.setAttribute("alpha", Integer.toString(sPLT_alpha[i])); |
| entry.setAttribute("frequency", |
| Integer.toString(sPLT_frequency[i])); |
| sPLT_node.appendChild(entry); |
| } |
| |
| root.appendChild(sPLT_node); |
| } |
| |
| // sRGB |
| if (sRGB_present) { |
| IIOMetadataNode sRGB_node = new IIOMetadataNode("sRGB"); |
| sRGB_node.setAttribute("renderingIntent", |
| renderingIntentNames[sRGB_renderingIntent]); |
| |
| root.appendChild(sRGB_node); |
| } |
| |
| // tEXt |
| if (tEXt_keyword.size() > 0) { |
| IIOMetadataNode tEXt_parent = new IIOMetadataNode("tEXt"); |
| for (int i = 0; i < tEXt_keyword.size(); i++) { |
| IIOMetadataNode tEXt_node = new IIOMetadataNode("tEXtEntry"); |
| tEXt_node.setAttribute("keyword" , (String)tEXt_keyword.get(i)); |
| tEXt_node.setAttribute("value" , (String)tEXt_text.get(i)); |
| |
| tEXt_parent.appendChild(tEXt_node); |
| } |
| |
| root.appendChild(tEXt_parent); |
| } |
| |
| // tIME |
| if (tIME_present) { |
| IIOMetadataNode tIME_node = new IIOMetadataNode("tIME"); |
| tIME_node.setAttribute("year", Integer.toString(tIME_year)); |
| tIME_node.setAttribute("month", Integer.toString(tIME_month)); |
| tIME_node.setAttribute("day", Integer.toString(tIME_day)); |
| tIME_node.setAttribute("hour", Integer.toString(tIME_hour)); |
| tIME_node.setAttribute("minute", Integer.toString(tIME_minute)); |
| tIME_node.setAttribute("second", Integer.toString(tIME_second)); |
| |
| root.appendChild(tIME_node); |
| } |
| |
| // tRNS |
| if (tRNS_present) { |
| IIOMetadataNode tRNS_node = new IIOMetadataNode("tRNS"); |
| |
| if (tRNS_colorType == PNGImageReader.PNG_COLOR_PALETTE) { |
| node = new IIOMetadataNode("tRNS_Palette"); |
| |
| for (int i = 0; i < tRNS_alpha.length; i++) { |
| IIOMetadataNode entry = |
| new IIOMetadataNode("tRNS_PaletteEntry"); |
| entry.setAttribute("index", Integer.toString(i)); |
| entry.setAttribute("alpha", |
| Integer.toString(tRNS_alpha[i] & 0xff)); |
| node.appendChild(entry); |
| } |
| } else if (tRNS_colorType == PNGImageReader.PNG_COLOR_GRAY) { |
| node = new IIOMetadataNode("tRNS_Grayscale"); |
| node.setAttribute("gray", Integer.toString(tRNS_gray)); |
| } else if (tRNS_colorType == PNGImageReader.PNG_COLOR_RGB) { |
| node = new IIOMetadataNode("tRNS_RGB"); |
| node.setAttribute("red", Integer.toString(tRNS_red)); |
| node.setAttribute("green", Integer.toString(tRNS_green)); |
| node.setAttribute("blue", Integer.toString(tRNS_blue)); |
| } |
| tRNS_node.appendChild(node); |
| |
| root.appendChild(tRNS_node); |
| } |
| |
| // zTXt |
| if (zTXt_keyword.size() > 0) { |
| IIOMetadataNode zTXt_parent = new IIOMetadataNode("zTXt"); |
| for (int i = 0; i < zTXt_keyword.size(); i++) { |
| IIOMetadataNode zTXt_node = new IIOMetadataNode("zTXtEntry"); |
| zTXt_node.setAttribute("keyword", (String)zTXt_keyword.get(i)); |
| |
| int cm = ((Integer)zTXt_compressionMethod.get(i)).intValue(); |
| zTXt_node.setAttribute("compressionMethod", |
| zTXt_compressionMethodNames[cm]); |
| |
| zTXt_node.setAttribute("text", (String)zTXt_text.get(i)); |
| |
| zTXt_parent.appendChild(zTXt_node); |
| } |
| |
| root.appendChild(zTXt_parent); |
| } |
| |
| // Unknown chunks |
| if (unknownChunkType.size() > 0) { |
| IIOMetadataNode unknown_parent = |
| new IIOMetadataNode("UnknownChunks"); |
| for (int i = 0; i < unknownChunkType.size(); i++) { |
| IIOMetadataNode unknown_node = |
| new IIOMetadataNode("UnknownChunk"); |
| unknown_node.setAttribute("type", |
| (String)unknownChunkType.get(i)); |
| unknown_node.setUserObject((byte[])unknownChunkData.get(i)); |
| |
| unknown_parent.appendChild(unknown_node); |
| } |
| |
| root.appendChild(unknown_parent); |
| } |
| |
| return root; |
| } |
| |
| private int getNumChannels() { |
| // Determine number of channels |
| // Be careful about palette color with transparency |
| int numChannels = IHDR_numChannels[IHDR_colorType]; |
| if (IHDR_colorType == PNGImageReader.PNG_COLOR_PALETTE && |
| tRNS_present && tRNS_colorType == IHDR_colorType) { |
| numChannels = 4; |
| } |
| return numChannels; |
| } |
| |
| public IIOMetadataNode getStandardChromaNode() { |
| IIOMetadataNode chroma_node = new IIOMetadataNode("Chroma"); |
| IIOMetadataNode node = null; // scratch node |
| |
| node = new IIOMetadataNode("ColorSpaceType"); |
| node.setAttribute("name", colorSpaceTypeNames[IHDR_colorType]); |
| chroma_node.appendChild(node); |
| |
| node = new IIOMetadataNode("NumChannels"); |
| node.setAttribute("value", Integer.toString(getNumChannels())); |
| chroma_node.appendChild(node); |
| |
| if (gAMA_present) { |
| node = new IIOMetadataNode("Gamma"); |
| node.setAttribute("value", Float.toString(gAMA_gamma*1.0e-5F)); |
| chroma_node.appendChild(node); |
| } |
| |
| node = new IIOMetadataNode("BlackIsZero"); |
| node.setAttribute("value", "TRUE"); |
| chroma_node.appendChild(node); |
| |
| if (PLTE_present) { |
| boolean hasAlpha = tRNS_present && |
| (tRNS_colorType == PNGImageReader.PNG_COLOR_PALETTE); |
| |
| node = new IIOMetadataNode("Palette"); |
| for (int i = 0; i < PLTE_red.length; i++) { |
| IIOMetadataNode entry = |
| new IIOMetadataNode("PaletteEntry"); |
| entry.setAttribute("index", Integer.toString(i)); |
| entry.setAttribute("red", |
| Integer.toString(PLTE_red[i] & 0xff)); |
| entry.setAttribute("green", |
| Integer.toString(PLTE_green[i] & 0xff)); |
| entry.setAttribute("blue", |
| Integer.toString(PLTE_blue[i] & 0xff)); |
| if (hasAlpha) { |
| int alpha = (i < tRNS_alpha.length) ? |
| (tRNS_alpha[i] & 0xff) : 255; |
| entry.setAttribute("alpha", Integer.toString(alpha)); |
| } |
| node.appendChild(entry); |
| } |
| chroma_node.appendChild(node); |
| } |
| |
| if (bKGD_present) { |
| if (bKGD_colorType == PNGImageReader.PNG_COLOR_PALETTE) { |
| node = new IIOMetadataNode("BackgroundIndex"); |
| node.setAttribute("value", Integer.toString(bKGD_index)); |
| } else { |
| node = new IIOMetadataNode("BackgroundColor"); |
| int r, g, b; |
| |
| if (bKGD_colorType == PNGImageReader.PNG_COLOR_GRAY) { |
| r = g = b = bKGD_gray; |
| } else { |
| r = bKGD_red; |
| g = bKGD_green; |
| b = bKGD_blue; |
| } |
| node.setAttribute("red", Integer.toString(r)); |
| node.setAttribute("green", Integer.toString(g)); |
| node.setAttribute("blue", Integer.toString(b)); |
| } |
| chroma_node.appendChild(node); |
| } |
| |
| return chroma_node; |
| } |
| |
| public IIOMetadataNode getStandardCompressionNode() { |
| IIOMetadataNode compression_node = new IIOMetadataNode("Compression"); |
| IIOMetadataNode node = null; // scratch node |
| |
| node = new IIOMetadataNode("CompressionTypeName"); |
| node.setAttribute("value", "deflate"); |
| compression_node.appendChild(node); |
| |
| node = new IIOMetadataNode("Lossless"); |
| node.setAttribute("value", "TRUE"); |
| compression_node.appendChild(node); |
| |
| node = new IIOMetadataNode("NumProgressiveScans"); |
| node.setAttribute("value", |
| (IHDR_interlaceMethod == 0) ? "1" : "7"); |
| compression_node.appendChild(node); |
| |
| return compression_node; |
| } |
| |
| private String repeat(String s, int times) { |
| if (times == 1) { |
| return s; |
| } |
| StringBuffer sb = new StringBuffer((s.length() + 1)*times - 1); |
| sb.append(s); |
| for (int i = 1; i < times; i++) { |
| sb.append(" "); |
| sb.append(s); |
| } |
| return sb.toString(); |
| } |
| |
| public IIOMetadataNode getStandardDataNode() { |
| IIOMetadataNode data_node = new IIOMetadataNode("Data"); |
| IIOMetadataNode node = null; // scratch node |
| |
| node = new IIOMetadataNode("PlanarConfiguration"); |
| node.setAttribute("value", "PixelInterleaved"); |
| data_node.appendChild(node); |
| |
| node = new IIOMetadataNode("SampleFormat"); |
| node.setAttribute("value", |
| IHDR_colorType == PNGImageReader.PNG_COLOR_PALETTE ? |
| "Index" : "UnsignedIntegral"); |
| data_node.appendChild(node); |
| |
| String bitDepth = Integer.toString(IHDR_bitDepth); |
| node = new IIOMetadataNode("BitsPerSample"); |
| node.setAttribute("value", repeat(bitDepth, getNumChannels())); |
| data_node.appendChild(node); |
| |
| if (sBIT_present) { |
| node = new IIOMetadataNode("SignificantBitsPerSample"); |
| String sbits; |
| if (sBIT_colorType == PNGImageReader.PNG_COLOR_GRAY || |
| sBIT_colorType == PNGImageReader.PNG_COLOR_GRAY_ALPHA) { |
| sbits = Integer.toString(sBIT_grayBits); |
| } else { // sBIT_colorType == PNGImageReader.PNG_COLOR_RGB || |
| // sBIT_colorType == PNGImageReader.PNG_COLOR_RGB_ALPHA |
| sbits = Integer.toString(sBIT_redBits) + " " + |
| Integer.toString(sBIT_greenBits) + " " + |
| Integer.toString(sBIT_blueBits); |
| } |
| |
| if (sBIT_colorType == PNGImageReader.PNG_COLOR_GRAY_ALPHA || |
| sBIT_colorType == PNGImageReader.PNG_COLOR_RGB_ALPHA) { |
| sbits += " " + Integer.toString(sBIT_alphaBits); |
| } |
| |
| node.setAttribute("value", sbits); |
| data_node.appendChild(node); |
| } |
| |
| // SampleMSB |
| |
| return data_node; |
| } |
| |
| public IIOMetadataNode getStandardDimensionNode() { |
| IIOMetadataNode dimension_node = new IIOMetadataNode("Dimension"); |
| IIOMetadataNode node = null; // scratch node |
| |
| node = new IIOMetadataNode("PixelAspectRatio"); |
| float ratio = pHYs_present ? |
| (float)pHYs_pixelsPerUnitXAxis/pHYs_pixelsPerUnitYAxis : 1.0F; |
| node.setAttribute("value", Float.toString(ratio)); |
| dimension_node.appendChild(node); |
| |
| node = new IIOMetadataNode("ImageOrientation"); |
| node.setAttribute("value", "Normal"); |
| dimension_node.appendChild(node); |
| |
| if (pHYs_present && pHYs_unitSpecifier == PHYS_UNIT_METER) { |
| node = new IIOMetadataNode("HorizontalPixelSize"); |
| node.setAttribute("value", |
| Float.toString(1000.0F/pHYs_pixelsPerUnitXAxis)); |
| dimension_node.appendChild(node); |
| |
| node = new IIOMetadataNode("VerticalPixelSize"); |
| node.setAttribute("value", |
| Float.toString(1000.0F/pHYs_pixelsPerUnitYAxis)); |
| dimension_node.appendChild(node); |
| } |
| |
| return dimension_node; |
| } |
| |
| public IIOMetadataNode getStandardDocumentNode() { |
| if (!tIME_present) { |
| return null; |
| } |
| |
| IIOMetadataNode document_node = new IIOMetadataNode("Document"); |
| IIOMetadataNode node = null; // scratch node |
| |
| node = new IIOMetadataNode("ImageModificationTime"); |
| node.setAttribute("year", Integer.toString(tIME_year)); |
| node.setAttribute("month", Integer.toString(tIME_month)); |
| node.setAttribute("day", Integer.toString(tIME_day)); |
| node.setAttribute("hour", Integer.toString(tIME_hour)); |
| node.setAttribute("minute", Integer.toString(tIME_minute)); |
| node.setAttribute("second", Integer.toString(tIME_second)); |
| document_node.appendChild(node); |
| |
| return document_node; |
| } |
| |
| public IIOMetadataNode getStandardTextNode() { |
| int numEntries = tEXt_keyword.size() + |
| iTXt_keyword.size() + zTXt_keyword.size(); |
| if (numEntries == 0) { |
| return null; |
| } |
| |
| IIOMetadataNode text_node = new IIOMetadataNode("Text"); |
| IIOMetadataNode node = null; // scratch node |
| |
| for (int i = 0; i < tEXt_keyword.size(); i++) { |
| node = new IIOMetadataNode("TextEntry"); |
| node.setAttribute("keyword", (String)tEXt_keyword.get(i)); |
| node.setAttribute("value", (String)tEXt_text.get(i)); |
| node.setAttribute("encoding", "ISO-8859-1"); |
| node.setAttribute("compression", "none"); |
| |
| text_node.appendChild(node); |
| } |
| |
| for (int i = 0; i < iTXt_keyword.size(); i++) { |
| node = new IIOMetadataNode("TextEntry"); |
| node.setAttribute("keyword", iTXt_keyword.get(i)); |
| node.setAttribute("value", iTXt_text.get(i)); |
| node.setAttribute("language", |
| iTXt_languageTag.get(i)); |
| if (iTXt_compressionFlag.get(i)) { |
| node.setAttribute("compression", "zip"); |
| } else { |
| node.setAttribute("compression", "none"); |
| } |
| |
| text_node.appendChild(node); |
| } |
| |
| for (int i = 0; i < zTXt_keyword.size(); i++) { |
| node = new IIOMetadataNode("TextEntry"); |
| node.setAttribute("keyword", (String)zTXt_keyword.get(i)); |
| node.setAttribute("value", (String)zTXt_text.get(i)); |
| node.setAttribute("compression", "zip"); |
| |
| text_node.appendChild(node); |
| } |
| |
| return text_node; |
| } |
| |
| public IIOMetadataNode getStandardTransparencyNode() { |
| IIOMetadataNode transparency_node = |
| new IIOMetadataNode("Transparency"); |
| IIOMetadataNode node = null; // scratch node |
| |
| node = new IIOMetadataNode("Alpha"); |
| boolean hasAlpha = |
| (IHDR_colorType == PNGImageReader.PNG_COLOR_RGB_ALPHA) || |
| (IHDR_colorType == PNGImageReader.PNG_COLOR_GRAY_ALPHA) || |
| (IHDR_colorType == PNGImageReader.PNG_COLOR_PALETTE && |
| tRNS_present && |
| (tRNS_colorType == IHDR_colorType) && |
| (tRNS_alpha != null)); |
| node.setAttribute("value", hasAlpha ? "nonpremultipled" : "none"); |
| transparency_node.appendChild(node); |
| |
| if (tRNS_present) { |
| node = new IIOMetadataNode("TransparentColor"); |
| if (tRNS_colorType == PNGImageReader.PNG_COLOR_RGB) { |
| node.setAttribute("value", |
| Integer.toString(tRNS_red) + " " + |
| Integer.toString(tRNS_green) + " " + |
| Integer.toString(tRNS_blue)); |
| } else if (tRNS_colorType == PNGImageReader.PNG_COLOR_GRAY) { |
| node.setAttribute("value", Integer.toString(tRNS_gray)); |
| } |
| transparency_node.appendChild(node); |
| } |
| |
| return transparency_node; |
| } |
| |
| // Shorthand for throwing an IIOInvalidTreeException |
| private void fatal(Node node, String reason) |
| throws IIOInvalidTreeException { |
| throw new IIOInvalidTreeException(reason, node); |
| } |
| |
| // Get an integer-valued attribute |
| private String getStringAttribute(Node node, String name, |
| String defaultValue, boolean required) |
| throws IIOInvalidTreeException { |
| Node attr = node.getAttributes().getNamedItem(name); |
| if (attr == null) { |
| if (!required) { |
| return defaultValue; |
| } else { |
| fatal(node, "Required attribute " + name + " not present!"); |
| } |
| } |
| return attr.getNodeValue(); |
| } |
| |
| |
| // Get an integer-valued attribute |
| private int getIntAttribute(Node node, String name, |
| int defaultValue, boolean required) |
| throws IIOInvalidTreeException { |
| String value = getStringAttribute(node, name, null, required); |
| if (value == null) { |
| return defaultValue; |
| } |
| return Integer.parseInt(value); |
| } |
| |
| // Get a float-valued attribute |
| private float getFloatAttribute(Node node, String name, |
| float defaultValue, boolean required) |
| throws IIOInvalidTreeException { |
| String value = getStringAttribute(node, name, null, required); |
| if (value == null) { |
| return defaultValue; |
| } |
| return Float.parseFloat(value); |
| } |
| |
| // Get a required integer-valued attribute |
| private int getIntAttribute(Node node, String name) |
| throws IIOInvalidTreeException { |
| return getIntAttribute(node, name, -1, true); |
| } |
| |
| // Get a required float-valued attribute |
| private float getFloatAttribute(Node node, String name) |
| throws IIOInvalidTreeException { |
| return getFloatAttribute(node, name, -1.0F, true); |
| } |
| |
| // Get a boolean-valued attribute |
| private boolean getBooleanAttribute(Node node, String name, |
| boolean defaultValue, |
| boolean required) |
| throws IIOInvalidTreeException { |
| Node attr = node.getAttributes().getNamedItem(name); |
| if (attr == null) { |
| if (!required) { |
| return defaultValue; |
| } else { |
| fatal(node, "Required attribute " + name + " not present!"); |
| } |
| } |
| String value = attr.getNodeValue(); |
| // Allow lower case booleans for backward compatibility, #5082756 |
| if (value.equals("TRUE") || value.equals("true")) { |
| return true; |
| } else if (value.equals("FALSE") || value.equals("false")) { |
| return false; |
| } else { |
| fatal(node, "Attribute " + name + " must be 'TRUE' or 'FALSE'!"); |
| return false; |
| } |
| } |
| |
| // Get a required boolean-valued attribute |
| private boolean getBooleanAttribute(Node node, String name) |
| throws IIOInvalidTreeException { |
| return getBooleanAttribute(node, name, false, true); |
| } |
| |
| // Get an enumerated attribute as an index into a String array |
| private int getEnumeratedAttribute(Node node, |
| String name, String[] legalNames, |
| int defaultValue, boolean required) |
| throws IIOInvalidTreeException { |
| Node attr = node.getAttributes().getNamedItem(name); |
| if (attr == null) { |
| if (!required) { |
| return defaultValue; |
| } else { |
| fatal(node, "Required attribute " + name + " not present!"); |
| } |
| } |
| String value = attr.getNodeValue(); |
| for (int i = 0; i < legalNames.length; i++) { |
| if (value.equals(legalNames[i])) { |
| return i; |
| } |
| } |
| |
| fatal(node, "Illegal value for attribute " + name + "!"); |
| return -1; |
| } |
| |
| // Get a required enumerated attribute as an index into a String array |
| private int getEnumeratedAttribute(Node node, |
| String name, String[] legalNames) |
| throws IIOInvalidTreeException { |
| return getEnumeratedAttribute(node, name, legalNames, -1, true); |
| } |
| |
| // Get a String-valued attribute |
| private String getAttribute(Node node, String name, |
| String defaultValue, boolean required) |
| throws IIOInvalidTreeException { |
| Node attr = node.getAttributes().getNamedItem(name); |
| if (attr == null) { |
| if (!required) { |
| return defaultValue; |
| } else { |
| fatal(node, "Required attribute " + name + " not present!"); |
| } |
| } |
| return attr.getNodeValue(); |
| } |
| |
| // Get a required String-valued attribute |
| private String getAttribute(Node node, String name) |
| throws IIOInvalidTreeException { |
| return getAttribute(node, name, null, true); |
| } |
| |
| public void mergeTree(String formatName, Node root) |
| throws IIOInvalidTreeException { |
| if (formatName.equals(nativeMetadataFormatName)) { |
| if (root == null) { |
| throw new IllegalArgumentException("root == null!"); |
| } |
| mergeNativeTree(root); |
| } else if (formatName.equals |
| (IIOMetadataFormatImpl.standardMetadataFormatName)) { |
| if (root == null) { |
| throw new IllegalArgumentException("root == null!"); |
| } |
| mergeStandardTree(root); |
| } else { |
| throw new IllegalArgumentException("Not a recognized format!"); |
| } |
| } |
| |
| private void mergeNativeTree(Node root) |
| throws IIOInvalidTreeException { |
| Node node = root; |
| if (!node.getNodeName().equals(nativeMetadataFormatName)) { |
| fatal(node, "Root must be " + nativeMetadataFormatName); |
| } |
| |
| node = node.getFirstChild(); |
| while (node != null) { |
| String name = node.getNodeName(); |
| |
| if (name.equals("IHDR")) { |
| IHDR_width = getIntAttribute(node, "width"); |
| IHDR_height = getIntAttribute(node, "height"); |
| IHDR_bitDepth = |
| Integer.valueOf(IHDR_bitDepths[ |
| getEnumeratedAttribute(node, |
| "bitDepth", |
| IHDR_bitDepths)]); |
| IHDR_colorType = getEnumeratedAttribute(node, "colorType", |
| IHDR_colorTypeNames); |
| IHDR_compressionMethod = |
| getEnumeratedAttribute(node, "compressionMethod", |
| IHDR_compressionMethodNames); |
| IHDR_filterMethod = |
| getEnumeratedAttribute(node, |
| "filterMethod", |
| IHDR_filterMethodNames); |
| IHDR_interlaceMethod = |
| getEnumeratedAttribute(node, "interlaceMethod", |
| IHDR_interlaceMethodNames); |
| IHDR_present = true; |
| } else if (name.equals("PLTE")) { |
| byte[] red = new byte[256]; |
| byte[] green = new byte[256]; |
| byte[] blue = new byte[256]; |
| int maxindex = -1; |
| |
| Node PLTE_entry = node.getFirstChild(); |
| if (PLTE_entry == null) { |
| fatal(node, "Palette has no entries!"); |
| } |
| |
| while (PLTE_entry != null) { |
| if (!PLTE_entry.getNodeName().equals("PLTEEntry")) { |
| fatal(node, |
| "Only a PLTEEntry may be a child of a PLTE!"); |
| } |
| |
| int index = getIntAttribute(PLTE_entry, "index"); |
| if (index < 0 || index > 255) { |
| fatal(node, |
| "Bad value for PLTEEntry attribute index!"); |
| } |
| if (index > maxindex) { |
| maxindex = index; |
| } |
| red[index] = |
| (byte)getIntAttribute(PLTE_entry, "red"); |
| green[index] = |
| (byte)getIntAttribute(PLTE_entry, "green"); |
| blue[index] = |
| (byte)getIntAttribute(PLTE_entry, "blue"); |
| |
| PLTE_entry = PLTE_entry.getNextSibling(); |
| } |
| |
| int numEntries = maxindex + 1; |
| PLTE_red = new byte[numEntries]; |
| PLTE_green = new byte[numEntries]; |
| PLTE_blue = new byte[numEntries]; |
| System.arraycopy(red, 0, PLTE_red, 0, numEntries); |
| System.arraycopy(green, 0, PLTE_green, 0, numEntries); |
| System.arraycopy(blue, 0, PLTE_blue, 0, numEntries); |
| PLTE_present = true; |
| } else if (name.equals("bKGD")) { |
| bKGD_present = false; // Guard against partial overwrite |
| Node bKGD_node = node.getFirstChild(); |
| if (bKGD_node == null) { |
| fatal(node, "bKGD node has no children!"); |
| } |
| String bKGD_name = bKGD_node.getNodeName(); |
| if (bKGD_name.equals("bKGD_Palette")) { |
| bKGD_index = getIntAttribute(bKGD_node, "index"); |
| bKGD_colorType = PNGImageReader.PNG_COLOR_PALETTE; |
| } else if (bKGD_name.equals("bKGD_Grayscale")) { |
| bKGD_gray = getIntAttribute(bKGD_node, "gray"); |
| bKGD_colorType = PNGImageReader.PNG_COLOR_GRAY; |
| } else if (bKGD_name.equals("bKGD_RGB")) { |
| bKGD_red = getIntAttribute(bKGD_node, "red"); |
| bKGD_green = getIntAttribute(bKGD_node, "green"); |
| bKGD_blue = getIntAttribute(bKGD_node, "blue"); |
| bKGD_colorType = PNGImageReader.PNG_COLOR_RGB; |
| } else { |
| fatal(node, "Bad child of a bKGD node!"); |
| } |
| if (bKGD_node.getNextSibling() != null) { |
| fatal(node, "bKGD node has more than one child!"); |
| } |
| |
| bKGD_present = true; |
| } else if (name.equals("cHRM")) { |
| cHRM_whitePointX = getIntAttribute(node, "whitePointX"); |
| cHRM_whitePointY = getIntAttribute(node, "whitePointY"); |
| cHRM_redX = getIntAttribute(node, "redX"); |
| cHRM_redY = getIntAttribute(node, "redY"); |
| cHRM_greenX = getIntAttribute(node, "greenX"); |
| cHRM_greenY = getIntAttribute(node, "greenY"); |
| cHRM_blueX = getIntAttribute(node, "blueX"); |
| cHRM_blueY = getIntAttribute(node, "blueY"); |
| |
| cHRM_present = true; |
| } else if (name.equals("gAMA")) { |
| gAMA_gamma = getIntAttribute(node, "value"); |
| gAMA_present = true; |
| } else if (name.equals("hIST")) { |
| char[] hist = new char[256]; |
| int maxindex = -1; |
| |
| Node hIST_entry = node.getFirstChild(); |
| if (hIST_entry == null) { |
| fatal(node, "hIST node has no children!"); |
| } |
| |
| while (hIST_entry != null) { |
| if (!hIST_entry.getNodeName().equals("hISTEntry")) { |
| fatal(node, |
| "Only a hISTEntry may be a child of a hIST!"); |
| } |
| |
| int index = getIntAttribute(hIST_entry, "index"); |
| if (index < 0 || index > 255) { |
| fatal(node, |
| "Bad value for histEntry attribute index!"); |
| } |
| if (index > maxindex) { |
| maxindex = index; |
| } |
| hist[index] = |
| (char)getIntAttribute(hIST_entry, "value"); |
| |
| hIST_entry = hIST_entry.getNextSibling(); |
| } |
| |
| int numEntries = maxindex + 1; |
| hIST_histogram = new char[numEntries]; |
| System.arraycopy(hist, 0, hIST_histogram, 0, numEntries); |
| |
| hIST_present = true; |
| } else if (name.equals("iCCP")) { |
| iCCP_profileName = getAttribute(node, "profileName"); |
| iCCP_compressionMethod = |
| getEnumeratedAttribute(node, "compressionMethod", |
| iCCP_compressionMethodNames); |
| Object compressedProfile = |
| ((IIOMetadataNode)node).getUserObject(); |
| if (compressedProfile == null) { |
| fatal(node, "No ICCP profile present in user object!"); |
| } |
| if (!(compressedProfile instanceof byte[])) { |
| fatal(node, "User object not a byte array!"); |
| } |
| |
| iCCP_compressedProfile = |
| (byte[])((byte[])compressedProfile).clone(); |
| |
| iCCP_present = true; |
| } else if (name.equals("iTXt")) { |
| Node iTXt_node = node.getFirstChild(); |
| while (iTXt_node != null) { |
| if (!iTXt_node.getNodeName().equals("iTXtEntry")) { |
| fatal(node, |
| "Only an iTXtEntry may be a child of an iTXt!"); |
| } |
| |
| String keyword = getAttribute(iTXt_node, "keyword"); |
| if (isValidKeyword(keyword)) { |
| iTXt_keyword.add(keyword); |
| |
| boolean compressionFlag = |
| getBooleanAttribute(iTXt_node, "compressionFlag"); |
| iTXt_compressionFlag.add(Boolean.valueOf(compressionFlag)); |
| |
| String compressionMethod = |
| getAttribute(iTXt_node, "compressionMethod"); |
| iTXt_compressionMethod.add(Integer.valueOf(compressionMethod)); |
| |
| String languageTag = |
| getAttribute(iTXt_node, "languageTag"); |
| iTXt_languageTag.add(languageTag); |
| |
| String translatedKeyword = |
| getAttribute(iTXt_node, "translatedKeyword"); |
| iTXt_translatedKeyword.add(translatedKeyword); |
| |
| String text = getAttribute(iTXt_node, "text"); |
| iTXt_text.add(text); |
| |
| } |
| // silently skip invalid text entry |
| |
| iTXt_node = iTXt_node.getNextSibling(); |
| } |
| } else if (name.equals("pHYs")) { |
| pHYs_pixelsPerUnitXAxis = |
| getIntAttribute(node, "pixelsPerUnitXAxis"); |
| pHYs_pixelsPerUnitYAxis = |
| getIntAttribute(node, "pixelsPerUnitYAxis"); |
| pHYs_unitSpecifier = |
| getEnumeratedAttribute(node, "unitSpecifier", |
| unitSpecifierNames); |
| |
| pHYs_present = true; |
| } else if (name.equals("sBIT")) { |
| sBIT_present = false; // Guard against partial overwrite |
| Node sBIT_node = node.getFirstChild(); |
| if (sBIT_node == null) { |
| fatal(node, "sBIT node has no children!"); |
| } |
| String sBIT_name = sBIT_node.getNodeName(); |
| if (sBIT_name.equals("sBIT_Grayscale")) { |
| sBIT_grayBits = getIntAttribute(sBIT_node, "gray"); |
| sBIT_colorType = PNGImageReader.PNG_COLOR_GRAY; |
| } else if (sBIT_name.equals("sBIT_GrayAlpha")) { |
| sBIT_grayBits = getIntAttribute(sBIT_node, "gray"); |
| sBIT_alphaBits = getIntAttribute(sBIT_node, "alpha"); |
| sBIT_colorType = PNGImageReader.PNG_COLOR_GRAY_ALPHA; |
| } else if (sBIT_name.equals("sBIT_RGB")) { |
| sBIT_redBits = getIntAttribute(sBIT_node, "red"); |
| sBIT_greenBits = getIntAttribute(sBIT_node, "green"); |
| sBIT_blueBits = getIntAttribute(sBIT_node, "blue"); |
| sBIT_colorType = PNGImageReader.PNG_COLOR_RGB; |
| } else if (sBIT_name.equals("sBIT_RGBAlpha")) { |
| sBIT_redBits = getIntAttribute(sBIT_node, "red"); |
| sBIT_greenBits = getIntAttribute(sBIT_node, "green"); |
| sBIT_blueBits = getIntAttribute(sBIT_node, "blue"); |
| sBIT_alphaBits = getIntAttribute(sBIT_node, "alpha"); |
| sBIT_colorType = PNGImageReader.PNG_COLOR_RGB_ALPHA; |
| } else if (sBIT_name.equals("sBIT_Palette")) { |
| sBIT_redBits = getIntAttribute(sBIT_node, "red"); |
| sBIT_greenBits = getIntAttribute(sBIT_node, "green"); |
| sBIT_blueBits = getIntAttribute(sBIT_node, "blue"); |
| sBIT_colorType = PNGImageReader.PNG_COLOR_PALETTE; |
| } else { |
| fatal(node, "Bad child of an sBIT node!"); |
| } |
| if (sBIT_node.getNextSibling() != null) { |
| fatal(node, "sBIT node has more than one child!"); |
| } |
| |
| sBIT_present = true; |
| } else if (name.equals("sPLT")) { |
| sPLT_paletteName = getAttribute(node, "name"); |
| sPLT_sampleDepth = getIntAttribute(node, "sampleDepth"); |
| |
| int[] red = new int[256]; |
| int[] green = new int[256]; |
| int[] blue = new int[256]; |
| int[] alpha = new int[256]; |
| int[] frequency = new int[256]; |
| int maxindex = -1; |
| |
| Node sPLT_entry = node.getFirstChild(); |
| if (sPLT_entry == null) { |
| fatal(node, "sPLT node has no children!"); |
| } |
| |
| while (sPLT_entry != null) { |
| if (!sPLT_entry.getNodeName().equals("sPLTEntry")) { |
| fatal(node, |
| "Only an sPLTEntry may be a child of an sPLT!"); |
| } |
| |
| int index = getIntAttribute(sPLT_entry, "index"); |
| if (index < 0 || index > 255) { |
| fatal(node, |
| "Bad value for PLTEEntry attribute index!"); |
| } |
| if (index > maxindex) { |
| maxindex = index; |
| } |
| red[index] = getIntAttribute(sPLT_entry, "red"); |
| green[index] = getIntAttribute(sPLT_entry, "green"); |
| blue[index] = getIntAttribute(sPLT_entry, "blue"); |
| alpha[index] = getIntAttribute(sPLT_entry, "alpha"); |
| frequency[index] = |
| getIntAttribute(sPLT_entry, "frequency"); |
| |
| sPLT_entry = sPLT_entry.getNextSibling(); |
| } |
| |
| int numEntries = maxindex + 1; |
| sPLT_red = new int[numEntries]; |
| sPLT_green = new int[numEntries]; |
| sPLT_blue = new int[numEntries]; |
| sPLT_alpha = new int[numEntries]; |
| sPLT_frequency = new int[numEntries]; |
| System.arraycopy(red, 0, sPLT_red, 0, numEntries); |
| System.arraycopy(green, 0, sPLT_green, 0, numEntries); |
| System.arraycopy(blue, 0, sPLT_blue, 0, numEntries); |
| System.arraycopy(alpha, 0, sPLT_alpha, 0, numEntries); |
| System.arraycopy(frequency, 0, |
| sPLT_frequency, 0, numEntries); |
| |
| sPLT_present = true; |
| } else if (name.equals("sRGB")) { |
| sRGB_renderingIntent = |
| getEnumeratedAttribute(node, "renderingIntent", |
| renderingIntentNames); |
| |
| sRGB_present = true; |
| } else if (name.equals("tEXt")) { |
| Node tEXt_node = node.getFirstChild(); |
| while (tEXt_node != null) { |
| if (!tEXt_node.getNodeName().equals("tEXtEntry")) { |
| fatal(node, |
| "Only an tEXtEntry may be a child of an tEXt!"); |
| } |
| |
| String keyword = getAttribute(tEXt_node, "keyword"); |
| tEXt_keyword.add(keyword); |
| |
| String text = getAttribute(tEXt_node, "value"); |
| tEXt_text.add(text); |
| |
| tEXt_node = tEXt_node.getNextSibling(); |
| } |
| } else if (name.equals("tIME")) { |
| tIME_year = getIntAttribute(node, "year"); |
| tIME_month = getIntAttribute(node, "month"); |
| tIME_day = getIntAttribute(node, "day"); |
| tIME_hour = getIntAttribute(node, "hour"); |
| tIME_minute = getIntAttribute(node, "minute"); |
| tIME_second = getIntAttribute(node, "second"); |
| |
| tIME_present = true; |
| } else if (name.equals("tRNS")) { |
| tRNS_present = false; // Guard against partial overwrite |
| Node tRNS_node = node.getFirstChild(); |
| if (tRNS_node == null) { |
| fatal(node, "tRNS node has no children!"); |
| } |
| String tRNS_name = tRNS_node.getNodeName(); |
| if (tRNS_name.equals("tRNS_Palette")) { |
| byte[] alpha = new byte[256]; |
| int maxindex = -1; |
| |
| Node tRNS_paletteEntry = tRNS_node.getFirstChild(); |
| if (tRNS_paletteEntry == null) { |
| fatal(node, "tRNS_Palette node has no children!"); |
| } |
| while (tRNS_paletteEntry != null) { |
| if (!tRNS_paletteEntry.getNodeName().equals( |
| "tRNS_PaletteEntry")) { |
| fatal(node, |
| "Only a tRNS_PaletteEntry may be a child of a tRNS_Palette!"); |
| } |
| int index = |
| getIntAttribute(tRNS_paletteEntry, "index"); |
| if (index < 0 || index > 255) { |
| fatal(node, |
| "Bad value for tRNS_PaletteEntry attribute index!"); |
| } |
| if (index > maxindex) { |
| maxindex = index; |
| } |
| alpha[index] = |
| (byte)getIntAttribute(tRNS_paletteEntry, |
| "alpha"); |
| |
| tRNS_paletteEntry = |
| tRNS_paletteEntry.getNextSibling(); |
| } |
| |
| int numEntries = maxindex + 1; |
| tRNS_alpha = new byte[numEntries]; |
| tRNS_colorType = PNGImageReader.PNG_COLOR_PALETTE; |
| System.arraycopy(alpha, 0, tRNS_alpha, 0, numEntries); |
| } else if (tRNS_name.equals("tRNS_Grayscale")) { |
| tRNS_gray = getIntAttribute(tRNS_node, "gray"); |
| tRNS_colorType = PNGImageReader.PNG_COLOR_GRAY; |
| } else if (tRNS_name.equals("tRNS_RGB")) { |
| tRNS_red = getIntAttribute(tRNS_node, "red"); |
| tRNS_green = getIntAttribute(tRNS_node, "green"); |
| tRNS_blue = getIntAttribute(tRNS_node, "blue"); |
| tRNS_colorType = PNGImageReader.PNG_COLOR_RGB; |
| } else { |
| fatal(node, "Bad child of a tRNS node!"); |
| } |
| if (tRNS_node.getNextSibling() != null) { |
| fatal(node, "tRNS node has more than one child!"); |
| } |
| |
| tRNS_present = true; |
| } else if (name.equals("zTXt")) { |
| Node zTXt_node = node.getFirstChild(); |
| while (zTXt_node != null) { |
| if (!zTXt_node.getNodeName().equals("zTXtEntry")) { |
| fatal(node, |
| "Only an zTXtEntry may be a child of an zTXt!"); |
| } |
| |
| String keyword = getAttribute(zTXt_node, "keyword"); |
| zTXt_keyword.add(keyword); |
| |
| int compressionMethod = |
| getEnumeratedAttribute(zTXt_node, "compressionMethod", |
| zTXt_compressionMethodNames); |
| zTXt_compressionMethod.add(new Integer(compressionMethod)); |
| |
| String text = getAttribute(zTXt_node, "text"); |
| zTXt_text.add(text); |
| |
| zTXt_node = zTXt_node.getNextSibling(); |
| } |
| } else if (name.equals("UnknownChunks")) { |
| Node unknown_node = node.getFirstChild(); |
| while (unknown_node != null) { |
| if (!unknown_node.getNodeName().equals("UnknownChunk")) { |
| fatal(node, |
| "Only an UnknownChunk may be a child of an UnknownChunks!"); |
| } |
| String chunkType = getAttribute(unknown_node, "type"); |
| Object chunkData = |
| ((IIOMetadataNode)unknown_node).getUserObject(); |
| |
| if (chunkType.length() != 4) { |
| fatal(unknown_node, |
| "Chunk type must be 4 characters!"); |
| } |
| if (chunkData == null) { |
| fatal(unknown_node, |
| "No chunk data present in user object!"); |
| } |
| if (!(chunkData instanceof byte[])) { |
| fatal(unknown_node, |
| "User object not a byte array!"); |
| } |
| unknownChunkType.add(chunkType); |
| unknownChunkData.add(((byte[])chunkData).clone()); |
| |
| unknown_node = unknown_node.getNextSibling(); |
| } |
| } else { |
| fatal(node, "Unknown child of root node!"); |
| } |
| |
| node = node.getNextSibling(); |
| } |
| } |
| |
| /* |
| * Accrding to PNG spec, keywords are restricted to 1 to 79 bytes |
| * in length. Keywords shall contain only printable Latin-1 characters |
| * and spaces; To reduce the chances for human misreading of a keyword, |
| * leading spaces, trailing spaces, and consecutive spaces are not |
| * permitted in keywords. |
| * |
| * See: http://www.w3.org/TR/PNG/#11keywords |
| */ |
| private boolean isValidKeyword(String s) { |
| int len = s.length(); |
| if (len < 1 || len >= 80) { |
| return false; |
| } |
| if (s.startsWith(" ") || s.endsWith(" ") || s.contains(" ")) { |
| return false; |
| } |
| return isISOLatin(s, false); |
| } |
| |
| /* |
| * According to PNG spec, keyword shall contain only printable |
| * Latin-1 [ISO-8859-1] characters and spaces; that is, only |
| * character codes 32-126 and 161-255 decimal are allowed. |
| * For Latin-1 value fields the 0x10 (linefeed) control |
| * character is aloowed too. |
| * |
| * See: http://www.w3.org/TR/PNG/#11keywords |
| */ |
| private boolean isISOLatin(String s, boolean isLineFeedAllowed) { |
| int len = s.length(); |
| for (int i = 0; i < len; i++) { |
| char c = s.charAt(i); |
| if (c < 32 || c > 255 || (c > 126 && c < 161)) { |
| // not printable. Check whether this is an allowed |
| // control char |
| if (!isLineFeedAllowed || c != 0x10) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| private void mergeStandardTree(Node root) |
| throws IIOInvalidTreeException { |
| Node node = root; |
| if (!node.getNodeName() |
| .equals(IIOMetadataFormatImpl.standardMetadataFormatName)) { |
| fatal(node, "Root must be " + |
| IIOMetadataFormatImpl.standardMetadataFormatName); |
| } |
| |
| node = node.getFirstChild(); |
| while (node != null) { |
| String name = node.getNodeName(); |
| |
| if (name.equals("Chroma")) { |
| Node child = node.getFirstChild(); |
| while (child != null) { |
| String childName = child.getNodeName(); |
| if (childName.equals("Gamma")) { |
| float gamma = getFloatAttribute(child, "value"); |
| gAMA_present = true; |
| gAMA_gamma = (int)(gamma*100000 + 0.5); |
| } else if (childName.equals("Palette")) { |
| byte[] red = new byte[256]; |
| byte[] green = new byte[256]; |
| byte[] blue = new byte[256]; |
| int maxindex = -1; |
| |
| Node entry = child.getFirstChild(); |
| while (entry != null) { |
| int index = getIntAttribute(entry, "index"); |
| if (index >= 0 && index <= 255) { |
| red[index] = |
| (byte)getIntAttribute(entry, "red"); |
| green[index] = |
| (byte)getIntAttribute(entry, "green"); |
| blue[index] = |
| (byte)getIntAttribute(entry, "blue"); |
| if (index > maxindex) { |
| maxindex = index; |
| } |
| } |
| entry = entry.getNextSibling(); |
| } |
| |
| int numEntries = maxindex + 1; |
| PLTE_red = new byte[numEntries]; |
| PLTE_green = new byte[numEntries]; |
| PLTE_blue = new byte[numEntries]; |
| System.arraycopy(red, 0, PLTE_red, 0, numEntries); |
| System.arraycopy(green, 0, PLTE_green, 0, numEntries); |
| System.arraycopy(blue, 0, PLTE_blue, 0, numEntries); |
| PLTE_present = true; |
| } else if (childName.equals("BackgroundIndex")) { |
| bKGD_present = true; |
| bKGD_colorType = PNGImageReader.PNG_COLOR_PALETTE; |
| bKGD_index = getIntAttribute(child, "value"); |
| } else if (childName.equals("BackgroundColor")) { |
| int red = getIntAttribute(child, "red"); |
| int green = getIntAttribute(child, "green"); |
| int blue = getIntAttribute(child, "blue"); |
| if (red == green && red == blue) { |
| bKGD_colorType = PNGImageReader.PNG_COLOR_GRAY; |
| bKGD_gray = red; |
| } else { |
| bKGD_red = red; |
| bKGD_green = green; |
| bKGD_blue = blue; |
| } |
| bKGD_present = true; |
| } |
| // } else if (childName.equals("ColorSpaceType")) { |
| // } else if (childName.equals("NumChannels")) { |
| |
| child = child.getNextSibling(); |
| } |
| } else if (name.equals("Compression")) { |
| Node child = node.getFirstChild(); |
| while (child != null) { |
| String childName = child.getNodeName(); |
| if (childName.equals("NumProgressiveScans")) { |
| // Use Adam7 if NumProgressiveScans > 1 |
| int scans = getIntAttribute(child, "value"); |
| IHDR_interlaceMethod = (scans > 1) ? 1 : 0; |
| // } else if (childName.equals("CompressionTypeName")) { |
| // } else if (childName.equals("Lossless")) { |
| // } else if (childName.equals("BitRate")) { |
| } |
| child = child.getNextSibling(); |
| } |
| } else if (name.equals("Data")) { |
| Node child = node.getFirstChild(); |
| while (child != null) { |
| String childName = child.getNodeName(); |
| if (childName.equals("BitsPerSample")) { |
| String s = getAttribute(child, "value"); |
| StringTokenizer t = new StringTokenizer(s); |
| int maxBits = -1; |
| while (t.hasMoreTokens()) { |
| int bits = Integer.parseInt(t.nextToken()); |
| if (bits > maxBits) { |
| maxBits = bits; |
| } |
| } |
| if (maxBits < 1) { |
| maxBits = 1; |
| } |
| if (maxBits == 3) maxBits = 4; |
| if (maxBits > 4 || maxBits < 8) { |
| maxBits = 8; |
| } |
| if (maxBits > 8) { |
| maxBits = 16; |
| } |
| IHDR_bitDepth = maxBits; |
| } else if (childName.equals("SignificantBitsPerSample")) { |
| String s = getAttribute(child, "value"); |
| StringTokenizer t = new StringTokenizer(s); |
| int numTokens = t.countTokens(); |
| if (numTokens == 1) { |
| sBIT_colorType = PNGImageReader.PNG_COLOR_GRAY; |
| sBIT_grayBits = Integer.parseInt(t.nextToken()); |
| } else if (numTokens == 2) { |
| sBIT_colorType = |
| PNGImageReader.PNG_COLOR_GRAY_ALPHA; |
| sBIT_grayBits = Integer.parseInt(t.nextToken()); |
| sBIT_alphaBits = Integer.parseInt(t.nextToken()); |
| } else if (numTokens == 3) { |
| sBIT_colorType = PNGImageReader.PNG_COLOR_RGB; |
| sBIT_redBits = Integer.parseInt(t.nextToken()); |
| sBIT_greenBits = Integer.parseInt(t.nextToken()); |
| sBIT_blueBits = Integer.parseInt(t.nextToken()); |
| } else if (numTokens == 4) { |
| sBIT_colorType = |
| PNGImageReader.PNG_COLOR_RGB_ALPHA; |
| sBIT_redBits = Integer.parseInt(t.nextToken()); |
| sBIT_greenBits = Integer.parseInt(t.nextToken()); |
| sBIT_blueBits = Integer.parseInt(t.nextToken()); |
| sBIT_alphaBits = Integer.parseInt(t.nextToken()); |
| } |
| if (numTokens >= 1 && numTokens <= 4) { |
| sBIT_present = true; |
| } |
| // } else if (childName.equals("PlanarConfiguration")) { |
| // } else if (childName.equals("SampleFormat")) { |
| // } else if (childName.equals("SampleMSB")) { |
| } |
| child = child.getNextSibling(); |
| } |
| } else if (name.equals("Dimension")) { |
| boolean gotWidth = false; |
| boolean gotHeight = false; |
| boolean gotAspectRatio = false; |
| |
| float width = -1.0F; |
| float height = -1.0F; |
| float aspectRatio = -1.0F; |
| |
| Node child = node.getFirstChild(); |
| while (child != null) { |
| String childName = child.getNodeName(); |
| if (childName.equals("PixelAspectRatio")) { |
| aspectRatio = getFloatAttribute(child, "value"); |
| gotAspectRatio = true; |
| } else if (childName.equals("HorizontalPixelSize")) { |
| width = getFloatAttribute(child, "value"); |
| gotWidth = true; |
| } else if (childName.equals("VerticalPixelSize")) { |
| height = getFloatAttribute(child, "value"); |
| gotHeight = true; |
| // } else if (childName.equals("ImageOrientation")) { |
| // } else if |
| // (childName.equals("HorizontalPhysicalPixelSpacing")) { |
| // } else if |
| // (childName.equals("VerticalPhysicalPixelSpacing")) { |
| // } else if (childName.equals("HorizontalPosition")) { |
| // } else if (childName.equals("VerticalPosition")) { |
| // } else if (childName.equals("HorizontalPixelOffset")) { |
| // } else if (childName.equals("VerticalPixelOffset")) { |
| } |
| child = child.getNextSibling(); |
| } |
| |
| if (gotWidth && gotHeight) { |
| pHYs_present = true; |
| pHYs_unitSpecifier = 1; |
| pHYs_pixelsPerUnitXAxis = (int)(width*1000 + 0.5F); |
| pHYs_pixelsPerUnitYAxis = (int)(height*1000 + 0.5F); |
| } else if (gotAspectRatio) { |
| pHYs_present = true; |
| pHYs_unitSpecifier = 0; |
| |
| // Find a reasonable rational approximation |
| int denom = 1; |
| for (; denom < 100; denom++) { |
| int num = (int)(aspectRatio*denom); |
| if (Math.abs(num/denom - aspectRatio) < 0.001) { |
| break; |
| } |
| } |
| pHYs_pixelsPerUnitXAxis = (int)(aspectRatio*denom); |
| pHYs_pixelsPerUnitYAxis = denom; |
| } |
| } else if (name.equals("Document")) { |
| Node child = node.getFirstChild(); |
| while (child != null) { |
| String childName = child.getNodeName(); |
| if (childName.equals("ImageModificationTime")) { |
| tIME_present = true; |
| tIME_year = getIntAttribute(child, "year"); |
| tIME_month = getIntAttribute(child, "month"); |
| tIME_day = getIntAttribute(child, "day"); |
| tIME_hour = |
| getIntAttribute(child, "hour", 0, false); |
| tIME_minute = |
| getIntAttribute(child, "minute", 0, false); |
| tIME_second = |
| getIntAttribute(child, "second", 0, false); |
| // } else if (childName.equals("SubimageInterpretation")) { |
| // } else if (childName.equals("ImageCreationTime")) { |
| } |
| child = child.getNextSibling(); |
| } |
| } else if (name.equals("Text")) { |
| Node child = node.getFirstChild(); |
| while (child != null) { |
| String childName = child.getNodeName(); |
| if (childName.equals("TextEntry")) { |
| String keyword = |
| getAttribute(child, "keyword", "", false); |
| String value = getAttribute(child, "value"); |
| String language = |
| getAttribute(child, "language", "", false); |
| String compression = |
| getAttribute(child, "compression", "none", false); |
| |
| if (!isValidKeyword(keyword)) { |
| // Just ignore this node, PNG requires keywords |
| } else if (isISOLatin(value, true)) { |
| if (compression.equals("zip")) { |
| // Use a zTXt node |
| zTXt_keyword.add(keyword); |
| zTXt_text.add(value); |
| zTXt_compressionMethod.add(Integer.valueOf(0)); |
| } else { |
| // Use a tEXt node |
| tEXt_keyword.add(keyword); |
| tEXt_text.add(value); |
| } |
| } else { |
| // Use an iTXt node |
| iTXt_keyword.add(keyword); |
| iTXt_compressionFlag.add(Boolean.valueOf(compression.equals("zip"))); |
| iTXt_compressionMethod.add(Integer.valueOf(0)); |
| iTXt_languageTag.add(language); |
| iTXt_translatedKeyword.add(keyword); // fake it |
| iTXt_text.add(value); |
| } |
| } |
| child = child.getNextSibling(); |
| } |
| // } else if (name.equals("Transparency")) { |
| // Node child = node.getFirstChild(); |
| // while (child != null) { |
| // String childName = child.getNodeName(); |
| // if (childName.equals("Alpha")) { |
| // } else if (childName.equals("TransparentIndex")) { |
| // } else if (childName.equals("TransparentColor")) { |
| // } else if (childName.equals("TileTransparencies")) { |
| // } else if (childName.equals("TileOpacities")) { |
| // } |
| // child = child.getNextSibling(); |
| // } |
| // } else { |
| // // fatal(node, "Unknown child of root node!"); |
| } |
| |
| node = node.getNextSibling(); |
| } |
| } |
| |
| // Reset all instance variables to their initial state |
| public void reset() { |
| IHDR_present = false; |
| PLTE_present = false; |
| bKGD_present = false; |
| cHRM_present = false; |
| gAMA_present = false; |
| hIST_present = false; |
| iCCP_present = false; |
| iTXt_keyword = new ArrayList<String>(); |
| iTXt_compressionFlag = new ArrayList<Boolean>(); |
| iTXt_compressionMethod = new ArrayList<Integer>(); |
| iTXt_languageTag = new ArrayList<String>(); |
| iTXt_translatedKeyword = new ArrayList<String>(); |
| iTXt_text = new ArrayList<String>(); |
| pHYs_present = false; |
| sBIT_present = false; |
| sPLT_present = false; |
| sRGB_present = false; |
| tEXt_keyword = new ArrayList<String>(); |
| tEXt_text = new ArrayList<String>(); |
| tIME_present = false; |
| tRNS_present = false; |
| zTXt_keyword = new ArrayList<String>(); |
| zTXt_compressionMethod = new ArrayList<Integer>(); |
| zTXt_text = new ArrayList<String>(); |
| unknownChunkType = new ArrayList<String>(); |
| unknownChunkData = new ArrayList<byte[]>(); |
| } |
| } |
