Is there a difference between the jvm's on the main java page and the one on oracle's site ?

Hey Hansi, thanks for the post.. always looking for new ways to speed up my data loads (particularly the tip on flushing the BufferedImage).  The code may be quicker than a PImage load, but seems a lot slower than using ImageIO.read(URL);

I'm actually trying to improve the performance of my Texture loads for OpenGL.  My code below is the fastest way I've found so far (at least for texture loading), but wanted to try the direct OpenGL methods when I get a chance and figure it out.

Your code timed at 1419.0ms
The code below timed at 522.0ms

http://stackoverflow.com/questions/1927419/loading-pngs-into-opengl-performance-issues-java-jogl-much-slower-than-c-t

1. BufferedImage loadTexture(String file) {
2.   try {
3.     BufferedImage img = ImageIO.read(getJarURL(file));
4.     BufferedImage argbImg = new BufferedImage(img.getWidth(), img.getHeight(), BufferedImage.TYPE_INT_ARGB_PRE);
5.     java.awt.Graphics2D g2d = argbImg.createGraphics();
6.     g2d.drawImage(img, 0, 0, null);
7.     img.flush();
8.     return argbImg;
9.   }
10.   catch (Exception e) {
11.     println("Error loading images: " + e);
12.     return null;
13.   }
14. }
15. //Then something like...
    
16. staimg = TextureIO.newTexture(loadTexture("data/background.png"), true);
    

I found this code below
http://www.java-tips.org/java-se-tips/java.awt.image/how-to-use-pixelgrabber-class-to-acquire-pixel-data-from-an-image-o.html

it only works with local drive .png files but its almost twice as fast than loadImage()

just use loadImagex() instead of loadImage()

1. 
   PImage loadImagex(String inFile){
     //http://www.java-tips.org/java-se-tips/java.awt.image/how-to-use-pixelgrabber-class-to-acquire-pixel-data-from-an-image-o.html
     Image image = Toolkit.getDefaultToolkit().getImage(inFile);
     int [] data= new int [1];
     PImage retval = createImage(1,1,ARGB);
     try {
   
       PixelGrabber grabber =
         new PixelGrabber(image, 0, 0, -1, -1, false);
   
       if (grabber.grabPixels()) {
         int w = grabber.getWidth();
         int h = grabber.getHeight();
         retval = createImage(w,h,ARGB);
         if (isGreyscaleImage(grabber)) {
           byte[] datax = (byte[]) grabber.getPixels();
         
             arraycopy(datax,retval.pixels);
           
           // Process greyscale image ...
   
         }
         else {
           data = (int[]) grabber.getPixels();
           arraycopy(data,retval.pixels);
           //arraycopy(data,pixels);
           // Process Color image
   
         }
       }
     }
     catch (InterruptedException e1) {
       e1.printStackTrace();
     }
   
   
     return retval;
   }
   
   public static final boolean isGreyscaleImage(PixelGrabber pg) {
     return pg.getPixels() instanceof byte[];
   }
   

Nice!
I'll try to put something together in a quick sketch.
Toolkit.getDefaultToolkit().getImage(inFile);  does read faster on JPG images, not sure about my PNG, will have to test, but it takes longer to load them into my TextureIO.newTexture() leaving the results about the same.  Didn't try all the pixel grabbing, since I"m not trying to get it into a PImage, but a Texture2D.  So now I'll be trying to figure out how to get that Image Toolkit trick, which I turned into a BufferedImage, into a Texture2D.  I think I've worked out the another way that's a lot faster for building the TextureIO if I can quickly build the glTexImage2D.

I tried loadImagex() as a drop in replacement for a PImage loadImage() and it didn't work for me, none of the images showed up.

I find that it only works with local .png files. (i.e. the files have to be on your hard drive and they have to be .png files)

But it almost twice as fast as loadImage();

