update external headers

ios/include/imageio/BlockCompression.h

@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+//! \file Functions and types related to block-compressed texture formats.
+
+#ifndef IMAGEIO_BLOCKCOMPRESSION_H_
+#define IMAGEIO_BLOCKCOMPRESSION_H_
+
+#include <image/LinearImage.h>
+
+#include <memory>
+#include <string>
+
+#include <math/vec2.h>
+
+#include <utils/compiler.h>
+
+#include <stdint.h>
+
+namespace image {
+
+enum class CompressedFormat {
+    INVALID = 0,
+
+    R11_EAC = 0x9270,
+    SIGNED_R11_EAC = 0x9271,
+    RG11_EAC = 0x9272,
+    SIGNED_RG11_EAC = 0x9273,
+    RGB8_ETC2 = 0x9274,
+    SRGB8_ETC2 = 0x9275,
+    RGB8_ALPHA1_ETC2 = 0x9276,
+    SRGB8_ALPHA1_ETC = 0x9277,
+    RGBA8_ETC2_EAC = 0x9278,
+    SRGB8_ALPHA8_ETC2_EAC = 0x9279,
+
+    RGB_S3TC_DXT1 = 0x83F0,
+    RGBA_S3TC_DXT1 = 0x83F1,
+    RGBA_S3TC_DXT3 = 0x83F2,
+    RGBA_S3TC_DXT5 = 0x83F3,
+    SRGB_S3TC_DXT1 = 0x8C4C,
+    SRGB_ALPHA_S3TC_DXT1 = 0x8C4D,
+    SRGB_ALPHA_S3TC_DXT3 = 0x8C4E,
+    SRGB_ALPHA_S3TC_DXT5 = 0x8C4F,
+
+    RGBA_ASTC_4x4 = 0x93B0,
+    RGBA_ASTC_5x4 = 0x93B1,
+    RGBA_ASTC_5x5 = 0x93B2,
+    RGBA_ASTC_6x5 = 0x93B3,
+    RGBA_ASTC_6x6 = 0x93B4,
+    RGBA_ASTC_8x5 = 0x93B5,
+    RGBA_ASTC_8x6 = 0x93B6,
+    RGBA_ASTC_8x8 = 0x93B7,
+    RGBA_ASTC_10x5 = 0x93B8,
+    RGBA_ASTC_10x6 = 0x93B9,
+    RGBA_ASTC_10x8 = 0x93BA,
+    RGBA_ASTC_10x10 = 0x93BB,
+    RGBA_ASTC_12x10 = 0x93BC,
+    RGBA_ASTC_12x12 = 0x93BD,
+    SRGB8_ALPHA8_ASTC_4x4 = 0x93D0,
+    SRGB8_ALPHA8_ASTC_5x4 = 0x93D1,
+    SRGB8_ALPHA8_ASTC_5x5 = 0x93D2,
+    SRGB8_ALPHA8_ASTC_6x5 = 0x93D3,
+    SRGB8_ALPHA8_ASTC_6x6 = 0x93D4,
+    SRGB8_ALPHA8_ASTC_8x5 = 0x93D5,
+    SRGB8_ALPHA8_ASTC_8x6 = 0x93D6,
+    SRGB8_ALPHA8_ASTC_8x8 = 0x93D7,
+    SRGB8_ALPHA8_ASTC_10x5 = 0x93D8,
+    SRGB8_ALPHA8_ASTC_10x6 = 0x93D9,
+    SRGB8_ALPHA8_ASTC_10x8 = 0x93DA,
+    SRGB8_ALPHA8_ASTC_10x10 = 0x93DB,
+    SRGB8_ALPHA8_ASTC_12x10 = 0x93DC,
+    SRGB8_ALPHA8_ASTC_12x12 = 0x93DD,
+};
+
+// Represents the opaque result of compression and the chosen texture format.
+struct CompressedTexture {
+    const CompressedFormat format;
+    const uint32_t size;
+    std::unique_ptr<uint8_t[]> data;
+};
+
+// ASTC ////////////////////////////////////////////////////////////////////////////////////////////
+
+// Controls how fast compression occurs at the cost of quality in the resulting image.
+enum class AstcPreset {
+    VERYFAST,
+    FAST,
+    MEDIUM,
+    THOROUGH,
+    EXHAUSTIVE,
+};
+
+// Informs the encoder what texels represent; this is especially crucial for normal maps.
+enum class AstcSemantic {
+    COLORS_LDR,
+    COLORS_HDR,
+    NORMALS,
+};
+
+// The encoder configuration controls the quality and speed of compression, as well as the resulting
+// format. The specified block size must be one of the 14 block sizes that can be consumed by ES 3.2
+// as per https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glCompressedTexImage2D.xhtml
+struct AstcConfig {
+    AstcPreset quality;
+    AstcSemantic semantic;
+     filament::math::ushort2 blocksize;
+    bool srgb;
+};
+
+// Uses the CPU to compress a linear image (1 to 4 channels) into an ASTC texture. The 16-byte
+// header block that ARM uses in their file format is not included.
+CompressedTexture astcCompress(const LinearImage& source, AstcConfig config);
+
+// Parses a simple underscore-delimited string to produce an ASTC compression configuration. This
+// makes it easy to incorporate the compression API into command-line tools. If the string is
+// malformed, this returns a config with a 0x0 blocksize. Example strings: fast_ldr_4x4,
+// thorough_normals_6x6, veryfast_hdr_12x10
+AstcConfig astcParseOptionString(const std::string& options);
+
+// ETC /////////////////////////////////////////////////////////////////////////////////////////////
+
+enum class EtcErrorMetric {
+    RGBA,
+    RGBX,
+    REC709,
+    NUMERIC,
+    NORMALXYZ,
+};
+
+// Informs the ETC encoder of the desired output. Effort sets the quality / speed tradeoff with
+// a number between 0 and 100.
+struct EtcConfig {
+    CompressedFormat format;
+    EtcErrorMetric metric;
+    int effort;
+};
+
+// Uses the CPU to compress a linear image (1 to 4 channels) into an ETC texture.
+CompressedTexture etcCompress(const LinearImage& source, EtcConfig config);
+
+// Converts a string into an ETC compression configuration where the string has the form
+// FORMAT_METRIC_EFFORT where:
+// - FORMAT is one of: r11, signed_r11, rg11, signed_rg11, rgb8, srgb8, rgb8_alpha,
+//   srgb8_alpha, rgba8, and srgb8_alpha8
+// - METRIC is one of: rgba, rgbx, rec709, numeric, and normalxyz
+// - EFFORT is an integer between 0 and 100
+EtcConfig etcParseOptionString(const std::string& options);
+
+// S3TC ////////////////////////////////////////////////////////////////////////////////////////////
+
+// Informs the S3TC encoder of the desired output.
+struct S3tcConfig {
+    CompressedFormat format;
+    bool srgb;
+};
+
+// Uses the CPU to compress a linear image (1 to 4 channels) into an S3TC texture.
+CompressedTexture s3tcCompress(const LinearImage& source, S3tcConfig config);
+
+// Parses an underscore-delimited string to produce an S3TC compression configuration. Currently
+// this only accepts "rgb_dxt1" and "rgba_dxt5". If the string is malformed, this returns a config
+// with an invalid format.
+S3tcConfig s3tcParseOptionString(const std::string& options);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct CompressionConfig {
+    enum { INVALID, ASTC, S3TC, ETC } type;
+    AstcConfig astc;
+    S3tcConfig s3tc;
+    EtcConfig etc;
+};
+
+bool parseOptionString(const std::string& options, CompressionConfig* config);
+
+UTILS_PUBLIC
+CompressedTexture compressTexture(const CompressionConfig& config, const LinearImage& image);
+
+} // namespace image
+
+#endif /* IMAGEIO_BLOCKCOMPRESSION_H_ */

