//**************************************************************// //******************** Color Block Luminance Distance ********// //**************************************************************// protected static void findMinMaxColorsLuminanceDistance(ColorBlock4x4 block, Color32 minColor, Color32 maxColor) { int minLuminance = Integer.MAX_VALUE; int maxLuminance = -1; int minIndex = 0; int maxIndex = 0; for (int i = 0; i < 16; i++) { int luminance = colorLuminance(block.color[i]); if (luminance < minLuminance) { minIndex = i; minLuminance = luminance; } if (luminance > maxLuminance) { maxIndex = i; maxLuminance = luminance; } } copyColorComponents(block.color[minIndex], minColor); copyColorComponents(block.color[maxIndex], maxColor); }
/** * 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); } } }
//**************************************************************// //******************** Color Block Box Fitting ***************// //**************************************************************// protected static void findMinMaxColorsBox(ColorBlock4x4 block, Color32 minColor, Color32 maxColor) { minColor.r = minColor.g = minColor.b = 255; maxColor.r = maxColor.g = maxColor.b = 0; for (int i = 0; i < 16; i++) { minColorComponents(minColor, block.color[i], minColor); maxColorComponents(maxColor, block.color[i], maxColor); } }
protected bool blockHasDXT1Alpha(ColorBlock4x4 colorBlock, int alphaThreshold) { // DXT1 provides support for binary alpha. Therefore we determine treat a color block as needing alpha support // if any of the alpha values are less than a certain threshold. for (int i = 0; i < 16; i++) { if (colorBlock.color[i].a < alphaThreshold) { return(true); } } return(false); }
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); }
protected static void selectDiagonal(ColorBlock4x4 block, Color32 minColor, Color32 maxColor) { int centerR = (minColor.r + maxColor.r) / 2; int centerG = (minColor.g + maxColor.g) / 2; int centerB = (minColor.b + maxColor.b) / 2; int cvx = 0; int cvy = 0; for (int i = 0; i < 16; i++) { int tx = block.color[i].r - centerR; int ty = block.color[i].g - centerG; int tz = block.color[i].b - centerB; cvx += tx * tz; cvy += ty * tz; } int x0 = minColor.r; int y0 = minColor.g; int x1 = maxColor.r; int y1 = maxColor.g; if (cvx < 0) { int tmp = x0; x0 = x1; x1 = tmp; } if (cvy < 0) { int tmp = y0; y0 = y1; y1 = tmp; } minColor.r = x0; minColor.g = y0; maxColor.r = x1; maxColor.g = y1; }
/** * 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); } }
//**************************************************************// //******************** Color Block Euclidean Distance ********// //**************************************************************// protected static void findMinMaxColorsEuclideanDistance(ColorBlock4x4 block, Color32 minColor, Color32 maxColor) { double maxDistance = -1.0; int minIndex = 0; int maxIndex = 0; for (int i = 0; i < 15; i++) { for (int j = i + 1; j < 16; j++) { double d = colorDistanceSquared(block.color[i], block.color[j]); if (d > maxDistance) { minIndex = i; maxIndex = j; maxDistance = d; } } } copyColorComponents(block.color[minIndex], minColor); copyColorComponents(block.color[maxIndex], maxColor); }
//**************************************************************// //******************** Alpha Block Assembly ******************// //**************************************************************// protected static long computeAlphaValueMask(ColorBlock4x4 colorBlock) { // Alpha is encoded as 4 bit values. Each pair of values will be packed into one byte. The first value goes // in bits 0-4, and the second value goes in bits 5-8. The resultant 64 bit value is structured so that when // converted to little endian ordering, the alpha values will be in the correct order. Here's what the // structure looks like packed into Java's long, where the value aN represents the Nth alpha value in // hexadecimal notation. // // | 63-56 | 55-48 | 47-40 | 39-32 | 31-24 | 23-16 | 15-8 | 7-0 | // | aFaE | aDaC | aBaA | a9a8 | a7a6 | a5a4 | a3a2 | a1a0 | long bitmask = 0L; for (int i = 0; i < 8; i++) { int a0 = 0xF & alpha4FromAlpha8(colorBlock.color[2 * i].a); int a1 = 0xF & alpha4FromAlpha8(colorBlock.color[2 * i + 1].a); long mask10 = (a1 << 4) | a0; bitmask |= (mask10 << (8 * i)); } return(bitmask); }
protected static long computePaletteIndices4(ColorBlock4x4 block, Color32[] palette) { // This implementation is based on the paper by J.M.P. van Waveren: // http://cache-www.intel.com/cd/00/00/32/43/324337_324337.pdf // // We compare the sums of absolute differences, and choose the nearest color index. We avoid conditional // branching to determine the nearest index, which would suffer from a lot of branch mispredition. Instead, // we compute each distance and derive a 2-bit binary index directly from the results of the distance // comparisons. 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]); int d3 = colorDistanceSquared(palette[3], block.color[i]); int b0 = greaterThan(d0, d3); int b1 = greaterThan(d1, d2); int b2 = greaterThan(d0, d2); int b3 = greaterThan(d1, d3); int b4 = greaterThan(d2, d3); int x0 = b1 & b2; int x1 = b0 & b3; int x2 = b0 & b4; index = (x2 | ((x0 | x1) << 1)); mask |= (index << (i << 1)); } return(mask); }
/** * 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]); } } }
protected void compressBlockDXT3a(ColorBlock4x4 colorBlock, AlphaBlockDXT3 dxtBlock) { dxtBlock.alphaValueMask = computeAlphaValueMask(colorBlock); }