PngProcessor.java

/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.builder.png;

import static com.google.common.base.Preconditions.checkNotNull;

import com.android.SdkConstants;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.annotations.VisibleForTesting;
import com.google.common.collect.Lists;
import com.google.common.io.Files;

import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.zip.Deflater;

import javax.imageio.ImageIO;

/**
 * a PngProcessor.
 *
 * It reads a png file and write another png file that's been optimized
 * and processed in case of a 9-patch.
 */
public class PngProcessor {

    private static final int COLOR_WHITE              = 0xFFFFFFFF;
    private static final int COLOR_TICK               = 0xFF000000;
    private static final int COLOR_LAYOUT_BOUNDS_TICK = 0xFFFF0000;

    private static final int PNG_9PATCH_NO_COLOR          = 0x00000001;
    private static final int PNG_9PATCH_TRANSPARENT_COLOR = 0x00000000;


    @NonNull
    private final File mFile;

    private Chunk mIhdr;
    private Chunk mIdat;
    private List<Chunk> mOtherChunks = Lists.newArrayList();

    /**
     * Processes a given png and writes the resulting png file.
     * @param from the input file
     * @param to the destination file
     * @throws IOException
     * @throws NinePatchException
     */
    public static void process(@NonNull File from, @NonNull File to)
            throws IOException, NinePatchException {
        PngProcessor processor = new PngProcessor(from);
        processor.read();

        if (!processor.is9Patch() && processor.size() >= from.length()) {
            Files.copy(from, to);
            return;
        }

        PngWriter writer = new PngWriter(to);
        writer.setIhdr(processor.getIhdr())
                .setChunks(processor.getOtherChunks())
                .setChunk(processor.getIdat());

        writer.write();
    }

    public static void clearCache() {
        ByteUtils.Cache.getCache().clear();
    }

    @VisibleForTesting
    PngProcessor(@NonNull File file) {
        checkNotNull(file);

        mFile = file;
    }

    @VisibleForTesting
    @NonNull
    Chunk getIhdr() {
        return mIhdr;
    }

    @VisibleForTesting
    @NonNull
    List<Chunk> getOtherChunks() {
        return mOtherChunks;
    }

    @VisibleForTesting
    @NonNull
    Chunk getIdat() {
        return mIdat;
    }

    @VisibleForTesting
    void read() throws IOException, NinePatchException {
        BufferedImage image = ImageIO.read(mFile);

        processImageContent(image);
    }

    private void addChunk(@NonNull Chunk chunk) {
        mOtherChunks.add(chunk);
    }

    /**
     * Returns the size of the generated png.
     */
    long size() {
        long size = PngWriter.SIGNATURE.length;

        size += mIhdr.size();
        size += mIdat.size();
        for (Chunk chunk : mOtherChunks) {
            size += chunk.size();
        }

        return size;
    }

    private void processImageContent(@NonNull BufferedImage image) throws NinePatchException,
            IOException {
        int width = image.getWidth();
        int height = image.getHeight();

        int[] content = new int[width * height];

        image.getRGB(0, 0, width, height, content, 0, width);

        int startX = 0;
        int startY = 0;
        int endX = width;
        int endY = height;

        if (is9Patch()) {
            startX = 1;
            startY = 1;
            endX--;
            endY--;

            processBorder(content, width, height);
        }

        ColorType colorType = createImage(content, width, startX, endX, startY, endY, is9Patch());

        mIhdr = computeIhdr(endX - startX, endY - startY, (byte) 8, colorType);
    }

    private void writeIDat(byte[] data) throws IOException {
        // create a growing buffer for the result.
        ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);

        Deflater deflater = new Deflater(Deflater.DEFLATED);
        deflater.setInput(data);
        deflater.finish();

        // temp buffer for compressed data.
        byte[] tmpBuffer = new byte[1024];
        while (!deflater.finished()) {
            int compressedLen = deflater.deflate(tmpBuffer);
            bos.write(tmpBuffer, 0, compressedLen);
        }

        bos.close();

        byte[] compressedData = bos.toByteArray();

