public void prepareInsertEmpty(int imageIndex, ImageTypeSpecifier imageType, int width, int height, IIOMetadata imageMetadata, List<? extends BufferedImage> thumbnails, ImageWriteParam param) throws IOException { checkParamsEmpty(imageType, width, height, thumbnails); this.isInsertingEmpty = true; SampleModel emptySM = imageType.getSampleModel(); RenderedImage emptyImage = new EmptyImage(0, 0, width, height, 0, 0, emptySM.getWidth(), emptySM.getHeight(), emptySM, imageType.getColorModel()); insert(imageIndex, new IIOImage(emptyImage, null, imageMetadata), param, false); }
public boolean canEncodeImage(ImageTypeSpecifier type) { SampleModel sampleModel = type.getSampleModel(); // Find the maximum bit depth across all channels int[] sampleSize = sampleModel.getSampleSize(); int bitDepth = sampleSize[0]; for (int i = 1; i < sampleSize.length; i++) { if (sampleSize[i] > bitDepth) { bitDepth = sampleSize[i]; } } // 4450894: Ensure bitDepth is between 1 and 8 if (bitDepth < 1 || bitDepth > 8) { return false; } return true; }
public ImageTypeSpecifier getRawImageType(int imageIndex) throws IOException { setThreadLock(); try { if (currentImage != imageIndex) { cbLock.check(); readHeader(imageIndex, true); } // Returns null if it can't be represented return getImageType(colorSpaceCode).getType(); } finally { clearThreadLock(); } }
public boolean canNodeAppear(String elementName, ImageTypeSpecifier imageType) { // All images can have these if (elementName.equals(getRootName()) || elementName.equals("JPEGvariety") || isInSubtree(elementName, "markerSequence")) { return true; } // If it is an element in the app0jfif subtree, just check // that the image type is JFIF compliant. if ((isInSubtree(elementName, "app0JFIF")) && JPEG.isJFIFcompliant(imageType, true)) { return true; } return false; }
private void checkAdobe(AdobeMarkerSegment adobe, ImageTypeSpecifier type, boolean input) { if (adobe != null) { int rightTransform = JPEG.transformForType(type, input); if (adobe.transform != rightTransform) { warningOccurred(input ? WARNING_IMAGE_METADATA_ADOBE_MISMATCH : WARNING_DEST_METADATA_ADOBE_MISMATCH); if (rightTransform == JPEG.ADOBE_IMPOSSIBLE) { ignoreAdobe = true; } else { newAdobeTransform = rightTransform; } } } }
public void testGetAsTree() { ImageWriteParam p = w.getDefaultWriteParam(); IIOMetadata m = w.getDefaultImageMetadata(ImageTypeSpecifier.createFromBufferedImageType(type), p); String format = m.getNativeMetadataFormatName(); System.out.println("native format: " + format); int count = 0; try { while (count < 100) { System.out.println(" test " + count++); m.getAsTree(format); } } catch (OutOfMemoryError e) { System.gc(); throw new RuntimeException("Test failed. Number of performed operations: " + count, e); } }
private boolean jfifOK(ImageTypeSpecifier imageType, ImageWriteParam param, IIOMetadata streamMetadata, IIOMetadata imageMetadata) { // If the image type and metadata are JFIF compatible, return true if ((imageType != null) && (!JPEG.isJFIFcompliant(imageType, true))) { return false; } if (imageMetadata != null) { JPEGMetadata metadata = null; if (imageMetadata instanceof JPEGMetadata) { metadata = (JPEGMetadata) imageMetadata; } else { metadata = (JPEGMetadata)convertImageMetadata(imageMetadata, imageType, param); } // metadata must have a jfif node if (metadata.findMarkerSegment (JFIFMarkerSegment.class, true) == null){ return false; } } return true; }
public boolean canEncodeImage(ImageTypeSpecifier type) { int dataType= type.getSampleModel().getDataType(); if (dataType < DataBuffer.TYPE_BYTE || dataType > DataBuffer.TYPE_INT) return false; SampleModel sm = type.getSampleModel(); int numBands = sm.getNumBands(); if (!(numBands == 1 || numBands == 3)) return false; if (numBands == 1 && dataType != DataBuffer.TYPE_BYTE) return false; if (dataType > DataBuffer.TYPE_BYTE && !(sm instanceof SinglePixelPackedSampleModel)) return false; return true; }
public Iterator getImageTypes(int imageIndex) throws IOException { if (input == null) throw new IllegalStateException(); if (imageIndex >= 5 || imageIndex < 0) throw new IndexOutOfBoundsException(); Vector imageTypes = new Vector(); imageTypes.add(ImageTypeSpecifier.createFromBufferedImageType (BufferedImage.TYPE_BYTE_GRAY )); return imageTypes.iterator(); }
public boolean canEncodeImage(ImageTypeSpecifier type) { if (type == null) { throw new IllegalArgumentException("type == null!"); } SampleModel sm = type.getSampleModel(); ColorModel cm = type.getColorModel(); boolean canEncode = sm.getNumBands() == 1 && sm.getSampleSize(0) <= 8 && sm.getWidth() <= 65535 && sm.getHeight() <= 65535 && (cm == null || cm.getComponentSize()[0] <= 8); if (canEncode) { return true; } else { return PaletteBuilder.canCreatePalette(type); } }
public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageType, ImageWriteParam param) { List<TIFFTagSet> tagSets = new ArrayList<TIFFTagSet>(1); tagSets.add(BaselineTIFFTagSet.getInstance()); TIFFImageMetadata imageMetadata = new TIFFImageMetadata(tagSets); if(imageType != null) { TIFFImageMetadata im = (TIFFImageMetadata)convertImageMetadata(imageMetadata, imageType, param); if(im != null) { imageMetadata = im; } } return imageMetadata; }
public static void main(String[] args) throws Exception { //nomarkers.jpg has YCbCr color space String fileName = "nomarkers.jpg"; String sep = System.getProperty("file.separator"); String dir = System.getProperty("test.src", "."); String filePath = dir+sep+fileName; System.out.println("Test file: " + filePath); File imageFile = new File(filePath); ImageInputStream inputStream = ImageIO. createImageInputStream(imageFile); Iterator<ImageReader> readers = ImageIO.getImageReaders(inputStream); if(readers.hasNext()) { ImageReader reader = readers.next(); reader.setInput(inputStream); ImageTypeSpecifier typeSpecifier = reader.getRawImageType(0); //check if ImageTypeSpecifier is null for YCbCr JPEG Image if (typeSpecifier == null) { throw new RuntimeException("ImageReader returns null raw image" + " type"); } } }
protected IIOMetadata prepareImageMetadata(int i, BufferedImage img, ImageWriteParam wparam) { GIFImageMetadata idata = (GIFImageMetadata) writer.getDefaultImageMetadata(ImageTypeSpecifier.createFromRenderedImage(img), wparam); idata.delayTime = 100; idata.disposalMethod = 0; idata.transparentColorFlag = false; if (i == 0) { ArrayList<byte[]> appIDs = new ArrayList<byte[]>(); appIDs.add(new String("NETSCAPE").getBytes()); ArrayList<byte[]> authCodes = new ArrayList<byte[]>(); authCodes.add(new String("2.0").getBytes()); ArrayList<byte[]> appData = new ArrayList<byte[]>(); byte[] authData = {1, 0, 0}; appData.add(authData); idata.applicationIDs = appIDs; idata.authenticationCodes = authCodes; idata.applicationData = appData; } return idata; }
public static void main(String[] args) throws Exception { String format = "javax_imageio_1.0"; BufferedImage img = new BufferedImage(16, 16, BufferedImage.TYPE_INT_RGB); ImageWriter iw = ImageIO.getImageWritersByMIMEType("image/png").next(); IIOMetadata meta = iw.getDefaultImageMetadata(new ImageTypeSpecifier(img), null); DOMImplementationRegistry registry; registry = DOMImplementationRegistry.newInstance(); DOMImplementation impl = registry.getDOMImplementation("XML 3.0"); Document doc = impl.createDocument(null, format, null); Element root, text, entry; root = doc.getDocumentElement(); root.appendChild(text = doc.createElement("Text")); text.appendChild(entry = doc.createElement("TextEntry")); // keyword isn't #REQUIRED by the standard metadata format. // However, it is required by the PNG format, so we include it here. entry.setAttribute("keyword", "Comment"); entry.setAttribute("value", "Some demo comment"); meta.mergeTree(format, root); }
public boolean canNodeAppear(String elementName, ImageTypeSpecifier imageType) { // Just check if it appears in the format if (isInSubtree(elementName, getRootName())){ return true; } return false; }
private int getDestCSType(ImageTypeSpecifier destType) { ColorModel cm = destType.getColorModel(); boolean alpha = cm.hasAlpha(); ColorSpace cs = cm.getColorSpace(); int retval = JPEG.JCS_UNKNOWN; switch (cs.getType()) { case ColorSpace.TYPE_GRAY: retval = JPEG.JCS_GRAYSCALE; break; case ColorSpace.TYPE_RGB: if (alpha) { retval = JPEG.JCS_RGBA; } else { retval = JPEG.JCS_RGB; } break; case ColorSpace.TYPE_YCbCr: if (alpha) { retval = JPEG.JCS_YCbCrA; } else { retval = JPEG.JCS_YCbCr; } break; case ColorSpace.TYPE_3CLR: if (cs == JPEG.JCS.getYCC()) { if (alpha) { retval = JPEG.JCS_YCCA; } else { retval = JPEG.JCS_YCC; } } break; case ColorSpace.TYPE_CMYK: retval = JPEG.JCS_CMYK; break; } return retval; }
public synchronized ImageTypeSpecifier getType() { if (!failed && type == null) { try { type = produce(); } catch (Throwable e) { failed = true; } } return type; }
/** * Creates a default image metadata object and merges in the * supplied metadata. */ public IIOMetadata convertImageMetadata(IIOMetadata inData, ImageTypeSpecifier imageType, ImageWriteParam param) { if (inData == null) { throw new IllegalArgumentException("inData == null!"); } if (imageType == null) { throw new IllegalArgumentException("imageType == null!"); } GIFWritableImageMetadata im = (GIFWritableImageMetadata)getDefaultImageMetadata(imageType, param); // Save interlace flag state. boolean isProgressive = im.interlaceFlag; convertMetadata(IMAGE_METADATA_NAME, inData, im); // Undo change to interlace flag if not MODE_COPY_FROM_METADATA. if (param != null && param.canWriteProgressive() && param.getProgressiveMode() != ImageWriteParam.MODE_COPY_FROM_METADATA) { im.interlaceFlag = isProgressive; } return im; }
public ImageWriteParam getWriteParam() { ImageWriteParam p = w.getDefaultWriteParam(); p.setSourceBands(new int[] {0, 1, 2}); ImageTypeSpecifier type = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB); p.setDestinationType(type); return p; }
private static void writeTo(File f, ITXtTest t) { BufferedImage src = createBufferedImage(); try (ImageOutputStream imageOutputStream = ImageIO.createImageOutputStream(f)) { ImageTypeSpecifier imageTypeSpecifier = new ImageTypeSpecifier(src); ImageWriter imageWriter = ImageIO.getImageWritersByFormatName("PNG").next(); imageWriter.setOutput(imageOutputStream); IIOMetadata m = imageWriter.getDefaultImageMetadata(imageTypeSpecifier, null); String format = m.getNativeMetadataFormatName(); Node root = m.getAsTree(format); IIOMetadataNode iTXt = t.getNode(); root.appendChild(iTXt); m.setFromTree(format, root); imageWriter.write(new IIOImage(src, null, m)); System.out.println("Writing done."); } catch (Throwable e) { throw new RuntimeException("Writing test failed.", e); } }
public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex) throws IOException { checkIndex(imageIndex); try { readHeader(); } catch (IllegalArgumentException e) { throw new IIOException(I18N.getString("BMPImageReader6"), e); } ArrayList<ImageTypeSpecifier> list = new ArrayList<>(1); list.add(new ImageTypeSpecifier(originalColorModel, originalSampleModel)); return list.iterator(); }
private static void doTest(int type) throws IOException { BufferedImage src = createTestImage(type); File f = new File("test.jpg"); if (!ImageIO.write(src, "jpg", f)) { throw new RuntimeException("Failed to write test image."); } ImageInputStream iis = ImageIO.createImageInputStream(f); ImageReader reader = ImageIO.getImageReaders(iis).next(); reader.setInput(iis); Iterator<ImageTypeSpecifier> types = reader.getImageTypes(0); ImageTypeSpecifier srgb = null; ImageTypeSpecifier gray = null; // look for gray and srgb types while ((srgb == null || gray == null) && types.hasNext()) { ImageTypeSpecifier t = types.next(); if (t.getColorModel().getColorSpace().getType() == TYPE_GRAY) { gray = t; } if (t.getColorModel().getColorSpace() == sRGB) { srgb = t; } } if (gray == null) { throw new RuntimeException("No gray type available."); } if (srgb == null) { throw new RuntimeException("No srgb type available."); } System.out.println("Read as GRAY..."); testType(reader, gray, src); System.out.println("Read as sRGB..."); testType(reader, srgb, src); }
private static void writeTo(File f, ITXtTest t) { BufferedImage src = createBufferedImage(); try { ImageOutputStream imageOutputStream = ImageIO.createImageOutputStream(f); ImageTypeSpecifier imageTypeSpecifier = new ImageTypeSpecifier(src); ImageWriter imageWriter = ImageIO.getImageWritersByFormatName("PNG").next(); imageWriter.setOutput(imageOutputStream); IIOMetadata m = imageWriter.getDefaultImageMetadata(imageTypeSpecifier, null); String format = m.getNativeMetadataFormatName(); Node root = m.getAsTree(format); IIOMetadataNode iTXt = t.getNode(); root.appendChild(iTXt); m.setFromTree(format, root); imageWriter.write(new IIOImage(src, null, m)); imageOutputStream.close(); System.out.println("Writing done."); } catch (Throwable e) { throw new RuntimeException("Writing test failed.", e); } }
public ImageTypeSpecifier next() { if (theNext != null || hasNext()) { ImageTypeSpecifier t = theNext; theNext = null; return t; } else { throw new NoSuchElementException(); } }
public Iterator getImageTypes(int imageIndex) throws IOException { checkIndex(imageIndex); try { readHeader(); } catch (IllegalArgumentException e) { throw new IIOException(I18N.getString("BMPImageReader6"), e); } ArrayList list = new ArrayList(1); list.add(new ImageTypeSpecifier(originalColorModel, originalSampleModel)); return list.iterator(); }
/** Checks that the provided <code>ImageWriter</code> can encode * the provided <code>ImageTypeSpecifier</code> or not. If not, an * <code>IIOException</code> will be thrown. * @param writer The provided <code>ImageWriter</code>. * @param type The image to be tested. * @throws IIOException If the writer cannot encoded the provided image. */ public static final void canEncodeImage(ImageWriter writer, ImageTypeSpecifier type) throws IIOException { ImageWriterSpi spi = writer.getOriginatingProvider(); if(type != null && spi != null && !spi.canEncodeImage(type)) { throw new IIOException(I18N.getString("ImageUtil2")+" "+ writer.getClass().getName()); } }
public IIOMetadata convertImageMetadata(IIOMetadata inData, ImageTypeSpecifier imageType, ImageWriteParam param) { setThreadLock(); try { return convertImageMetadataOnThread(inData, imageType, param); } finally { clearThreadLock(); } }
private static void doTest(int mode) { String fileFormat = "bmp"; try { ImageWriter iw = (ImageWriter)ImageIO.getImageWritersBySuffix(fileFormat).next(); if(iw == null) { throw new RuntimeException("No available image writer for " + fileFormat + " Test failed."); } File file = new File("image." + fileFormat); ImageOutputStream ios = ImageIO.createImageOutputStream(file); iw.setOutput(ios); BufferedImage bimg = new BufferedImage(100, 100, BufferedImage.TYPE_INT_RGB); Graphics g = bimg.getGraphics(); g.setColor(Color.green); g.fillRect(0,0,100,100); ImageWriteParam param = iw.getDefaultWriteParam(); param.setCompressionMode(mode); IIOMetadata meta = iw.getDefaultImageMetadata(new ImageTypeSpecifier(bimg), param); IIOImage iioImg = new IIOImage(bimg, null, meta); iw.write(null, iioImg, param); } catch(Exception e) { e.printStackTrace(); throw new RuntimeException("Test failed."); } }
public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageType, ImageWriteParam param) { setThreadLock(); try { return new JPEGMetadata(imageType, param, this); } finally { clearThreadLock(); } }