Would be great if we could expand it's use to include jpg.  :-)  I guess at the least.. it would be easy to add if the string ends with ".png" do this, if not pass it to loadImage().  This is something I'm excited about... increasing my load performance would be great.  When you say local.. I expect the inner class calls would also work.. getClass().getClassLoader().getResource(file);

I see:
retval = createImage(w,h,ARGB);
Try:
retval = createImage(w,h,RGB);
to load Jpeg (no guarantee to work, but worth a try).

Phillo, that did work, along with adding in a default for dataPath(), like loadImage does.  Here is my revised version.
UPDATE: Better version below

1. PImage loadImagex(String inFile) {
2.   //http://www.java-tips.org/java-se-tips/java.awt.image/how-to-use-pixelgrabber-class-to-acquire-pixel-data-from-an-image-o.html
3.   URL urlpath = null;
4.   File ffile = new File(dataPath(inFile));
5.   if (!ffile.exists()) {
6.     ffile = new File(inFile);
7.     if (!!ffile.exists()) {
8.       urlpath = getClass().getClassLoader().getResource("data/" + inFile);  //for applets
9.       if (urlpath == null) {
10.         urlpath = getClass().getClassLoader().getResource(inFile);  //for applets
11.       }
12.     } else {
13.       try {
14.         urlpath = ffile.toURL();
15.       } catch (MalformedURLException e1) {
16.         e1.printStackTrace();
17.       }
18.     }
19.   } else {
20.     try {
21.         urlpath = ffile.toURL();
22.       } catch (MalformedURLException e1) {
23.         e1.printStackTrace();
24.       }
25.   }
26.   if (urlpath != null) {
27.   Image image = Toolkit.getDefaultToolkit().getImage(urlpath);
28.   if (image == null) {
29.     image = Toolkit.getDefaultToolkit().getImage(inFile);
30.   }
31.   int [] data= new int [1];
32.   PImage retval = null;
33.   try {
34.     java.awt.image.PixelGrabber grabber =
35.       new java.awt.image.PixelGrabber(image, 0, 0, -1, -1, false);
36.     if (grabber.grabPixels()) {
37.       int w = grabber.getWidth();
38.       int h = grabber.getHeight();
39.       if (inFile.toLowerCase().endsWith(".jpg") || inFile.toLowerCase().endsWith(".jpeg") ) {
40.         retval = createImage(w, h, RGB);
41.       }
42.       else {
43.         retval = createImage(w, h, ARGB);
44.       }
45.       if (grabber.getPixels() instanceof byte[]) {
46.         byte[] datax = (byte[]) grabber.getPixels();
47.         arraycopy(datax, retval.pixels);
48.         // Process greyscale image ...
49.       }
50.       else {
51.         data = (int[]) grabber.getPixels();
52.         arraycopy(data, retval.pixels);
53.         //arraycopy(data,pixels);
54.         // Process Color image
55.       }
56.     }
57.   }
58.   catch (InterruptedException e1) {
59.     e1.printStackTrace();
60.   }
61.   return retval;
62.   } else {
63.     return null;
64.   }
65. }

Testing this on applet didn't work.. guess my getClass().getClassLoader().getResource() hack is not working correctly.  If we can get this to work for Applets, I would definitely use it.

Here is a version that I tested to work with an applet, though it's not as fast Owaunandrew's code, it's still twice as fast as the normal loadImage() and it works with jpg and png.  If the image is not a jpg, png or encounters problems, it drops back to the normal loadImage(), so it could be used as a drop in replacement for loadImage() to gain added performance on these file types.

Normal loadImage(): avg 80ms
Owaunandrew's code: avg 35ms
Modified below using loadBytes(): avg 40ms

