| /* |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * under the License. |
| */ |
| |
| package org.apache.commons.imaging.formats.pcx; |
| |
| import java.awt.image.BufferedImage; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import org.apache.commons.imaging.ImageWriteException; |
| import org.apache.commons.imaging.PixelDensity; |
| import org.apache.commons.imaging.common.BinaryOutputStream; |
| import org.apache.commons.imaging.palette.PaletteFactory; |
| import org.apache.commons.imaging.palette.SimplePalette; |
| |
| public class PcxWriter implements PcxConstants |
| { |
| private int encoding; |
| private int bitDepth = -1; |
| private PixelDensity pixelDensity = null; |
| |
| public PcxWriter(Map params) throws ImageWriteException |
| { |
| // make copy of params; we'll clear keys as we consume them. |
| params = (params == null) ? new HashMap() : new HashMap(params); |
| |
| // clear format key. |
| if (params.containsKey(PARAM_KEY_FORMAT)) |
| params.remove(PARAM_KEY_FORMAT); |
| |
| // uncompressed PCX files are not even documented in ZSoft's spec, |
| // let alone supported by most image viewers |
| encoding = PcxImageParser.PcxHeader.ENCODING_RLE; |
| if (params.containsKey(PARAM_KEY_PCX_COMPRESSION)) |
| { |
| Object value = params.remove(PARAM_KEY_PCX_COMPRESSION); |
| if (value != null) |
| { |
| if (!(value instanceof Number)) |
| throw new ImageWriteException( |
| "Invalid compression parameter: " + value); |
| int compression = ((Number) value).intValue(); |
| if (compression == PCX_COMPRESSION_UNCOMPRESSED) |
| encoding = PcxImageParser.PcxHeader.ENCODING_UNCOMPRESSED; |
| } |
| } |
| |
| if (params.containsKey(PARAM_KEY_PCX_BIT_DEPTH)) |
| { |
| Object value = params.remove(PARAM_KEY_PCX_BIT_DEPTH); |
| if (value != null) |
| { |
| if (!(value instanceof Number)) |
| throw new ImageWriteException( |
| "Invalid bit depth parameter: " + value); |
| bitDepth = ((Number)value).intValue(); |
| } |
| } |
| |
| if (params.containsKey(PARAM_KEY_PIXEL_DENSITY)) |
| { |
| Object value = params.remove(PARAM_KEY_PIXEL_DENSITY); |
| if (value != null) |
| { |
| if (!(value instanceof PixelDensity)) |
| throw new ImageWriteException( |
| "Invalid pixel density parameter"); |
| pixelDensity = (PixelDensity) params.remove(PARAM_KEY_PIXEL_DENSITY); |
| } |
| } |
| if (pixelDensity == null) |
| { |
| // DPI is mandatory, so we have to invent something |
| pixelDensity = PixelDensity.createFromPixelsPerInch(72, 72); |
| } |
| |
| if (params.size() > 0) |
| { |
| Object firstKey = params.keySet().iterator().next(); |
| throw new ImageWriteException("Unknown parameter: " + firstKey); |
| } |
| } |
| |
| private void writeScanLine(BinaryOutputStream bos, byte[] scanline) |
| throws IOException, ImageWriteException |
| { |
| if (encoding == PcxImageParser.PcxHeader.ENCODING_UNCOMPRESSED) |
| bos.writeByteArray(scanline); |
| else |
| { |
| if (encoding == PcxImageParser.PcxHeader.ENCODING_RLE) |
| { |
| int previousByte = -1; |
| int repeatCount = 0; |
| for (int i = 0; i < scanline.length; i++) |
| { |
| if ((scanline[i] & 0xff) == previousByte && repeatCount < 63) |
| ++repeatCount; |
| else |
| { |
| if (repeatCount > 0) |
| { |
| if (repeatCount == 1 && (previousByte & 0xc0) != 0xc0) |
| bos.write(previousByte); |
| else |
| { |
| bos.write(0xc0 | repeatCount); |
| bos.write(previousByte); |
| } |
| } |
| previousByte = 0xff & scanline[i]; |
| repeatCount = 1; |
| } |
| } |
| if (repeatCount > 0) |
| { |
| if (repeatCount == 1 && (previousByte & 0xc0) != 0xc0) |
| bos.write(previousByte); |
| else |
| { |
| bos.write(0xc0 | repeatCount); |
| bos.write(previousByte); |
| } |
| } |
| } |
| else |
| throw new ImageWriteException("Invalid PCX encoding " + encoding); |
| } |
| } |
| |
| public void writeImage(BufferedImage src, OutputStream os) |
| throws ImageWriteException, IOException |
| { |
| final PaletteFactory paletteFactory = new PaletteFactory(); |
| final SimplePalette palette = paletteFactory.makePaletteSimple(src, 256); |
| BinaryOutputStream bos = new BinaryOutputStream(os, BinaryOutputStream.BYTE_ORDER_INTEL); |
| if (palette == null || bitDepth == 24 || bitDepth == 32) |
| { |
| if (bitDepth == 32) |
| write32BppPCX(src, bos); |
| else |
| write24BppPCX(src, bos); |
| } |
| else if (palette.length() > 16 || bitDepth == 8) |
| write256ColorPCX(src, palette, bos); |
| else if (palette.length() > 2 || bitDepth == 4) |
| write16ColorPCX(src, palette, bos); |
| else |
| { |
| boolean onlyBlackAndWhite = true; |
| if (palette.length() >= 1) |
| { |
| int rgb = palette.getEntry(0); |
| if (rgb != 0 && rgb != 0xffffff) |
| onlyBlackAndWhite = false; |
| } |
| if (palette.length() == 2) |
| { |
| int rgb = palette.getEntry(1); |
| if (rgb != 0 && rgb != 0xffffff) |
| onlyBlackAndWhite = false; |
| } |
| if (onlyBlackAndWhite) |
| writeBlackAndWhitePCX(src, palette, bos); |
| else |
| write16ColorPCX(src, palette, bos); |
| } |
| } |
| |
| private void write32BppPCX(BufferedImage src, BinaryOutputStream bos) |
| throws ImageWriteException, IOException |
| { |
| final int bytesPerLine = src.getWidth() % 2 == 0 ? |
| src.getWidth() : src.getWidth() + 1; |
| |
| // PCX header |
| bos.write(10); // manufacturer |
| bos.write(5); // version |
| bos.write(encoding); // encoding |
| bos.write(32); // bits per pixel |
| bos.write2Bytes(0); // xMin |
| bos.write2Bytes(0); // yMin |
| bos.write2Bytes(src.getWidth() - 1); // xMax |
| bos.write2Bytes(src.getHeight() - 1); // yMax |
| bos.write2Bytes((short)Math.round(pixelDensity.horizontalDensityInches())); // hDpi |
| bos.write2Bytes((short)Math.round(pixelDensity.verticalDensityInches())); // vDpi |
| bos.writeByteArray(new byte[48]); // 16 color palette |
| bos.write(0); // reserved |
| bos.write(1); // planes |
| bos.write2Bytes(bytesPerLine); // bytes per line |
| bos.write2Bytes(1); // palette info |
| bos.write2Bytes(0); // hScreenSize |
| bos.write2Bytes(0); // vScreenSize |
| bos.writeByteArray(new byte[54]); |
| |
| int rgbs[] = new int[src.getWidth()]; |
| byte rgbBytes[] = new byte[4 * bytesPerLine]; |
| for (int y = 0; y < src.getHeight(); y++) |
| { |
| src.getRGB(0, y, src.getWidth(), 1, rgbs, 0, src.getWidth()); |
| for (int x = 0; x < rgbs.length; x++) |
| { |
| rgbBytes[4*x + 0] = (byte) (rgbs[x] & 0xff); |
| rgbBytes[4*x + 1] = (byte) ((rgbs[x] >> 8) & 0xff); |
| rgbBytes[4*x + 2] = (byte) ((rgbs[x] >> 16) & 0xff); |
| rgbBytes[4*x + 3] = 0; |
| } |
| writeScanLine(bos, rgbBytes); |
| } |
| } |
| |
| private void write24BppPCX(BufferedImage src, BinaryOutputStream bos) |
| throws ImageWriteException, IOException |
| { |
| final int bytesPerLine = src.getWidth() % 2 == 0 ? |
| src.getWidth() : src.getWidth() + 1; |
| |
| // PCX header |
| bos.write(10); // manufacturer |
| bos.write(5); // version |
| bos.write(encoding); // encoding |
| bos.write(8); // bits per pixel |
| bos.write2Bytes(0); // xMin |
| bos.write2Bytes(0); // yMin |
| bos.write2Bytes(src.getWidth() - 1); // xMax |
| bos.write2Bytes(src.getHeight() - 1); // yMax |
| bos.write2Bytes((short)Math.round(pixelDensity.horizontalDensityInches())); // hDpi |
| bos.write2Bytes((short)Math.round(pixelDensity.verticalDensityInches())); // vDpi |
| bos.writeByteArray(new byte[48]); // 16 color palette |
| bos.write(0); // reserved |
| bos.write(3); // planes |
| bos.write2Bytes(bytesPerLine); // bytes per line |
| bos.write2Bytes(1); // palette info |
| bos.write2Bytes(0); // hScreenSize |
| bos.write2Bytes(0); // vScreenSize |
| bos.writeByteArray(new byte[54]); |
| |
| int rgbs[] = new int[src.getWidth()]; |
| byte rgbBytes[] = new byte[3 * bytesPerLine]; |
| for (int y = 0; y < src.getHeight(); y++) |
| { |
| src.getRGB(0, y, src.getWidth(), 1, rgbs, 0, src.getWidth()); |
| for (int x = 0; x < rgbs.length; x++) |
| { |
| rgbBytes[x] = (byte) ((rgbs[x] >> 16) & 0xff); |
| rgbBytes[bytesPerLine + x] = (byte) ((rgbs[x] >> 8) & 0xff); |
| rgbBytes[2 * bytesPerLine + x] = (byte) (rgbs[x] & 0xff); |
| } |
| writeScanLine(bos, rgbBytes); |
| } |
| } |
| |
| private void writeBlackAndWhitePCX(BufferedImage src, SimplePalette palette, BinaryOutputStream bos) |
| throws ImageWriteException, IOException |
| { |
| int bytesPerLine = (src.getWidth() + 7) / 8; |
| if (bytesPerLine % 2 != 0) |
| ++bytesPerLine; |
| |
| // PCX header |
| bos.write(10); // manufacturer |
| bos.write(3); // version - it seems some apps only open |
| // black and white files if the version is 3... |
| bos.write(encoding); // encoding |
| bos.write(1); // bits per pixel |
| bos.write2Bytes(0); // xMin |
| bos.write2Bytes(0); // yMin |
| bos.write2Bytes(src.getWidth() - 1); // xMax |
| bos.write2Bytes(src.getHeight() - 1); // yMax |
| bos.write2Bytes((short)Math.round(pixelDensity.horizontalDensityInches())); // hDpi |
| bos.write2Bytes((short)Math.round(pixelDensity.verticalDensityInches())); // vDpi |
| bos.writeByteArray(new byte[48]); // 16 color palette |
| bos.write(0); // reserved |
| bos.write(1); // planes |
| bos.write2Bytes(bytesPerLine); // bytes per line |
| bos.write2Bytes(1); // palette info |
| bos.write2Bytes(0); // hScreenSize |
| bos.write2Bytes(0); // vScreenSize |
| bos.writeByteArray(new byte[54]); |
| |
| byte[] row = new byte[bytesPerLine]; |
| for (int y = 0; y < src.getHeight(); y++) |
| { |
| Arrays.fill(row, (byte)0); |
| for (int x = 0; x < src.getWidth(); x++) |
| { |
| int rgb = 0xffffff & src.getRGB(x, y); |
| int bit; |
| if (rgb == 0x000000) |
| bit = 0; |
| else if (rgb == 0xffffff) |
| bit = 1; |
| else |
| throw new ImageWriteException("Pixel neither black nor white"); |
| row[x / 8] |= (bit << (7 - (x % 8))); |
| } |
| writeScanLine(bos, row); |
| } |
| } |
| |
| private void write16ColorPCX(BufferedImage src, SimplePalette palette, BinaryOutputStream bos) |
| throws ImageWriteException, IOException |
| { |
| int bytesPerLine = (src.getWidth() + 1) / 2; |
| if (bytesPerLine % 2 != 0) |
| ++bytesPerLine; |
| |
| byte[] palette16 = new byte[16*3]; |
| for (int i = 0; i < 16; i++) |
| { |
| int rgb; |
| if (i < palette.length()) |
| rgb = palette.getEntry(i); |
| else |
| rgb = 0; |
| palette16[3*i + 0] = (byte) (0xff & (rgb >> 16)); |
| palette16[3*i + 1] = (byte) (0xff & (rgb >> 8)); |
| palette16[3*i + 2] = (byte) (0xff & rgb); |
| } |
| |
| // PCX header |
| bos.write(10); // manufacturer |
| bos.write(5); // version |
| bos.write(encoding); // encoding |
| bos.write(4); // bits per pixel |
| bos.write2Bytes(0); // xMin |
| bos.write2Bytes(0); // yMin |
| bos.write2Bytes(src.getWidth() - 1); // xMax |
| bos.write2Bytes(src.getHeight() - 1); // yMax |
| bos.write2Bytes((short)Math.round(pixelDensity.horizontalDensityInches())); // hDpi |
| bos.write2Bytes((short)Math.round(pixelDensity.verticalDensityInches())); // vDpi |
| bos.writeByteArray(palette16); // 16 color palette |
| bos.write(0); // reserved |
| bos.write(1); // planes |
| bos.write2Bytes(bytesPerLine); // bytes per line |
| bos.write2Bytes(1); // palette info |
| bos.write2Bytes(0); // hScreenSize |
| bos.write2Bytes(0); // vScreenSize |
| bos.writeByteArray(new byte[54]); |
| |
| byte[] indeces = new byte[bytesPerLine]; |
| for (int y = 0; y < src.getHeight(); y++) |
| { |
| Arrays.fill(indeces, (byte)0); |
| for (int x = 0; x < src.getWidth(); x++) |
| { |
| int argb = src.getRGB(x, y); |
| int index = palette.getPaletteIndex(0xffffff & argb); |
| indeces[x / 2] |= (index << 4*(1 - (x % 2))); |
| } |
| writeScanLine(bos, indeces); |
| } |
| } |
| |
| private void write256ColorPCX(BufferedImage src, SimplePalette palette, BinaryOutputStream bos) |
| throws ImageWriteException, IOException |
| { |
| final int bytesPerLine = src.getWidth() % 2 == 0 ? |
| src.getWidth() : src.getWidth() + 1; |
| |
| // PCX header |
| bos.write(10); // manufacturer |
| bos.write(5); // version |
| bos.write(encoding); // encoding |
| bos.write(8); // bits per pixel |
| bos.write2Bytes(0); // xMin |
| bos.write2Bytes(0); // yMin |
| bos.write2Bytes(src.getWidth() - 1); // xMax |
| bos.write2Bytes(src.getHeight() - 1); // yMax |
| bos.write2Bytes((short)Math.round(pixelDensity.horizontalDensityInches())); // hDpi |
| bos.write2Bytes((short)Math.round(pixelDensity.verticalDensityInches())); // vDpi |
| bos.writeByteArray(new byte[48]); // 16 color palette |
| bos.write(0); // reserved |
| bos.write(1); // planes |
| bos.write2Bytes(bytesPerLine); // bytes per line |
| bos.write2Bytes(1); // palette info |
| bos.write2Bytes(0); // hScreenSize |
| bos.write2Bytes(0); // vScreenSize |
| bos.writeByteArray(new byte[54]); |
| |
| byte[] indeces = new byte[bytesPerLine]; |
| for (int y = 0; y < src.getHeight(); y++) |
| { |
| for (int x = 0; x < src.getWidth(); x++) |
| { |
| int argb = src.getRGB(x, y); |
| int index = palette.getPaletteIndex(0xffffff & argb); |
| indeces[x] = (byte) index; |
| } |
| writeScanLine(bos, indeces); |
| } |
| // palette |
| bos.write(12); |
| for (int i = 0; i < 256; i++) |
| { |
| int rgb; |
| if (i < palette.length()) |
| rgb = palette.getEntry(i); |
| else |
| rgb = 0; |
| bos.write((rgb >> 16) & 0xff); |
| bos.write((rgb >> 8) & 0xff); |
| bos.write(rgb & 0xff); |
| } |
| } |
| } |
