gov/nasa/worldwind/formats/dds/DDSConverter.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind.formats.dds;
   8
   9 import gov.nasa.worldwind.util.*;
  10
  11 import java.awt.image.*;
  12 import java.io.*;
  13 import java.nio.*;
  14
  15 /**
  16  * @author Tom Gaskins
  17  * @version $Id: DDSConverter.java 2471 2007-07-31 21:50:57Z tgaskins $
  18  */
  19 public class DDSConverter
  20 {
  21     private static final int DDSD_CAPS = 0x0001;
  22     private static final int DDSD_HEIGHT = 0x0002;
  23     private static final int DDSD_WIDTH = 0x0004;
  24     private static final int DDSD_PIXELFORMAT = 0x1000;
  25     private static final int DDSD_MIPMAPCOUNT = 0x20000;
  26     private static final int DDSD_LINEARSIZE = 0x80000;
  27     private static final int DDPF_FOURCC = 0x0004;
  28     private static final int DDSCAPS_TEXTURE = 0x1000;
  29
  30     protected static class Color
  31     {
  32         private int r, g, b;
  33
  34         public Color()
  35         {
  36             this.r = this.g = this.b = 0;
  37         }
  38
  39         public Color(int r, int g, int b)
  40         {
  41             this.r = r;
  42             this.g = g;
  43             this.b = b;
  44         }
  45
  46         public boolean equals(Object o)
  47         {
  48             if (this == o)
  49                 return true;
  50             if (o == null || getClass() != o.getClass())
  51                 return false;
  52
  53             final Color color = (Color) o;
  54
  55             if (b != color.b)
  56                 return false;
  57             if (g != color.g)
  58                 return false;
  59             //noinspection RedundantIfStatement
  60             if (r != color.r)
  61                 return false;
  62
  63             return true;
  64         }
  65
  66         public int hashCode()
  67         {
  68             int result;
  69             result = r;
  70             result = 29 * result + g;
  71             result = 29 * result + b;
  72             return result;
  73         }
  74     }
  75
  76     public static ByteBuffer convertToDDS(ByteBuffer image, String mimeType) throws IOException
  77     {
  78         if (image == null)
  79         {
  80             String message = Logging.getMessage("nullValue.ByteBufferIsNull");
  81             Logging.logger().severe(message);
  82             throw new IllegalArgumentException(message);
  83         }
  84
  85         if (mimeType == null)
  86         {
  87             String message = Logging.getMessage("nullValue.MimeTypeIsNull");
  88             Logging.logger().severe(message);
  89             throw new IllegalArgumentException(message);
  90         }
  91
  92         String suffix = WWIO.getSuffixForMimeType(mimeType);
  93         if (suffix == null)
  94         {
  95             String message = Logging.getMessage("DDSConverter.UnsupportedMimeType", mimeType);
  96             Logging.logger().severe(message);
  97             throw new IllegalArgumentException(message);
  98         }
  99
 100         File tempFile = WWIO.saveBufferToTempFile(image, suffix);
 101
 102         return convertToDDS(tempFile);
 103     }
 104
 105     public static ByteBuffer convertToDDS(File file) throws IOException
 106     {
 107         if (file == null)
 108         {
 109             String message = Logging.getMessage("nullValue.FileIsNull");
 110             Logging.logger().severe(message);
 111             throw new IllegalArgumentException(message);
 112         }
 113
 114         if (!file.exists() || !file.canRead())
 115         {
 116             String message = Logging.getMessage("DDSConverter.NoFileOrNoPermission");
 117             Logging.logger().severe(message);
 118             throw new IllegalArgumentException(message);
 119         }
 120
 121         java.awt.image.BufferedImage image = javax.imageio.ImageIO.read(file);
 122         if (image == null)
 123         {
 124             return null;
 125         }
 126
 127         // Don't waste the space for transparency if
 128         if (image.getColorModel().hasAlpha())
 129             return convertToDxt3(image);
 130         else
 131             return convertToDxt1NoTransparency(image);
 132     }
 133
 134     public static ByteBuffer convertToDxt1NoTransparency(ByteBuffer image, String mimeType)
 135         throws IOException
 136     {
 137         if (image == null)
 138         {
 139             String message = Logging.getMessage("nullValue.ByteBufferIsNull");
 140             Logging.logger().severe(message);
 141             throw new IllegalArgumentException(message);
 142         }
 143
 144         if (mimeType == null)
 145         {
 146             String message = Logging.getMessage("nullValue.MimeTypeIsNull");
 147             Logging.logger().severe(message);
 148             throw new IllegalArgumentException(message);
 149         }
 150
 151         String suffix = WWIO.getSuffixForMimeType(mimeType);
 152         if (suffix == null)
 153         {
 154             String message = Logging.getMessage("DDSConverter.UnsupportedMimeType", mimeType);
 155             Logging.logger().severe(message);
 156             throw new IllegalArgumentException(message);
 157         }
 158
 159         File tempFile = WWIO.saveBufferToTempFile(image, suffix);
 160
 161         return convertToDxt1NoTransparency(tempFile);
 162     }
 163
 164     public static ByteBuffer convertToDxt1NoTransparency(File file) throws IOException
 165     {
 166         if (file == null)
 167         {     //
 168             String message = Logging.getMessage("nullValue.FileIsNull");
 169             Logging.logger().severe(message);
 170             throw new IllegalArgumentException(message);
 171         }
 172
 173         if (!file.exists() || !file.canRead())
 174         {
 175             String message = Logging.getMessage("DDSConverter.NoFileOrNoPermission");
 176             Logging.logger().severe(message);
 177             throw new IllegalArgumentException(message);
 178         }
 179
 180         java.awt.image.BufferedImage image = javax.imageio.ImageIO.read(file);
 181
 182         if (image == null)
 183         {
 184             return null; // TODO: logger
 185         }
 186
 187         return convertToDxt1NoTransparency(image);
 188     }
 189
 190     public static ByteBuffer convertToDxt1NoTransparency(BufferedImage image)
 191     {
 192         if (image == null)
 193         {
 194             return null;
 195         }
 196
 197         int[] pixels = new int[16];
 198         int bufferSize = 128 + image.getWidth() * image.getHeight() / 2;
 199         ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
 200         buffer.order(ByteOrder.LITTLE_ENDIAN);
 201         buildHeaderDxt1(buffer, image.getWidth(), image.getHeight());
 202
 203         int numTilesWide = image.getWidth() / 4;
 204         int numTilesHigh = image.getHeight() / 4;
 205         for (int i = 0; i < numTilesHigh; i++)
 206         {
 207             for (int j = 0; j < numTilesWide; j++)
 208             {
 209                 java.awt.image.BufferedImage originalTile = image.getSubimage(j * 4, i * 4, 4, 4);
 210                 originalTile.getRGB(0, 0, 4, 4, pixels, 0, 4);
 211                 Color[] colors = getColors888(pixels);
 212
 213                 for (int k = 0; k < pixels.length; k++)
 214                 {
 215                     pixels[k] = getPixel565(colors[k]);
 216                     colors[k] = getColor565(pixels[k]);
 217                 }
 218
 219                 int[] extremaIndices = determineExtremeColors(colors);
 220                 if (pixels[extremaIndices[0]] < pixels[extremaIndices[1]])
 221                 {
 222                     int t = extremaIndices[0];
 223                     extremaIndices[0] = extremaIndices[1];
 224                     extremaIndices[1] = t;
 225                 }
 226
 227                 buffer.putShort((short) pixels[extremaIndices[0]]);
 228                 buffer.putShort((short) pixels[extremaIndices[1]]);
 229
 230                 long bitmask = computeBitMask(colors, extremaIndices);
 231                 buffer.putInt((int) bitmask);
 232             }
 233         }
 234
 235         return buffer;
 236     }
 237
 238     public static ByteBuffer convertToDxt3(ByteBuffer image, String mimeType)
 239         throws IOException
 240     {
 241         if (image == null)
 242         {
 243             String message = Logging.getMessage("nullValue.ByteBufferIsNull");
 244             Logging.logger().severe(message);
 245             throw new IllegalArgumentException(message);
 246         }
 247
 248         if (mimeType == null)
 249         {
 250             String message = Logging.getMessage("nullValue.MimeTypeIsNull");
 251             Logging.logger().severe(message);
 252             throw new IllegalArgumentException(message);
 253         }
 254
 255         String suffix = WWIO.getSuffixForMimeType(mimeType);
 256         if (suffix == null)
 257         {
 258             String message = Logging.getMessage("DDSConverter.UnsupportedMimeType", mimeType);
 259             Logging.logger().severe(message);
 260             throw new IllegalArgumentException(message);
 261         }
 262
 263         File tempFile = WWIO.saveBufferToTempFile(image, suffix);
 264
 265         return convertToDxt3(tempFile);
 266     }
 267
 268     public static ByteBuffer convertToDxt3(File file) throws IOException
 269     {
 270         if (file == null)
 271         {
 272             String message = Logging.getMessage("nullValue.FileIsNull");
 273             Logging.logger().severe(message);
 274             throw new IllegalArgumentException(message);
 275         }
 276
 277         if (!file.exists() || !file.canRead())
 278         {
 279             String message = Logging.getMessage("DDSConverter.NoFileOrNoPermission");
 280             Logging.logger().severe(message);
 281             throw new IllegalArgumentException(message);
 282         }
 283
 284         java.awt.image.BufferedImage image = javax.imageio.ImageIO.read(file);
 285         if (image == null)
 286         {
 287             return null;
 288         }
 289
 290         return convertToDxt3(image);
 291     }
 292
 293     public static ByteBuffer convertToDxt3(BufferedImage image)
 294     {
 295         if (image == null)
 296             return null; // TODO: arg check
 297
 298         // Don't waste the space for transparency if
 299         if (!image.getColorModel().hasAlpha())
 300             return convertToDxt1NoTransparency(image);
 301
 302         int[] pixels = new int[16];
 303         int bufferSize = 128 + image.getWidth() * image.getHeight();
 304         ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
 305         buffer.order(ByteOrder.LITTLE_ENDIAN);
 306         buildHeaderDxt3(buffer, image.getWidth(), image.getHeight());
 307
 308         int numTilesWide = image.getWidth() / 4;
 309         int numTilesHigh = image.getHeight() / 4;
 310         for (int i = 0; i < numTilesHigh; i++)
 311         {
 312             for (int j = 0; j < numTilesWide; j++)
 313             {
 314                 java.awt.image.BufferedImage originalTile = image.getSubimage(j * 4, i * 4, 4, 4);
 315                 originalTile.getRGB(0, 0, 4, 4, pixels, 0, 4);
 316                 Color[] colors = getColors888(pixels);
 317
 318                 // Store the alhpa table.
 319                 for (int k = 0; k < pixels.length; k += 2)
 320                 {
 321                     buffer.put((byte) ((pixels[k] >>> 24) | (pixels[k + 1] >>> 28)));
 322                 }
 323
 324                 for (int k = 0; k < pixels.length; k++)
 325                 {
 326                     pixels[k] = getPixel565(colors[k]);
 327                     colors[k] = getColor565(pixels[k]);
 328                 }
 329
 330                 int[] extremaIndices = determineExtremeColors(colors);
 331                 if (pixels[extremaIndices[0]] < pixels[extremaIndices[1]])
 332                 {
 333                     int t = extremaIndices[0];
 334                     extremaIndices[0] = extremaIndices[1];
 335                     extremaIndices[1] = t;
 336                 }
 337
 338                 buffer.putShort((short) pixels[extremaIndices[0]]);
 339                 buffer.putShort((short) pixels[extremaIndices[1]]);
 340
 341                 long bitmask = computeBitMask(colors, extremaIndices);
 342                 buffer.putInt((int) bitmask);
 343             }
 344         }
 345
 346         return buffer;
 347     }
 348
 349     protected static void buildHeaderDxt1(ByteBuffer buffer, int width, int height)
 350     {
 351         buffer.rewind();
 352         buffer.put((byte) 'D');
 353         buffer.put((byte) 'D');
 354         buffer.put((byte) 'S');
 355         buffer.put((byte) ' ');
 356         buffer.putInt(124);
 357         int flag = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_MIPMAPCOUNT | DDSD_LINEARSIZE;
 358         buffer.putInt(flag);
 359         buffer.putInt(height);
 360         buffer.putInt(width);
 361         buffer.putInt(width * height / 2);
 362         buffer.putInt(0); // depth
 363         buffer.putInt(0); // mipmap count
 364         buffer.position(buffer.position() + 44); // 11 unused double-words
 365         buffer.putInt(32); // pixel format size
 366         buffer.putInt(DDPF_FOURCC);
 367         buffer.put((byte) 'D');
 368         buffer.put((byte) 'X');
 369         buffer.put((byte) 'T');
 370         buffer.put((byte) '1');
 371         buffer.putInt(0); // bits per pixel for RGB (non-compressed) formats
 372         buffer.putInt(0); // rgb bit masks for RGB formats
 373         buffer.putInt(0); // rgb bit masks for RGB formats
 374         buffer.putInt(0); // rgb bit masks for RGB formats
 375         buffer.putInt(0); // alpha mask for RGB formats
 376         buffer.putInt(DDSCAPS_TEXTURE);
 377         buffer.putInt(0); // ddsCaps2
 378         buffer.position(buffer.position() + 12); // 3 unused double-words
 379     }
 380
 381     protected static void buildHeaderDxt3(ByteBuffer buffer, int width, int height)
 382     {
 383         buffer.rewind();
 384         buffer.put((byte) 'D');
 385         buffer.put((byte) 'D');
 386         buffer.put((byte) 'S');
 387         buffer.put((byte) ' ');
 388         buffer.putInt(124);
 389         int flag = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_MIPMAPCOUNT | DDSD_LINEARSIZE;
 390         buffer.putInt(flag);
 391         buffer.putInt(height);
 392         buffer.putInt(width);
 393         buffer.putInt(width * height);
 394         buffer.putInt(0); // depth
 395         buffer.putInt(0); // mipmap count
 396         buffer.position(buffer.position() + 44); // 11 unused double-words
 397         buffer.putInt(32); // pixel format size
 398         buffer.putInt(DDPF_FOURCC);
 399         buffer.put((byte) 'D');
 400         buffer.put((byte) 'X');
 401         buffer.put((byte) 'T');
 402         buffer.put((byte) '3');
 403         buffer.putInt(0); // bits per pixel for RGB (non-compressed) formats
 404         buffer.putInt(0); // rgb bit masks for RGB formats
 405         buffer.putInt(0); // rgb bit masks for RGB formats
 406         buffer.putInt(0); // rgb bit masks for RGB formats
 407         buffer.putInt(0); // alpha mask for RGB formats
 408         buffer.putInt(DDSCAPS_TEXTURE);
 409         buffer.putInt(0); // ddsCaps2
 410         buffer.position(buffer.position() + 12); // 3 unused double-words
 411     }
 412
 413     protected static int[] determineExtremeColors(Color[] colors)
 414     {
 415         int farthest = Integer.MIN_VALUE;
 416         int[] ex = new int[2];
 417
 418         for (int i = 0; i < colors.length - 1; i++)
 419         {
 420             for (int j = i + 1; j < colors.length; j++)
 421             {
 422                 int d = distance(colors[i], colors[j]);
 423                 if (d > farthest)
 424                 {
 425                     farthest = d;
 426                     ex[0] = i;
 427                     ex[1] = j;
 428                 }
 429             }
 430         }
 431
 432         return ex;
 433     }
 434
 435     protected static long computeBitMask(Color[] colors, int[] extremaIndices)
 436     {
 437         Color[] colorPoints = new Color[] {null, null, new Color(), new Color()};
 438         colorPoints[0] = colors[extremaIndices[0]];
 439         colorPoints[1] = colors[extremaIndices[1]];
 440         if (colorPoints[0].equals(colorPoints[1]))
 441             return 0;
 442
 443 //        colorPoints[0].r = (colorPoints[0].r & 0xF8) | (colorPoints[0].r >> 5 );
 444 //        colorPoints[0].g = (colorPoints[0].g & 0xFC) | (colorPoints[0].g >> 6 );
 445 //        colorPoints[0].b = (colorPoints[0].b & 0xF8) | (colorPoints[0].b >> 5 );
 446 //
 447 //        colorPoints[1].r = (colorPoints[1].r & 0xF8) | (colorPoints[1].r >> 5 );
 448 //        colorPoints[1].g = (colorPoints[1].g & 0xFC) | (colorPoints[1].g >> 6 );
 449 //        colorPoints[1].b = (colorPoints[1].b & 0xF8) | (colorPoints[1].b >> 5 );
 450
 451         colorPoints[2].r = (2 * colorPoints[0].r + colorPoints[1].r + 1) / 3;
 452         colorPoints[2].g = (2 * colorPoints[0].g + colorPoints[1].g + 1) / 3;
 453         colorPoints[2].b = (2 * colorPoints[0].b + colorPoints[1].b + 1) / 3;
 454         colorPoints[3].r = (colorPoints[0].r + 2 * colorPoints[1].r + 1) / 3;
 455         colorPoints[3].g = (colorPoints[0].g + 2 * colorPoints[1].g + 1) / 3;
 456         colorPoints[3].b = (colorPoints[0].b + 2 * colorPoints[1].b + 1) / 3;
 457
 458         long bitmask = 0;
 459         for (int i = 0; i < colors.length; i++)
 460         {
 461             int closest = Integer.MAX_VALUE;
 462             int mask = 0;
 463             for (int j = 0; j < colorPoints.length; j++)
 464             {
 465                 int d = distance(colors[i], colorPoints[j]);
 466                 if (d < closest)
 467                 {
 468                     closest = d;
 469                     mask = j;
 470                 }
 471             }
 472             bitmask |= mask << i * 2;
 473         }
 474
 475         return bitmask;
 476     }
 477
 478     protected static int getPixel565(Color color)
 479     {
 480         int r = color.r >> 3;
 481         int g = color.g >> 2;
 482         int b = color.b >> 3;
 483         return r << 11 | g << 5 | b;
 484     }
 485
 486     protected static Color getColor565(int pixel)
 487     {
 488         Color color = new Color();
 489
 490         color.r = (int) (((long) pixel) & 0xf800) >> 11;
 491         color.g = (int) (((long) pixel) & 0x07e0) >> 5;
 492         color.b = (int) (((long) pixel) & 0x001f);
 493
 494         return color;
 495     }
 496
 497     protected static Color getColor888(int r8g8b8)
 498     {
 499         return new Color(
 500             (int) (((long) r8g8b8) & 0xff0000) >> 16,
 501             (int) (((long) r8g8b8) & 0x00ff00) >> 8,
 502             (int) (((long) r8g8b8) & 0x0000ff)
 503         );
 504     }
 505
 506     protected static Color[] getColors888(int[] pixels)
 507     {
 508         Color[] colors = new Color[pixels.length];
 509
 510         for (int i = 0; i < pixels.length; i++)
 511         {
 512             colors[i] = new Color();
 513             colors[i].r = (int) (((long) pixels[i]) & 0xff0000) >> 16;
 514             colors[i].g = (int) (((long) pixels[i]) & 0x00ff00) >> 8;
 515             colors[i].b = (int) (((long) pixels[i]) & 0x0000ff);
 516         }
 517
 518         return colors;
 519     }
 520
 521     protected static int distance(Color ca, Color cb)
 522     {
 523         return (cb.r - ca.r) * (cb.r - ca.r) + (cb.g - ca.g) * (cb.g - ca.g) + (cb.b - ca.b) * (cb.b - ca.b);
 524     }
 525
 526     protected static void equalTransparentCase(TransparentColor[] colors, int[] extremaIndices, short value)
 527     {
 528         // we want extremaIndices[0] to be greater than extremaIndices[1]
 529
 530         if (value == 0)
 531         {
 532             // transparent
 533             colors[extremaIndices[0]] = TransparentColor.OFF_TRANSPARENT;
 534         }
 535         /*else
 536         {
 537             // not transparent anywhere - it's all one colour, so we don't need to bother making changes
 538         }*/
 539
 540     }
 541
 542     protected static int distance(TransparentColor ca, TransparentColor cb)
 543     {
 544         return (cb.r - ca.r) * (cb.r - ca.r) + (cb.g - ca.g) * (cb.g - ca.g) + (cb.b - ca.b) * (cb.b - ca.b)
 545             + (cb.a - ca.a) * (cb.a - ca.a);
 546     }
 547
 548 //    public static void main(String[] args)
 549 //    {
 550 //        try
 551 //        {
 552 //            String fileName = "testdata/0000_0001";
 553 //            ByteBuffer buffer = convertToDxt1NoTransparency(new File(fileName + ".jpg"));
 554 //            buffer.rewind();
 555 //            FileOutputStream fos = new FileOutputStream(fileName + ".dds");
 556 //            channels.FileChannel channel = fos.getChannel();
 557 //            channel.write(buffer);
 558 //        }
 559 //        catch (IOException e)
 560 //        {
 561 //            e.printStackTrace();
 562 //        }
 563 //
 564 //        return;
 565 //    }
 566
 567     protected static long computeBitMask(TransparentColor[] colors, int[] extremaIndices)
 568     {
 569         TransparentColor[] colorPoints = {null, null, new TransparentColor(), new TransparentColor()};
 570
 571         colorPoints[0] = colors[extremaIndices[0]];
 572         colorPoints[1] = colors[extremaIndices[1]];
 573
 574         colorPoints[2].r = (colorPoints[0].r + colorPoints[1].r) / 2;
 575         colorPoints[2].g = (colorPoints[0].g + colorPoints[1].g) / 2;
 576         colorPoints[2].b = (colorPoints[0].b + colorPoints[1].b) / 2;
 577         colorPoints[2].a = 1;
 578
 579         colorPoints[3].r = 0;
 580         colorPoints[3].g = 0;
 581         colorPoints[3].b = 0;
 582         colorPoints[3].a = 0;
 583
 584         long bitmask = 0;
 585         for (int i = 0; i < colors.length; i++)
 586         {
 587             int closest = Integer.MAX_VALUE;
 588             int mask = 0;
 589             if (colors[i].a == 0)
 590             {
 591                 mask = 3;
 592             }
 593             else
 594             {
 595                 for (int j = 0; j < colorPoints.length; j++)
 596                 {
 597                     int d = distance(colors[i], colorPoints[j]);
 598                     if (d < closest)
 599                     {
 600                         closest = d;
 601                         mask = j;
 602                     }
 603                 }
 604             }
 605             bitmask |= mask << i * 2;
 606         }
 607
 608         return bitmask;
 609     }
 610
 611     protected static short getShort5551(TransparentColor color)
 612     {
 613         short s = 0;
 614         s |= ((color.r & 0x0f8) << 8) | ((color.g & 0x0f8) << 4) | ((color.b & 0x0f8) >> 3) | ((color.a & 0x0f8) >> 7);
 615 //        System.out.println(Integer.toBinaryString(s));
 616         return s;
 617     }
 618
 619     protected static int[] determineExtremeColors(TransparentColor[] colors)
 620     {
 621         int farthest = Integer.MIN_VALUE;
 622         int[] ex = {0, 0};
 623
 624         for (int i = 0; i < colors.length - 1; i++)
 625         {
 626             for (int j = i + 1; j < colors.length; j++)
 627             {
 628                 int d = distance(colors[i], colors[j]);
 629                 if (d > farthest)
 630                 {
 631                     farthest = d;
 632                     ex[0] = i;
 633                     ex[1] = j;
 634                 }
 635             }
 636         }
 637
 638         return ex;
 639     }
 640
 641     protected static TransparentColor[] getColors5551(int[] pixels)
 642     {
 643         TransparentColor colors[] = new TransparentColor[pixels.length];
 644
 645         for (int i = 0; i < pixels.length; i++)
 646         {
 647             colors[i] = generateColor5551(pixels[i]);
 648         }
 649         return colors;
 650     }
 651
 652     protected static TransparentColor generateColor5551(int pixel)
 653     {
 654         short alpha = (short) (pixel >> 24);
 655         if ((alpha & 0xf0) == 0)
 656         {
 657             return TransparentColor.TRANSPARENT;
 658         }
 659
 660         // ok, it's not transparent - that's already been ruled out.
 661
 662         TransparentColor tc = new TransparentColor();
 663         tc.a = 0x000000ff;
 664         tc.r = (pixel & 0x00ff0000) >> 16;
 665         tc.g = (pixel & 0x0000ff00) >> 8;
 666         tc.b = (pixel & 0x000000ff);
 667
 668         return tc;
 669     }
 670
 671     protected static class TransparentColor
 672     {
 673         private static final TransparentColor TRANSPARENT = new TransparentColor(0, 0, 0, 0);
 674         private static final TransparentColor OFF_TRANSPARENT = new TransparentColor(0, 0, 1, 0);
 675         private int r, g, b, a;
 676
 677         private TransparentColor()
 678         {
 679         }
 680
 681         private TransparentColor(int r, int g, int b, int a)
 682         {
 683             this.r = r;
 684             this.g = g;
 685             this.b = b;
 686             this.a = a;
 687         }
 688
 689         public boolean equals(Object o)
 690         {
 691             if (this == o)
 692                 return true;
 693             if (o == null || getClass() != o.getClass())
 694                 return false;
 695
 696             final TransparentColor that =
 697                 (TransparentColor) o;
 698
 699             if (a != that.a)
 700                 return false;
 701             if (b != that.b)
 702                 return false;
 703             if (g != that.g)
 704                 return false;
 705             //noinspection RedundantIfStatement
 706             if (r != that.r)
 707                 return false;
 708
 709             return true;
 710         }
 711
 712         public int hashCode()
 713         {
 714             int result;
 715             result = r;
 716             result = 29 * result + g;
 717             result = 29 * result + b;
 718             result = 29 * result + a;
 719             return result;
 720         }
 721
 722         public String toString()
 723         {
 724             return "TransColor argb: " + this.a + ", " + this.r + ", " + this.g + ", " + this.b;
 725         }
 726     }
 727 }