aapt2/compile/Image.h

/*
 * Copyright (C) 2016 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.
 */

#ifndef AAPT_COMPILE_IMAGE_H
#define AAPT_COMPILE_IMAGE_H

#include <android-base/macros.h>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>

namespace aapt {

/**
 * An in-memory image, loaded from disk, with pixels in RGBA_8888 format.
 */
class Image {
public:
    explicit Image() = default;

    /**
     * A `height` sized array of pointers, where each element points to a
     * `width` sized row of RGBA_8888 pixels.
     */
    std::unique_ptr<uint8_t*[]> rows;

    /**
     * The width of the image in RGBA_8888 pixels. This is int32_t because of 9-patch data
     * format limitations.
     */
    int32_t width = 0;

    /**
     * The height of the image in RGBA_8888 pixels. This is int32_t because of 9-patch data
     * format limitations.
     */
    int32_t height = 0;

    /**
     * Buffer to the raw image data stored sequentially.
     * Use `rows` to access the data on a row-by-row basis.
     */
    std::unique_ptr<uint8_t[]> data;

private:
    DISALLOW_COPY_AND_ASSIGN(Image);
};

/**
 * A range of pixel values, starting at 'start' and ending before 'end' exclusive. Or rather [a, b).
 */
struct Range {
    int32_t start = 0;
    int32_t end = 0;

    explicit Range() = default;
    inline explicit Range(int32_t s, int32_t e) : start(s), end(e) {
    }
};

inline bool operator==(const Range& left, const Range& right) {
    return left.start == right.start && left.end == right.end;
}

/**
 * Inset lengths from all edges of a rectangle. `left` and `top` are measured from the left and top
 * edges, while `right` and `bottom` are measured from the right and bottom edges, respectively.
 */
struct Bounds {
    int32_t left = 0;
    int32_t top = 0;
    int32_t right = 0;
    int32_t bottom = 0;

    explicit Bounds() = default;
    inline explicit Bounds(int32_t l, int32_t t, int32_t r, int32_t b) :
            left(l), top(t), right(r), bottom(b) {
    }

    bool nonZero() const;
};

inline bool Bounds::nonZero() const {
    return left != 0 || top != 0 || right != 0 || bottom != 0;
}

inline bool operator==(const Bounds& left, const Bounds& right) {
    return left.left == right.left && left.top == right.top &&
            left.right == right.right && left.bottom == right.bottom;
}

/**
 * Contains 9-patch data from a source image. All measurements exclude the 1px border of the
 * source 9-patch image.
 */
class NinePatch {
public:
    static std::unique_ptr<NinePatch> create(uint8_t** rows,
                                             const int32_t width, const int32_t height,
                                             std::string* errOut);

    /**
     * Packs the RGBA_8888 data pointed to by pixel into a uint32_t
     * with format 0xAARRGGBB (the way 9-patch expects it).
     */
    static uint32_t packRGBA(const uint8_t* pixel);

    /**
     * 9-patch content padding/insets. All positions are relative to the 9-patch
     * NOT including the 1px thick source border.
     */
    Bounds padding;

    /**
     * Optical layout bounds/insets. This overrides the padding for
     * layout purposes. All positions are relative to the 9-patch
     * NOT including the 1px thick source border.
     * See https://developer.android.com/about/versions/android-4.3.html#OpticalBounds
     */
    Bounds layoutBounds;

    /**
     * Outline of the image, calculated based on opacity.
     */
    Bounds outline;

    /**
     * The computed radius of the outline. If non-zero, the outline is a rounded-rect.
     */
    float outlineRadius = 0.0f;

    /**
     * The largest alpha value within the outline.
     */
    uint32_t outlineAlpha = 0x000000ffu;

    /**
     * Horizontal regions of the image that are stretchable.
     * All positions are relative to the 9-patch
     * NOT including the 1px thick source border.
     */
    std::vector<Range> horizontalStretchRegions;

    /**
     * Vertical regions of the image that are stretchable.
     * All positions are relative to the 9-patch
     * NOT including the 1px thick source border.
     */
    std::vector<Range> verticalStretchRegions;

    /**
     * The colors within each region, fixed or stretchable.
     * For w*h regions, the color of region (x,y) is addressable
     * via index y*w + x.
     */
    std::vector<uint32_t> regionColors;

    /**
     * Returns serialized data containing the original basic 9-patch meta data.
     * Optical layout bounds and round rect outline data must be serialized
     * separately using serializeOpticalLayoutBounds() and serializeRoundedRectOutline().
     */
    std::unique_ptr<uint8_t[]> serializeBase(size_t* outLen) const;

    /**
     * Serializes the layout bounds.
     */
    std::unique_ptr<uint8_t[]> serializeLayoutBounds(size_t* outLen) const;

    /**
     * Serializes the rounded-rect outline.
     */
    std::unique_ptr<uint8_t[]> serializeRoundedRectOutline(size_t* outLen) const;

private:
    explicit NinePatch() = default;

    DISALLOW_COPY_AND_ASSIGN(NinePatch);
};

::std::ostream& operator<<(::std::ostream& out, const Range& range);
::std::ostream& operator<<(::std::ostream& out, const Bounds& bounds);
::std::ostream& operator<<(::std::ostream& out, const NinePatch& ninePatch);

} // namespace aapt

#endif /* AAPT_COMPILE_IMAGE_H */