1. PImage loadImagex(String inFile) {
2.   if (inFile.toLowerCase().endsWith(".jpg") || inFile.toLowerCase().endsWith(".jpeg") ||  inFile.toLowerCase().endsWith(".png")) {
3.     //http://www.java-tips.org/java-se-tips/java.awt.image/how-to-use-pixelgrabber-class-to-acquire-pixel-data-from-an-image-o.html
4.     byte[] bytes   = loadBytes(inFile);
5.     if (bytes != null) {
6.       Image image = Toolkit.getDefaultToolkit().createImage(bytes);
7.       int [] data= new int [1];
8.       PImage retval = null;
9.       try {
10.         java.awt.image.PixelGrabber grabber =
11.           new java.awt.image.PixelGrabber(image, 0, 0, -1, -1, false);
12.         if (grabber.grabPixels()) {
13.           int w = grabber.getWidth();
14.           int h = grabber.getHeight();
15.           if (inFile.toLowerCase().endsWith(".jpg") || inFile.toLowerCase().endsWith(".jpeg") ) {
16.             retval = createImage(w, h, RGB);
17.           }
18.           else {
19.             retval = createImage(w, h, ARGB);
20.           }
21.           if (grabber.getPixels() instanceof byte[]) {
22.             // Process greyscale image ...
23.             byte[] datax = (byte[]) grabber.getPixels();
24.             arraycopy(datax, retval.pixels);
25.           }
26.           else {
27.             // Process Color image
28.             data = (int[]) grabber.getPixels();
29.             arraycopy(data, retval.pixels);
30.           }
31.         }
32.       }
33.       catch (InterruptedException e1) {
34.         System.err.println("Problem loading loadImagex, defaulting to loadImage().  Error: " + e1);
35.         return loadImage(inFile);
36.       }
37.       if (retval != null) {
38.         return retval;
39.       }
40.       return loadImage(inFile);
41.     }
42.     return loadImages(inFile);
43.   }
44.   return loadImage(inFile);
45. }

Textures... I'm still trying to work out the best method for loading them.  The code I posted in my first post in this thread is the fastest thus far overall, but I had mix results with it working.  When I say overall, I break the Texture time into two parts: Loading the file, applying the file to a texture.  I break these in two parts as the first can be done on a separate thread, where the second must be done on the main thread where it has access to the GL context.  The code above is very fast on loading the file, but average on applying the texture, the sum being the fastest.  The code I will post below is fast on applying the texture but average on the load.  So I'm hoping to find a good match of fast load and fast apply, but at the moment applying the texture with speed is more important to me as it actually halts the pipeline and delays the draw. 

So I'm using the below method, but if anyone knows how to very quickly load data into TextureData or directly into a Texture2D, that would probably be the best method.  The second part at the bottom is what really boosts the speed of applying the texture over the common method of directly loading to the TextureIO.newTexture();

First part

1. import com.sun.opengl.util.texture.*;
2. import javax.imageio.ImageIO;
3. import javax.media.opengl.GL;
4. 
   
5. Texture mytexture;
6. 
   
7. void setup() { 
8. TextureData td;
9.  try {  //this can be done in a separate thread
10.     // BufferedImage, mipmap or InputStream, mipmap, extension
11.     // BufferedImage using ReadIO worked best in my tests,
12.     // but the InputStream createInput can be used directly by adding the "png" extension
    
13.      td = TextureIO.newTextureData(ImageIO.read(createInput("test.png")), true); 
14.     //td = TextureIO.newTextureData(createInput("test.png"), true, "png");
    
15.   }
16.   catch (IOException e) {
17.     println("Error Loading Image: " + e);
18.   }
19. 
    
20.   mytexture = buildTexture(td);
21. }
22. 
    
23. void draw() {
    
24.     mytexture.enable();
25.     mytexture.bind();
26.     //openglstuff...
27.     mytexture.disable();
28. }
    

 
Second part, which has to be done in the main thread

1. Texture buildTexture(TextureData td) {
2.   Texture tex = TextureIO.newTexture(GL.GL_TEXTURE_2D);
3.   tex.setTexParameteri(GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
4.   tex.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
5.   tex.setTexParameteri(GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
6.   tex.setTexParameteri(GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
7.   tex.bind();
8.   tex.updateImage(td);
9.   tex.disable();
10.   return tex;
11. }