pngencoder Goto Github PK

import com.pngencoder.PngEncoder;
import com.pngencoder.PngEncoderBufferedImageConverter;

public class Examples {
    public static void encodeToOutputStream(BufferedImage bufferedImage, OutputStream outputStream) {
        new PngEncoder()
                .withBufferedImage(bufferedImage)
                .toStream(outputStream);
    }

    public static void encodeToFile(BufferedImage bufferedImage, File file) {
        new PngEncoder()
                .withBufferedImage(bufferedImage)
                .toFile(file);
    }

    public static void encodeToFilePath(BufferedImage bufferedImage, Path filePath) {
        new PngEncoder()
                .withBufferedImage(bufferedImage)
                .toFile(filePath);
    }

    public static void encodeToFileName(BufferedImage bufferedImage, String fileName) {
        new PngEncoder()
                .withBufferedImage(bufferedImage)
                .toFile(fileName);
    }

    public static byte[] encodeToBytes(BufferedImage bufferedImage) {
        return new PngEncoder()
                .withBufferedImage(bufferedImage)
                .toBytes();
    }

    public static byte[] encodeWithBestPredictorCompression(BufferedImage bufferedImage) {
        // This produces image files way smaller than what ImageIO does. But
        // it takes also way more time. Predictor encoding is off by default as it
        // causes a performance hit.
        return new PngEncoder()
                .withBufferedImage(bufferedImage)
                .withPredictorEncoding(true)
                .withCompressionLevel(9)
                .toBytes();
    }

    public static byte[] encodeWithBestCompressionWithoutPredictor(BufferedImage bufferedImage) {
        // Compression level 9 is the default, and you actually need not set it.
        // It produces images with a size comparable to ImageIO.
        return new PngEncoder()
                .withBufferedImage(bufferedImage)
                .withCompressionLevel(9)
                .toBytes();
    }

    public static byte[] encodeWithBestSpeed(BufferedImage bufferedImage) {
        // If speed is more important than size you can lower the compression level.
        // 1 is about three times faster but the file becomes about three times larger.
        return new PngEncoder()
                .withBufferedImage(bufferedImage)
                .withCompressionLevel(1)
                .toBytes();
    }

    public static byte[] encodeWithBestCompressionTryIndexedEncoding(BufferedImage bufferedImage) {
        // If there are likely no more than 256 colors used in the image (including color+alpha combinations),
        // then you can try the indexed encoding. If it does not work, as there are more than 256 colors, it 
        // will silently fall back to normal encoding. This setting will give you the best possible compression,
        // but may also take the most time. 
        return new PngEncoder()
                .withBufferedImage(bufferedImage)
                .withCompressionLevel(9)
                .withTryIndexedEncoding(true)
                .withPredictorEncoding(true)
                .toBytes();
    }

    public static CompletableFuture<Void> encodeToFileInOtherThread(BufferedImage bufferedImage, File file) {
        // Perhaps all the work can be done async to let the main thread continue?
        // More of a general performance tip that's not limited to this PngEncoder library.
        return CompletableFuture.runAsync(() -> new PngEncoder()
                .withBufferedImage(bufferedImage)
                .toFile(file));
    }

    public static byte[] encodeIntArgbData(int[] data, int width, int height) {
        // Creating the BufferedImage this way is almost instant.
        // It uses the underlying int[] data directly.
        BufferedImage bufferedImage = PngEncoderBufferedImageConverter.createFromIntArgb(data, width, height);
        return new PngEncoder()
                .withBufferedImage(bufferedImage)
                .toBytes();
    }

    public static byte[] encodeWithMultiThreadedCompressionDisabled(BufferedImage bufferedImage) {
        // By default the compression is done in multiple threads.
        // This improves the speed a lot, but you can disable it to compress in the invoking thread only.
        return new PngEncoder()
                .withBufferedImage(bufferedImage)
                .withMultiThreadedCompressionEnabled(false)
                .toBytes();
    }
}