old-autovect-branch/libjava/classpath/gnu/java/awt/peer/gtk/GdkPixbufDecoder.java

   1 /* GdkPixbufDecoder.java -- Image data decoding object
   2    Copyright (C) 2003, 2004, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package gnu.java.awt.peer.gtk;
  40
  41 import gnu.classpath.Configuration;
  42
  43 import java.awt.image.BufferedImage;
  44 import java.awt.image.ColorModel;
  45 import java.awt.image.DirectColorModel;
  46 import java.awt.image.ImageConsumer;
  47 import java.awt.image.ImageProducer;
  48 import java.awt.image.Raster;
  49 import java.awt.image.RenderedImage;
  50 import java.io.DataOutput;
  51 import java.io.IOException;
  52 import java.io.InputStream;
  53 import java.net.URL;
  54 import java.util.ArrayList;
  55 import java.util.Hashtable;
  56 import java.util.Iterator;
  57 import java.util.Locale;
  58 import java.util.Vector;
  59
  60 import javax.imageio.IIOImage;
  61 import javax.imageio.ImageReadParam;
  62 import javax.imageio.ImageReader;
  63 import javax.imageio.ImageTypeSpecifier;
  64 import javax.imageio.ImageWriteParam;
  65 import javax.imageio.ImageWriter;
  66 import javax.imageio.metadata.IIOMetadata;
  67 import javax.imageio.spi.IIORegistry;
  68 import javax.imageio.spi.ImageReaderSpi;
  69 import javax.imageio.spi.ImageWriterSpi;
  70 import javax.imageio.stream.ImageInputStream;
  71 import javax.imageio.stream.ImageOutputStream;
  72
  73 public class GdkPixbufDecoder extends gnu.java.awt.image.ImageDecoder
  74 {
  75   static
  76   {
  77     if (Configuration.INIT_LOAD_LIBRARY)
  78       {
  79         System.loadLibrary("gtkpeer");
  80       }
  81     initStaticState ();
  82   }
  83
  84   static native void initStaticState();
  85   private final int native_state = GtkGenericPeer.getUniqueInteger ();
  86
  87   // initState() has been called, but pumpDone() has not yet been called.
  88   private boolean needsClose = false;
  89
  90   // the current set of ImageConsumers for this decoder
  91   Vector curr;
  92
  93   // interface to GdkPixbuf
  94   native void initState ();
  95   native void pumpBytes (byte[] bytes, int len) throws IOException;
  96   native void pumpDone () throws IOException;
  97   native void finish (boolean needsClose);
  98   static native void streamImage(int[] bytes, String format, int width, int height, boolean hasAlpha, DataOutput sink);
  99
 100   // gdk-pixbuf provids data in RGBA format
 101   static final ColorModel cm = new DirectColorModel (32, 0xff000000,
 102                                                      0x00ff0000,
 103                                                      0x0000ff00,
 104                                                      0x000000ff);
 105   public GdkPixbufDecoder (InputStream in)
 106   {
 107     super (in);
 108   }
 109
 110   public GdkPixbufDecoder (String filename)
 111   {
 112     super (filename);
 113   }
 114
 115   public GdkPixbufDecoder (URL url)
 116   {
 117     super (url);
 118   }
 119
 120   public GdkPixbufDecoder (byte[] imagedata, int imageoffset, int imagelength)
 121   {
 122     super (imagedata, imageoffset, imagelength);
 123   }
 124
 125   // called back by native side: area_prepared_cb
 126   void areaPrepared (int width, int height)
 127   {
 128
 129     if (curr == null)
 130       return;
 131
 132     for (int i = 0; i < curr.size (); i++)
 133       {
 134         ImageConsumer ic = (ImageConsumer) curr.elementAt (i);
 135         ic.setDimensions (width, height);
 136         ic.setColorModel (cm);
 137         ic.setHints (ImageConsumer.RANDOMPIXELORDER);
 138       }
 139   }
 140
 141   // called back by native side: area_updated_cb
 142   void areaUpdated (int x, int y, int width, int height,
 143                     int pixels[], int scansize)
 144   {
 145     if (curr == null)
 146       return;
 147
 148     for (int i = 0; i < curr.size (); i++)
 149       {
 150         ImageConsumer ic = (ImageConsumer) curr.elementAt (i);
 151         ic.setPixels (x, y, width, height, cm, pixels, 0, scansize);
 152       }
 153   }
 154
 155   // called from an async image loader of one sort or another, this method
 156   // repeatedly reads bytes from the input stream and passes them through a
 157   // GdkPixbufLoader using the native method pumpBytes. pumpBytes in turn
 158   // decodes the image data and calls back areaPrepared and areaUpdated on
 159   // this object, feeding back decoded pixel blocks, which we pass to each
 160   // of the ImageConsumers in the provided Vector.
 161
 162   public void produce (Vector v, InputStream is) throws IOException
 163   {
 164     curr = v;
 165
 166     byte bytes[] = new byte[4096];
 167     int len = 0;
 168     initState();
 169     needsClose = true;
 170     while ((len = is.read (bytes)) != -1)
 171       pumpBytes (bytes, len);
 172     pumpDone();
 173     needsClose = false;
 174
 175     for (int i = 0; i < curr.size (); i++)
 176       {
 177         ImageConsumer ic = (ImageConsumer) curr.elementAt (i);
 178         ic.imageComplete (ImageConsumer.STATICIMAGEDONE);
 179       }
 180
 181     curr = null;
 182   }
 183
 184   public void finalize()
 185   {
 186     finish(needsClose);
 187   }
 188
 189
 190   public static class ImageFormatSpec
 191   {
 192     public String name;
 193     public boolean writable = false;
 194     public ArrayList mimeTypes = new ArrayList();
 195     public ArrayList extensions = new ArrayList();
 196
 197     public ImageFormatSpec(String name, boolean writable)
 198     {
 199       this.name = name;
 200       this.writable = writable;
 201     }
 202
 203     public synchronized void addMimeType(String m)
 204     {
 205       mimeTypes.add(m);
 206     }
 207
 208     public synchronized void addExtension(String e)
 209     {
 210       extensions.add(e);
 211     }
 212   }
 213
 214   static ArrayList imageFormatSpecs;
 215
 216   public static ImageFormatSpec registerFormat(String name, boolean writable)
 217   {
 218     ImageFormatSpec ifs = new ImageFormatSpec(name, writable);
 219     synchronized(GdkPixbufDecoder.class)
 220       {
 221         if (imageFormatSpecs == null)
 222           imageFormatSpecs = new ArrayList();
 223         imageFormatSpecs.add(ifs);
 224       }
 225     return ifs;
 226   }
 227
 228   static String[] getFormatNames(boolean writable)
 229   {
 230     ArrayList names = new ArrayList();
 231     synchronized (imageFormatSpecs)
 232       {
 233         Iterator i = imageFormatSpecs.iterator();
 234         while (i.hasNext())
 235           {
 236             ImageFormatSpec ifs = (ImageFormatSpec) i.next();
 237             if (writable && !ifs.writable)
 238               continue;
 239             names.add(ifs.name);
 240
 241             /*
 242              * In order to make the filtering code work, we need to register
 243              * this type under every "format name" likely to be used as a synonym.
 244              * This generally means "all the extensions people might use".
 245              */
 246
 247             Iterator j = ifs.extensions.iterator();
 248             while (j.hasNext())
 249               names.add((String) j.next());
 250           }
 251       }
 252     Object[] objs = names.toArray();
 253     String[] strings = new String[objs.length];
 254     for (int i = 0; i < objs.length; ++i)
 255       strings[i] = (String) objs[i];
 256     return strings;
 257   }
 258
 259   static String[] getFormatExtensions(boolean writable)
 260   {
 261     ArrayList extensions = new ArrayList();
 262     synchronized (imageFormatSpecs)
 263       {
 264         Iterator i = imageFormatSpecs.iterator();
 265         while (i.hasNext())
 266           {
 267             ImageFormatSpec ifs = (ImageFormatSpec) i.next();
 268             if (writable && !ifs.writable)
 269               continue;
 270             Iterator j = ifs.extensions.iterator();
 271             while (j.hasNext())
 272               extensions.add((String) j.next());
 273           }
 274       }
 275     Object[] objs = extensions.toArray();
 276     String[] strings = new String[objs.length];
 277     for (int i = 0; i < objs.length; ++i)
 278       strings[i] = (String) objs[i];
 279     return strings;
 280   }
 281
 282   static String[] getFormatMimeTypes(boolean writable)
 283   {
 284     ArrayList mimeTypes = new ArrayList();
 285     synchronized (imageFormatSpecs)
 286       {
 287         Iterator i = imageFormatSpecs.iterator();
 288         while (i.hasNext())
 289           {
 290             ImageFormatSpec ifs = (ImageFormatSpec) i.next();
 291             if (writable && !ifs.writable)
 292               continue;
 293             Iterator j = ifs.mimeTypes.iterator();
 294             while (j.hasNext())
 295               mimeTypes.add((String) j.next());
 296           }
 297       }
 298     Object[] objs = mimeTypes.toArray();
 299     String[] strings = new String[objs.length];
 300     for (int i = 0; i < objs.length; ++i)
 301       strings[i] = (String) objs[i];
 302     return strings;
 303   }
 304
 305
 306   static String findFormatName(Object ext, boolean needWritable)
 307   {
 308     if (ext == null)
 309       return null;
 310
 311     if (!(ext instanceof String))
 312       throw new IllegalArgumentException("extension is not a string");
 313
 314     String str = (String) ext;
 315
 316     Iterator i = imageFormatSpecs.iterator();
 317     while (i.hasNext())
 318       {
 319         ImageFormatSpec ifs = (ImageFormatSpec) i.next();
 320
 321         if (needWritable && !ifs.writable)
 322           continue;
 323
 324         if (ifs.name.equals(str))
 325           return str;
 326
 327         Iterator j = ifs.extensions.iterator();
 328         while (j.hasNext())
 329           {
 330             String extension = (String)j.next();
 331             if (extension.equals(str))
 332               return ifs.name;
 333           }
 334
 335         j = ifs.mimeTypes.iterator();
 336         while (j.hasNext())
 337           {
 338             String mimeType = (String)j.next();
 339             if (mimeType.equals(str))
 340               return ifs.name;
 341           }
 342       }
 343     throw new IllegalArgumentException("unknown extension '" + str + "'");
 344   }
 345
 346   private static GdkPixbufReaderSpi readerSpi;
 347   private static GdkPixbufWriterSpi writerSpi;
 348
 349   public static synchronized GdkPixbufReaderSpi getReaderSpi()
 350   {
 351     if (readerSpi == null)
 352       readerSpi = new GdkPixbufReaderSpi();
 353     return readerSpi;
 354   }
 355
 356   public static synchronized GdkPixbufWriterSpi getWriterSpi()
 357   {
 358     if (writerSpi == null)
 359       writerSpi = new GdkPixbufWriterSpi();
 360     return writerSpi;
 361   }
 362
 363   public static void registerSpis(IIORegistry reg)
 364   {
 365     reg.registerServiceProvider(getReaderSpi(), ImageReaderSpi.class);
 366     reg.registerServiceProvider(getWriterSpi(), ImageWriterSpi.class);
 367   }
 368
 369   public static class GdkPixbufWriterSpi extends ImageWriterSpi
 370   {
 371     public GdkPixbufWriterSpi()
 372     {
 373       super("GdkPixbuf", "2.x",
 374             GdkPixbufDecoder.getFormatNames(true),
 375             GdkPixbufDecoder.getFormatExtensions(true),
 376             GdkPixbufDecoder.getFormatMimeTypes(true),
 377             "gnu.java.awt.peer.gtk.GdkPixbufDecoder$GdkPixbufWriter",
 378             new Class[] { ImageOutputStream.class },
 379             new String[] { "gnu.java.awt.peer.gtk.GdkPixbufDecoder$GdkPixbufReaderSpi" },
 380             false, null, null, null, null,
 381             false, null, null, null, null);
 382     }
 383
 384     public boolean canEncodeImage(ImageTypeSpecifier ts)
 385     {
 386       return true;
 387     }
 388
 389     public ImageWriter createWriterInstance(Object ext)
 390     {
 391       return new GdkPixbufWriter(this, ext);
 392     }
 393
 394     public String getDescription(java.util.Locale loc)
 395     {
 396       return "GdkPixbuf Writer SPI";
 397     }
 398
 399   }
 400
 401   public static class GdkPixbufReaderSpi extends ImageReaderSpi
 402   {
 403     public GdkPixbufReaderSpi()
 404     {
 405       super("GdkPixbuf", "2.x",
 406             GdkPixbufDecoder.getFormatNames(false),
 407             GdkPixbufDecoder.getFormatExtensions(false),
 408             GdkPixbufDecoder.getFormatMimeTypes(false),
 409             "gnu.java.awt.peer.gtk.GdkPixbufDecoder$GdkPixbufReader",
 410             new Class[] { ImageInputStream.class },
 411             new String[] { "gnu.java.awt.peer.gtk.GdkPixbufDecoder$GdkPixbufWriterSpi" },
 412             false, null, null, null, null,
 413             false, null, null, null, null);
 414     }
 415
 416     public boolean canDecodeInput(Object obj)
 417     {
 418       return true;
 419     }
 420
 421     public ImageReader createReaderInstance(Object ext)
 422     {
 423       return new GdkPixbufReader(this, ext);
 424     }
 425
 426     public String getDescription(Locale loc)
 427     {
 428       return "GdkPixbuf Reader SPI";
 429     }
 430   }
 431
 432   private static class GdkPixbufWriter
 433     extends ImageWriter
 434   {
 435     String ext;
 436     public GdkPixbufWriter(GdkPixbufWriterSpi ownerSpi, Object ext)
 437     {
 438       super(ownerSpi);
 439       this.ext = findFormatName(ext, true);
 440     }
 441
 442     public IIOMetadata convertImageMetadata (IIOMetadata inData,
 443                                              ImageTypeSpecifier imageType,
 444                                              ImageWriteParam param)
 445     {
 446       return null;
 447     }
 448
 449     public IIOMetadata convertStreamMetadata (IIOMetadata inData,
 450                                               ImageWriteParam param)
 451     {
 452       return null;
 453     }
 454
 455     public IIOMetadata getDefaultImageMetadata (ImageTypeSpecifier imageType,
 456                                                 ImageWriteParam param)
 457     {
 458       return null;
 459     }
 460
 461     public IIOMetadata getDefaultStreamMetadata (ImageWriteParam param)
 462     {
 463       return null;
 464     }
 465
 466   public void write (IIOMetadata streamMetadata, IIOImage i, ImageWriteParam param)
 467     throws IOException
 468     {
 469       RenderedImage image = i.getRenderedImage();
 470       Raster ras = image.getData();
 471       int width = ras.getWidth();
 472       int height = ras.getHeight();
 473       ColorModel model = image.getColorModel();
 474       int[] pixels = GdkGraphics2D.findSimpleIntegerArray (image.getColorModel(), ras);
 475
 476       if (pixels == null)
 477         {
 478           BufferedImage img = new BufferedImage(width, height,
 479                                                 (model != null && model.hasAlpha() ?
 480                                                  BufferedImage.TYPE_INT_ARGB
 481                                                  : BufferedImage.TYPE_INT_RGB));
 482           int[] pix = new int[4];
 483           for (int y = 0; y < height; ++y)
 484             for (int x = 0; x < width; ++x)
 485               img.setRGB(x, y, model.getRGB(ras.getPixel(x, y, pix)));
 486           pixels = GdkGraphics2D.findSimpleIntegerArray (img.getColorModel(),
 487                                                          img.getRaster());
 488           model = img.getColorModel();
 489         }
 490
 491       processImageStarted(1);
 492       streamImage(pixels, this.ext, width, height, model.hasAlpha(),
 493                   (DataOutput) this.getOutput());
 494       processImageComplete();
 495     }
 496   }
 497
 498   private static class GdkPixbufReader
 499     extends ImageReader
 500     implements ImageConsumer
 501   {
 502     // ImageConsumer parts
 503     GdkPixbufDecoder dec;
 504     BufferedImage bufferedImage;
 505     ColorModel defaultModel;
 506     int width;
 507     int height;
 508     String ext;
 509
 510     public GdkPixbufReader(GdkPixbufReaderSpi ownerSpi, Object ext)
 511     {
 512       super(ownerSpi);
 513       this.ext = findFormatName(ext, false);
 514     }
 515
 516     public GdkPixbufReader(GdkPixbufReaderSpi ownerSpi, Object ext, GdkPixbufDecoder d)
 517     {
 518       this(ownerSpi, ext);
 519       dec = d;
 520     }
 521
 522     public void setDimensions(int w, int h)
 523     {
 524       processImageStarted(1);
 525       width = w;
 526       height = h;
 527     }
 528
 529     public void setProperties(Hashtable props) {}
 530
 531     public void setColorModel(ColorModel model)
 532     {
 533       defaultModel = model;
 534     }
 535
 536     public void setHints(int flags) {}
 537
 538     public void setPixels(int x, int y, int w, int h,
 539                           ColorModel model, byte[] pixels,
 540                           int offset, int scansize)
 541     {
 542     }
 543
 544     public void setPixels(int x, int y, int w, int h,
 545                           ColorModel model, int[] pixels,
 546                           int offset, int scansize)
 547     {
 548       if (model == null)
 549         model = defaultModel;
 550
 551       if (bufferedImage == null)
 552         {
 553           bufferedImage = new BufferedImage (width, height, (model != null && model.hasAlpha() ?
 554                                                              BufferedImage.TYPE_INT_ARGB
 555                                                              : BufferedImage.TYPE_INT_RGB));
 556         }
 557
 558       int pixels2[];
 559       if (model != null)
 560         {
 561           pixels2 = new int[pixels.length];
 562           for (int yy = 0; yy < h; yy++)
 563             for (int xx = 0; xx < w; xx++)
 564               {
 565                 int i = yy * scansize + xx;
 566                 pixels2[i] = model.getRGB (pixels[i]);
 567               }
 568         }
 569       else
 570         pixels2 = pixels;
 571
 572       bufferedImage.setRGB (x, y, w, h, pixels2, offset, scansize);
 573       processImageProgress(y / (height == 0 ? 1 : height));
 574     }
 575
 576     public void imageComplete(int status)
 577     {
 578       processImageComplete();
 579     }
 580
 581     public BufferedImage getBufferedImage()
 582     {
 583       if (bufferedImage == null && dec != null)
 584         dec.startProduction (this);
 585       return bufferedImage;
 586     }
 587
 588     // ImageReader parts
 589
 590     public int getNumImages(boolean allowSearch)
 591       throws IOException
 592     {
 593       return 1;
 594     }
 595
 596     public IIOMetadata getImageMetadata(int i)
 597     {
 598       return null;
 599     }
 600
 601     public IIOMetadata getStreamMetadata()
 602       throws IOException
 603     {
 604       return null;
 605     }
 606
 607     public Iterator getImageTypes(int imageIndex)
 608       throws IOException
 609     {
 610       BufferedImage img = getBufferedImage();
 611       Vector vec = new Vector();
 612       vec.add(new ImageTypeSpecifier(img));
 613       return vec.iterator();
 614     }
 615
 616     public int getHeight(int imageIndex)
 617       throws IOException
 618     {
 619       return getBufferedImage().getHeight();
 620     }
 621
 622     public int getWidth(int imageIndex)
 623       throws IOException
 624     {
 625       return getBufferedImage().getWidth();
 626     }
 627
 628     public void setInput(Object input,
 629                          boolean seekForwardOnly,
 630                          boolean ignoreMetadata)
 631     {
 632       super.setInput(input, seekForwardOnly, ignoreMetadata);
 633       dec = new GdkPixbufDecoder((InputStream) getInput());
 634     }
 635
 636     public BufferedImage read(int imageIndex, ImageReadParam param)
 637       throws IOException
 638     {
 639       return getBufferedImage ();
 640     }
 641   }
 642
 643   // remaining helper class and static method is a convenience for the Gtk
 644   // peers, for loading a BufferedImage in off a disk file without going
 645   // through the whole imageio system.
 646
 647   public static BufferedImage createBufferedImage (String filename)
 648   {
 649     GdkPixbufReader r = new GdkPixbufReader (getReaderSpi(),
 650                                              "png", // reader auto-detects, doesn't matter
 651                                              new GdkPixbufDecoder (filename));
 652     return r.getBufferedImage ();
 653   }
 654
 655   public static BufferedImage createBufferedImage (URL u)
 656   {
 657     GdkPixbufReader r = new GdkPixbufReader (getReaderSpi(),
 658                                              "png", // reader auto-detects, doesn't matter
 659                                              new GdkPixbufDecoder (u));
 660     return r.getBufferedImage ();
 661   }
 662
 663   public static BufferedImage createBufferedImage (byte[] imagedata, int imageoffset,
 664                                                    int imagelength)
 665   {
 666     GdkPixbufReader r = new GdkPixbufReader (getReaderSpi(),
 667                                              "png", // reader auto-detects, doesn't matter
 668                                              new GdkPixbufDecoder (imagedata,
 669                                                                    imageoffset,
 670                                                                    imagelength));
 671     return r.getBufferedImage ();
 672   }
 673
 674   public static BufferedImage createBufferedImage (ImageProducer producer)
 675   {
 676     GdkPixbufReader r = new GdkPixbufReader (getReaderSpi(), "png" /* ignored */, null);
 677     producer.startProduction(r);
 678     return r.getBufferedImage ();
 679   }
 680
 681 }