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

comparison dwt/internal/image/WinBMPFileFormat.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.WinBMPFileFormat;
+import dwt.internal.image.FileFormat;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-import dwt.DWT;
-import dwt.graphics.ImageData;
-import dwt.graphics.ImageLoader;
 import dwt.graphics.PaletteData;
 import dwt.graphics.Point;
 import dwt.graphics.RGB;
+import dwt.dwthelper.ByteArrayOutputStream;
-public final class WinBMPFileFormat : FileFormat {
+import dwt.DWT;
+import dwt.dwthelper.utils;
+import tango.core.Exception;
+final class WinBMPFileFormat : FileFormat {
 static final int BMPFileHeaderSize = 14;
 static final int BMPHeaderFixedSize = 40;
 int importantColors;
-Point pelsPerMeter = new Point(0, 0);
+Point pelsPerMeter;
+public this(){
+pelsPerMeter = new Point(0, 0);
+}
 /**
 * Compress numBytes bytes of image data from src, storing in dest
 * (starting at 0), using the technique specified by comp.
 * If last is true, this indicates the last line of the image.
 dest[dp] = 1; dp++;
 } else {
 dest[dp] = 0; dp++;
 }
 size += 2;
 return size;
 }
 int compressRLE8Data(byte[] src, int srcOffset, int numBytes, byte[] dest, bool last) {
 int sp = srcOffset, end = srcOffset + numBytes, dp = 0;
 int size = 0, left, i, n;
 dest[dp] = 1; dp++;
 } else {
 dest[dp] = 0; dp++;
 }
 size += 2;
 return size;
 }
 void decompressData(byte[] src, byte[] dest, int stride, int cmp) {
 if (cmp is 1) { // BMP_RLE8_COMPRESSION
 if (decompressRLE8Data(src, src.length, stride, dest, dest.length) <= 0)
 x += len;
 }
 }
 return 1;
 }
-bool isFileFormat(LEDataInputStream stream) {
+override bool isFileFormat(LEDataInputStream stream) {
 try {
 byte[] header = new byte[18];
 stream.read(header);
 stream.unread(header);
 int infoHeaderSize = (header[14] & 0xFF) | ((header[15] & 0xFF) << 8) | ((header[16] & 0xFF) << 16) | ((header[17] & 0xFF) << 24);
 }
 if (header[0] !is 0x4D42)
 DWT.error(DWT.ERROR_INVALID_IMAGE);
 return header;
 }
-ImageData[] loadFromByteStream() {
+override ImageData[] loadFromByteStream() {
 int[] fileHeader = loadFileHeader();
 byte[] infoHeader = new byte[BMPHeaderFixedSize];
 try {
 inputStream.read(infoHeader);
 } catch (Exception e) {
 this.importantColors = (infoHeader[36] & 0xFF) | ((infoHeader[37] & 0xFF) << 8) | ((infoHeader[38] & 0xFF) << 16) | ((infoHeader[39] & 0xFF) << 24);
 int xPelsPerMeter = (infoHeader[24] & 0xFF) | ((infoHeader[25] & 0xFF) << 8) | ((infoHeader[26] & 0xFF) << 16) | ((infoHeader[27] & 0xFF) << 24);
 int yPelsPerMeter = (infoHeader[28] & 0xFF) | ((infoHeader[29] & 0xFF) << 8) | ((infoHeader[30] & 0xFF) << 16) | ((infoHeader[31] & 0xFF) << 24);
 this.pelsPerMeter = new Point(xPelsPerMeter, yPelsPerMeter);
 int type = (this.compression is 1 /*BMP_RLE8_COMPRESSION*/) || (this.compression is 2 /*BMP_RLE4_COMPRESSION*/) ? DWT.IMAGE_BMP_RLE : DWT.IMAGE_BMP;
-return new ImageData[] {
+return [
 ImageData.internal_new(
 width,
 height,
 bitCount,
 palette,
 type,
 0,
 0,
 0,
 0)
-};
+];
 }
 PaletteData loadPalette(byte[] infoHeader) {
 int depth = (infoHeader[14] & 0xFF) | ((infoHeader[15] & 0xFF) << 8);
 if (depth <= 8) {
 int numColors = (infoHeader[32] & 0xFF) | ((infoHeader[33] & 0xFF) << 8) | ((infoHeader[34] & 0xFF) << 16) | ((infoHeader[35] & 0xFF) << 24);
 }
 return bytes;
 }
 /**
 * Unload the given image's data into the given byte stream
 * using the given compression strategy.
 * Answer the number of bytes written.
 */