        mIdat = new Chunk(PngWriter.IDAT, compressedData);
    }

    /**
     * Creates the PNG image buffer to be encoded in IDAT.
     *
     * This figures out the smallest way to encode it, and creates the IDAT chunk (and other needed
     * chunks like PLTE).
     *
     * @param content the image array in ARGB.
     * @param scanline the scanline value for the image buffer
     * @param startX the startX of the image we want to create from the buffer
     * @param endX the endX of the image we want to create from the buffer
     * @param startY the startY of the image we want to create from the buffer
     * @param endY the endY of the image we want to create from the buffer
     * @param is9Patch whether the image is a nine-patch
     */
    private ColorType createImage(@NonNull int[] content, int scanline,
            int startX, int endX, int startY, int endY, boolean is9Patch) throws IOException {
        int[] paletteColors = new int[256];
        int paletteColorCount = 0;

        int grayscaleTolerance = -1;
        int maxGrayDeviation = 0;

        boolean isOpaque = true;
        boolean isPalette = true;
        boolean isGrayscale = true;

        int width = endX - startX;
        int height = endY - startY;

        // RGBA buffer, in case it's the best one.
        int rgbaLen = (1 + width * 4) * height;
        ByteBuffer rgbaBufer = ByteBuffer.allocate(rgbaLen);

        // Store palette data optimistically in case we use palette mode.
        // Better than regoing through content after.
        int indexedLen = (1 + width) * height;
        byte[] indexedContent = new byte[indexedLen];
        int indexedContentIndex = 0;

        // Scan the entire image and determine if:
        // 1. Every pixel has R == G == B (grayscale)
        // 2. Every pixel has A == 255 (opaque)
        // 3. There are no more than 256 distinct RGBA colors
        for (int y = startY ; y < endY ; y++) {
            rgbaBufer.put((byte) 0);
            indexedContent[indexedContentIndex++] = 0;

            for (int x = startX ; x < endX ; x++) {
                int argb = content[(scanline * y) + x];

                int aa =  argb >>> 24;
                int rr = (argb >>  16) & 0x000000FF;
                int gg = (argb >>   8) & 0x000000FF;
                int bb =  argb & 0x000000FF;

                int odev = maxGrayDeviation;
                maxGrayDeviation = Math.max(Math.abs(rr - gg), maxGrayDeviation);
                maxGrayDeviation = Math.max(Math.abs(gg - bb), maxGrayDeviation);
                maxGrayDeviation = Math.max(Math.abs(bb - rr), maxGrayDeviation);

                // Check if image is really grayscale
                if (isGrayscale && (rr != gg || rr != bb)) {
                    isGrayscale = false;
                }

                // Check if image is really opaque
                if (isOpaque && aa != 0xff) {
                    isOpaque = false;
                }

                // Check if image is really <= 256 colors
                if (isPalette) {
                    int rgba = (argb << 8) | aa;

                    boolean match = false;
                    int idx;
                    for (idx = 0; idx < paletteColorCount; idx++) {
                        if (paletteColors[idx] == rgba) {
                            match = true;
                            break;
                        }
                    }

                    // Write the palette index for the pixel to outRows optimistically
                    // We might overwrite it later if we decide to encode as gray or
                    // gray + alpha
                    indexedContent[indexedContentIndex++] = (byte)idx;
                    if (!match) {
                        if (paletteColorCount == 256) {
                            isPalette = false;
                        } else {
                            paletteColors[paletteColorCount++] = rgba;
                        }
                    }
                }

                // write rgba optimistically
                rgbaBufer.putInt((argb << 8) | aa);
            }
        }

        boolean hasTransparency = !isOpaque;

        int bpp = isOpaque ? 3 : 4;
        int paletteSize = width * height + (isOpaque ? 3 : 4) * paletteColorCount;

        ColorType colorType;

        // Choose the best color type for the image.
        // 1. Opaque gray - use COLOR_TYPE_GRAY at 1 byte/pixel
        // 2. Gray + alpha - use COLOR_TYPE_PALETTE if the number of distinct combinations
        //     is sufficiently small, otherwise use COLOR_TYPE_GRAY_ALPHA
        // 3. RGB(A) - use COLOR_TYPE_PALETTE if the number of distinct colors is sufficiently
        //     small, otherwise use COLOR_TYPE_RGB{_ALPHA}
        if (isGrayscale) {
            if (isOpaque) {
                colorType = ColorType.GRAY_SCALE; // 1 byte/pixel
            } else {
                // Use a simple heuristic to determine whether using a palette will
                // save space versus using gray + alpha for each pixel.
                // This doesn't take into account chunk overhead, filtering, LZ
                // compression, etc.
                if (isPalette && paletteSize < 2 * width * height) {
                    colorType = ColorType.PLTE; // 1 byte/pixel + 4 bytes/color
                } else {
                    colorType = ColorType.GRAY_SCALE_ALPHA; // 2 bytes per pixel
                }
            }
        } else if (isPalette && paletteSize < bpp * width * height) {
            colorType = ColorType.PLTE; // 1 byte/pixel + 4 bytes/color
        } else {
            if (maxGrayDeviation <= grayscaleTolerance) {
                colorType = isOpaque ? ColorType.GRAY_SCALE : ColorType.GRAY_SCALE_ALPHA;
            } else {
                colorType = isOpaque ? ColorType.RGB : ColorType.RGBA;
            }
        }

        // If the image is a 9-patch, we need to preserve it as a ARGB file to make
        // sure the pixels will not be pre-dithered/clamped until we decide they are
        if (is9Patch && (colorType == ColorType.RGB ||
                colorType == ColorType.GRAY_SCALE || colorType == ColorType.PLTE)) {
            colorType = ColorType.RGBA;
        }

        // Perform postprocessing of the image or palette data based on the final
        // color type chosen
        if (colorType == ColorType.PLTE) {
            byte[] rgbPalette = new byte[paletteColorCount * 3];
            byte[] alphaPalette = null;
            if (hasTransparency) {
                alphaPalette = new byte[paletteColorCount];
            }

            // Create the RGB and alpha palettes
            for (int idx = 0; idx < paletteColorCount; idx++) {
                int color = paletteColors[idx];
                rgbPalette[idx * 3]     = (byte) ( color >>> 24);
                rgbPalette[idx * 3 + 1] = (byte) ((color >>  16) & 0xFF);
                rgbPalette[idx * 3 + 2] = (byte) ((color >>   8) & 0xFF);
                if (hasTransparency) {
                    alphaPalette[idx]   = (byte)  (color         & 0xFF);
                }
            }

            // create chunks.
            addChunk(new Chunk(PngWriter.PLTE, rgbPalette));

            if (hasTransparency) {
                addChunk(new Chunk(PngWriter.TRNS, alphaPalette));
            }

            // create image data chunk
            writeIDat(indexedContent);

        } else if (colorType == ColorType.GRAY_SCALE || colorType == ColorType.GRAY_SCALE_ALPHA) {
            int grayLen = (1 + width * (1 + (hasTransparency ? 1 : 0))) * height;
            byte[] grayContent = new byte[grayLen];
            int grayContentIndex = 0;

            for (int y = startY ; y < endY ; y++) {
                grayContent[grayContentIndex++] = 0;

                for (int x = startX ; x < endX ; x++) {
                    int argb = content[(scanline * y) + x];

                    int rr = (argb >> 16) & 0x000000FF;

                    if (isGrayscale) {
                        grayContent[grayContentIndex++] = (byte) rr;
                    } else {
                        int gg = (argb >>  8) & 0x000000FF;
                        int bb =  argb & 0x000000FF;

                        // convert RGB to Grayscale.
                        // Ref: http://en.wikipedia.org/wiki/Luma_(video)
                        grayContent[grayContentIndex++] = (byte) (rr * 0.2126f + gg * 0.7152f + bb * 0.0722f);
                    }

                    if (hasTransparency) {
                        int aa = argb >>> 24;
                        grayContent[grayContentIndex++] = (byte) aa;
                    }
                }
            }

            // create image data chunk
            writeIDat(grayContent);

        } else if (colorType == ColorType.RGBA) {
            writeIDat(rgbaBufer.array());
        } else {
            //RGB mode
            int rgbLen = (1 + width * 3) * height;
            byte[] rgbContent = new byte[rgbLen];
            int rgbContentIndex = 0;

            for (int y = startY ; y < endY ; y++) {
                rgbContent[rgbContentIndex++] = 0;

                for (int x = startX ; x < endX ; x++) {
                    int argb = content[(scanline * y) + x];

                    rgbContent[rgbContentIndex++] = (byte) ((argb >> 16) & 0x000000FF);
                    rgbContent[rgbContentIndex++] = (byte) ((argb >>  8) & 0x000000FF);
                    rgbContent[rgbContentIndex++] = (byte) ( argb        & 0x000000FF);
                }
            }

            // create image data chunk
            writeIDat(rgbContent);
        }

        return colorType;
    }

    /**
     * process the border of the image to find 9-patch info
     * @param content the content of ARGB
     * @param width the width
     * @param height the height
     * @throws NinePatchException
     */
    private void processBorder(int[] content, int width, int height)
            throws NinePatchException {
        // Validate size...
        if (width < 3 || height < 3) {
            throw new NinePatchException(mFile, "Image must be at least 3x3 (1x1 without frame) pixels");
        }

        int i, j;

        int[] xDivs = new int[width];
        int[] yDivs = new int[height];
        int[] colors;
        Arrays.fill(xDivs, -1);
        Arrays.fill(yDivs, -1);

        int numXDivs;
        int numYDivs;
        byte numColors;
        int numRows, numCols;
        int top, left, right, bottom;

        int paddingLeft, paddingTop, paddingRight, paddingBottom;

        boolean transparent = (content[0] & 0xFF000000) == 0;

        int colorIndex = 0;

        // Validate frame...
        if (!transparent && content[0] != 0xFFFFFFFF) {
            throw new NinePatchException(mFile,
                    "Must have one-pixel frame that is either transparent or white");
        }

        // Find left and right of sizing areas...
        AtomicInteger outInt = new AtomicInteger(0);
        try {
            getHorizontalTicks(
                    content, 0, width,
                    transparent, true /*required*/,
                    xDivs, 0, 1, outInt,
                    true /*multipleAllowed*/);
            numXDivs = outInt.get();
        } catch (TickException e) {
            throw new NinePatchException(mFile, e, "top");
        }

        // Find top and bottom of sizing areas...
        outInt.set(0);
        try {
            getVerticalTicks(content, 0, width, height,
                    transparent, true /*required*/,
                    yDivs, 0, 1, outInt,
                    true /*multipleAllowed*/);
            numYDivs = outInt.get();
        } catch (TickException e) {
            throw new NinePatchException(mFile, e, "left");
        }

        // Find left and right of padding area...
        int[] values = new int[2];
        try {
            getHorizontalTicks(
                    content, width * (height - 1), width,
                    transparent, false /*required*/,
                    values, 0, 1, null,
                    false /*multipleAllowed*/);
            paddingLeft = values[0];
            paddingRight = values[1];
            values[0] = values[1] = 0;
        } catch (TickException e) {
            throw new NinePatchException(mFile, e, "bottom");
        }

        // Find top and bottom of padding area...
        try {
            getVerticalTicks(
                    content, width - 1, width, height,
                    transparent, false /*required*/,
                    values, 0, 1, null,
                    false /*multipleAllowed*/);
            paddingTop = values[0];
            paddingBottom = values[1];
        } catch (TickException e) {
            throw new NinePatchException(mFile, e, "right");
        }

        try {
            // Find left and right of layout padding...
            getHorizontalLayoutBoundsTicks(content, width * (height - 1), width,
                    transparent, false, values);
        } catch (TickException e) {
            throw new NinePatchException(mFile, e, "bottom");
        }

        int[] values2 = new int[2];
        try {
            getVerticalLayoutBoundsTicks(content, width - 1, width, height,
                    transparent, false, values2);
        } catch (TickException e) {
            throw new NinePatchException(mFile, e, "right");
        }

        LayoutBoundChunkBuilder layoutBoundChunkBuilder = null;
        if (values[0] != 0 || values[1] != 0 || values2[0] != 0 || values2[1] != 0) {
            layoutBoundChunkBuilder = new LayoutBoundChunkBuilder(
                    values[0], values2[0], values[1], values2[1]);
        }

        // If padding is not yet specified, take values from size.
        if (paddingLeft < 0) {
            paddingLeft = xDivs[0];
            paddingRight = width - 2 - xDivs[1];
        } else {
            // Adjust value to be correct!
            paddingRight = width - 2 - paddingRight;
        }
        if (paddingTop < 0) {
            paddingTop = yDivs[0];
            paddingBottom = height - 2 - yDivs[1];
        } else {
            // Adjust value to be correct!
            paddingBottom = height - 2 - paddingBottom;
        }

        // Remove frame from image.
        width -= 2;
        height -= 2;

        // Figure out the number of rows and columns in the N-patch
        numCols = numXDivs + 1;
        if (xDivs[0] == 0) {  // Column 1 is strechable
            numCols--;
        }
        if (xDivs[numXDivs - 1] == width) {
            numCols--;
        }
        numRows = numYDivs + 1;
        if (yDivs[0] == 0) {  // Row 1 is strechable
            numRows--;
        }
        if (yDivs[numYDivs - 1] == height) {
            numRows--;
        }

        // Make sure the amount of rows and columns will fit in the number of
        // colors we can use in the 9-patch format.
        if (numRows * numCols > 0x7F) {
            throw new NinePatchException(mFile, "Too many rows and columns in 9-patch perimeter");
        }

        numColors = (byte) (numRows * numCols);
        colors = new int[numColors];

        // Fill in color information for each patch.

        int c;
        top = 0;

        // The first row always starts with the top being at y=0 and the bottom
        // being either yDivs[1] (if yDivs[0]=0) of yDivs[0].  In the former case
        // the first row is stretchable along the Y axis, otherwise it is fixed.
        // The last row always ends with the bottom being bitmap.height and the top
        // being either yDivs[numYDivs-2] (if yDivs[numYDivs-1]=bitmap.height) or
        // yDivs[numYDivs-1]. In the former case the last row is stretchable along
        // the Y axis, otherwise it is fixed.
        //
        // The first and last columns are similarly treated with respect to the X
        // axis.
        //
        // The above is to help explain some of the special casing that goes on the
        // code below.

        // The initial yDiv and whether the first row is considered stretchable or
        // not depends on whether yDiv[0] was zero or not.
        for (j = (yDivs[0] == 0 ? 1 : 0);
                j <= numYDivs && top < height;
                j++) {
            if (j == numYDivs) {
                bottom = height;
            } else {
                bottom = yDivs[j];
            }
            left = 0;
            // The initial xDiv and whether the first column is considered
            // stretchable or not depends on whether xDiv[0] was zero or not.
            for (i = xDivs[0] == 0 ? 1 : 0;
                    i <= numXDivs && left < width;
                    i++) {
                if (i == numXDivs) {
                    right = width;
                } else {
                    right = xDivs[i];
                }
                c = getColor(content, width + 2, left, top, right - 1, bottom - 1);
                colors[colorIndex++] = c;
                left = right;
            }
            top = bottom;
        }

        // Create the chunks.
        NinePatchChunkBuilder ninePatchChunkBuilder = new NinePatchChunkBuilder(
                xDivs, numXDivs, yDivs, numYDivs, colors,
                paddingLeft, paddingRight, paddingTop, paddingBottom);

        addChunk(ninePatchChunkBuilder.getChunk());
        if (layoutBoundChunkBuilder != null) {
            addChunk(layoutBoundChunkBuilder.getChunk());
        }
    }

    /**
     * returns a color. the top/left/right/bottom coordinate are in a subframe of content, starting
     * in (1,1).
     * @param content the image buffer
     * @param width the width of the image buffer
     * @param left left coordinate.
     * @param top top coordinate.
     * @param right right coordinate.
     * @param bottom bottom coordinate.
     * @return a color.
     */
    static int getColor(@NonNull int[] content, int width,
            int left, int top, int right, int bottom) {
        int color = content[(top + 1) * width + left + 1];
        int alpha = color & 0xFF000000;

        if (left > right || top > bottom) {
            return PNG_9PATCH_TRANSPARENT_COLOR;
        }

        while (top <= bottom) {
            for (int i = left; i <= right; i++) {
                int c = content[(top + 1) * width + i + 1];
                if (alpha == 0) {
                    if ((c & 0xFF000000) != 0) {
                        return PNG_9PATCH_NO_COLOR;
                    }
                } else if (c != color) {
                    return PNG_9PATCH_NO_COLOR;
                }
            }
            top++;
        }

        if (alpha == 0) {
            return PNG_9PATCH_TRANSPARENT_COLOR;
        }

        return color;
    }


    private static enum TickType {
        NONE, TICK, LAYOUT_BOUNDS, BOTH
    }

    @NonNull
    private static TickType getTickType(int color, boolean transparent) throws TickException {

        int alpha = color >>> 24;

        if (transparent) {
            if (alpha == 0) {
                return TickType.NONE;
            }
            if (color == COLOR_LAYOUT_BOUNDS_TICK) {
                return TickType.LAYOUT_BOUNDS;
            }
            if (color == COLOR_TICK) {
                return TickType.TICK;
            }

            // Error cases
            if (alpha != 0xFF) {
                throw TickException.createWithColor(
                        "Frame pixels must be either solid or transparent (not intermediate alphas)",
                        color);
            }
            if ((color & 0x00FFFFFF) != 0) {
                throw TickException.createWithColor("Ticks in transparent frame must be black or red",
                        color);
            }
            return TickType.TICK;
        }

        if (alpha != 0xFF) {
            throw TickException.createWithColor("White frame must be a solid color (no alpha)",
                    color);
        }
        if (color == COLOR_WHITE) {
            return TickType.NONE;
        }
        if (color == COLOR_TICK) {
            return TickType.TICK;
        }
        if (color == COLOR_LAYOUT_BOUNDS_TICK) {
            return TickType.LAYOUT_BOUNDS;
        }

        if ((color & 0x00FFFFFF) != 0) {
            throw TickException.createWithColor("Ticks in transparent frame must be black or red",
                    color);
        }

        return TickType.TICK;
    }


    private static enum Tick {
        START, INSIDE_1, OUTSIDE_1
    }

    private static void getHorizontalTicks(
            @NonNull int[] content, int offset, int width,
            boolean transparent, boolean required,
            @NonNull int[] divs, int left, int right,
            @Nullable AtomicInteger outDivs, boolean multipleAllowed) throws TickException {
        int i;
        divs[left] = divs[right] = -1;
        Tick state = Tick.START;
        boolean found = false;

        for (i = 1; i < width - 1; i++) {
            TickType tickType;
            try {
                tickType = getTickType(content[offset + i], transparent);
            } catch (TickException e) {
                throw new TickException(e, i);
            }

            if (TickType.TICK == tickType) {
                if (state == Tick.START ||
                        (state == Tick.OUTSIDE_1 && multipleAllowed)) {
                    divs[left] = i - 1;
                    divs[right] = width - 2;
                    found = true;
                    if (outDivs != null) {
                        outDivs.addAndGet(2);
                    }
                    state = Tick.INSIDE_1;
                } else if (state == Tick.OUTSIDE_1) {
                    throw new TickException("Can't have more than one marked region along edge");
                }
            } else {
                if (state == Tick.INSIDE_1) {
                    // We're done with this div.  Move on to the next.
                    divs[right] = i - 1;
                    right += 2;
                    left += 2;
                    state = Tick.OUTSIDE_1;
                }
            }

        }

        if (required && !found) {
            throw new TickException("No marked region found along edge");
        }
    }

    private static void getVerticalTicks(
            @NonNull int[] content, int offset, int width, int height,
            boolean transparent, boolean required,
            @NonNull int[] divs, int top, int bottom,
            @Nullable AtomicInteger outDivs, boolean multipleAllowed) throws TickException {

        int i;
        divs[top] = divs[bottom] = -1;
        Tick state = Tick.START;
        boolean found = false;

        for (i = 1; i < height - 1; i++) {
            TickType tickType;
            try {
                tickType = getTickType(content[offset + width * i], transparent);
            } catch (TickException e) {
                throw new TickException(e, i);
            }

            if (TickType.TICK == tickType) {
                if (state == Tick.START ||
                        (state == Tick.OUTSIDE_1 && multipleAllowed)) {
                    divs[top] = i - 1;
                    divs[bottom] = height - 2;
                    found = true;
                    if (outDivs != null) {
                        outDivs.addAndGet(2);
                    }
                    state = Tick.INSIDE_1;
                } else if (state == Tick.OUTSIDE_1) {
                    throw new TickException("Can't have more than one marked region along edge");
                }
            } else {
                if (state == Tick.INSIDE_1) {
                    // We're done with this div.  Move on to the next.
                    divs[bottom] = i - 1;
                    top += 2;
                    bottom += 2;
                    state = Tick.OUTSIDE_1;
                }
            }
        }

        if (required && !found) {
            throw new TickException("No marked region found along edge");
        }
    }

    private static void getHorizontalLayoutBoundsTicks(
            @NonNull int[] content, int offset, int width, boolean transparent, boolean required,
            @NonNull int[] outValues) throws TickException {

        int i;
        outValues[0] = outValues[1] = 0;

        // Look for left tick
        if (TickType.LAYOUT_BOUNDS == getTickType(content[offset + 1], transparent)) {
            // Starting with a layout padding tick
            i = 1;
            while (i < width - 1) {
                outValues[0]++;
                i++;
                TickType tick = getTickType(content[offset + i], transparent);
                if (tick != TickType.LAYOUT_BOUNDS) {
                    break;
                }
            }
        }

        // Look for right tick
        if (TickType.LAYOUT_BOUNDS == getTickType(content[offset + (width - 2)], transparent)) {
            // Ending with a layout padding tick
            i = width - 2;
            while (i > 1) {
                outValues[1]++;
                i--;
                TickType tick = getTickType(content[offset + i], transparent);
                if (tick != TickType.LAYOUT_BOUNDS) {
                    break;
                }
            }
        }
    }

    private static void getVerticalLayoutBoundsTicks(
            @NonNull int[] content, int offset, int width, int height,
            boolean transparent, boolean required,
            @NonNull int[] outValues) throws TickException {
        int i;
        outValues[0] = outValues[1] = 0;

        // Look for top tick
        if (TickType.LAYOUT_BOUNDS == getTickType(content[offset + width], transparent)) {
            // Starting with a layout padding tick
            i = 1;
            while (i < height - 1) {
                outValues[0]++;
                i++;
                TickType tick = getTickType(content[offset + width * i], transparent);
                if (tick != TickType.LAYOUT_BOUNDS) {
                    break;
                }
            }
        }

        // Look for bottom tick
        if (TickType.LAYOUT_BOUNDS == getTickType(content[offset + width * (height - 2)],
                transparent)) {
            // Ending with a layout padding tick
            i = height - 2;
            while (i > 1) {
                outValues[1]++;
                i--;
                TickType tick = getTickType(content[offset + width * i], transparent);
                if (tick != TickType.LAYOUT_BOUNDS) {
                    break;
                }
            }
        }
    }

    @VisibleForTesting
    Chunk computeIhdr(int width, int height, byte bitDepth, @NonNull ColorType colorType) {
        byte[] buffer = new byte[13];

        ByteUtils utils = ByteUtils.Cache.get();

        System.arraycopy(utils.getIntAsArray(width), 0, buffer, 0, 4);
        System.arraycopy(utils.getIntAsArray(height), 0, buffer, 4, 4);
        buffer[8] = bitDepth;
        buffer[9] = colorType.getFlag();
        buffer[10] = 0; // compressionMethod
        buffer[11] = 0; // filterMethod;
        buffer[12] = 0; // interlaceMethod

        return new Chunk(PngWriter.IHDR, buffer);
    }

    boolean is9Patch() {
        return mFile.getPath().endsWith(SdkConstants.DOT_9PNG);
    }
}