public void write(IIOMetadata sm, IIOImage iioimage, ImageWriteParam p) throws IOException { if (stream == null) { throw new IllegalStateException("output == null!"); } if (iioimage == null) { throw new IllegalArgumentException("iioimage == null!"); } if (iioimage.hasRaster()) { throw new UnsupportedOperationException("canWriteRasters() == false!"); } resetLocal(); GIFWritableStreamMetadata streamMetadata; if (sm == null) { streamMetadata = (GIFWritableStreamMetadata)getDefaultStreamMetadata(p); } else { streamMetadata = (GIFWritableStreamMetadata)convertStreamMetadata(sm, p); } write(true, true, streamMetadata, iioimage, p); }
private static long saveImage(final BufferedImage image, final ImageWriter writer, final ImageWriteParam writerParams, final String mode, final String suffix) throws IOException { final File imgFile = new File("WriterCompressionTest-" + mode + '.' + suffix); System.out.println("Writing file: " + imgFile.getAbsolutePath()); final ImageOutputStream imgOutStream = ImageIO.createImageOutputStream(new FileOutputStream(imgFile)); try { writer.setOutput(imgOutStream); writer.write(null, new IIOImage(image, null, null), writerParams); } finally { imgOutStream.close(); } return imgFile.length(); }
public byte[] writeTest(BufferedImage bi, ImageWriteParam p, IIOMetadata m) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); // write test image as jpeg ImageOutputStream ios = ImageIO.createImageOutputStream(baos); w.setOutput(ios); w.write(null, new IIOImage(bi, null, m), p); ios.close(); return baos.toByteArray(); }
public static void writeJPG( BufferedImage rendered, float quality, File f ) { try { JPEGImageWriteParam jpegParams = new JPEGImageWriteParam( null ); jpegParams.setCompressionMode( ImageWriteParam.MODE_EXPLICIT ); jpegParams.setCompressionQuality( 1f ); ImageWriter writer = ImageIO.getImageWritersByFormatName( "jpeg" ).next(); ImageWriteParam param = writer.getDefaultWriteParam(); param.setCompressionMode( ImageWriteParam.MODE_EXPLICIT ); // Needed see javadoc param.setCompressionQuality( quality ); // Highest quality writer.setOutput( new FileImageOutputStream( f ) ); writer.write( null, new IIOImage( rendered, null, null ), jpegParams ); } catch ( Throwable th ) { th.printStackTrace(); } }
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; }
private static void encodeRLE8Test() throws IOException { // create 8bpp image byte[] r = new byte[256]; r[0] = (byte)0xff; byte[] g = new byte[256]; g[1] = (byte)0xff; byte[] b = new byte[256]; b[2] = (byte)0xff; IndexColorModel icm = new IndexColorModel(8, 256, r, g, b); BufferedImage bimg = new BufferedImage(100, 100, BufferedImage.TYPE_BYTE_INDEXED, icm); Graphics gr = bimg.getGraphics(); gr.setColor(Color.green); gr.fillRect(0, 0, 100, 100); doTest(bimg, "BI_RLE8", ImageWriteParam.MODE_EXPLICIT); }
/** * Encodes an image in JPEG format and writes it to an output stream. * * @param bufferedImage the image to be encoded (<code>null</code> not * permitted). * @param outputStream the OutputStream to write the encoded image to * (<code>null</code> not permitted). * * @throws IOException if there is an I/O problem. * @throws NullPointerException if <code>bufferedImage</code> is * <code>null</code>. */ public void encode(BufferedImage bufferedImage, OutputStream outputStream) throws IOException { if (bufferedImage == null) { throw new IllegalArgumentException("Null 'image' argument."); } if (outputStream == null) { throw new IllegalArgumentException("Null 'outputStream' argument."); } Iterator iterator = ImageIO.getImageWritersByFormatName("jpeg"); ImageWriter writer = (ImageWriter) iterator.next(); ImageWriteParam p = writer.getDefaultWriteParam(); p.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); p.setCompressionQuality(this.quality); ImageOutputStream ios = ImageIO.createImageOutputStream(outputStream); writer.setOutput(ios); writer.write(null, new IIOImage(bufferedImage, null, null), p); ios.flush(); writer.dispose(); ios.close(); }
public void compressSave(MultipartFile file, String uploadLocation) throws IOException { //Compresses JPG file but kills the quality. BufferedImage image = ImageIO.read(new ByteArrayInputStream(file.getBytes())); File compressedImageFile = new File(uploadLocation); OutputStream os = new FileOutputStream(compressedImageFile); Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg"); ImageWriter writer = (ImageWriter) writers.next(); ImageOutputStream ios = ImageIO.createImageOutputStream(os); writer.setOutput(ios); ImageWriteParam param = writer.getDefaultWriteParam(); if(param.canWriteCompressed()) { param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); param.setCompressionQuality(0.05f); } writer.write(null, new IIOImage(image, null, null), param); }
public void writeToSequence(IIOImage image, ImageWriteParam param) throws IOException { if (stream == null) { throw new IllegalStateException("output == null!"); } if (image == null) { throw new IllegalArgumentException("image == null!"); } if (image.hasRaster()) { throw new UnsupportedOperationException("canWriteRasters() == false!"); } if (!isWritingSequence) { throw new IllegalStateException("prepareWriteSequence() was not invoked!"); } write(!wroteSequenceHeader, false, theStreamMetadata, image, param); if (!wroteSequenceHeader) { wroteSequenceHeader = true; } this.imageIndex++; }
protected File writeImageWithHist(BufferedImage bi) throws IOException { File f = File.createTempFile("hist_", ".png", new File(".")); ImageWriter writer = ImageIO.getImageWritersByFormatName("PNG").next(); ImageOutputStream ios = ImageIO.createImageOutputStream(f); writer.setOutput(ios); ImageWriteParam param = writer.getDefaultWriteParam(); ImageTypeSpecifier type = new ImageTypeSpecifier(bi); IIOMetadata imgMetadata = writer.getDefaultImageMetadata(type, param); /* add hIST node to image metadata */ imgMetadata = upgradeMetadata(imgMetadata, bi); IIOImage iio_img = new IIOImage(bi, null, // no thumbnails imgMetadata); writer.write(iio_img); ios.flush(); ios.close(); return f; }
private static Image createTestImage() throws IOException { BufferedImage frame1 = createFrame(new int[] { 0xffff0000, 0xffff0000 }); BufferedImage frame2 = createFrame(new int[] { 0xff0000ff, 0xffff0000 }); ImageWriter writer = ImageIO.getImageWritersByFormatName("GIF").next(); ImageOutputStream ios = ImageIO.createImageOutputStream(new File("lut_test.gif")); ImageWriteParam param = writer.getDefaultWriteParam(); writer.setOutput(ios); writer.prepareWriteSequence(null); writer.writeToSequence(new IIOImage(frame1, null, null), param); writer.writeToSequence(new IIOImage(frame2, null, null), param); writer.endWriteSequence(); writer.reset(); writer.dispose(); ios.flush(); ios.close(); return Toolkit.getDefaultToolkit().createImage("lut_test.gif"); }
public TIFFDeflater(String compressionType, int compressionTagValue, ImageWriteParam param, int predictorValue) { super(compressionType, compressionTagValue, true); this.predictor = predictorValue; // Set the deflate level. int deflateLevel; if(param != null && param.getCompressionMode() == ImageWriteParam.MODE_EXPLICIT) { float quality = param.getCompressionQuality(); deflateLevel = (int)(1 + 8*quality); } else { deflateLevel = Deflater.DEFAULT_COMPRESSION; } this.deflater = new Deflater(deflateLevel); }
/** * 根据质量压缩图片,不改变图片的尺寸 * * @param imgContent * 图片内容 * @param quality * 缩放比例 * @param extName * 后缀名 * @return */ public byte[] compress(byte[] imgContent, float quality, String extName) { if (quality > 1 || quality <= 0 || imgContent == null || WakaUtils.string.isEmpty(extName)) { throw new ZhhrUtilException("压缩文件失败!入参为空"); } try (InputStream is = new ByteArrayInputStream(imgContent); ByteArrayOutputStream os = new ByteArrayOutputStream(); ImageOutputStream ios = ImageIO.createImageOutputStream(os);) { BufferedImage image = ImageIO.read(is); Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(extName); ImageWriter writer = writers.next(); writer.setOutput(ios); ImageWriteParam param = writer.getDefaultWriteParam(); param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); param.setCompressionQuality(quality); writer.write(null, new IIOImage(image, null, null), param); writer.dispose(); return os.toByteArray(); } catch (IOException e) { throw new ZhhrUtilException(e.getMessage(), e); } }
public static void main(String args[]) { int[] iModes = { ImageWriteParam.MODE_DISABLED, ImageWriteParam.MODE_EXPLICIT, ImageWriteParam.MODE_COPY_FROM_METADATA, ImageWriteParam.MODE_DEFAULT }; String[] strModes = { "ImageWriteParam.MODE_DISABLED", "ImageWriteParam.MODE_EXPLICIT", "ImageWriteParam.MODE_COPY_FROM_METADATA", "ImageWriteParam.MODE_DEFAULT" }; for(int i=0; i<iModes.length; i++) { System.out.println("Test compression mode "+strModes[i]); doTest(iModes[i]); } }
public ImageCompressionTypesTest(String format) { Iterator it = ImageIO.getImageWritersByFormatName(format); while (it.hasNext()) { writer = (ImageWriter) it.next(); break; } ImageWriteParam param = writer.getDefaultWriteParam(); param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); System.out.println("Checking compression types for : " + format); String compTypes[] = param.getCompressionTypes(); if (compTypes.length > 1) { for (int i = 0; i < compTypes.length; i++) { for (int j = i + 1; j < compTypes.length; j++) { if (compTypes[i].equalsIgnoreCase(compTypes[j])) { throw new RuntimeException("Duplicate compression" + " type exists for image format " + format); } } } } }
public static void main(String[] args) { ImageWriteParam iwp = new JPEGImageWriteParam(null); iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); float[] vals = iwp.getCompressionQualityValues(); String[] descs = iwp.getCompressionQualityDescriptions(); if (vals.length != (descs.length + 1)) { throw new RuntimeException("Test failed: Values array is not " + "one larger than descriptions array"); } }
@Override public BufferedImage apply(BufferedImage img) { if(compressionLevel == 0f) return img; try { ImageWriter iw = ImageIO.getImageWritersByFormatName("jpeg").next(); JPEGImageWriteParam iwp = (JPEGImageWriteParam) iw.getDefaultWriteParam(); iwp.setOptimizeHuffmanTables(false); iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); iwp.setProgressiveMode(ImageWriteParam.MODE_DISABLED); iwp.setCompressionQuality(1f-compressionLevel); ByteArrayOutputStream baos = new ByteArrayOutputStream(); iw.setOutput(new MemoryCacheImageOutputStream(baos)); IIOImage outputImage = new IIOImage(img, null, null); iw.write(null, outputImage, iwp); iw.dispose(); baos.flush(); byte[] returnImage = baos.toByteArray(); baos.close(); BufferedImage img2 = ImageIO.read(new ByteArrayInputStream(returnImage)); if(img2 == null) throw new Exception(); else img = img2; } catch (Exception e) { e.printStackTrace(); } return img; }
/** * Reads the original image, creates a resized copy of it and returns its input stream. largestDimension is the * largest dimension of the resized image, the other dimension is scaled accordingly. * * @param image * original image * @param largestDimension * the largest dimension of the resized image, the other dimension is scaled accordingly * @return * @throws IOException * @throws UploadImageGalleryFileException */ public static InputStream resize(BufferedImage image, int largestDimension) throws IOException { try { //resize to 150 pixels max BufferedImage outImage = Scalr.resize(image, Method.QUALITY, largestDimension); //set jpeg compression quality explicitly ImageWriter imageWriter = ImageIO.getImageWritersByFormatName("jpeg").next(); ImageWriteParam jpgWriteParam = imageWriter.getDefaultWriteParam(); jpgWriteParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); jpgWriteParam.setCompressionQuality(.95f); // buffer all data in a circular buffer of infinite sizes CircularByteBuffer outputBuffer = new CircularByteBuffer(CircularByteBuffer.INFINITE_SIZE); ImageOutputStream ios = ImageIO.createImageOutputStream(outputBuffer.getOutputStream()); imageWriter.setOutput(ios); IIOImage outputImage = new IIOImage(outImage, null, null); imageWriter.write(null, outputImage, jpgWriteParam); imageWriter.dispose(); outputBuffer.getOutputStream().close(); return outputBuffer.getInputStream(); } catch (IOException e) { log.error(e.getStackTrace()); return null; } }
public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageType, ImageWriteParam param) { setThreadLock(); try { return new JPEGMetadata(imageType, param, this); } finally { clearThreadLock(); } }
public IIOMetadata convertStreamMetadata(IIOMetadata inData, ImageWriteParam param) { // There isn't much we can do. If it's one of ours, then // return it. Otherwise just return null. We use it only // for tables, so we can't get a default and modify it, // as this will usually not be what is intended. if (inData instanceof JPEGMetadata) { JPEGMetadata jpegData = (JPEGMetadata) inData; if (jpegData.isStream) { return inData; } } return null; }
public IIOMetadata convertImageMetadata(IIOMetadata inData, ImageTypeSpecifier imageType, ImageWriteParam param) { setThreadLock(); try { return convertImageMetadataOnThread(inData, imageType, param); } finally { clearThreadLock(); } }
public int getNumThumbnailsSupported(ImageTypeSpecifier imageType, ImageWriteParam param, IIOMetadata streamMetadata, IIOMetadata imageMetadata) { if (jfifOK(imageType, param, streamMetadata, imageMetadata)) { return Integer.MAX_VALUE; } return 0; }
public void doTest(int type) throws IOException { BufferedImage src = getTestImage(type); ByteArrayOutputStream baos = new ByteArrayOutputStream(); ImageOutputStream ios = ImageIO.createImageOutputStream(baos); ImageWriter writer = ImageIO.getImageWritersByFormatName("BMP").next(); writer.setOutput(ios); ImageWriteParam wparam = writer.getDefaultWriteParam(); wparam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); switch(type) { case TEST_RLE8: wparam.setCompressionType("BI_RLE8"); break; case TEST_RLE4: wparam.setCompressionType("BI_RLE4"); break; default: throw new IllegalArgumentException("Wrong test type: " + type); } writer.write(null, new IIOImage(src, null, null), wparam); ios.close(); baos.close(); // read result ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); BufferedImage dst = ImageIO.read(bais); checkResult(src, dst); }
public void write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param) throws IOException { setThreadLock(); try { cbLock.check(); writeOnThread(streamMetadata, image, param); } finally { clearThreadLock(); } }
/** * Creates a default stream metadata object and merges in the * supplied metadata. */ public IIOMetadata convertStreamMetadata(IIOMetadata inData, ImageWriteParam param) { if (inData == null) { throw new IllegalArgumentException("inData == null!"); } IIOMetadata sm = getDefaultStreamMetadata(param); convertMetadata(STREAM_METADATA_NAME, inData, sm); return sm; }
/** * 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() != param.MODE_COPY_FROM_METADATA) { im.interlaceFlag = isProgressive; } return im; }
private static void test4434886() { ImageWriteParam iwp = new ImageWriteParam4434886(); iwp.setTilingMode(ImageWriteParam.MODE_EXPLICIT); try { iwp.setTiling(-1,-2,-3,-4); throw new RuntimeException("Failed to get IAE!"); } catch (IllegalArgumentException e) { } }
public static void main(String[] args) { try { AnimationTest t = new AnimationTest(); t.initFrame(); ImageWriter w = t.initWriter(); ImageWriteParam p = w.getDefaultWriteParam(); IIOMetadata streamMetadata = w.getDefaultStreamMetadata(p); w.prepareWriteSequence(streamMetadata); for (int i = 0; i < 50; i++) { BufferedImage f = t.createNextFrame(); ImageTypeSpecifier type = new ImageTypeSpecifier(f); IIOMetadata m = w.getDefaultImageMetadata(type, p); w.writeToSequence(new IIOImage(f, null, m), p); } w.endWriteSequence(); t.checkAnimation(); } catch (Exception e) { throw new RuntimeException("Test failed.", e); } }
private static void test4441315() { ImageWriteParam iwp = new ImageWriteParam4441315(); try { iwp.setProgressiveMode(ImageWriteParam.MODE_EXPLICIT); throw new RuntimeException("Failed to get IAE!"); } catch (IllegalArgumentException e) { } }
private static void test4434870() { ImageWriteParam iwp = new ImageWriteParam4434870(); try { Dimension[] dimensions = iwp.getPreferredTileSizes(); iwp.setTilingMode(ImageWriteParam.MODE_EXPLICIT); iwp.setTiling(100, 100, 0,0); throw new RuntimeException("Failed to get IAE!"); } catch (IllegalArgumentException e) { } }
public IIOMetadata convertImageMetadata(IIOMetadata inData, ImageTypeSpecifier imageType, ImageWriteParam param) { // TODO - deal with imageType if (inData instanceof PNGMetadata) { return (PNGMetadata)((PNGMetadata)inData).clone(); } else { return new PNGMetadata(inData); } }
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 Dimension[] getPreferredThumbnailSizes(ImageTypeSpecifier imageType, ImageWriteParam param, IIOMetadata streamMetadata, IIOMetadata imageMetadata) { if (jfifOK(imageType, param, streamMetadata, imageMetadata)) { return (Dimension [])preferredThumbSizes.clone(); } return null; }
public void writeToSequence(IIOImage image, ImageWriteParam param) throws IOException { setThreadLock(); try { cbLock.check(); if (sequencePrepared == false) { throw new IllegalStateException("sequencePrepared not called!"); } // In the case of JPEG this does nothing different from write write(null, image, param); } finally { clearThreadLock(); } }