-int unloadData(ImageData image, OutputStream out, int comp) {
+int unloadData(ImageData image, OutputStream ostr, int comp) {
 int totalSize = 0;
 try {
 if (comp is 0)
-return unloadDataNoCompression(image, out);
+return unloadDataNoCompression(image, ostr);
 int bpl = (image.width * image.depth + 7) / 8;
 int bmpBpl = (bpl + 3) / 4 * 4; // BMP pads scanlines to multiples of 4 bytes
 int imageBpl = image.bytesPerLine;
 // Compression can actually take twice as much space, in worst case
 byte[] buf = new byte[bmpBpl * 2];
 byte[] buf2 = new byte[32768];
 int buf2Offset = 0;
 for (int y = image.height - 1; y >= 0; y--) {
 int lineSize = compress(comp, data, srcOffset, bpl, buf, y is 0);
 if (buf2Offset + lineSize > buf2.length) {
-out.write(buf2, 0, buf2Offset);
+ostr.write(buf2, 0, buf2Offset);
 buf2Offset = 0;
 }
 System.arraycopy(buf, 0, buf2, buf2Offset, lineSize);
 buf2Offset += lineSize;
 totalSize += lineSize;
 srcOffset -= imageBpl;
 }
 if (buf2Offset > 0)
-out.write(buf2, 0, buf2Offset);
+ostr.write(buf2, 0, buf2Offset);
 } catch (IOException e) {
 DWT.error(DWT.ERROR_IO, e);
 }
 return totalSize;
 }
 /**
 * Prepare the given image's data for unloading into a byte stream
 * using no compression strategy.
 * Answer the number of bytes written.
 */
-int unloadDataNoCompression(ImageData image, OutputStream out) {
+int unloadDataNoCompression(ImageData image, OutputStream ostr) {
 int bmpBpl = 0;
 try {
 int bpl = (image.width * image.depth + 7) / 8;
 bmpBpl = (bpl + 3) / 4 * 4; // BMP pads scanlines to multiples of 4 bytes
 int linesPerBuf = 32678 / bmpBpl;
 buf[bufOffset + wIndex] = data[dataIndex + wIndex];
 }
 bufOffset += bmpBpl;
 dataIndex -= imageBpl;
 }
-out.write(buf, 0, bufOffset);
+ostr.write(buf, 0, bufOffset);
 }
 } else {
 for (int y = 0; y < image.height; y += linesPerBuf) {
 int tmp = image.height - y;
 int count = tmp < linesPerBuf ? tmp : linesPerBuf;
 for (int i = 0; i < count; i++) {
 System.arraycopy(data, dataIndex, buf, bufOffset, bpl);
 bufOffset += bmpBpl;
 dataIndex -= imageBpl;
 }
-out.write(buf, 0, bufOffset);
+ostr.write(buf, 0, bufOffset);
 }
 }
 } catch (IOException e) {
 DWT.error(DWT.ERROR_IO, e);
 }
 }
 /**
 * Unload a DeviceIndependentImage using Windows .BMP format into the given
 * byte stream.
 */
-void unloadIntoByteStream(ImageLoader loader) {
+override void unloadIntoByteStream(ImageLoader loader) {
 ImageData image = loader.data[0];
 byte[] rgbs;
 int numCols;
 if (!((image.depth is 1) || (image.depth is 4) || (image.depth is 8) ||
 (image.depth is 16) || (image.depth is 24) || (image.depth is 32)))
 fileHeader[4] += rgbs.length;
 }
 // Prepare data. This is done first so we don't have to try to rewind
 // the stream and fill in the details later.
-ByteArrayOutputStream out = new ByteArrayOutputStream();
+ByteArrayOutputStream ostr = new ByteArrayOutputStream();
-unloadData(image, out, comp);
+unloadData(image, ostr, comp);
-byte[] data = out.toByteArray();
+byte[] data = ostr.toByteArray();
 // Calculate file size
 fileHeader[1] = fileHeader[4] + data.length;
 // Write the headers
 try {
 outputStream.writeInt(numCols);
 outputStream.writeInt(importantColors);
 } catch (IOException e) {
 DWT.error(DWT.ERROR_IO, e);
 }
 // Unload palette
 if (numCols > 0) {
 try {
 outputStream.write(rgbs);
 } catch (IOException e) {

Mercurial > projects > dwt-mac

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