/*
* JSwiff is an open source Java API for Macromedia Flash file generation
* and manipulation
*
* Copyright (C) 2004-2005 Ralf Terdic (contact@jswiff.com)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package com.jswiff.swfrecords;
import com.jswiff.io.InputBitStream;
import com.jswiff.io.OutputBitStream;
import java.io.IOException;
/**
* <p>
* This class is used within <code>DefineBitsLossless2</code> tags (with 8-bit
* colormapped images). It contains a color table and an array of pixel data.
* The color table contains a palette of up to 256 RGBA colors (i.e.
* transparency is also supported). The pixel data array contains color table
* indices. Its size is the product of padded image width and image height.
* </p>
*
* <p>
* Each line is padded with a scanline pad which makes sure the internal
* representation starts and ends at a 32-bit boundary. Use
* <code>getScanlinePadLength()</code> to compute this padding length
* depending on the width of the image. The computed number of pixels must be
* added as pad to the end of each image line. The color of the pad pixels is
* ignored.
* </p>
*/
public final class AlphaColorMapData extends ZlibBitmapData {
private RGBA[] colorTableRGBA;
private short[] colorMapPixelData;
/**
* Creates a new AlphaColorMapData instance. Supply a color table (of up to
* 256 RGBA values) and an array of pixel data of size [paddedWidth x
* height]. The pixel data consists of color table indices.
*
* @param colorTableRGBA color table, i.e. an array of up to 256 RGBA values
* @param colorMapPixelData array of color table indices
*/
public AlphaColorMapData(RGBA[] colorTableRGBA, short[] colorMapPixelData) {
this.colorTableRGBA = colorTableRGBA;
this.colorMapPixelData = colorMapPixelData;
}
/**
* Creates a new ColorMapData instance, reading data from a bit stream.
*
* @param stream source bit stream
* @param colorTableSize color of table size (up to 256)
* @param width image width in pixels (without padding!)
* @param height image height in pixels
*
* @throws IOException if an I/O error occured
*/
public AlphaColorMapData(
InputBitStream stream, short colorTableSize, int width, int height)
throws IOException {
colorTableRGBA = new RGBA[colorTableSize];
for (int i = 0; i < colorTableSize; i++) {
colorTableRGBA[i] = new RGBA(stream);
}
int imageDataSize = (width + getScanlinePadLength(width)) * height;
colorMapPixelData = new short[imageDataSize];
for (int i = 0; i < imageDataSize; i++) {
colorMapPixelData[i] = stream.readUI8();
}
}
/**
* Computes the length of the scanline padding for a given image width. The
* internal representation of the bitmap data requires a line to start and
* end at a 32-bit boundary. As pixel data consists of one byte per pixel,
* the padding can be 0, 1, 2 or 3 pixels long, depending on the width of
* the image.
*
* @param width image width (in pixels)
*
* @return padding length (in bytes)
*/
public static int getScanlinePadLength(int width) {
int pad = 0;
if ((width & 3) != 0) {
pad = 4 - (width & 3); // 1, 2 or 3 pad pixels
}
return pad;
}
/**
* Returns the pixel data array, for each pixel a color table index. Warning:
* the image data may contain up to 4 pad pixels at the end of each line as
* the internal representation of the pixel data requires lines to start and
* end on 32-bit boundaries. Use <code>getScanLinePadLength()</code> to
* compute the number of pad pixels per line.
*
* @return image data
*/
public short[] getColorMapPixelData() {
return colorMapPixelData;
}
/**
* Returns the color table which contains up to 256 RGBA values which can be
* referenced by indices contained in the image data array.
*
* @return color table (as RGBA array)
*/
public RGBA[] getColorTableRGBA() {
return colorTableRGBA;
}
/**
* Writes the instance to a bit stream.
*
* @param stream target bit stream
*
* @throws IOException if an I/O error occured
*/
public void write(OutputBitStream stream) throws IOException {
for (int i = 0; i < colorTableRGBA.length; i++) {
colorTableRGBA[i].write(stream);
}
for (int i = 0; i < colorMapPixelData.length; i++) {
stream.writeUI8(colorMapPixelData[i]);
}
}
}