Move image processing to a separate interface with implementation. (#95)

Author: JuliaSamartseva

play-validations/memory-footprint/src/main/java/com/google/wear/watchface/dfx/memory/DrawableResourceDetails.java

@@ -20,39 +20,33 @@
 import static java.lang.Math.max;
 import static java.lang.Math.min;
 
-import java.awt.image.BufferedImage;
 import java.io.ByteArrayInputStream;
-import java.io.IOException;
 import java.security.MessageDigest;
 import java.util.Formatter;
-import java.util.Iterator;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
-import javax.imageio.ImageIO;
-import javax.imageio.ImageReader;
-import javax.imageio.stream.ImageInputStream;
 
 /** Details about a drawable resource that are relevant for the memory footprint calculation. */
 class DrawableResourceDetails {
     private static final int CHANNEL_MASK_A = 0xff000000;
 
     /**
-     * A lookup table used for computing the loss of precision whern an 8bit value is qualtized to a
+     * A lookup table used for computing the loss of precision where an 8bit value is quantized to a
      * 5bit value.
      */
-    private static final int QUANTZATION_ERROR_LUT5[] =
-            create8bppToNbppQualtizationErrorLookUpTable(5);
+    private static final int QUANTIZATION_ERROR_LUT5[] =
+            create8bppToNbppQuantizationErrorLookUpTable(5);
 
     /**
-     * A lookup table used for computing the loss of precision whern an 8bit value is qualtized to a
+     * A lookup table used for computing the loss of precision where an 8bit value is quantized to a
      * 6bit value.
      */
-    private static final int QUANTZATION_ERROR_LUT6[] =
-            create8bppToNbppQualtizationErrorLookUpTable(6);
+    private static final int QUANTIZATION_ERROR_LUT6[] =
+            create8bppToNbppQuantizationErrorLookUpTable(6);
 
     /** This corresponds to an average difference in luminosity of 5/10th of an 8bit value. */
-    private static final double MAX_ACCEPTIABLE_QUANTIZATION_ERROR = 0.5f;
+    private static final double MAX_ACCEPTABLE_QUANTIZATION_ERROR = 0.5f;
 
     public static class Bounds {
         int left;
@@ -123,11 +117,13 @@ public java.lang.String toString() {
      * take in its uncompressed format.
      *
      * @param resource the resource from a watch face package.
+     * @param imageProcessor the image processing implementation.
      * @return the memory footprint of that asset file or {@code Optional.empty()} if the file is
      *     not a drawable asset.
      * @throws java.lang.IllegalArgumentException when the image cannot be processed.
      */
-    static Optional<DrawableResourceDetails> fromPackageResource(AndroidResource resource) {
+    static Optional<DrawableResourceDetails> fromPackageResource(
+            AndroidResource resource, ImageProcessor imageProcessor) {
         // For fonts we assume the raw size of the resource is the MCU footprint.
         if (resource.isFont()) {
             return Optional.of(
@@ -153,58 +149,54 @@ static Optional<DrawableResourceDetails> fromPackageResource(AndroidResource res
                     String.format("Error while processing image %s", resource.getFilePath()), e);
         }
 
-        try (ImageInputStream imageInputStream =
-                ImageIO.createImageInputStream(new ByteArrayInputStream(resource.getData()))) {
-            Iterator<ImageReader> imageReaders = ImageIO.getImageReaders(imageInputStream);
-            if (!imageReaders.hasNext()) {
-                return Optional.empty();
-            }
-            ImageReader reader = imageReaders.next();
-            reader.setInput(imageInputStream);
-            // allowSearch forces the reader to return the true number of images even if the file
-            // format does not specify it, requiring an exhaustive search.
-            int numberOfImages = reader.getNumImages(/* allowSearch= */ true);
-            int maxWidth = 0;
-            int maxHeight = 0;
-            double maxQuantizationError = 0.0;
-            DrawableResourceDetails.Bounds accumulatedBounds = null;
-            for (int i = 0; i < numberOfImages; i++) {
-                // If an asset such as a GIF or a WEBP has more than 1 frame, then find the
-                // maximum size for any frame and multiply that by the number of frames.
-                maxWidth = max(maxWidth, reader.getWidth(i));
-                maxHeight = max(maxHeight, reader.getHeight(i));
-
-                BufferedImage image = reader.read(i);
-                Bounds bounds = computeBounds(image);
-
-                if (bounds != null) {
-                    if (accumulatedBounds == null) {
-                        accumulatedBounds = bounds;
-                    } else {
-                        accumulatedBounds = accumulatedBounds.computeUnion(bounds);
-                    }
-                }
+        ImageProcessor.ImageReader reader =
+                imageProcessor.createImageReader(new ByteArrayInputStream(resource.getData()));
+
+        if (reader == null) {
+            return Optional.empty();
+        }
 
-                QualtizationStats stats = computeQualtizationStats(image);
-                maxQuantizationError = max(maxQuantizationError, stats.getVisibleError());
+        int numberOfImages = reader.getNumImages();
+        int maxWidth = 0;
+        int maxHeight = 0;
+        double maxQuantizationError = 0.0;
+        DrawableResourceDetails.Bounds accumulatedBounds = null;
+
+        for (int i = 0; i < numberOfImages; i++) {
+            // If an asset such as a GIF or a WEBP has more than 1 frame, then find the
+            // maximum size for any frame and multiply that by the number of frames.
+            maxWidth = max(maxWidth, reader.getWidth(i));
+            maxHeight = max(maxHeight, reader.getHeight(i));
+
+            ImageProcessor.ImageData image = reader.read(i);
+            Bounds bounds = computeBounds(image);
+
+            if (bounds != null) {
+                if (accumulatedBounds == null) {
+                    accumulatedBounds = bounds;
+                } else {
+                    accumulatedBounds = accumulatedBounds.computeUnion(bounds);
+                }
             }
-            long biggestFrameMemoryFootprint = ((long) maxWidth) * maxHeight * 4;
-            boolean canBeQuantized = (maxQuantizationError < MAX_ACCEPTIABLE_QUANTIZATION_ERROR);
-            return Optional.of(
-                    new Builder()
-                            .setName(resource.getResourceName())
-                            .setNumberOfImages(numberOfImages)
-                            .setBiggestFrameFootprintBytes(biggestFrameMemoryFootprint)
-                            .setBounds(accumulatedBounds)
-                            .setWidth(maxWidth)
-                            .setHeight(maxHeight)
-                            .setSha1(sha1)
-                            .setCanUseRGB565(canBeQuantized)
-                            .build());
-        } catch (IOException e) {
-            throw new IllegalArgumentException(
-                    String.format("Error while processing image %s", resource.getFilePath()), e);
+
+            QuantizationStats stats = computeQualtizationStats(image);
+            maxQuantizationError = max(maxQuantizationError, stats.getVisibleError());
         }
+
+        long biggestFrameMemoryFootprint = ((long) maxWidth) * maxHeight * 4;
+        boolean canBeQuantized = (maxQuantizationError < MAX_ACCEPTABLE_QUANTIZATION_ERROR);
+
+        return Optional.of(
+                new Builder()
+                        .setName(resource.getResourceName())
+                        .setNumberOfImages(numberOfImages)
+                        .setBiggestFrameFootprintBytes(biggestFrameMemoryFootprint)
+                        .setBounds(accumulatedBounds)
+                        .setWidth(maxWidth)
+                        .setHeight(maxHeight)
+                        .setSha1(sha1)
+                        .setCanUseRGB565(canBeQuantized)
+                        .build());
     }
 
     private final String name;
@@ -437,10 +429,10 @@ public DrawableResourceDetails build() {
      * Reads the image with the specified index and then computes the {@link Bounds} of the visible
      * pixels.
      *
-     * @param image the {@link BufferedImage}
+     * @param image the {@link ImageProcessor.ImageData}
      * @return The {@link Bounds} of the visible pixels.
      */
-    private static Bounds computeBounds(BufferedImage image) {
+    private static Bounds computeBounds(ImageProcessor.ImageData image) {
         Bounds bounds = new Bounds();
 
         // Scan from the top down to find the first non-transparent row.
@@ -454,11 +446,11 @@ private static Bounds computeBounds(BufferedImage image) {
         }
 
         if (y == height) {
-            // The image is fully transparent!
+            // The image is fully transparent.
             return null;
         }
 
-        // Scan from the bottum up to find the first non-transparent row.
+        // Scan from the bottom up to find the first non-transparent row.
         for (y = height; y > 0; ) {
             y--;
             if (!isRowFullyTransparent(image, y)) {
@@ -488,20 +480,20 @@ private static Bounds computeBounds(BufferedImage image) {
         return bounds;
     }
 
-    private static boolean isRowFullyTransparent(BufferedImage image, int y) {
+    private static boolean isRowFullyTransparent(ImageProcessor.ImageData image, int y) {
         int width = image.getWidth();
         for (int x = 0; x < width; x++) {
-            if (!isFullyTransparent(image.getRGB(x, y))) {
+            if (!isFullyTransparent(image.getRgb(x, y))) {
                 return false;
             }
         }
         return true;
     }
 
     private static boolean isColumnFullyTransparent(
-            BufferedImage image, int x, int top, int bottom) {
+            ImageProcessor.ImageData image, int x, int top, int bottom) {
         for (int y = top; y < bottom; y++) {
-            if (!isFullyTransparent(image.getRGB(x, y))) {
+            if (!isFullyTransparent(image.getRgb(x, y))) {
                 return false;
             }
         }
@@ -512,7 +504,7 @@ private static boolean isFullyTransparent(int argb) {
         return (argb & CHANNEL_MASK_A) == 0;
     }
 
-    private static class QualtizationStats {
+    private static class QuantizationStats {
         long visiblePixels = 0;
         long visiblePixelQuantizationErrorSum = 0;
 
@@ -521,34 +513,34 @@ private static class QualtizationStats {
         }
     }
 
-    private static QualtizationStats computeQualtizationStats(BufferedImage image) {
+    private static QuantizationStats computeQualtizationStats(ImageProcessor.ImageData image) {
         int width = image.getWidth();
         int height = image.getHeight();
-        QualtizationStats qualtizationStats = new QualtizationStats();
+        QuantizationStats quantizationStats = new QuantizationStats();
         for (int y = 0; y < height; y++) {
             for (int x = 0; x < width; x++) {
-                int argb = image.getRGB(x, y);
+                int argb = image.getRgb(x, y);
                 int a = (argb >> 24) & 0xff;
                 if (a < 255) {
                     continue;
                 }
 
-                qualtizationStats.visiblePixels++;
+                quantizationStats.visiblePixels++;
 
                 int r = (argb >> 16) & 0xff;
                 int g = (argb >> 8) & 0xff;
                 int b = argb & 0xff;
 
-                qualtizationStats.visiblePixelQuantizationErrorSum += QUANTZATION_ERROR_LUT5[r];
-                qualtizationStats.visiblePixelQuantizationErrorSum += QUANTZATION_ERROR_LUT6[g];
-                qualtizationStats.visiblePixelQuantizationErrorSum += QUANTZATION_ERROR_LUT5[b];
+                quantizationStats.visiblePixelQuantizationErrorSum += QUANTIZATION_ERROR_LUT5[r];
+                quantizationStats.visiblePixelQuantizationErrorSum += QUANTIZATION_ERROR_LUT6[g];
+                quantizationStats.visiblePixelQuantizationErrorSum += QUANTIZATION_ERROR_LUT5[b];
             }
         }
-        return qualtizationStats;
+        return quantizationStats;
     }
 
     /** Constructs a table of the error introduced by quantizing an 8 bit value to a N bit value. */
-    private static int[] create8bppToNbppQualtizationErrorLookUpTable(int n) {
+    private static int[] create8bppToNbppQuantizationErrorLookUpTable(int n) {
         int[] table = new int[256];
         int bitsLost = 8 - n;
         int twoPowN = 1 << bitsLost;
@@ -557,7 +549,7 @@ private static int[] create8bppToNbppQualtizationErrorLookUpTable(int n) {
             // This rounds i to the nearest n-bit value before converting back to an 8 bit value.
             int quantizedValue = min(((i + halfTwoPowN) / twoPowN) * twoPowN, 255);
 
-            // Record the error due to qualtization in the table. This has a saw-tooth pattern where
+            // Record the error due to quantization in the table. This has a saw-tooth pattern where
             // n-bit values that correspond directly to 8 bit ones have an error of 0, rising to a
             // maximum error of halfPlusOne in between.
             table[i] = abs(i - quantizedValue);

play-validations/memory-footprint/src/main/java/com/google/wear/watchface/dfx/memory/ImageProcessor.kt

@@ -0,0 +1,42 @@
+package com.google.wear.watchface.dfx.memory
+
+import java.io.IOException
+import java.io.InputStream
+import java.util.Optional
+
+/** An interface for processing image data.  */
+interface ImageProcessor {
+    /** Holds the dimensions and pixel data of an image.  */
+    interface ImageData {
+        /** Width of the image in pixels.  */
+        val width: Int
+
+        /** Height of the image in pixels.  */
+        val height: Int
+
+        /** Returns the RGB color of the pixel at the specified coordinates.  */
+        fun getRgb(x: Int, y: Int): Int
+    }
+
+    /** A reader for decoding image files, including animated formats.  */
+    interface ImageReader {
+        /** Returns the width of a specific image frame.  */
+        fun getWidth(imageIndex: Int): Int
+
+        /** Returns the height of a specific image frame.  */
+        fun getHeight(imageIndex: Int): Int
+
+        /** Total number of frames in the source. */
+        val numImages: Int
+
+        /** Reads and decodes a specific image frame into an [ImageData] object.  */
+        fun read(imageIndex: Int): ImageData?
+    }
+
+    /**
+     * Creates an [ImageReader] for the given image input stream.
+     *
+     * @param stream The input stream of the image data.
+     */
+    fun createImageReader(stream: InputStream): ImageReader?
+}

play-validations/memory-footprint/src/main/java/com/google/wear/watchface/dfx/memory/JvmImageProcessor.kt

@@ -0,0 +1,42 @@
+package com.google.wear.watchface.dfx.memory
+
+import com.google.wear.watchface.dfx.memory.ImageProcessor.ImageData
+import java.io.InputStream
+import javax.imageio.ImageIO
+
+/** JVM-specific implementation of ImageProcessor using AWT and ImageIO. */
+class JvmImageProcessor : ImageProcessor {
+    override fun createImageReader(stream: InputStream): ImageProcessor.ImageReader? {
+        val imageInputStream = ImageIO.createImageInputStream(stream)
+        val imageReaders = ImageIO.getImageReaders(imageInputStream)
+
+        if (!imageReaders.hasNext()) {
+            return null
+        }
+
+        val reader = imageReaders.next()
+        reader.input = imageInputStream
+
+        return object : ImageProcessor.ImageReader {
+            override fun getWidth(imageIndex: Int) = reader.getWidth(imageIndex)
+
+            override fun getHeight(imageIndex: Int) = reader.getHeight(imageIndex)
+
+            override val numImages: Int = reader.getNumImages(true)
+
+            override fun read(imageIndex: Int): ImageData {
+                val bufferedImage = reader.read(imageIndex)
+
+                return object : ImageData {
+                    override val width: Int = bufferedImage.width
+
+                    override val height: Int = bufferedImage.height
+
+                    override fun getRgb(x: Int, y: Int): Int {
+                        return bufferedImage.getRGB(x, y)
+                    }
+                }
+            }
+        }
+    }
+}

play-validations/memory-footprint/src/main/java/com/google/wear/watchface/dfx/memory/ResourceMemoryEvaluator.java

@@ -114,7 +114,9 @@ static List<MemoryFootprint> evaluateMemoryFootprint(EvaluationSettings evaluati
         try (InputPackage inputPackage = InputPackage.open(evaluationSettings.getWatchFacePath())) {
             WatchFaceData watchFaceData =
                     WatchFaceData.fromResourcesStream(
-                            inputPackage.getWatchFaceFiles(), evaluationSettings);
+                            inputPackage.getWatchFaceFiles(),
+                            evaluationSettings,
+                            new JvmImageProcessor());
 
             if (!evaluationSettings.isHoneyfaceMode()) {
                 String wffVersion =