* Only writing GIF files is supported right now. * Reading GIF files with JIU can be done with the {@link net.sourceforge.jiu.gui.awt.ToolkitLoader} * class which uses the image reader built into the Java runtime library ({@link java.awt.Toolkit} class). * That reader has supported GIF since Java 1.0. *
* GIFCodec codec = new GIFCodec();
* codec.appendComment("Bob and Susan at the Munich airport (2002-06-13).");
* codec.setImage(image); // BilevelImage, Gray8Image or Paletted8Image
* codec.setInterlacing(true);
* codec.setFile("output.gif", CodecMode.SAVE);
* codec.process();
* codec.close();
*
* * Interlaced files store the image in four passes, progressively adding * rows until the complete image is stored. * When decoding, the progressive display of interlaced files makes it * supposedly quicker to find out what's displayed in the image. *
* On the other hand, transmission typically takes longer, because interlacing * often leads to slightly larger files. * When using interlaced mode, lines that get stored one after another * have some room between them in the image, so there are less similarities * between consecutive lines, which worsens compression ratio (compression * works better with a lot of similarities in the data to be compressed). *
Gif89a.txt that I found
* somewhere on the Net they grant a royalty-free license for use of the
* format to anyone - in order to improve the popularity of the format, I guess.
* I don't think that it should be possible to put a file format under a copyright,
* but all that Compuserve asks for in exchange for freely using the format
* is the inclusion of a message.
* So, here is that message:
* * "The Graphics Interchange Format(c) is the Copyright property of * CompuServe Incorporated. GIF(sm) is a Service Mark property of * CompuServe Incorporated." **
true)
* or non-interlaced mode (false).
* @return interlacing mode
* @see #setInterlacing
*/
public boolean isInterlaced()
{
return interlaced;
}
public boolean isLoadingSupported()
{
return false;
}
public boolean isSavingSupported()
{
return true;
}
public void process() throws
MissingParameterException,
OperationFailedException
{
initModeFromIOObjects();
if (getMode() == CodecMode.LOAD)
{
throw new OperationFailedException("Loading is not supported.");
}
else
{
save();
}
}
private void resetBlock()
{
for (int i = 0; i < block.length; i++)
{
block[i] = 0;
}
blockLength = 0;
bitOffset = 0;
}
private void resetEncoder()
{
codeSize = initialCodeSize + 1;
clearCode = 1 << initialCodeSize;
endOfInformationCode = clearCode + 1;
freeCode = endOfInformationCode + 1;
maxCode = (1 << codeSize) - 1;
for (int i = 0; i < currentCode.length; i++)
{
currentCode[i] = 0;
}
}
private void save() throws
MissingParameterException,
OperationFailedException,
UnsupportedTypeException,
WrongParameterException
{
PixelImage image = getImage();
if (image == null)
{
throw new MissingParameterException("No image available for saving.");
}
width = image.getWidth();
height = image.getHeight();
setBoundsIfNecessary(width, height);
width = getBoundsWidth();
height = getBoundsHeight();
if (image instanceof Paletted8Image)
{
Palette palette = ((Paletted8Image)image).getPalette();
int numEntries = palette.getNumEntries();
if (numEntries < 1 || numEntries > 256)
{
throw new WrongParameterException("Palette of image to be saved must have 1..256 entries.");
}
bitsPerPixel = 8;
// determine minimum number of bits per pixel necessary to store image
for (int i = 1; i <= 8; i++)
{
if ((1 << i) >= numEntries)
{
bitsPerPixel = i;
break;
}
}
}
else
if (image instanceof Gray8Image)
{
bitsPerPixel = 8;
}
else
if (image instanceof BilevelImage)
{
bitsPerPixel = 1;
}
else
{
throw new UnsupportedTypeException("Unsupported image type: " + image.getClass().getName());
}
out = getOutputAsDataOutput();
if (out == null)
{
throw new MissingParameterException("Output stream / random access file parameter missing.");
}
// now write the output stream
try
{
writeStream();
}
catch (IOException ioe)
{
throw new OperationFailedException("I/O failure: " + ioe.toString());
}
}
/**
* Specify the value of the background color.
* Default is 0.
* @param colorIndex int value with the color (index into the palette) of the background color
* @see #getBackgroundColor
*/
public void setBackgroundColor(int colorIndex)
{
backgroundColor = colorIndex;
}
/**
* Specifies whether the image will be stored in interlaced mode
* (true) or non-interlaced mode (false).
* @param useInterlacing boolean, if true interlaced mode, otherwise non-interlaced mode
* @see #isInterlaced()
*/
public void setInterlacing(boolean useInterlacing)
{
interlaced = useInterlacing;
}
private void writeBlock() throws IOException
{
if (bitOffset > 0)
{
blockLength++;
}
if (blockLength == 0)
{
return;
}
out.write(blockLength);
out.write(block, 0, blockLength);
resetBlock();
}
private void writeCode(int code) throws IOException
{
int remainingBits = codeSize;
do
{
int bitsFree = 8 - bitOffset;
int bits;
/* bits => number of bits to be copied from "code" to
"block[blockLength]" in this loop iteration */
if (bitsFree < remainingBits)
{
bits = bitsFree;
}
else
{
bits = remainingBits;
}
int value = block[blockLength] & 0xff;
value += (code & ((1 << bits) - 1)) << bitOffset;
block[blockLength] = (byte)value;
bitOffset += bits;
if (bitOffset == 8)
{
blockLength++;
bitOffset = 0;
if (blockLength == 255)
{
writeBlock();
}
}
code >>= bits;
remainingBits -= bits;
}
while (remainingBits != 0);
}
private void writeComments() throws IOException
{
if (getNumComments() < 1)
{
return;
}
for (int commentIndex = 0; commentIndex < getNumComments(); commentIndex++)
{
String comment = getComment(commentIndex);
byte[] data = comment.getBytes();
out.write(0x21); // extension introducer
out.write(0xfe); // comment label
int offset = 0;
while (offset < data.length)
{
int number = Math.min(data.length - offset, 255);
out.write(number);
out.write(data, offset, number);
offset += number;
}
out.write(0); // zero-length block
}
}
/**
* Writes a global header, a global palette and
* an image descriptor to output.
*/
private void writeHeader() throws IOException
{
// pick a GIF version; stay with 87a if possible (no comments included
// which require 89a)
byte[] magic;
if (getNumComments() > 0)
{
magic = MAGIC_GIF89A;
}
else
{
magic = MAGIC_GIF87A;
}
// global header
out.write(magic);
writeShort(width);
writeShort(height);
int depth = bitsPerPixel - 1;
/* meaning of packed byte
128 => there is a global palette following
(depth << 4) => the number of bits used for encoding
depth - 1 => the number of bits in the global palette (same as for encoding) */
int packed = 128 | (depth << 4) | depth;
out.write(packed);
out.write(backgroundColor);
int pixelAspectRatio = 0;
out.write(pixelAspectRatio);
// global palette
writePalette();
// write textual comments (if any) to file as extension blocks
writeComments();
// image descriptor
out.write(44); // comma
writeShort(0); // x1
writeShort(0); // y1
writeShort(width); // width
writeShort(height); // height
packed = 0;
if (isInterlaced())
{
packed |= 64;
}
out.write(packed); // flags
}
private void writeImage() throws IOException
{
out.write(initialCodeSize);
resetBlock();
resetEncoder();
writeCode(clearCode);
int suffixChar = getNextSample();
int prefixCode = suffixChar;
do
{
suffixChar = getNextSample();
int d = 1;
int hashIndex = (prefixCode ^ (suffixChar << 5)) % 5003;
boolean endInnerLoop;
do
{
if (currentCode[hashIndex] == 0)
{
writeCode(prefixCode);
d = freeCode;
if (freeCode <= 4095)
{
oldCode[hashIndex] = prefixCode;
newCode[hashIndex] = suffixChar;
currentCode[hashIndex] = freeCode;
freeCode++;
}
if (d > maxCode)
{
if (codeSize < 12)
{
codeSize++;
maxCode = (1 << codeSize) - 1;
}
else
{
writeCode(clearCode);
resetEncoder();
}
}
prefixCode = suffixChar;
break;
}
if (oldCode[hashIndex] == prefixCode && newCode[hashIndex] == suffixChar)
{
prefixCode= currentCode[hashIndex];
endInnerLoop = true;
}
else
{
hashIndex += d;
d += 2;
if (hashIndex > 5003)
{
hashIndex -= 5003;
}
endInnerLoop = false;
}
}
while (!endInnerLoop);
}
while (notFinished);
writeCode(prefixCode);
writeCode(endOfInformationCode);
writeBlock();
}
private void writePalette() throws IOException
{
PixelImage image = getImage();
if (image instanceof Paletted8Image)
{
Palette palette = ((Paletted8Image)image).getPalette();
int numEntries = 1 << bitsPerPixel;
for (int i = 0; i < numEntries; i++)
{
if (i < palette.getNumEntries())
{
out.write(palette.getSample(RGBIndex.INDEX_RED, i));
out.write(palette.getSample(RGBIndex.INDEX_GREEN, i));
out.write(palette.getSample(RGBIndex.INDEX_BLUE, i));
}
else
{
out.write(0);
out.write(0);
out.write(0);
}
}
}
else
if (image instanceof Gray8Image)
{
for (int i = 0; i < 256; i++)
{
out.write(i);
out.write(i);
out.write(i);
}
}
else
if (image instanceof BilevelImage)
{
out.write(0);
out.write(0);
out.write(0);
out.write(255);
out.write(255);
out.write(255);
}
}
private void writeShort(int value) throws IOException
{
out.write(value & 0xff);
out.write((value >> 8) & 0xff);
}
private void writeStream() throws IOException
{
initEncoding();
writeHeader();
writeImage();
writeTrailer();
}
private void writeTrailer() throws IOException
{
out.write(0); // zero-length block
out.write(59); // semicolon
}
}