Hi,
I'm trying to load some 32 bit, uncompressed TGA files (some saved from Photoshop CS 2, others saved from Apple's Preview) and not one of them will load. All have alpha channels and none are compressed. I'm not absolutely sure if this is a bug (or I would have put it in the bug database, but it may be just me). Can anyone else confirm this or tell me what I'm doing wrong?

here's a sample TGA file:
http://temp.duodec.net/Explosion1.tga

generally, only tga images that are created by processing are going to work, i should update the reference to say that. use png instead.

interesting... what sort of process are you running, i.e. is this something that others will run into as well? tga support was implemented as a means for a better option than uncompressed tiff, which was causing problems with some adobe products.

offhand, my guess is that your file is using the 'normal' row order for tga (starting at the bottom), i'd have to take a look, though.

if you're gonna write the code, then definitely post, because it'll be useful to someone else. inclusion in PApplet would hinge on how small the changes are--since tga isn't a huge priority (unless your process is something that more people will be using), it's less likely to get more code.

verified that it's the y-ordering issue.. you can actually use this (pre-0115) version of the tga loader to load it properly. i'll hack this back into the loader since it's functionality that we lost and will only take a couple of lines to fix.

Code:

PImage loadImageTGA(String filename) {
    // load image file as byte array
    byte[] buffer = loadBytes(filename);
    if (buffer == null) return null;

    // check if it's a TGA and has 8bits/colour channel
    //if (buffer[2] == 2 && buffer[17] == 8) {
    // [toxi20050929] changed format validation
    // only number of bits/pixel are checked now...
    if (buffer[2] == 2 && (buffer[16] == 24 || buffer[16]==32 )) {
	// get image dimensions
	int w = ((buffer[13] & 0xff) << 8) + (buffer[12] & 0xff);
	int h = ((buffer[15] & 0xff) << 8) + (buffer[14] & 0xff);
	// check if image has alpha
	boolean hasAlpha=(buffer[16] == 32);

	// setup new image object
	PImage img = new PImage(w,h);
	img.format = (hasAlpha ? ARGB : RGB);

	// targa's are written upside down, so we need to parse it in reverse
	int index = (h-1) * w;
	// actual bitmap data starts at byte 18
	int offset = 18;

	// read out line by line
	for (int y = h-1; y >= 0; y--) {
	  for (int x = 0; x < w; x++) {
	    img.pixels[index + x] =
		(buffer[offset++] & 0xff) |
		((buffer[offset++] & 0xff) << 8) |
		((buffer[offset++] & 0xff) << 16) |
		(hasAlpha ? ((buffer[offset++] & 0xff) << 24) : 0xff000000);
	  }
	  index -= w;
	}
	return img;
    }
    System.err.println("loadImage(): bad targa image format");
    return null;
  }