toolchain/gcc/libjava/java/awt/image/BufferedImage.java

   1 /* Copyright (C) 2000, 2002, 2003  Free Software Foundation
   2
   3 This file is part of GNU Classpath.
   4
   5 GNU Classpath is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 GNU Classpath is distributed in the hope that it will be useful, but
  11 WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU Classpath; see the file COPYING.  If not, write to the
  17 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18 02111-1307 USA.
  19
  20 Linking this library statically or dynamically with other modules is
  21 making a combined work based on this library.  Thus, the terms and
  22 conditions of the GNU General Public License cover the whole
  23 combination.
  24
  25 As a special exception, the copyright holders of this library give you
  26 permission to link this library with independent modules to produce an
  27 executable, regardless of the license terms of these independent
  28 modules, and to copy and distribute the resulting executable under
  29 terms of your choice, provided that you also meet, for each linked
  30 independent module, the terms and conditions of the license of that
  31 module.  An independent module is a module which is not derived from
  32 or based on this library.  If you modify this library, you may extend
  33 this exception to your version of the library, but you are not
  34 obligated to do so.  If you do not wish to do so, delete this
  35 exception statement from your version. */
  36
  37
  38 package java.awt.image;
  39
  40 import java.awt.Graphics;
  41 import java.awt.Graphics2D;
  42 import java.awt.Image;
  43 import java.awt.Point;
  44 import java.awt.Rectangle;
  45 import java.awt.Transparency;
  46 import java.awt.color.ColorSpace;
  47 import java.util.Hashtable;
  48 import java.util.Vector;
  49 import gnu.java.awt.ComponentDataBlitOp;
  50
  51 /**
  52  * A buffered image always starts at coordinates (0, 0).
  53  *
  54  * The buffered image is not subdivided into multiple tiles. Instead,
  55  * the image consists of one large tile (0,0) with the width and
  56  * height of the image. This tile is always considered to be checked
  57  * out.
  58  *
  59  * @author Rolf W. Rasmussen <rolfwr@ii.uib.no>
  60  */
  61 public class BufferedImage extends Image
  62   implements WritableRenderedImage
  63 {
  64   public static final int TYPE_CUSTOM         =  0,
  65                           TYPE_INT_RGB        =  1,
  66                           TYPE_INT_ARGB       =  2,
  67                           TYPE_INT_ARGB_PRE   =  3,
  68                           TYPE_INT_BGR        =  4,
  69                           TYPE_3BYTE_BGR      =  5,
  70                           TYPE_4BYTE_ABGR     =  6,
  71                           TYPE_4BYTE_ABGR_PRE =  7,
  72                           TYPE_USHORT_565_RGB =  8,
  73                           TYPE_USHORT_555_RGB =  9,
  74                           TYPE_BYTE_GRAY      = 10,
  75                           TYPE_USHORT_GRAY    = 11,
  76                           TYPE_BYTE_BINARY    = 12,
  77                           TYPE_BYTE_INDEXED   = 13;
  78
  79   final static int[] bits3 = { 8, 8, 8 };
  80   final static int[] bits4 = { 8, 8, 8 };
  81   final static int[] bits1byte = { 8 };
  82   final static int[] bits1ushort = { 16 };
  83
  84   final static int[] masks_int = { 0x00ff0000,
  85                                    0x0000ff00,
  86                                    0x000000ff,
  87                                    DataBuffer.TYPE_INT };
  88   final static int[] masks_565 = { 0xf800,
  89                                    0x07e0,
  90                                    0x001f,
  91                                    DataBuffer.TYPE_USHORT};
  92   final static int[] masks_555 = { 0x7c00,
  93                                    0x03e0,
  94                                    0x001f,
  95                                    DataBuffer.TYPE_USHORT};
  96
  97   Vector observers;
  98
  99   public BufferedImage(int w, int h, int type)
 100   {
 101     ColorModel cm = null;
 102
 103     boolean alpha = false;
 104     boolean premultiplied = false;
 105     switch (type)
 106       {
 107       case TYPE_4BYTE_ABGR_PRE:
 108       case TYPE_INT_ARGB_PRE:
 109         premultiplied = true;
 110         // fall through
 111       case TYPE_INT_ARGB:
 112       case TYPE_4BYTE_ABGR:
 113         alpha = true;
 114       }
 115
 116     ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
 117     switch (type)
 118       {
 119       case TYPE_INT_RGB:
 120       case TYPE_INT_ARGB:
 121       case TYPE_INT_ARGB_PRE:
 122       case TYPE_USHORT_565_RGB:
 123       case TYPE_USHORT_555_RGB:
 124         int[] masks = null;
 125         switch (type)
 126           {
 127           case TYPE_INT_RGB:
 128           case TYPE_INT_ARGB:
 129           case TYPE_INT_ARGB_PRE:
 130             masks = masks_int;
 131             break;
 132           case TYPE_USHORT_565_RGB:
 133             masks = masks_565;
 134             break;
 135           case TYPE_USHORT_555_RGB:
 136             masks = masks_555;
 137             break;
 138           }
 139
 140         cm = new DirectColorModel(cs,
 141                                   32, // 32 bits in an int
 142                                   masks[0], // r
 143                                   masks[1], // g
 144                                   masks[2], // b
 145                                   alpha ? 0xff000000 : 0,
 146                                   premultiplied,
 147                                   masks[3] // data type
 148                                   );
 149         break;
 150
 151       case TYPE_INT_BGR:
 152         String msg =
 153           "FIXME: Programmer is confused. Why (and how) does a " +
 154           "TYPE_INT_BGR image use ComponentColorModel to store " +
 155           "8-bit values? Is data type TYPE_INT or TYPE_BYTE. What " +
 156           "is the difference between TYPE_INT_BGR and TYPE_3BYTE_BGR?";
 157         throw new UnsupportedOperationException(msg);
 158
 159       case TYPE_3BYTE_BGR:
 160       case TYPE_4BYTE_ABGR:
 161       case TYPE_4BYTE_ABGR_PRE:
 162       case TYPE_BYTE_GRAY:
 163       case TYPE_USHORT_GRAY:
 164         int[] bits = null;
 165         int dataType = DataBuffer.TYPE_BYTE;
 166         switch (type) {
 167         case TYPE_3BYTE_BGR:
 168           bits = bits3;
 169           break;
 170         case TYPE_4BYTE_ABGR:
 171         case TYPE_4BYTE_ABGR_PRE:
 172           bits = bits4;
 173           break;
 174         case TYPE_BYTE_GRAY:
 175           bits = bits1byte;
 176           break;
 177         case TYPE_USHORT_GRAY:
 178           bits = bits1ushort;
 179           dataType = DataBuffer.TYPE_USHORT;
 180           break;
 181         }
 182         cm = new ComponentColorModel(cs, bits, alpha, premultiplied,
 183                                      alpha ?
 184                                      Transparency.TRANSLUCENT:
 185                                      Transparency.OPAQUE,
 186                                      dataType);
 187         break;
 188       case TYPE_BYTE_BINARY:
 189         byte[] vals = { 0, (byte) 0xff };
 190         cm = new IndexColorModel(8, 2, vals, vals, vals);
 191         break;
 192       case TYPE_BYTE_INDEXED:
 193         String msg2 = "type not implemented yet";
 194         throw new UnsupportedOperationException(msg2);
 195         // FIXME: build color-cube and create color model
 196       }
 197
 198     init(cm,
 199          cm.createCompatibleWritableRaster(w, h),
 200          premultiplied,
 201          null, // no properties
 202          type
 203          );
 204   }
 205
 206   public BufferedImage(int w, int h, int type,
 207                        IndexColorModel indexcolormodel)
 208   {
 209     if ((type != TYPE_BYTE_BINARY) && (type != TYPE_BYTE_INDEXED))
 210       throw new IllegalArgumentException("type must be binary or indexed");
 211
 212     init(indexcolormodel,
 213          indexcolormodel.createCompatibleWritableRaster(w, h),
 214          false, // not premultiplied (guess)
 215          null, // no properties
 216          type);
 217   }
 218
 219   public BufferedImage(ColorModel colormodel,
 220                        WritableRaster writableraster,
 221                        boolean premultiplied,
 222                        Hashtable properties)
 223   {
 224     init(colormodel, writableraster, premultiplied, properties,
 225          TYPE_CUSTOM);
 226     // TODO: perhaps try to identify type?
 227   }
 228
 229   WritableRaster raster;
 230   ColorModel colorModel;
 231   Hashtable properties;
 232   boolean isPremultiplied;
 233   int type;
 234
 235   private void init(ColorModel cm,
 236                     WritableRaster writableraster,
 237                     boolean premultiplied,
 238                     Hashtable properties,
 239                     int type)
 240   {
 241     raster = writableraster;
 242     colorModel = cm;
 243     this.properties = properties;
 244     isPremultiplied = premultiplied;
 245     this.type = type;
 246   }
 247
 248   //public void addTileObserver(TileObserver tileobserver) {}
 249
 250   public void coerceData(boolean premultiplied)
 251   {
 252     colorModel = colorModel.coerceData(raster, premultiplied);
 253   }
 254
 255   public WritableRaster copyData(WritableRaster dest)
 256   {
 257     if (dest == null)
 258       dest = raster.createCompatibleWritableRaster();
 259
 260     int x = dest.getMinX();
 261     int y = dest.getMinY();
 262     int w = dest.getWidth();
 263     int h = dest.getHeight();
 264
 265     // create a src child that has the right bounds...
 266     WritableRaster src =
 267       raster.createWritableChild(x, y, w, h, x, y,
 268                                  null  // same bands
 269                                  );
 270     if (src.getSampleModel () instanceof ComponentSampleModel
 271         && dest.getSampleModel () instanceof ComponentSampleModel)
 272       // Refer to ComponentDataBlitOp for optimized data blitting:
 273       ComponentDataBlitOp.INSTANCE.filter(src, dest);
 274     else
 275       {
 276         // slower path
 277         int samples[] = src.getPixels (x, y, w, h, (int [])null);
 278         dest.setPixels (x, y, w, h, samples);
 279       }
 280     return dest;
 281   }
 282
 283   public Graphics2D createGraphics()
 284   {
 285     throw new UnsupportedOperationException("not implemented");
 286     // will require a lot of effort to implement
 287   }
 288
 289   public void flush() {
 290   }
 291
 292   public WritableRaster getAlphaRaster()
 293   {
 294     return colorModel.getAlphaRaster(raster);
 295   }
 296
 297   public ColorModel getColorModel()
 298   {
 299     return colorModel;
 300   }
 301
 302   public Raster getData()
 303   {
 304     return copyData(null);
 305     /* TODO: this might be optimized by returning the same
 306        raster (not writable) as long as image data doesn't change. */
 307   }
 308
 309   public Raster getData(Rectangle rectangle)
 310   {
 311     WritableRaster dest =
 312       raster.createCompatibleWritableRaster(rectangle);
 313     return copyData(dest);
 314   }
 315
 316   public Graphics getGraphics()
 317   {
 318     return createGraphics();
 319   }
 320
 321   public int getHeight()
 322   {
 323     return raster.getHeight();
 324   }
 325
 326   public int getHeight(ImageObserver imageobserver)
 327   {
 328     return getHeight();
 329   }
 330
 331   public int getMinTileX()
 332   {
 333     return 0;
 334   }
 335
 336   public int getMinTileY()
 337   {
 338     return 0;
 339   }
 340
 341   public int getMinX()
 342   {
 343     return 0;
 344   }
 345
 346   public int getMinY()
 347   {
 348     return 0;
 349   }
 350
 351   public int getNumXTiles()
 352   {
 353     return 1;
 354   }
 355
 356   public int getNumYTiles()
 357   {
 358         return 1;
 359   }
 360
 361   public Object getProperty(String string)
 362   {
 363     if (properties == null)
 364       return null;
 365     return properties.get(string);
 366   }
 367
 368   public Object getProperty(String string, ImageObserver imageobserver)
 369   {
 370     return getProperty(string);
 371   }
 372
 373
 374   public String[] getPropertyNames()
 375   {
 376     // FIXME: implement
 377     return null;
 378   }
 379
 380   public int getRGB(int x, int y)
 381   {
 382     Object rgbElem = raster.getDataElements(x, y,
 383                                             null // create as needed
 384                                             );
 385     return colorModel.getRGB(rgbElem);
 386   }
 387
 388   public int[] getRGB(int startX, int startY, int w, int h,
 389                       int[] rgbArray,
 390                       int offset, int scanlineStride)
 391   {
 392     if (rgbArray == null)
 393     {
 394       /*
 395         000000000000000000
 396         00000[#######-----   [ = start
 397         -----########-----   ] = end
 398         -----#######]00000
 399         000000000000000000  */
 400       int size = (h-1)*scanlineStride + w;
 401       rgbArray = new int[size];
 402     }
 403
 404     int endX = startX + w;
 405     int endY = startY + h;
 406
 407     /* *TODO*:
 408        Opportunity for optimization by examining color models...
 409
 410        Perhaps wrap the rgbArray up in a WritableRaster with packed
 411        sRGB color model and perform optimized rendering into the
 412        array. */
 413
 414     Object rgbElem = null;
 415     for (int y=startY; y<endY; y++)
 416       {
 417         int xoffset = offset;
 418         for (int x=startX; x<endX; x++)
 419           {
 420             int rgb;
 421             rgbElem = raster.getDataElements(x, y, rgbElem);
 422             rgb = colorModel.getRGB(rgbElem);
 423             rgbArray[xoffset++] = rgb;
 424           }
 425         offset += scanlineStride;
 426       }
 427     return rgbArray;
 428   }
 429
 430   public WritableRaster getRaster()
 431   {
 432     return raster;
 433   }
 434
 435   public SampleModel getSampleModel()
 436   {
 437     return raster.getSampleModel();
 438   }
 439
 440   public ImageProducer getSource()
 441   {
 442     throw new UnsupportedOperationException("not implemented");
 443   }
 444
 445   public Vector getSources()
 446   {
 447     return null;
 448   }
 449
 450   public BufferedImage getSubimage(int x, int y, int w, int h)
 451   {
 452     WritableRaster subRaster =
 453       getRaster().createWritableChild(x, y, w, h, 0, 0, null);
 454
 455     return new BufferedImage(getColorModel(),
 456                              subRaster,
 457                              isPremultiplied,
 458                              properties);
 459   }
 460
 461   public Raster getTile(int tileX, int tileY)
 462   {
 463     return getWritableTile(tileX, tileY);
 464   }
 465
 466   public int getTileGridXOffset()
 467   {
 468     return 0; // according to javadocs
 469   }
 470
 471   public int getTileGridYOffset()
 472   {
 473     return 0; // according to javadocs
 474   }
 475
 476   public int getTileHeight()
 477   {
 478     return getHeight(); // image is one big tile
 479   }
 480
 481   public int getTileWidth()
 482   {
 483     return getWidth(); // image is one big tile
 484   }
 485
 486   public int getType()
 487   {
 488     return type;
 489   }
 490
 491   public int getWidth()
 492   {
 493     return raster.getWidth();
 494   }
 495
 496   public int getWidth(ImageObserver imageobserver)
 497   {
 498     return getWidth();
 499   }
 500
 501   public WritableRaster getWritableTile(int tileX, int tileY)
 502   {
 503     isTileWritable(tileX, tileY);  // for exception
 504     return raster;
 505   }
 506
 507   private static final Point[] tileIndices = { new Point() };
 508
 509   public Point[] getWritableTileIndices()
 510   {
 511     return tileIndices;
 512   }
 513
 514   public boolean hasTileWriters()
 515   {
 516     return true;
 517   }
 518
 519   public boolean isAlphaPremultiplied()
 520   {
 521     return isPremultiplied;
 522   }
 523
 524   public boolean isTileWritable(int tileX, int tileY)
 525   {
 526     if ((tileX != 0) || (tileY != 0))
 527       throw new ArrayIndexOutOfBoundsException("only tile is (0,0)");
 528     return true;
 529   }
 530
 531   public void releaseWritableTile(int tileX, int tileY)
 532   {
 533     isTileWritable(tileX, tileY);  // for exception
 534   }
 535
 536   //public void removeTileObserver(TileObserver tileobserver) {}
 537
 538   public void setData(Raster src)
 539   {
 540     int x = src.getMinX();
 541     int y = src.getMinY();
 542     int w = src.getWidth();
 543     int h = src.getHeight();
 544
 545     // create a dest child that has the right bounds...
 546     WritableRaster dest =
 547       raster.createWritableChild(x, y, w, h, x, y,
 548                                  null  // same bands
 549                                  );
 550
 551     if (src.getSampleModel () instanceof ComponentSampleModel
 552         && dest.getSampleModel () instanceof ComponentSampleModel)
 553
 554       // Refer to ComponentDataBlitOp for optimized data blitting:
 555       ComponentDataBlitOp.INSTANCE.filter(src, dest);
 556     else
 557       {
 558         // slower path
 559         int samples[] = src.getPixels (x, y, w, h, (int [])null);
 560         dest.setPixels (x, y, w, h, samples);
 561       }
 562   }
 563
 564   public void setRGB(int x, int y, int argb)
 565   {
 566     Object rgbElem = colorModel.getDataElements(argb, null);
 567     raster.setDataElements(x, y, rgbElem);
 568   }
 569
 570   public void setRGB(int startX, int startY, int w, int h,
 571                      int[] argbArray, int offset, int scanlineStride)
 572   {
 573     int endX = startX + w;
 574     int endY = startY + h;
 575
 576     Object rgbElem = null;
 577     for (int y=startY; y<endY; y++)
 578       {
 579         int xoffset = offset;
 580         for (int x=startX; x<endX; x++)
 581           {
 582             int argb = argbArray[xoffset++];
 583             rgbElem = colorModel.getDataElements(argb, rgbElem);
 584             raster.setDataElements(x, y, rgbElem);
 585           }
 586         offset += scanlineStride;
 587       }
 588   }
 589
 590   public String toString()
 591   {
 592     StringBuffer buf;
 593
 594     buf = new StringBuffer(/* estimated length */ 120);
 595     buf.append("BufferedImage@");
 596     buf.append(Integer.toHexString(hashCode()));
 597     buf.append(": type=");
 598     buf.append(type);
 599     buf.append(' ');
 600     buf.append(colorModel);
 601     buf.append(' ');
 602     buf.append(raster);
 603
 604     return buf.toString();
 605   }
 606
 607
 608   /**
 609    * Adds a tile observer. If the observer is already present, it receives
 610    * multiple notifications.
 611    *
 612    * @param to The TileObserver to add.
 613    */
 614   public void addTileObserver (TileObserver to)
 615   {
 616     if (observers == null)
 617       observers = new Vector ();
 618
 619     observers.add (to);
 620   }
 621
 622   /**
 623    * Removes a tile observer. If the observer was not registered,
 624    * nothing happens. If the observer was registered for multiple
 625    * notifications, it is now registered for one fewer notification.
 626    *
 627    * @param to The TileObserver to remove.
 628    */
 629   public void removeTileObserver (TileObserver to)
 630   {
 631     if (observers == null)
 632       return;
 633
 634     observers.remove (to);
 635   }
 636 }