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