projects/dwt-mac: dwt/internal/image/PNGFileFormat.d comparison

comparison dwt/internal/image/PNGFileFormat.d @ 34:5123b17c98ef

Ported dwt.events.*, dwt.graphics.GC, Region, dwt.internal.image.*

author	Jacob Carlborg <doob@me.com> <jacob.carlborg@gmail.com>
date	Sun, 14 Sep 2008 01:45:57 +0200
parents	e831403a80a9
children	d8635bb48c7c

comparison

equal deleted inserted replaced

-:965ac0a77267
+:5123b17c98ef
 /*******************************************************************************
-* Copyright (c) 2000, 2006 IBM Corporation and others.
+* Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
+* Port to the D programming language:
+*     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
-module dwt.internal.image;
+module dwt.internal.image.PNGFileFormat;
-import java.io.IOException;
-import java.io.InputStream;
 import dwt.DWT;
 import dwt.graphics.ImageData;
+import dwt.graphics.ImageLoaderEvent;
 import dwt.graphics.ImageLoader;
-import dwt.graphics.ImageLoaderEvent;
 import dwt.graphics.PaletteData;
 import dwt.internal.Compatibility;
+import dwt.internal.image.FileFormat;
-public final class PNGFileFormat : FileFormat {
+import dwt.internal.image.PngIhdrChunk;
+import dwt.internal.image.PngPlteChunk;
+import dwt.internal.image.PngChunkReader;
+import dwt.internal.image.PngChunk;
+import dwt.internal.image.PngTrnsChunk;
+import dwt.internal.image.PngIdatChunk;
+import dwt.internal.image.PngEncoder;
+import dwt.internal.image.PngInputStream;
+import dwt.internal.image.PngDecodingDataStream;
+import dwt.dwthelper.utils;
+import dwt.dwthelper.BufferedInputStream;
+import tango.core.Exception;
+final class PNGFileFormat : FileFormat {
 static final int SIGNATURE_LENGTH = 8;
 static final int PRIME = 65521;
 PngIhdrChunk headerChunk;
 PngPlteChunk paletteChunk;
 ImageData imageData;
 byte headerByte2;
 int adler;
 /**
 * Skip over signature data. This has already been
 * verified in isFileFormat().
 */
-void readSignature() {
+void readSignature()  {
 byte[] signature = new byte[SIGNATURE_LENGTH];
 inputStream.read(signature);
 }
 /**
 * Load the PNG image from the byte stream.
 */
-ImageData[] loadFromByteStream() {
+override ImageData[] loadFromByteStream() {
 try {
 readSignature();
 PngChunkReader chunkReader = new PngChunkReader(inputStream);
 headerChunk = chunkReader.getIhdrChunk();
 int width = headerChunk.getWidth(), height = headerChunk.getHeight();
 if (width <= 0 || height <= 0) DWT.error(DWT.ERROR_INVALID_IMAGE);
 int imageSize = getAlignedBytesPerRow() * height;
 data = new byte[imageSize];
 imageData = ImageData.internal_new(
 width,
 height,
 headerChunk.getSwtBitsPerPixel(),
 new PaletteData(0, 0, 0),
 -1,
 DWT.IMAGE_PNG,
 0,
 0,
 0,
 0);
 if (headerChunk.usesDirectColor()) {
 imageData.palette = headerChunk.getPaletteData();
 }
 // Read and process chunks until the IEND chunk is encountered.
 while (chunkReader.hasMoreChunks()) {
 readNextChunk(chunkReader);
 }
-return new ImageData[] {imageData};
+return [imageData];
 } catch (IOException e) {
 DWT.error(DWT.ERROR_INVALID_IMAGE);
 return null;
 }
 }
 /**
 * Read and handle the next chunk of data from the
 * PNG file.
 */
-void readNextChunk(PngChunkReader chunkReader) {
+void readNextChunk(PngChunkReader chunkReader)  {
 PngChunk chunk = chunkReader.readNextChunk();
 switch (chunk.getChunkType()) {
 case PngChunk.CHUNK_IEND:
 break;
 case PngChunk.CHUNK_PLTE:
 if (!headerChunk.usesDirectColor()) {
 paletteChunk = cast(PngPlteChunk) chunk;
 imageData.palette = paletteChunk.getPaletteData();
 }
 break;
 case PngChunk.CHUNK_tRNS:
 PngTrnsChunk trnsChunk = cast(PngTrnsChunk) chunk;
 if (trnsChunk.getTransparencyType(headerChunk) is
 PngTrnsChunk.TRANSPARENCY_TYPE_PIXEL)
 {
 imageData.transparentPixel =
 trnsChunk.getSwtTransparentPixel(headerChunk);
 } else {
 alphaPalette = trnsChunk.getAlphaValues(headerChunk, paletteChunk);
 int transparentCount = 0, transparentPixel = -1;
 for (int i = 0; i < alphaPalette.length; i++) {
 // been read and another IDAT block is encountered,
 // then this is an invalid image.
 DWT.error(DWT.ERROR_INVALID_IMAGE);
 } else {
 // Read in the pixel data for the image. This should
 // go through all the image's IDAT chunks.
 PngIdatChunk dataChunk = cast(PngIdatChunk) chunk;
 readPixelData(dataChunk, chunkReader);
 }
 break;
 default:
 if (chunk.isCritical()) {
 // All critical chunks must be supported.
 DWT.error(DWT.ERROR_NOT_IMPLEMENTED);
 }
 }
 }
-void unloadIntoByteStream(ImageLoader loader) {
+override void unloadIntoByteStream(ImageLoader loader) {
 PngEncoder encoder = new PngEncoder(loader);
 encoder.encode(outputStream);
 }
-bool isFileFormat(LEDataInputStream stream) {
+override bool isFileFormat(LEDataInputStream stream) {
 try {
 byte[] signature = new byte[SIGNATURE_LENGTH];
 stream.read(signature);
 stream.unread(signature);
 if ((signature[0] & 0xFF) !is 137) return false; //137
 if ((signature[2] & 0xFF) !is 78) return false; //N
 if ((signature[3] & 0xFF) !is 71) return false; //G
 if ((signature[4] & 0xFF) !is 13) return false; //<RETURN>
 if ((signature[5] & 0xFF) !is 10) return false; //<LINEFEED>
 if ((signature[6] & 0xFF) !is 26) return false; //<CTRL/Z>
 if ((signature[7] & 0xFF) !is 10) return false; //<LINEFEED>
 return true;
 } catch (Exception e) {
 return false;
 }
 }
 }
 }
 imageData.data = rgbData;
 imageData.alphaData = alphaData;
 break;
 }
 case PngIhdrChunk.COLOR_TYPE_RGB:
 imageData.data = data;
 break;
 case PngIhdrChunk.COLOR_TYPE_PALETTE:
 imageData.data = data;
 imageData.data = data;
 break;
 }
 }
 /**
 * PNG supports some color types and bit depths that are
 * unsupported by DWT. If the image uses an unsupported
 * color type (either of the gray scale types) or bit
 * depth (16), convert the data to an DWT-supported
 * format. Then assign the data into the ImageData given.
 */
 }
 /**
 * Read the image data from the data stream. This must handle
 * decoding the data, filtering, and interlacing.
 */
