commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dam...@apache.org
Subject svn commit: r1345260 - in /commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders: DataReaderStrips.java DataReaderTiled.java
Date Fri, 01 Jun 2012 15:59:00 GMT
Author: damjan
Date: Fri Jun  1 15:59:00 2012
New Revision: 1345260

URL: http://svn.apache.org/viewvc?rev=1345260&view=rev
Log:
Add a streamlined TIFF reader that reduces load time by a factor of 5.

Jira issue key: IMAGING-69
Submitted by: Gary Lucas <gwlucas at sonalysts dot com>


Modified:
    commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders/DataReaderStrips.java
    commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders/DataReaderTiled.java

Modified: commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders/DataReaderStrips.java
URL: http://svn.apache.org/viewvc/commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders/DataReaderStrips.java?rev=1345260&r1=1345259&r2=1345260&view=diff
==============================================================================
--- commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders/DataReaderStrips.java
(original)
+++ commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders/DataReaderStrips.java
Fri Jun  1 15:59:00 2012
@@ -25,6 +25,7 @@ import org.apache.commons.imaging.common
 import org.apache.commons.imaging.formats.tiff.TiffDirectory;
 import org.apache.commons.imaging.formats.tiff.TiffImageData;
 import org.apache.commons.imaging.formats.tiff.photometricinterpreters.PhotometricInterpreter;