ios/include/imageio/HDRDecoder.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2021 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 IMAGE_HDRDECODER_H_
+#define IMAGE_HDRDECODER_H_
+
+#include <imageio/ImageDecoder.h>
+
+namespace image {
+
+class HDRDecoder : public ImageDecoder::Decoder {
+public:
+    static HDRDecoder* create(std::istream& stream);
+    static bool checkSignature(char const* buf);
+
+    HDRDecoder(const HDRDecoder&) = delete;
+    HDRDecoder& operator=(const HDRDecoder&) = delete;
+
+private:
+    explicit HDRDecoder(std::istream& stream);
+    ~HDRDecoder() override;
+
+    // ImageDecoder::Decoder interface
+    LinearImage decode() override;
+
+    static const char sigRadiance[];
+    static const char sigRGBE[];
+    std::istream& mStream;
+    std::streampos mStreamStartPos;
+};
+
+} // namespace image
+
+#endif /* IMAGE_IMAGEDECODER_H_ */

ios/include/imageio/ImageDecoder.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2015 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 IMAGE_IMAGEDECODER_H_
+#define IMAGE_IMAGEDECODER_H_
+
+#include <iosfwd>
+#include <string>
+
+#include <image/LinearImage.h>
+
+#include <utils/compiler.h>
+
+namespace image {
+
+class UTILS_PUBLIC ImageDecoder {
+public:
+    enum class ColorSpace {
+        LINEAR,
+        SRGB
+    };
+
+    // Returns linear floating-point data, or a non-valid image if an error occured.
+    static LinearImage decode(std::istream& stream, const std::string& sourceName,
+            ColorSpace sourceSpace = ColorSpace::SRGB);
+
+    class Decoder {
+    public:
+        virtual LinearImage decode() = 0;
+        virtual ~Decoder() = default;
+
+        ColorSpace getColorSpace() const noexcept {
+            return mColorSpace;
+        }
+
+        void setColorSpace(ColorSpace colorSpace) noexcept {
+            mColorSpace = colorSpace;
+        }
+
+    private:
+        ColorSpace mColorSpace = ColorSpace::SRGB;
+    };
+
+private:
+    enum class Format {
+        NONE,
+        PNG,
+        HDR,
+        PSD,
+        EXR
+    };
+};
+
+} // namespace image
+
+#endif /* IMAGE_IMAGEDECODER_H_ */

