/** * Compress the 4x4 color block into a DXT2/DXT3 block using 16 4 bit alpha values, and four colors. This method * compresses the color block exactly as a DXT1 compressor, except that it guarantees that the DXT1 block will use * four colors. * <p/> * Access to this method must be synchronized by the caller. This method is frequently invoked by the DXT * compressor, so in order to reduce garbage each instance of this class has unsynchronized properties that are * reused during each call. * * @param colorBlock the 4x4 color block to compress. * @param attributes attributes that will control the compression. * @param dxtBlock the DXT2/DXT3 block that will receive the compressed data. * @throws ArgumentException if either <code>colorBlock</code> or <code>dxtBlock</code> are null. */ public void compressBlockDXT3(ColorBlock4x4 colorBlock, DXTCompressionAttributes attributes, BlockDXT3 dxtBlock) { if (colorBlock == null) { String message = Logging.getMessage("nullValue.ColorBlockIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } if (attributes == null) { String message = Logging.getMessage("nullValue.AttributesIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } if (dxtBlock == null) { String message = Logging.getMessage("nullValue.DXTBlockIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } // The DXT3 color block is compressed exactly like the DXT1 color block, except that the four color palette is // always used, no matter the ordering of color0 and color1. At this stage we only consider color values, // not alpha. this.dxt1Compressor.compressBlockDXT1(colorBlock, attributes, dxtBlock.colorBlock); // The DXT3 alpha block can be compressed separately. this.compressBlockDXT3a(colorBlock, dxtBlock.alphaBlock); }
public void compressImage(java.awt.image.BufferedImage image, DXTCompressionAttributes attributes, java.nio.ByteBuffer buffer) { if (image == null) { String message = Logging.getMessage("nullValue.ImageIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } if (attributes == null) { String message = Logging.getMessage("nullValue.AttributesIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } if (buffer == null) { String message = Logging.getMessage("nullValue.BufferNull"); Logging.logger().severe(message); throw new ArgumentException(message); } // If it is determined that the image and block have no alpha component, then we compress with DXT1 using a // four color palette. Otherwise, we use the three color palette (with the fourth color as transparent black). ColorBlock4x4 colorBlock = new ColorBlock4x4(); ColorBlockExtractor colorBlockExtractor = this.getColorBlockExtractor(image); BlockDXT1 dxt1Block = new BlockDXT1(); BlockDXT1Compressor dxt1Compressor = new BlockDXT1Compressor(); int width = image.getWidth(); int height = image.getHeight(); bool imageHasAlpha = image.getColorModel().hasAlpha(); bool enableAlpha = attributes.isEnableDXT1Alpha(); int alphaThreshold = attributes.getDXT1AlphaThreshold(); for (int j = 0; j < height; j += 4) { for (int i = 0; i < width; i += 4) { colorBlockExtractor.extractColorBlock4x4(attributes, i, j, colorBlock); if (enableAlpha && imageHasAlpha && blockHasDXT1Alpha(colorBlock, alphaThreshold)) { dxt1Compressor.compressBlockDXT1a(colorBlock, attributes, dxt1Block); } else { dxt1Compressor.compressBlockDXT1(colorBlock, attributes, dxt1Block); } buffer.putShort((short)dxt1Block.color0); buffer.putShort((short)dxt1Block.color1); buffer.putInt((int)dxt1Block.colorIndexMask); } } }
/** * Extracts a 4x4 block of pixel data at the specified coordinate <code>(x, y)</code>, and places the data in the * specified <code>colorBlock</code>. If the coordinate <code>(x, y)</code> with the image, but the entire 4x4 * block is not, this will either truncate the block to fit the image, or copy nearby pixels to fill the block. If * the <code>attributes</code> specify that color components should be premultiplied by alpha, this extactor will * perform the premultiplication operation on the incoming colors. * <p> * Access to this method must be synchronized by the caller. This method is frequenty invoked by the DXT * compressor, so in order to reduce garbage each instance of this class has unsynchronized properties that are * reused during each call. * * @param attributes the DXT compression attributes which may affect how colors are accessed. * @param x horizontal coordinate origin to extract pixel data from. * @param y vertical coordainte origin to extract pixel data from. * @param colorBlock 4x4 block of pixel data that will receive the data. * * @throws ArgumentException if either <code>attributes</code> or <code>colorBlock</code> is null. */ public void extractColorBlock4x4(DXTCompressionAttributes attributes, int x, int y, ColorBlock4x4 colorBlock) { if (attributes == null) { String message = Logging.getMessage("nullValue.AttributesIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } if (colorBlock == null) { String message = Logging.getMessage("nullValue.ColorBlockIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } // Image blocks that are smaller than 4x4 are handled by repeating the image pixels that intersect the // requested block range. int bw = Math.Min(this.width - x, 4); int bh = Math.Min(this.height - y, 4); int bxOffset = 4 * (bw - 1); int byOffset = 4 * (bh - 1); int bx, by; int blockPos = 0; // Extracts color data from the image in INT_ARGB format. So each integer in the buffer is a tightly packed // 8888 ARGB int, where the color components are not considered to be premultiplied. this.image.getRGB(x, y, bw, bh, this.buffer, 0, 4); for (int j = 0; j < 4; j++) { by = remainder[byOffset + j]; bx = remainder[bxOffset]; int32ToColor32(this.buffer[bx + by * 4], colorBlock.color[blockPos++]); bx = remainder[bxOffset + 1]; int32ToColor32(this.buffer[bx + by * 4], colorBlock.color[blockPos++]); bx = remainder[bxOffset + 2]; int32ToColor32(this.buffer[bx + by * 4], colorBlock.color[blockPos++]); bx = remainder[bxOffset + 3]; int32ToColor32(this.buffer[bx + by * 4], colorBlock.color[blockPos++]); } if (attributes.isPremultiplyAlpha()) { for (int i = 0; i < 16; i++) { premultiplyAlpha(colorBlock.color[i]); } } }
public void compressImage(java.awt.image.BufferedImage image, DXTCompressionAttributes attributes, java.nio.ByteBuffer buffer) { if (image == null) { String message = Logging.getMessage("nullValue.ImageIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } if (attributes == null) { String message = Logging.getMessage("nullValue.AttributesIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } if (buffer == null) { String message = Logging.getMessage("nullValue.BufferNull"); Logging.logger().severe(message); throw new ArgumentException(message); } ColorBlock4x4 colorBlock = new ColorBlock4x4(); ColorBlockExtractor colorBlockExtractor = this.getColorBlockExtractor(image); BlockDXT3 dxt3Block = new BlockDXT3(); BlockDXT3Compressor dxt3Compressor = new BlockDXT3Compressor(); int width = image.getWidth(); int height = image.getHeight(); for (int j = 0; j < height; j += 4) { for (int i = 0; i < width; i += 4) { colorBlockExtractor.extractColorBlock4x4(attributes, i, j, colorBlock); dxt3Compressor.compressBlockDXT3(colorBlock, attributes, dxt3Block); AlphaBlockDXT3 dxtAlphaBlock = dxt3Block.getAlphaBlock(); buffer.putLong(dxtAlphaBlock.alphaValueMask); BlockDXT1 dxtColorBlock = dxt3Block.getColorBlock(); buffer.putShort((short)dxtColorBlock.color0); buffer.putShort((short)dxtColorBlock.color1); buffer.putInt((int)dxtColorBlock.colorIndexMask); } } }
protected static long computePaletteIndices3(ColorBlock4x4 block, DXTCompressionAttributes attributes, Color32[] palette) { // This implementation is based on code available in the nvidia-texture-tools project: // http://code.google.com/p/nvidia-texture-tools/ // // If the pixel alpha is below the specified threshold, we return index 3. In a three color DXT1 palette, // index 3 is interpreted as transparent black. Otherwise, we compare the sums of absolute differences, and // choose the nearest color index. int alphaThreshold = attributes.getDXT1AlphaThreshold(); long mask = 0L; long index; for (int i = 0; i < 16; i++) { int d0 = colorDistanceSquared(palette[0], block.color[i]); int d1 = colorDistanceSquared(palette[1], block.color[i]); int d2 = colorDistanceSquared(palette[2], block.color[i]); // TODO: implement bit twiddle as in computePaletteIndex4 to avoid conditional branching if (block.color[i].a < alphaThreshold) { index = 3; } else if (d0 < d1 && d0 < d2) { index = 0; } else if (d1 < d2) { index = 1; } else { index = 2; } mask |= (index << (i << 1)); } return(mask); }
public int getCompressedSize(java.awt.image.BufferedImage image, DXTCompressionAttributes attributes) { if (image == null) { String message = Logging.getMessage("nullValue.ImageIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } if (attributes == null) { String message = Logging.getMessage("nullValue.AttributesIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } // TODO: comment, provide documentation reference int width = Math.Max(image.getWidth(), 4); int height = Math.Max(image.getHeight(), 4); return((width * height) / 2); }
/** * Compress the 4x4 color block into a DXT1 block using four colors. This method ignores transparency and * guarantees that the DXT1 block will use four colors. * <p> * Access to this method must be synchronized by the caller. This method is frequently invoked by the DXT * compressor, so in order to reduce garbage each instance of this class has unsynchronized properties that are * reused during each call. * * @param colorBlock the 4x4 color block to compress. * @param attributes attributes that will control the compression. * @param dxtBlock the DXT1 block that will receive the compressed data. * * @throws ArgumentException if either <code>colorBlock</code> or <code>dxtBlock</code> are null. */ public void compressBlockDXT1(ColorBlock4x4 colorBlock, DXTCompressionAttributes attributes, BlockDXT1 dxtBlock) { if (colorBlock == null) { String message = Logging.getMessage("nullValue.ColorBlockIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } if (attributes == null) { String message = Logging.getMessage("nullValue.AttributesIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } if (dxtBlock == null) { String message = Logging.getMessage("nullValue.DXTBlockIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } this.chooseMinMaxColors(colorBlock, attributes, this.minColor, this.maxColor); int color0 = short565FromColor32(this.maxColor); int color1 = short565FromColor32(this.minColor); if (color0 < color1) { int tmp = color0; color0 = color1; color1 = tmp; } // To get a four color palette with no alpha, the first color must be greater than the second color. computeColorPalette4(color0, color1, this.palette); dxtBlock.color0 = color0; dxtBlock.color1 = color1; dxtBlock.colorIndexMask = computePaletteIndices4(colorBlock, this.palette); }
protected void chooseMinMaxColors(ColorBlock4x4 block, DXTCompressionAttributes attributes, Color32 minColor, Color32 maxColor) { //noinspection StringEquality if (attributes.getColorBlockCompressionType() == DXTCompressionAttributes.COLOR_BLOCK_COMPRESSION_BBOX) { findMinMaxColorsBox(block, minColor, maxColor); selectDiagonal(block, minColor, maxColor); insetBox(minColor, maxColor); } else //noinspection StringEquality if (attributes.getColorBlockCompressionType() == DXTCompressionAttributes.COLOR_BLOCK_COMPRESSION_EUCLIDEAN_DISTANCE) { findMinMaxColorsEuclideanDistance(block, minColor, maxColor); } else //noinspection StringEquality if (attributes.getColorBlockCompressionType() == DXTCompressionAttributes.COLOR_BLOCK_COMPRESSION_LUMINANCE_DISTANCE) { // Default to using euclidean distance to compute the min and max palette colors. findMinMaxColorsLuminanceDistance(block, minColor, maxColor); } }
/** * Convenience method to convert the specified image <code>stream</code> to DDS according to the specified * compression <code>attributes</code>. The <code>stream</code> must be readable by {@link * javax.imageio.ImageIO#read(java.io.InputStream)}. Once the <code>stream</code> is read, this is equivalent to * calling {#compressImage(java.awt.image.BufferedImage, SharpEarth.formats.dds.DXTCompressionAttributes)} * with the BufferedImage created by ImageIO and the specified <code>attributes</code>. This returns null if the * <code>stream</code> is not in a format understood by ImageIO. * * @param inputStream image stream to convert to the DDS file format. * @param attributes attributes that control the compression. * * @return little endian ordered ByteBuffer containing the DDS file bytes, or null if the <code>stream</code> is not * in a format understood by ImageIO. * * @throws java.io.IOException if <code>stream</code> is in a format understood by ImageIO, but the image data * cannot be read by ImageIO. * @throws ArgumentException if either the <code>stream</code> or the <code>attributes</code> are null. */ public static java.nio.ByteBuffer compressImageStream(java.io.InputStream inputStream, DXTCompressionAttributes attributes) throws java.io.IOException