+import org.apache.commons.imaging.formats.tiff.photometricinterpreters.PhotometricInterpreterRgb;
 
 public final class DataReaderStrips extends DataReader {
 
@@ -52,12 +53,122 @@ public final class DataReaderStrips exte
 
     private void interpretStrip(ImageBuilder imageBuilder, byte bytes[],
             int pixels_per_strip) throws ImageReadException, IOException {
-        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
-        BitInputStream bis = new BitInputStream(bais, byteOrder);
-
         if (y >= height) {
             return;
         }
+
+        // changes added May 2012
+        // In the original implementation, a general-case bit reader called
+        // getSamplesAsBytes is used to retrieve the samples (raw data values)
+        // for each pixel in the strip. These samples are then passed into a
+        // photogrammetric interpreter that converts them to ARGB pixel values
+        // and stores them in the image. Because the bit-reader must handle
+        // a large number of formats, it involves several conditional
+        // branches that must be executed each time a pixel is read.
+        // Depending on the size of an image, the same evaluations must be
+        // executed redundantly thousands and perhaps millions of times
+        // in order to process the complete collection of pixels.
+        // This code attempts to remove that redundancy by
+        // evaluating the format up-front and bypassing the general-format
+        // code for two commonly used data formats: the 8 bits-per-pixel
+        // and 24 bits-per-pixel cases. For these formats, the
+        // special case code achieves substantial reductions in image-loading
+        // time. In other cases, it simply falls through to the original code
+        // and continues to read the data correctly as it did in previous
+        // versions of this class.
+        // In addition to bypassing the getBytesForSample() method,
+        // the 24-bit case also implements a special block for RGB
+        // formatted images. To get a sense of the contributions of each
+        // optimization (removing getSamplesAsBytes and removing the
+        // photometric interpreter), consider the following results from tests
+        // conducted with large TIFF images using the 24-bit RGB format
+        // bypass getSamplesAsBytes: 67.5 % reduction
+        // bypass both optimizations: 77.2 % reduction
+        //
+        //
+        // Future Changes
+        // Both of the 8-bit and 24-bit blocks make the assumption that a strip
+        // always begins on x = 0 and that each strip exactly fills out the rows
+        // it contains (no half rows). The original code did not make this
+        // assumption, but the approach is consistent with the TIFF 6.0 spec
+        // (1992),
+        // and should probably be considered as an enhancement to the
+        // original general-case code block that remains from the original
+        // implementation. Taking this approach saves one conditional
+        // operation per pixel or about 5 percent of the total run time
+        // in the 8 bits/pixel case.
+
+        // verify that all samples are one byte in size
+        boolean allSamplesAreOneByte = true;
+        for (int i = 0; i < bitsPerSample.length; i++) {
+            if (bitsPerSample[i] != 8) {
+                allSamplesAreOneByte = false;
+                break;
+            }
+        }
+
+        if (predictor != 2 && bitsPerPixel == 8 && allSamplesAreOneByte)
{
+            int k = 0;
+            int nRows = pixels_per_strip / width;
+            if (y + nRows > height) {
+                nRows = height - y;
+            }
+            int i0 = y;
+            int i1 = y + nRows;
+            x = 0;
+            y += nRows;
+            int[] samples = new int[1];
+            for (int i = i0; i < i1; i++) {
+                for (int j = 0; j < width; j++) {
+                    samples[0] = bytes[k++] & 0xff;
+                    photometricInterpreter.interpretPixel(imageBuilder,
+                            samples, j, i);
+                }
+            }
+            return;
+        } else if (predictor != 2 && bitsPerPixel == 24 && allSamplesAreOneByte)
{
+            int k = 0;
+            int nRows = pixels_per_strip / width;
+            if (y + nRows > height) {
+                nRows = height - y;
+            }
+            int i0 = y;
+            int i1 = y + nRows;
+            x = 0;
+            y += nRows;
+            if (photometricInterpreter instanceof PhotometricInterpreterRgb) {
+                for (int i = i0; i < i1; i++) {
+                    for (int j = 0; j < width; j++, k += 3) {
+                        int rgb = 0xff000000
+                                | (((bytes[k] << 8) | (bytes[k + 1] & 0xff)) <<
8)
+                                | (bytes[k + 2] & 0xff);
+                        imageBuilder.setRGB(j, i, rgb);
+                    }
+                }
+            } else {
+                int samples[] = new int[3];
+                for (int i = i0; i < i1; i++) {
+                    for (int j = 0; j < width; j++) {
+                        samples[0] = bytes[k++] & 0xff;
+                        samples[1] = bytes[k++] & 0xff;
+                        samples[2] = bytes[k++] & 0xff;
+                        photometricInterpreter.interpretPixel(imageBuilder,
+                                samples, j, i);
+                    }
+                }
+            }
+
+            return;
+        }
+
+        // ------------------------------------------------------------
+        // original code before May 2012 modification
+        // this logic will handle all cases not conforming to the
+        // special case handled above
+
+        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
+        BitInputStream bis = new BitInputStream(bais, byteOrder);
+
         int[] samples = new int[bitsPerSample.length];
         resetPredictor();
         for (int i = 0; i < pixels_per_strip; i++) {

Modified: commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders/DataReaderTiled.java
URL: http://svn.apache.org/viewvc/commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders/DataReaderTiled.java?rev=1345260&r1=1345259&r2=1345260&view=diff
==============================================================================
--- commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders/DataReaderTiled.java
(original)
+++ commons/proper/imaging/trunk/src/main/java/org/apache/commons/imaging/formats/tiff/datareaders/DataReaderTiled.java
Fri Jun  1 15:59:00 2012
@@ -25,6 +25,7 @@ import org.apache.commons.imaging.common
 import org.apache.commons.imaging.formats.tiff.TiffDirectory;
 import org.apache.commons.imaging.formats.tiff.TiffImageData;
 import org.apache.commons.imaging.formats.tiff.photometricinterpreters.PhotometricInterpreter;
+import org.apache.commons.imaging.formats.tiff.photometricinterpreters.PhotometricInterpreterRgb;
 
 public final class DataReaderTiled extends DataReader {
 
@@ -58,6 +59,65 @@ public final class DataReaderTiled exten
 
     private void interpretTile(ImageBuilder imageBuilder, byte bytes[],
             int startX, int startY) throws ImageReadException, IOException {
+        // changes introduced May 2012
+        // The following block of code implements changes that
+        // reduce image loading time by using special-case processing
+        // instead of the general-purpose logic from the original
+        // implementation. For a detailed discussion, see the comments for
+        // a similar treatment in the DataReaderStrip class
+        //
+
+        // verify that all samples are one byte in size
+        boolean allSamplesAreOneByte = true;
+        for (int i = 0; i < bitsPerSample.length; i++) {
+            if (bitsPerSample[i] != 8) {
+                allSamplesAreOneByte = false;
+                break;
+            }
+        }
+
+        if (predictor != 2 && bitsPerPixel == 24 && allSamplesAreOneByte)
{
+            int k = 0;
+            int i0 = startY;
+            int i1 = startY + tileLength;
+            if (i1 > height) {
+                // the tile is padded past bottom of image
+                i1 = height - startY;
+            }
+            int j0 = startX;
+            int j1 = startX + tileWidth;
+            if (j1 > width) {
+                // the tile is padded to beyond the tile width
+                j1 = width - startX;
+            }
+            if (photometricInterpreter instanceof PhotometricInterpreterRgb) {
+                for (int i = i0; i < i1; i++) {
+                    k = (i - i0) * tileWidth * 3;
+                    for (int j = j0; j < j1; j++, k += 3) {
+                        int rgb = 0xff000000
+                                | (((bytes[k] << 8) | (bytes[k + 1] & 0xff)) <<
8)
+                                | (bytes[k + 2] & 0xff);
+                        imageBuilder.setRGB(j, i, rgb);
+                    }
+                }
+            } else {
+                int samples[] = new int[3];
+                for (int i = i0; i < i1; i++) {
+                    k = (i - i0) * tileWidth * 3;
+                    for (int j = j0; j < j1; j++) {
+                        samples[0] = bytes[k++] & 0xff;
+                        samples[1] = bytes[k++] & 0xff;
+                        samples[2] = bytes[k++] & 0xff;
+                        photometricInterpreter.interpretPixel(imageBuilder,
+                                samples, j, i);
+                    }
+                }
+            }
+            return;
+        }
+
+        // End of May 2012 changes
+
         ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
         BitInputStream bis = new BitInputStream(bais, byteOrder);
 



Mime
View raw message