ios/include/imageio/ImageDiffer.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2018 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.
+ */
+
+#include <image/LinearImage.h>
+
+#include <utils/Path.h>
+
+namespace image {
+
+enum class ComparisonMode {
+    SKIP,
+    COMPARE,
+    UPDATE,
+};
+
+// Saves an image to disk or does a load-and-compare, depending on comparison mode.
+// This makes it easy for unit tests to have compare / update commands.
+// The passed-in image is the "result image" and the expected image is the "golden image".
+void updateOrCompare(LinearImage result, const utils::Path& golden, ComparisonMode, float epsilon);
+
+}  // namespace image

ios/include/imageio/ImageEncoder.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 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 IMAGE_IMAGEENCODER_H_
+#define IMAGE_IMAGEENCODER_H_
+
+#include <iosfwd>
+#include <string>
+
+#include <image/LinearImage.h>
+
+#include <utils/compiler.h>
+
+namespace image {
+
+class UTILS_PUBLIC ImageEncoder {
+public:
+    enum class Format {
+        PNG,        // 8-bit sRGB, 1 or 3 channels
+        PNG_LINEAR, // 8-bit linear RGB, 1 or 3 channels
+        HDR,        // 8-bit linear RGBE, 3 channels only
+        RGBM,       // 8-bit RGBM, as PNG, 3 channels only
+        PSD,        // 16-bit sRGB or 32-bit linear RGB, 3 channels only
+                    // Default: 16 bit
+        EXR,        // 16-bit linear RGB (half-float), 3 channels only
+                    // Default: PIZ compression
+        DDS,        // 8-bit sRGB, 1, 2 or 3 channels;
+                    // 16-bit or 32-bit linear RGB, 1, 2 or 3 channels
+                    // Default: 16 bit
+        DDS_LINEAR, // 8-bit, 16-bit or 32-bit linear RGB, 1, 2 or 3 channels
+                    // Default: 16 bit
+        RGB_10_11_11_REV,   // RGBA PNG file, but containing 11_11_10 data
+    };
+
+    // Consumes linear floating-point data, returns false if unable to encode.
+    static bool encode(std::ostream& stream, Format format, const LinearImage& image,
+            const std::string& compression, const std::string& destName);
+
+    static Format chooseFormat(const std::string& name, bool forceLinear = false);
+    static std::string chooseExtension(Format format);
+
+    class Encoder {
+    public:
+        virtual bool encode(const LinearImage& image) = 0;
+        virtual ~Encoder() = default;
+    };
+};
+
+} // namespace image
+
+#endif /* IMAGE_IMAGEENCODER_H_ */