propane 3.4.0-java → 3.7.0.pre-java

data/src/main/java/processing/core/PImage.java

@@ -24,10 +24,12 @@
 
 package processing.core;
 
-import processing.core.util.image.ImageSaveFacade;
-
-import java.awt.*;
-import java.awt.image.*;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
 
 
 /**
@@ -58,6 +60,17 @@ import java.awt.image.*;
  */
 public class PImage implements PConstants, Cloneable {
 
+  private static final byte TIFF_HEADER[] = {
+    77, 77, 0, 42, 0, 0, 0, 8, 0, 9, 0, -2, 0, 4, 0, 0, 0, 1, 0, 0,
+    0, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 3, 0, 0, 0, 1,
+    0, 0, 0, 0, 1, 2, 0, 3, 0, 0, 0, 3, 0, 0, 0, 122, 1, 6, 0, 3, 0,
+    0, 0, 1, 0, 2, 0, 0, 1, 17, 0, 4, 0, 0, 0, 1, 0, 0, 3, 0, 1, 21,
+    0, 3, 0, 0, 0, 1, 0, 3, 0, 0, 1, 22, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0,
+    1, 23, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 8, 0, 8
+  };
+
+  private static final String TIFF_ERROR = "Error: Processing can only read its own TIFF files.";
+
   /**
    * Format for this image, one of RGB, ARGB or ALPHA.
    * note that RGB images still require 0xff in the high byte
@@ -75,8 +88,8 @@ public class PImage implements PConstants, Cloneable {
    * values. The <b>index</b> value defines the position of a value within
    * the array. For example, the statement <b>color b = pixels[230]</b> will
    * set the variable <b>b</b> to be equal to the value at that location in
-   * the array.<br />
-   * <br />
+   * the array.
+   * 
    * Before accessing this array, the data must loaded with the
    * <b>loadPixels()</b> function. After the array data has been modified,
    * the <b>updatePixels()</b> function must be run to update the changes.
@@ -236,6 +249,7 @@ public class PImage implements PConstants, Cloneable {
     init(width, height, format, factor);
   }
 
+
   /**
    * Do not remove, see notes in the other variant.
    */
@@ -266,7 +280,7 @@ public class PImage implements PConstants, Cloneable {
   /**
    * Check the alpha on an image, using a really primitive loop.
    */
-  private void checkAlpha() {
+  public void checkAlpha() {
     if (pixels == null) return;
 
     for (int i = 0; i < pixels.length; i++) {
@@ -315,117 +329,11 @@ public class PImage implements PConstants, Cloneable {
     this.format = format;
     this.pixelDensity = factor;
     this.pixels = pixels;
-    this.pixelWidth = width * pixelDensity;
-    this.pixelHeight = height * pixelDensity;
-  }
-
-  /**
-   * Construct a new PImage from a java.awt.Image. This constructor assumes
-   * that you've done the work of making sure a MediaTracker has been used
-   * to fully download the data and that the img is valid.
-   *
-   * @nowebref
-   * @param img assumes a MediaTracker has been used to fully download
-   * the data and the img is valid
-   */
-  public PImage(Image img) {
-    initFromImage(img);
-  }
-
-  /**
-   * @nowebref
-   *
-   * @param requiresCheckAlpha
-   */
-  public PImage(Image img, boolean requiresCheckAlpha) {
-    initFromImage(img);
-
-    if (requiresCheckAlpha) {
-      checkAlpha();
-    }
-  }
-
-  /**
-   * @nowebref
-   *
-   * @param requiresCheckAlpha
-   */
-  public PImage(Image img, boolean requiresCheckAlpha, PApplet parent) {
-    initFromImage(img);
-
-    this.parent = parent;
-
-    if (requiresCheckAlpha) {
-      checkAlpha();
-    }
-  }
-
-  private void initFromImage(Image img) {
-    format = RGB;
-    if (img instanceof BufferedImage) {
-      BufferedImage bi = (BufferedImage) img;
-      width = bi.getWidth();
-      height = bi.getHeight();
-      int type = bi.getType();
-      if (type == BufferedImage.TYPE_3BYTE_BGR ||
-          type == BufferedImage.TYPE_4BYTE_ABGR) {
-        pixels = new int[width * height];
-        bi.getRGB(0, 0, width, height, pixels, 0, width);
-        if (type == BufferedImage.TYPE_4BYTE_ABGR) {
-          format = ARGB;
-        } else {
-          opaque();
-        }
-      } else {
-        DataBuffer db = bi.getRaster().getDataBuffer();
-        if (db instanceof DataBufferInt) {
-          pixels = ((DataBufferInt) db).getData();
-          if (type == BufferedImage.TYPE_INT_ARGB) {
-            format = ARGB;
-          } else if (type == BufferedImage.TYPE_INT_RGB) {
-            opaque();
-          }
-        }
-      }
-    }
-    // Implements fall-through if not DataBufferInt above, or not a
-    // known type, or not DataBufferInt for the data itself.
-    if (pixels == null) {  // go the old school Java 1.0 route
-      width = img.getWidth(null);
-      height = img.getHeight(null);
-      pixels = new int[width * height];
-      PixelGrabber pg =
-          new PixelGrabber(img, 0, 0, width, height, pixels, 0, width);
-      try {
-        pg.grabPixels();
-      } catch (InterruptedException e) { }
-    }
-    pixelDensity = 1;
-    pixelWidth = width;
-    pixelHeight = height;
-  }
-
-  /**
-   * Use the getNative() method instead, which allows library interfaces to be
-   * written in a cross-platform fashion for desktop, Android, and others.
-   * This is still included for PGraphics objects, which may need the image.
-   */
-  public Image getImage() {  // ignore
-    return (Image) getNative();
   }
 
 
-  /**
-   * Returns a native BufferedImage from this PImage.
-   */
   public Object getNative() {  // ignore
-    loadPixels();
-    int type = (format == RGB) ?
-      BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
-    BufferedImage image = new BufferedImage(pixelWidth, pixelHeight, type);
-    WritableRaster wr = image.getRaster();
-    wr.setDataElements(0, 0, pixelWidth, pixelHeight, pixels);
-    return image;
+    return null;
   }
 
 
@@ -490,7 +398,7 @@ public class PImage implements PConstants, Cloneable {
    *
    * <h3>Advanced</h3>
    * Call this when you want to mess with the pixels[] array.
-   * <p/>
+   * 
    * For subclasses where the pixels[] buffer isn't set by default,
    * this should copy all data into the pixels[] array
    *
@@ -592,8 +500,8 @@ public class PImage implements PConstants, Cloneable {
    * Resize the image to a new width and height. To make the image scale
    * proportionally, use 0 as the value for the <b>wide</b> or <b>high</b>
    * parameter. For instance, to make the width of an image 150 pixels, and
-   * change the height using the same proportion, use resize(150, 0).<br />
-   * <br />
+   * change the height using the same proportion, use resize(150, 0).
+   * 
    * Even though a PGraphics is technically a PImage, it is not possible to
    * rescale the image data found in a PGraphics. (It's simply not possible
    * to do this consistently across renderers: technically infeasible with
@@ -610,104 +518,7 @@ public class PImage implements PConstants, Cloneable {
    * @see PImage#get(int, int, int, int)
    */
   public void resize(int w, int h) {  // ignore
-    if (w <= 0 && h <= 0) {
-      throw new IllegalArgumentException("width or height must be > 0 for resize");
-    }
-
-    if (w == 0) {  // Use height to determine relative size
-      float diff = (float) h / (float) height;
-      w = (int) (width * diff);
-    } else if (h == 0) {  // Use the width to determine relative size
-      float diff = (float) w / (float) width;
-      h = (int) (height * diff);
-    }
-
-    BufferedImage img =
-      shrinkImage((BufferedImage) getNative(), w*pixelDensity, h*pixelDensity);
-
-    PImage temp = new PImage(img);
-    this.pixelWidth = temp.width;
-    this.pixelHeight = temp.height;
-
-    // Get the resized pixel array
-    this.pixels = temp.pixels;
-
-    this.width = pixelWidth / pixelDensity;
-    this.height = pixelHeight / pixelDensity;
-
-    // Mark the pixels array as altered
-    updatePixels();
-  }
-
-
-  // Adapted from getFasterScaledInstance() method from page 111 of
-  // "Filthy Rich Clients" by Chet Haase and Romain Guy
-  // Additional modifications and simplifications have been added,
-  // plus a fix to deal with an infinite loop if images are expanded.
-  // http://code.google.com/p/processing/issues/detail?id=1463
-  static private BufferedImage shrinkImage(BufferedImage img,
-                                           int targetWidth, int targetHeight) {
-    int type = (img.getTransparency() == Transparency.OPAQUE) ?
-      BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
-    BufferedImage outgoing = img;
-    BufferedImage scratchImage = null;
-    Graphics2D g2 = null;
-    int prevW = outgoing.getWidth();
-    int prevH = outgoing.getHeight();
-    boolean isTranslucent = img.getTransparency() != Transparency.OPAQUE;
-
-    // Use multi-step technique: start with original size, then scale down in
-    // multiple passes with drawImage() until the target size is reached
-    int w = img.getWidth();
-    int h = img.getHeight();
-
-    do {
-      if (w > targetWidth) {
-        w /= 2;
-        // if this is the last step, do the exact size
-        if (w < targetWidth) {
-          w = targetWidth;
-        }
-      } else if (targetWidth >= w) {
-        w = targetWidth;
-      }
-      if (h > targetHeight) {
-        h /= 2;
-        if (h < targetHeight) {
-          h = targetHeight;
-        }
-      } else if (targetHeight >= h) {
-        h = targetHeight;
-      }
-      if (scratchImage == null || isTranslucent) {
-        // Use a single scratch buffer for all iterations and then copy
-        // to the final, correctly-sized image before returning
-        scratchImage = new BufferedImage(w, h, type);
-        g2 = scratchImage.createGraphics();
-      }
-      g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-                          RenderingHints.VALUE_INTERPOLATION_BILINEAR);
-      g2.drawImage(outgoing, 0, 0, w, h, 0, 0, prevW, prevH, null);
-      prevW = w;
-      prevH = h;
-      outgoing = scratchImage;
-    } while (w != targetWidth || h != targetHeight);
-
-    if (g2 != null) {
-      g2.dispose();
-    }
-
-    // If we used a scratch buffer that is larger than our target size,
-    // create an image of the right size and copy the results into it
-    if (targetWidth != outgoing.getWidth() ||
-        targetHeight != outgoing.getHeight()) {
-      scratchImage = new BufferedImage(targetWidth, targetHeight, type);
-      g2 = scratchImage.createGraphics();
-      g2.drawImage(outgoing, 0, 0, null);
-      g2.dispose();
-      outgoing = scratchImage;
-    }
-    return outgoing;
+    throw new RuntimeException("resize() not implemented for this PImage type");
   }
 
 
@@ -745,14 +556,14 @@ public class PImage implements PConstants, Cloneable {
    * the display window by specifying an additional <b>width</b> and
    * <b>height</b> parameter. When getting an image, the <b>x</b> and
    * <b>y</b> parameters define the coordinates for the upper-left corner of
-   * the image, regardless of the current <b>imageMode()</b>.<br />
-   * <br />
+   * the image, regardless of the current <b>imageMode()</b>.
+   * 
    * If the pixel requested is outside of the image window, black is
    * returned. The numbers returned are scaled according to the current color
    * ranges, but only RGB values are returned by this function. For example,
    * even though you may have drawn a shape with <b>colorMode(HSB)</b>, the
-   * numbers returned will be in RGB format.<br />
-   * <br />
+   * numbers returned will be in RGB format.
+   * 
    * Getting the color of a single pixel with <b>get(x, y)</b> is easy, but
    * not as fast as grabbing the data directly from <b>pixels[]</b>. The
    * equivalent statement to <b>get(x, y)</b> using <b>pixels[]</b> is
@@ -899,15 +710,15 @@ public class PImage implements PConstants, Cloneable {
    * ( begin auto-generated from PImage_set.xml )
    *
    * Changes the color of any pixel or writes an image directly into the
-   * display window.<br />
-   * <br />
+   * display window.
+   * 
    * The <b>x</b> and <b>y</b> parameters specify the pixel to change and the
    * <b>color</b> parameter specifies the color value. The color parameter is
    * affected by the current color mode (the default is RGB values from 0 to
    * 255). When setting an image, the <b>x</b> and <b>y</b> parameters define
    * the coordinates for the upper-left corner of the image, regardless of
    * the current <b>imageMode()</b>.
-   * <br /><br />
+   * 
    * Setting the color of a single pixel with <b>set(x, y)</b> is easy, but
    * not as fast as putting the data directly into <b>pixels[]</b>. The
    * equivalent statement to <b>set(x, y, #000000)</b> using <b>pixels[]</b>
@@ -1003,7 +814,7 @@ public class PImage implements PConstants, Cloneable {
    * @param maskArray array of integers used as the alpha channel, needs to be
    * the same length as the image's pixel array.
    */
-  public void mask(int maskArray[]) {  // ignore
+  public void mask(int[] maskArray) {  // ignore
     loadPixels();
     // don't execute if mask image is different size
     if (maskArray.length != pixels.length) {
@@ -1023,8 +834,8 @@ public class PImage implements PConstants, Cloneable {
    * Masks part of an image from displaying by loading another image and
    * using it as an alpha channel. This mask image should only contain
    * grayscale data, but only the blue color channel is used. The mask image
-   * needs to be the same size as the image to which it is applied.<br />
-   * <br />
+   * needs to be the same size as the image to which it is applied.
+   * 
    * In addition to using a mask image, an integer array containing the alpha
    * channel data can be specified directly. This method is useful for
    * creating dynamically generated alpha masks. This array must be of the
@@ -1138,28 +949,28 @@ public class PImage implements PConstants, Cloneable {
   /**
    * ( begin auto-generated from PImage_filter.xml )
    *
-   * Filters an image as defined by one of the following modes:<br /><br
-   * />THRESHOLD - converts the image to black and white pixels depending if
+   * Filters an image as defined by one of the following modes:
+   * THRESHOLD - converts the image to black and white pixels depending if
    * they are above or below the threshold defined by the level parameter.
    * The level must be between 0.0 (black) and 1.0(white). If no level is
-   * specified, 0.5 is used.<br />
-   * <br />
-   * GRAY - converts any colors in the image to grayscale equivalents<br />
-   * <br />
-   * INVERT - sets each pixel to its inverse value<br />
-   * <br />
+   * specified, 0.5 is used.
+   * 
+   * GRAY - converts any colors in the image to grayscale equivalents
+   * 
+   * INVERT - sets each pixel to its inverse value
+   * 
    * POSTERIZE - limits each channel of the image to the number of colors
-   * specified as the level parameter<br />
-   * <br />
+   * specified as the level parameter
+   * 
    * BLUR - executes a Guassian blur with the level parameter specifying the
    * extent of the blurring. If no level parameter is used, the blur is
-   * equivalent to Guassian blur of radius 1<br />
-   * <br />
-   * OPAQUE - sets the alpha channel to entirely opaque<br />
-   * <br />
+   * equivalent to Guassian blur of radius 1
+   * 
+   * OPAQUE - sets the alpha channel to entirely opaque
+   * 
    * ERODE - reduces the light areas with the amount defined by the level
-   * parameter<br />
-   * <br />
+   * parameter
+   * 
    * DILATE - increases the light areas with the amount defined by the level parameter
    *
    * ( end auto-generated )
@@ -1178,7 +989,7 @@ public class PImage implements PConstants, Cloneable {
    * </UL>
    * Luminance conversion code contributed by
    * <A HREF="http://www.toxi.co.uk">toxi</A>
-   * <P/>
+   * 
    * Gaussian blur code contributed by
    * <A HREF="http://incubator.quasimondo.com">Mario Klingemann</A>
    *
@@ -1193,14 +1004,20 @@ public class PImage implements PConstants, Cloneable {
 
     switch (kind) {
       case BLUR:
-        if (format == ALPHA)
+      switch (format) {
+        case ALPHA:
           blurAlpha(param);
-        else if (format == ARGB)
+          break;
+        case ARGB:
           blurARGB(param);
-        else
+          break;
+        default:
           blurRGB(param);
+          break;
+      }
         break;
 
+
       case GRAY:
         throw new RuntimeException("Use filter(GRAY) instead of " +
                                    "filter(GRAY, param)");
@@ -1302,7 +1119,7 @@ public class PImage implements PConstants, Cloneable {
   protected void blurAlpha(float r) {
     int sum, cb;
     int read, ri, ym, ymi, bk0;
-    int b2[] = new int[pixels.length];
+    int[] b2 = new int[pixels.length];
     int yi = 0;
 
     buildBlurKernel(r);
@@ -1373,9 +1190,9 @@ public class PImage implements PConstants, Cloneable {
   protected void blurRGB(float r) {
     int sum, cr, cg, cb; //, k;
     int /*pixel,*/ read, ri, /*roff,*/ ym, ymi, /*riw,*/ bk0;
-    int r2[] = new int[pixels.length];
-    int g2[] = new int[pixels.length];
-    int b2[] = new int[pixels.length];
+    int[] r2 = new int[pixels.length];
+    int[] g2 = new int[pixels.length];
+    int[] b2 = new int[pixels.length];
     int yi = 0;
 
     buildBlurKernel(r);
@@ -1456,10 +1273,10 @@ public class PImage implements PConstants, Cloneable {
     int sum, cr, cg, cb, ca;
     int /*pixel,*/ read, ri, /*roff,*/ ym, ymi, /*riw,*/ bk0;
     int wh = pixels.length;
-    int r2[] = new int[wh];
-    int g2[] = new int[wh];
-    int b2[] = new int[wh];
-    int a2[] = new int[wh];
+    int[] r2 = new int[wh];
+    int[] g2 = new int[wh];
+    int[] b2 = new int[wh];
+    int[] a2 = new int[wh];
     int yi = 0;
 
     buildBlurKernel(r);
@@ -1695,7 +1512,7 @@ public class PImage implements PConstants, Cloneable {
    * source pixels to fit the specified target region. No alpha information
    * is used in the process, however if the source image has an alpha channel
    * set, it will be copied as well.
-   * <br /><br />
+   * 
    * As of release 0149, this function ignores <b>imageMode()</b>.
    *
    * ( end auto-generated )
@@ -1799,7 +1616,7 @@ public class PImage implements PConstants, Cloneable {
    * necessarily "correct" code. No biggie, most software does. A nitpicker
    * can find numerous "off by 1 division" problems in the blend code where
    * <TT>&gt;&gt;8</TT> or <TT>&gt;&gt;7</TT> is used when strictly speaking
-   * <TT>/255.0</T> or <TT>/127.0</TT> should have been used.</P>
+   * <TT>/255.0</TT> or <TT>/127.0</TT> should have been used.</P>
    * <P>For instance, exclusion (not intended for real-time use) reads
    * <TT>r1 + r2 - ((2 * r1 * r2) / 255)</TT> because <TT>255 == 1.0</TT>
    * not <TT>256 == 1.0</TT>. In other words, <TT>(255*255)>>8</TT> is not
@@ -1855,47 +1672,47 @@ public class PImage implements PConstants, Cloneable {
    * Blends a region of pixels into the image specified by the <b>img</b>
    * parameter. These copies utilize full alpha channel support and a choice
    * of the following modes to blend the colors of source pixels (A) with the
-   * ones of pixels in the destination image (B):<br />
-   * <br />
-   * BLEND - linear interpolation of colours: C = A*factor + B<br />
-   * <br />
-   * ADD - additive blending with white clip: C = min(A*factor + B, 255)<br />
-   * <br />
+   * ones of pixels in the destination image (B):
+   * 
+   * BLEND - linear interpolation of colours: C = A*factor + B
+   * 
+   * ADD - additive blending with white clip: C = min(A*factor + B, 255)
+   * 
    * SUBTRACT - subtractive blending with black clip: C = max(B - A*factor,
-   * 0)<br />
-   * <br />
-   * DARKEST - only the darkest colour succeeds: C = min(A*factor, B)<br />
-   * <br />
-   * LIGHTEST - only the lightest colour succeeds: C = max(A*factor, B)<br />
-   * <br />
-   * DIFFERENCE - subtract colors from underlying image.<br />
-   * <br />
-   * EXCLUSION - similar to DIFFERENCE, but less extreme.<br />
-   * <br />
-   * MULTIPLY - Multiply the colors, result will always be darker.<br />
-   * <br />
-   * SCREEN - Opposite multiply, uses inverse values of the colors.<br />
-   * <br />
+   * 0)
+   * 
+   * DARKEST - only the darkest colour succeeds: C = min(A*factor, B)
+   * 
+   * LIGHTEST - only the lightest colour succeeds: C = max(A*factor, B)
+   * 
+   * DIFFERENCE - subtract colors from underlying image.
+   * 
+   * EXCLUSION - similar to DIFFERENCE, but less extreme.
+   * 
+   * MULTIPLY - Multiply the colors, result will always be darker.
+   * 
+   * SCREEN - Opposite multiply, uses inverse values of the colors.
+   * 
    * OVERLAY - A mix of MULTIPLY and SCREEN. Multiplies dark values,
-   * and screens light values.<br />
-   * <br />
-   * HARD_LIGHT - SCREEN when greater than 50% gray, MULTIPLY when lower.<br />
-   * <br />
+   * and screens light values.
+   * 
+   * HARD_LIGHT - SCREEN when greater than 50% gray, MULTIPLY when lower.
+   * 
    * SOFT_LIGHT - Mix of DARKEST and LIGHTEST.
-   * Works like OVERLAY, but not as harsh.<br />
-   * <br />
+   * Works like OVERLAY, but not as harsh.
+   * 
    * DODGE - Lightens light tones and increases contrast, ignores darks.
-   * Called "Color Dodge" in Illustrator and Photoshop.<br />
-   * <br />
+   * Called "Color Dodge" in Illustrator and Photoshop.
+   * 
    * BURN - Darker areas are applied, increasing contrast, ignores lights.
-   * Called "Color Burn" in Illustrator and Photoshop.<br />
-   * <br />
+   * Called "Color Burn" in Illustrator and Photoshop.
+   * 
    * All modes use the alpha information (highest byte) of source image
    * pixels as the blending factor. If the source and destination regions are
    * different sizes, the image will be automatically resized to match the
    * destination size. If the <b>srcImg</b> parameter is not used, the
-   * display window is used as the source image.<br />
-   * <br />
+   * display window is used as the source image.
+   * 
    * As of release 0149, this function ignores <b>imageMode()</b>.
    *
    * ( end auto-generated )
@@ -3010,18 +2827,465 @@ int testFunction(int dst, int src) {
 
   // FILE I/O
 
-  protected String[] saveImageFormats;
+
+  protected boolean saveImpl(String filename) {
+    return false;
+  }
+
+
+  static public PImage loadTIFF(InputStream input) {  // ignore
+    byte tiff[] = PApplet.loadBytes(input);
+
+    if ((tiff[42] != tiff[102]) ||  // width/height in both places
+        (tiff[43] != tiff[103])) {
+      System.err.println(TIFF_ERROR);
+      return null;
+    }
+
+    int width =
+      ((tiff[30] & 0xff) << 8) | (tiff[31] & 0xff);
+    int height =
+      ((tiff[42] & 0xff) << 8) | (tiff[43] & 0xff);
+
+    int count =
+      ((tiff[114] & 0xff) << 24) |
+      ((tiff[115] & 0xff) << 16) |
+      ((tiff[116] & 0xff) << 8) |
+      (tiff[117] & 0xff);
+    if (count != width * height * 3) {
+      System.err.println(TIFF_ERROR + " (" + width + ", " + height +")");
+      return null;
+    }
+
+    // check the rest of the header
+    for (int i = 0; i < TIFF_HEADER.length; i++) {
+      if ((i == 30) || (i == 31) || (i == 42) || (i == 43) ||
+          (i == 102) || (i == 103) ||
+          (i == 114) || (i == 115) || (i == 116) || (i == 117)) continue;
+
+      if (tiff[i] != TIFF_HEADER[i]) {
+        System.err.println(TIFF_ERROR + " (" + i + ")");
+        return null;
+      }
+    }
+
+    PImage outgoing = new PImage(width, height, RGB);
+    int index = 768;
+    count /= 3;
+    for (int i = 0; i < count; i++) {
+      outgoing.pixels[i] =
+        0xFF000000 |
+        (tiff[index++] & 0xff) << 16 |
+        (tiff[index++] & 0xff) << 8 |
+        (tiff[index++] & 0xff);
+    }
+    return outgoing;
+  }
+
+  protected boolean saveTIFF(OutputStream output) {
+    // shutting off the warning, people can figure this out themselves
+    /*
+    if (format != RGB) {
+      System.err.println("Warning: only RGB information is saved with " +
+                         ".tif files. Use .tga or .png for ARGB images and others.");
+    }
+    */
+    try {
+      byte[] tiff = new byte[768];
+      System.arraycopy(TIFF_HEADER, 0, tiff, 0, TIFF_HEADER.length);
+
+      tiff[30] = (byte) ((pixelWidth >> 8) & 0xff);
+      tiff[31] = (byte) ((pixelWidth) & 0xff);
+      tiff[42] = tiff[102] = (byte) ((pixelHeight >> 8) & 0xff);
+      tiff[43] = tiff[103] = (byte) ((pixelHeight) & 0xff);
+
+      int count = pixelWidth*pixelHeight*3;
+      tiff[114] = (byte) ((count >> 24) & 0xff);
+      tiff[115] = (byte) ((count >> 16) & 0xff);
+      tiff[116] = (byte) ((count >> 8) & 0xff);
+      tiff[117] = (byte) ((count) & 0xff);
+
+      // spew the header to the disk
+      output.write(tiff);
+
+      for (int i = 0; i < pixels.length; i++) {
+        output.write((pixels[i] >> 16) & 0xff);
+        output.write((pixels[i] >> 8) & 0xff);
+        output.write(pixels[i] & 0xff);
+      }
+      output.flush();
+      return true;
+
+    } catch (IOException e) {
+    }
+    return false;
+  }
+
+
+  /**
+   * Targa image loader for RLE-compressed TGA files.
+   * <p>
+   * Rewritten for 0115 to read/write RLE-encoded targa images.
+   * For 0125, non-RLE encoded images are now supported, along with
+   * images whose y-order is reversed (which is standard for TGA files).
+   * <p>
+   * A version of this function is in MovieMaker.java. Any fixes here
+   * should be applied over in MovieMaker as well.
+   * <p>
+   * Known issue with RLE encoding and odd behavior in some apps:
+   * https://github.com/processing/processing/issues/2096
+   * Please help!
+   */
+  static public PImage loadTGA(InputStream input) throws IOException {  // ignore
+    byte[] header = new byte[18];
+    int offset = 0;
+    do {
+      int count = input.read(header, offset, header.length - offset);
+      if (count == -1) return null;
+      offset += count;
+    } while (offset < 18);
+
+    /*
+      header[2] image type code
+      2  (0x02) - Uncompressed, RGB images.
+      3  (0x03) - Uncompressed, black and white images.
+      10 (0x0A) - Run-length encoded RGB images.
+      11 (0x0B) - Compressed, black and white images. (grayscale?)
+
+      header[16] is the bit depth (8, 24, 32)
+
+      header[17] image descriptor (packed bits)
+      0x20 is 32 = origin upper-left
+      0x28 is 32 + 8 = origin upper-left + 32 bits
+
+        7  6  5  4  3  2  1  0
+      128 64 32 16  8  4  2  1
+    */
+
+    int format = 0;
+
+    if (((header[2] == 3) || (header[2] == 11)) &&  // B&W, plus RLE or not
+        (header[16] == 8) &&  // 8 bits
+        ((header[17] == 0x8) || (header[17] == 0x28))) {  // origin, 32 bit
+      format = ALPHA;
+
+    } else if (((header[2] == 2) || (header[2] == 10)) &&  // RGB, RLE or not
+               (header[16] == 24) &&  // 24 bits
+               ((header[17] == 0x20) || (header[17] == 0))) {  // origin
+      format = RGB;
+
+    } else if (((header[2] == 2) || (header[2] == 10)) &&
+               (header[16] == 32) &&
+               ((header[17] == 0x8) || (header[17] == 0x28))) {  // origin, 32
+      format = ARGB;
+    }
+
+    if (format == 0) {
+      System.err.println("Unknown .tga file format");
+      return null;
+    }
+
+    int w = ((header[13] & 0xff) << 8) + (header[12] & 0xff);
+    int h = ((header[15] & 0xff) << 8) + (header[14] & 0xff);
+    PImage outgoing = new PImage(w, h, format);
+
+    // where "reversed" means upper-left corner (normal for most of
+    // the modernized world, but "reversed" for the tga spec)
+    //boolean reversed = (header[17] & 0x20) != 0;
+    // https://github.com/processing/processing/issues/1682
+    boolean reversed = (header[17] & 0x20) == 0;
+
+    if ((header[2] == 2) || (header[2] == 3)) {  // not RLE encoded
+      if (reversed) {
+        int index = (h-1) * w;
+        switch (format) {
+        case ALPHA:
+          for (int y = h-1; y >= 0; y--) {
+            for (int x = 0; x < w; x++) {
+              outgoing.pixels[index + x] = input.read();
+            }
+            index -= w;
+          }
+          break;
+        case RGB:
+          for (int y = h-1; y >= 0; y--) {
+            for (int x = 0; x < w; x++) {
+              outgoing.pixels[index + x] =
+                input.read() | (input.read() << 8) | (input.read() << 16) |
+                0xff000000;
+            }
+            index -= w;
+          }
+          break;
+        case ARGB:
+          for (int y = h-1; y >= 0; y--) {
+            for (int x = 0; x < w; x++) {
+              outgoing.pixels[index + x] =
+                input.read() | (input.read() << 8) | (input.read() << 16) |
+                (input.read() << 24);
+            }
+            index -= w;
+          }
+        }
+      } else {  // not reversed
+        int count = w * h;
+        switch (format) {
+        case ALPHA:
+          for (int i = 0; i < count; i++) {
+            outgoing.pixels[i] = input.read();
+          }
+          break;
+        case RGB:
+          for (int i = 0; i < count; i++) {
+            outgoing.pixels[i] =
+              input.read() | (input.read() << 8) | (input.read() << 16) |
+              0xff000000;
+          }
+          break;
+        case ARGB:
+          for (int i = 0; i < count; i++) {
+            outgoing.pixels[i] =
+              input.read() | (input.read() << 8) | (input.read() << 16) |
+              (input.read() << 24);
+          }
+          break;
+        }
+      }
+
+    } else {  // header[2] is 10 or 11
+      int index = 0;
+      int[] px = outgoing.pixels;
+
+      while (index < px.length) {
+        int num = input.read();
+        boolean isRLE = (num & 0x80) != 0;
+        if (isRLE) {
+          num -= 127;  // (num & 0x7F) + 1
+          int pixel = 0;
+          switch (format) {
+          case ALPHA:
+            pixel = input.read();
+            break;
+          case RGB:
+            pixel = 0xFF000000 |
+              input.read() | (input.read() << 8) | (input.read() << 16);
+            //(is.read() << 16) | (is.read() << 8) | is.read();
+            break;
+          case ARGB:
+            pixel = input.read() |
+              (input.read() << 8) | (input.read() << 16) | (input.read() << 24);
+            break;
+          }
+          for (int i = 0; i < num; i++) {
+            px[index++] = pixel;
+            if (index == px.length) break;
+          }
+        } else {  // write up to 127 bytes as uncompressed
+          num += 1;
+          switch (format) {
+          case ALPHA:
+            for (int i = 0; i < num; i++) {
+              px[index++] = input.read();
+            }
+            break;
+          case RGB:
+            for (int i = 0; i < num; i++) {
+              px[index++] = 0xFF000000 |
+                input.read() | (input.read() << 8) | (input.read() << 16);
+              //(is.read() << 16) | (is.read() << 8) | is.read();
+            }
+            break;
+          case ARGB:
+            for (int i = 0; i < num; i++) {
+              px[index++] = input.read() | //(is.read() << 24) |
+                (input.read() << 8) | (input.read() << 16) | (input.read() << 24);
+              //(is.read() << 16) | (is.read() << 8) | is.read();
+            }
+            break;
+          }
+        }
+      }
+
+      if (!reversed) {
+        int[] temp = new int[w];
+        for (int y = 0; y < h/2; y++) {
+          int z = (h-1) - y;
+          System.arraycopy(px, y*w, temp, 0, w);
+          System.arraycopy(px, z*w, px, y*w, w);
+          System.arraycopy(temp, 0, px, z*w, w);
+        }
+      }
+    }
+    input.close();
+    return outgoing;
+  }
+
+
+  /**
+   * Creates a Targa32 formatted byte sequence of specified
+   * pixel buffer using RLE compression.
+   * <p>
+   * Also figured out how to avoid parsing the image upside-down
+   * (there's a header flag to set the image origin to top-left)
+   * </p>
+   * Starting with revision 0092, the format setting is taken into account:
+   * <UL>
+   * <LI><TT>ALPHA</TT> images written as 8bit grayscale (uses lowest byte)
+   * <LI><TT>RGB</TT> &rarr; 24 bits
+   * <LI><TT>ARGB</TT> &rarr; 32 bits
+   * </UL>
+   * All versions are RLE compressed.
+   * 
+   * Contributed by toxi 8-10 May 2005, based on this RLE
+   * <A HREF="http://www.wotsit.org/download.asp?f=tga">specification</A>
+   */
+  protected boolean saveTGA(OutputStream output) {
+    byte[] header = new byte[18];
+
+    switch (format) {
+      case ALPHA:
+        // save ALPHA images as 8bit grayscale
+        header[2] = 0x0B;
+        header[16] = 0x08;
+        header[17] = 0x28;
+        break;
+      case RGB:
+        header[2] = 0x0A;
+        header[16] = 24;
+        header[17] = 0x20;
+        break;
+      case ARGB:
+        header[2] = 0x0A;
+        header[16] = 32;
+        header[17] = 0x28;
+        break;
+      default:
+        throw new RuntimeException("Image format not recognized inside save()");
+    }
+     // set image dimensions lo-hi byte order
+     header[12] = (byte) (pixelWidth & 0xff);
+     header[13] = (byte) (pixelWidth >> 8);
+     header[14] = (byte) (pixelHeight & 0xff);
+     header[15] = (byte) (pixelHeight >> 8);
+
+     try {
+       output.write(header);
+
+       int maxLen = pixelHeight * pixelWidth;
+       int index = 0;
+       int col; //, prevCol;
+       int[] currChunk = new int[128];
+
+       // 8bit image exporter is in separate loop
+       // to avoid excessive conditionals...
+       if (format == ALPHA) {
+         while (index < maxLen) {
+           boolean isRLE = false;
+           int rle = 1;
+           currChunk[0] = col = pixels[index] & 0xff;
+           while (index + rle < maxLen) {
+             if (col != (pixels[index + rle]&0xff) || rle == 128) {
+               isRLE = (rle > 1);
+               break;
+             }
+             rle++;
+           }
+           if (isRLE) {
+             output.write(0x80 | (rle - 1));
+             output.write(col);
+
+           } else {
+             rle = 1;
+             while (index + rle < maxLen) {
+               int cscan = pixels[index + rle] & 0xff;
+               if ((col != cscan && rle < 128) || rle < 3) {
+                 currChunk[rle] = col = cscan;
+               } else {
+                 if (col == cscan) rle -= 2;
+                 break;
+               }
+               rle++;
+             }
+             output.write(rle - 1);
+             for (int i = 0; i < rle; i++) output.write(currChunk[i]);
+           }
+           index += rle;
+         }
+       } else {  // export 24/32 bit TARGA
+         while (index < maxLen) {
+           boolean isRLE = false;
+           currChunk[0] = col = pixels[index];
+           int rle = 1;
+           // try to find repeating bytes (min. len = 2 pixels)
+           // maximum chunk size is 128 pixels
+           while (index + rle < maxLen) {
+             if (col != pixels[index + rle] || rle == 128) {
+               isRLE = (rle > 1); // set flag for RLE chunk
+               break;
+             }
+             rle++;
+           }
+           if (isRLE) {
+             output.write(128 | (rle - 1));
+             output.write(col & 0xff);
+             output.write(col >> 8 & 0xff);
+             output.write(col >> 16 & 0xff);
+             if (format == ARGB) output.write(col >>> 24 & 0xff);
+
+           } else {  // not RLE
+             rle = 1;
+             while (index + rle < maxLen) {
+               if ((col != pixels[index + rle] && rle < 128) || rle < 3) {
+                 currChunk[rle] = col = pixels[index + rle];
+               } else {
+                 // check if the exit condition was the start of
+                 // a repeating colour
+                 if (col == pixels[index + rle]) rle -= 2;
+                 break;
+               }
+               rle++;
+             }
+             // write uncompressed chunk
+             output.write(rle - 1);
+             if (format == ARGB) {
+               for (int i = 0; i < rle; i++) {
+                 col = currChunk[i];
+                 output.write(col & 0xff);
+                 output.write(col >> 8 & 0xff);
+                 output.write(col >> 16 & 0xff);
+                 output.write(col >>> 24 & 0xff);
+               }
+             } else {
+               for (int i = 0; i < rle; i++) {
+                 col = currChunk[i];
+                 output.write(col & 0xff);
+                 output.write(col >> 8 & 0xff);
+                 output.write(col >> 16 & 0xff);
+               }
+             }
+           }
+           index += rle;
+         }
+       }
+       output.flush();
+       return true;
+
+     } catch (IOException e) {
+       return false;
+     }
+  }
+
 
   /**
    * ( begin auto-generated from PImage_save.xml )
    *
-   * Saves the image into a file.Append a file extension to the name of 
- the file, to indicate the file format to be used: either TIFF (.tif), 
- TARGA (.tga), JPEG (.jpg), or PNG (.png). If no extension is included 
- in the filename, the image will save in TIFF format and .tif will be 
- added to the name.  These files are saved to the sketch's folder, which
- may be opened by selecting "Show sketch folder" from the "Sketch" menu.
- <br /><br />To save an image created within the code, rather
+   * Saves the image into a file. Append a file extension to the name of
+   * the file, to indicate the file format to be used: either TIFF (.tif),
+   * TARGA (.tga), JPEG (.jpg), or PNG (.png). If no extension is included
+   * in the filename, the image will save in TIFF format and .tif will be
+   * added to the name.  These files are saved to the sketch's folder, which
+   * may be opened by selecting "Show sketch folder" from the "Sketch" menu.
+   * To save an image created within the code, rather
    * than through loading, it's necessary to make the image with the
    * <b>createImage()</b> function so it is aware of the location of the
    * program and can therefore save the file to the right place. See the
@@ -3053,23 +3317,61 @@ int testFunction(int dst, int src) {
    * require a black and white image. Basic testing produced a zero-length
    * file with no error.
    *
-     * @return 
    * @webref pimage:method
    * @brief Saves the image to a TIFF, TARGA, PNG, or JPEG file
    * @usage application
    * @param filename a sequence of letters and numbers
    */
-  public boolean save(String filename) { // ignore
-    // Make sure the pixel data is ready to go
-    loadPixels();
-
-    return ImageSaveFacade.get().save(
-        pixels,
-        pixelWidth,
-        pixelHeight,
-        format,
-        filename,
-        parent
-    );
-  }
+   public boolean save(String filename) {  // ignore
+     boolean success = false;
+
+     if (parent != null) {
+       // use savePath(), so that the intermediate directories are created
+       filename = parent.savePath(filename);
+
+     } else {
+       File file = new File(filename);
+       if (file.isAbsolute()) {
+         // make sure that the intermediate folders have been created
+         PApplet.createPath(file);
+       } else {
+         String msg =
+           "PImage.save() requires an absolute path. " +
+           "Use createImage(), or pass savePath() to save().";
+         PGraphics.showException(msg);
+       }
+     }
+
+     // Make sure the pixel data is ready to go
+     loadPixels();
+
+     try {
+       OutputStream os = null;
+
+       if (saveImpl(filename)) {
+         return true;
+       }
+
+       if (filename.toLowerCase().endsWith(".tga")) {
+         os = new BufferedOutputStream(new FileOutputStream(filename), 32768);
+         success = saveTGA(os); //, pixels, width, height, format);
+
+       } else {
+         if (!filename.toLowerCase().endsWith(".tif") &&
+             !filename.toLowerCase().endsWith(".tiff")) {
+           // if no .tif extension, add it..
+           filename += ".tif";
+         }
+         os = new BufferedOutputStream(new FileOutputStream(filename), 32768);
+         success = saveTIFF(os); //, pixels, width, height);
+       }
+       os.flush();
+       os.close();
+
+     } catch (IOException e) {
+       System.err.println("Error while saving image.");
+       success = false;
+     }
+     return success;
+   }
 }