-void readPixelData(PngIdatChunk chunk, PngChunkReader chunkReader) {
+void readPixelData(PngIdatChunk chunk, PngChunkReader chunkReader)  {
 InputStream stream = new PngInputStream(chunk, chunkReader);
 //TEMPORARY CODE
-bool use3_2 = System.getProperty("dwt.internal.image.PNGFileFormat_3.2") !is null;
+//PORTING_FIXME
+bool use3_2 = true;//System.getProperty("dwt.internal.image.PNGFileFormat_3.2") !is null;
 InputStream inflaterStream = use3_2 ? null : Compatibility.newInflaterInputStream(stream);
 if (inflaterStream !is null) {
 stream = inflaterStream;
 } else {
 stream = new PngDecodingDataStream(stream);
 return getBytesPerRow(headerChunk.getWidth());
 }
 /**
 * Answer the number of bytes needed to represent a pixel.
 * This value depends on the image's color type and bit
 * depth.
 * Note that this method rounds up if an image's pixel size
 * isn't byte-aligned.
 */
 int getBytesPerPixel() {
 int bitsPerPixel = headerChunk.getBitsPerPixel();
 return (bitsPerPixel + 7) / 8;
 }
 /**
 * Answer the number of bytes in a row of the given pixel
 * width. Each row is byte-aligned, so images with bit
 * depths less than a byte may have unused bits at the
 {
 int width = headerChunk.getWidth();
 int alignedBytesPerRow = getAlignedBytesPerRow();
 int height = headerChunk.getHeight();
 if (startRow >= height || startColumn >= width) return;
 int pixelsPerRow = (width - startColumn + columnInterval - 1) / columnInterval;
 int bytesPerRow = getBytesPerRow(pixelsPerRow);
 byte[] row1 = new byte[bytesPerRow];
 byte[] row2 = new byte[bytesPerRow];
 byte[] currentRow = row1;
 byte[] lastRow = row2;
 for (int row = startRow; row < height; row += rowInterval) {
 byte filterType = cast(byte)inputStream.read();
 int read = 0;
 while (read !is bytesPerRow) {
 read += inputStream.read(currentRow, read, bytesPerRow - read);
 }
 int maxShift = 8 - bitsPerPixel;
 for (int byteOffset = 0; byteOffset < currentRow.length; byteOffset++) {
 for (int bitOffset = maxShift; bitOffset >= 0; bitOffset -= bitsPerPixel) {
 if (column < width) {
 int dataOffset = rowBase + (column * bitsPerPixel / 8);
 int value = (currentRow[byteOffset] >> bitOffset) & valueMask;
 int dataShift = maxShift - (bitsPerPixel * (column % pixelsPerByte));
 data[dataOffset] |= value << dataShift;
 }
 column += columnInterval;
 }
 /**
 * Read the pixel data for an interlaced image from the
 * data stream.
 */
-void readInterlacedImage(InputStream inputStream) {
+void readInterlacedImage(InputStream inputStream)  {
 readInterlaceFrame(inputStream, 8, 8, 0, 0, 0);
 readInterlaceFrame(inputStream, 8, 8, 0, 4, 1);
 readInterlaceFrame(inputStream, 8, 4, 4, 0, 2);
 readInterlaceFrame(inputStream, 4, 4, 0, 2, 3);
 readInterlaceFrame(inputStream, 4, 2, 2, 0, 4);
 readInterlaceFrame(inputStream, 2, 2, 0, 1, 5);
 readInterlaceFrame(inputStream, 2, 1, 1, 0, 6);
 }
 /**
 * Fire an event to let listeners know that an interlaced
 * frame has been loaded.
 /**
 * Read the pixel data for a non-interlaced image from the
 * data stream.
 * Update the imageData to reflect the new data.
 */
-void readNonInterlacedImage(InputStream inputStream) {
+void readNonInterlacedImage(InputStream inputStream)  {
 int dataOffset = 0;
 int alignedBytesPerRow = getAlignedBytesPerRow();
 int bytesPerRow = getBytesPerRow();
 byte[] row1 = new byte[bytesPerRow];
 byte[] row2 = new byte[bytesPerRow];
 byte[] currentRow = row1;
 byte[] lastRow = row2;
 int height = headerChunk.getHeight();
 for (int row = 0; row < height; row++) {
 byte filterType = cast(byte)inputStream.read();
 int read = 0;
 * byte of the 16-bit value.
 */
 static void compress16BitDepthTo8BitDepth(
 byte[] source,
 int sourceOffset,
 byte[] destination,
 int destinationOffset,
 int numberOfValues)
 {
 //double multiplier = (Compatibility.pow2(8) - 1) / (Compatibility.pow2(16) - 1);
 for (int i = 0; i < numberOfValues; i++) {
 int sourceIndex = sourceOffset + (2 * i);
 int destinationIndex = destinationOffset + i;
 //int value = (source[sourceIndex] << 8) | source[sourceIndex + 1];
-//byte compressedValue = cast(byte)(value * multiplier);
+//byte compressedValue = (byte)(value * multiplier);
 byte compressedValue = source[sourceIndex];
 destination[destinationIndex] = compressedValue;
 }
 }
 /**
 * The fast way to do this is just to drop the low
 * byte of the 16-bit value.
 */
 static int compress16BitDepthTo8BitDepth(int value) {
 //double multiplier = (Compatibility.pow2(8) - 1) / (Compatibility.pow2(16) - 1);
-//byte compressedValue = cast(byte)(value * multiplier);
+//byte compressedValue = (byte)(value * multiplier);
 return value >> 8;
 }
 /**
 * PNG supports four filtering types. These types are applied
 * per row of image data. This method unfilters the given row
 }
 break;
 case PngIhdrChunk.FILTER_UP:
 for (int i = 0; i < row.length; i++) {
 int current = row[i] & 0xFF;
 int above = previousRow[i] & 0xFF;
 row[i] = cast(byte)((current + above) & 0xFF);
 }
 break;
 case PngIhdrChunk.FILTER_AVERAGE:
 for (int i = 0; i < row.length; i++) {
 case PngIhdrChunk.FILTER_PAETH:
 for (int i = 0; i < row.length; i++) {
 int left = (i < byteOffset) ? 0 : row[i - byteOffset] & 0xFF;
 int aboveLeft = (i < byteOffset) ? 0 : previousRow[i - byteOffset] & 0xFF;
 int above = previousRow[i] & 0xFF;
 int a = Math.abs(above - aboveLeft);
 int b = Math.abs(left - aboveLeft);
 int c = Math.abs(left - aboveLeft + above - aboveLeft);
 int preductor = 0;
 if (a <= b && a <= c) {
 preductor = left;
 } else if (b <= c) {
 preductor = above;
 } else {
 preductor = aboveLeft;
 }
 int currentValue = row[i] & 0xFF;
 row[i] = cast(byte) ((currentValue + preductor) & 0xFF);
 }
 break;
-}
+default:
 }
+}
-}
+}

Mercurial > projects > dwt-mac

comparison dwt/internal/image/PNGFileFormat.d @ 34:5123b17c98ef