Photos taken on a single user's android phone cannot be processed by ImageIO

Question

I have an Android app that takes photos, converts them to Bitmap using:

private Bitmap generateBitmap(byte[] data) {
    Bitmap bmp = BitmapFactory.decodeByteArray(data, 0, data.length);
    Matrix mat = new Matrix();
    mat.postRotate(-90);
    return Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(),
            bmp.getHeight(), mat, true);
}

then to PNG using:

bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);

The outputStream is then posted (multipart/form-data) to my web server (jboss). On the server, jax-rs and MultipartForm convert it to a data[] and send on for additional processing that begins with:

BufferedImage image = ImageIO.read(new ByteArrayInputStream(form.getImageFileData()));

The app is in production and works as expected, until now. We activated a new user last week (Samsung Galaxy Note Edge) and every single photo he uploads generates javax.imageio.IIOException: Error reading PNG image data when I invoke ImageIO.read() where the root cause of the stack trace is:

Caused by: java.util.zip.ZipException: incorrect data check

The photos display properly in a browser but I am unable to fully process them because of this exception. I can also open them in an editor rotate them 360 degrees, re-save them and then process them just fine.

Can anyone help me understand what could cause this problem on just this one device or suggest something I can do on the server to work around it and still generate the BufferedImage I need for further processing? Manually editing each photo is not an option.

UPDATE: As suggested, I ran pngcheck on 14 photos from this device. It returned 2 valid and 12 invalid with error: zlib: inflate error = -3 (data error). All 14 fail as described above using ImageIO.

An image with this problem can be seen at: https://tracweb-safecommunity.rhcloud.com/rest/monitoredProfile/106/testResult_8284.png

Answer 1

To me, it really seems that the particular device (vendor specific OS build?) generates broken PNGs. However, it seems that the only thing missing, is some Zip/zlib data integrity check value, and the image can be properly reconstructed, if you ignore the data integrity checks.

For some reason, my original answer (below) does not work for the OP. So here's an alternative (and more verbose) approach using only ImageIO:

InputStream input = new ByteArrayInputStream(form.getImageFileData());
Iterator<ImageReader> readers = ImageIO.getImageReaders(input);

if (!readers.hasNext()) {
    // TODO: Handle, return null or throw exception, whatever is more appropriate
}

ImageReader reader = readers.next();
reader.setInput(input);

try {
    ImageReadParam param = reader.getDefaultReadParam();
    int imageNo = 0;

    int width = reader.getWidth(imageNo);
    int height = reader.getHeight(imageNo);

    // If possible, create a destination image up front
    ImageTypeSpecifier type = reader.getRawImageType(imageNo);
    if (type != null) {
        param.setDestination(type.createBufferedImage(width, height));
    }

    // Decode into the destination
    BufferedImage image;
    try {
        image = reader.read(imageNo, param);
    }
    catch (IOException e) {
        if (e.getCause() instanceof ZipException && param.getDestination() != null) {
            // If we got here, the destination will contain a partial image
            // We'll use that.
            image = param.getDestination();
        }
        else {
            throw e;
        }
    }
}
finally {
    input.close();
}

The last line of the image will be missing due to the ZipException, otherwise, the image looks good.

---

Here's a possible workaround using Java. I have tested this on OS X, and it works for me, using both Java 1.7.0_71 and 1.8.0_51 (both Oracle JREs), using the supplied test file. A stack trace is printed to the console, and the last line of the image is missing, otherwise, it looks good:

byte[] data = form.getImageFileData();
Image tmp = Toolkit.getDefaultToolkit().createImage(data);
BufferedImage image = new BufferedImageFactory(tmp).getBufferedImage();

This will be a little slower than using ImageIO, so I suggest you first try using ImageIO as before, then use this code only as a fallback when it fails with a java.util.zip.ZipException root cause.

PS: You can probably convert the Image to BufferedImage using a MediaTracker to fully load it (or use the ImageIcon hack), and then painting the result to a BufferedImage too, if you don't mind losing some precision, like the original color model etc.

---

The BufferedImageFactory class is part of my TwelveMonkeys ImageIO library, is available under BSD license and can be found on GitHub.