@amazon-devices/expo-image 2.0.9000000000 → 3.0.0

package/kepler/test/contentposition/ImageContentPosition.cpp

@@ -1,100 +1,94 @@
 #include "../../contentposition/ImageContentPosition.h"
 
-#include <gmock/gmock-actions.h>
-#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include "catch.hpp"
+namespace expoimage {
+namespace {
 
-TEST_CASE("ImageContentPositionValue") {
-    SECTION("calcOffset") {
-        ImageContentPositionValue value{10.0f, false};
+// Helpers to make test intent clearer.
+ImageContentPositionValue px(float v) { return ImageContentPositionValue{v, false}; }
+ImageContentPositionValue empty() { return ImageContentPositionValue{}; }
 
-        volta::graphics::Size imageRect{100.0f, 100.0f};
-        volta::graphics::Size viewRect{50.0f, 50.0f};
+// ---- ImageContentPositionValue ----
 
-        ImageContentPositionValue emptyValue;
+TEST(ImageContentPositionValue, EmptyReturnsNullopt) {
+    ImageContentPositionValue value;
+    Size imageSize{100.0f, 100.0f};
+    Size viewSize{50.0f, 50.0f};
 
-        auto calc = [](float value,
-                       const volta::graphics::Size& imageRect,
-                       const volta::graphics::Size& viewRect,
-                       bool isPercentage,
-                       bool isReverse) -> float { return 2137.0f; };
+    auto calc = [](float, const Size&, const Size&, bool, bool) { return 123.0f; };
+    auto result = value.calcOffset(false, imageSize, viewSize, calc);
 
-        auto emptyResult = emptyValue.calcOffset(false, imageRect, viewRect, calc);
-
-        EXPECT_FALSE(emptyResult.has_value());
-
-        auto result = value.calcOffset(false, imageRect, viewRect, calc);
-        EXPECT_EQ(result.value(), 2137.0f);
-    }
+    EXPECT_FALSE(result.has_value());
 }
 
-TEST_CASE("ImageContentPosition") {
-    ImageContentPositionValue top{10.0f, false};
-    ImageContentPositionValue bottom{10.0f, false};
-    ImageContentPositionValue left{10.0f, false};
-    ImageContentPositionValue right{10.0f, false};
-    volta::graphics::Size imageRect{100.0f, 100.0f};
-    volta::graphics::Size viewRect{50.0f, 50.0f};
-
-    SECTION("offsetX with left position") {
-        ImageContentPosition pos;
-
-        float offset;
-
-        pos = ImageContentPosition(top, bottom, {}, {10.f, false});
-        offset = pos.offsetX(imageRect, viewRect);
-        EXPECT_EQ(offset, 10.f);
-    }
+TEST(ImageContentPositionValue, SetValueInvokesCalc) {
+    ImageContentPositionValue value{10.0f, false};
+    Size imageSize{100.0f, 100.0f};
+    Size viewSize{50.0f, 50.0f};
 
-    SECTION("offsetX with right position") {
-        ImageContentPosition pos;
+    auto calc = [](float, const Size&, const Size&, bool, bool) { return 2137.0f; };
+    auto result = value.calcOffset(false, imageSize, viewSize, calc);
 
-        float offset;
-
-        pos = ImageContentPosition(top, bottom, {}, {20.f, false});
-        offset = pos.offsetX(imageRect, viewRect);
-        EXPECT_EQ(offset, 20.f);
-    }
-
-    SECTION("offsetX without left and right positions") {
-        ImageContentPosition pos;
-
-        float offset;
+    ASSERT_TRUE(result.has_value());
+    EXPECT_FLOAT_EQ(result.value(), 2137.0f);
+}
 
-        pos = ImageContentPosition(top, bottom, {}, {});
-        offset = pos.offsetX(imageRect, viewRect);
-        EXPECT_EQ(offset, -25.f);
-    }
+// ---- ImageContentPosition ----
 
-    SECTION("offsetY with top position") {
-        ImageContentPosition pos;
+class ImageContentPositionTest : public ::testing::Test {
+protected:
+    Size imageRect_{100.0f, 100.0f};
+    Size viewRect_{50.0f, 50.0f};
+};
 
-        float offset;
+TEST_F(ImageContentPositionTest, OffsetX_LeftTakesPrecedence) {
+    ImageContentPosition pos(empty(), empty(), empty(), px(10.0f));
+    EXPECT_FLOAT_EQ(pos.offsetX(imageRect_, viewRect_), 10.0f);
+}
 
-        pos = ImageContentPosition({10.f, false}, {}, right, left);
-        offset = pos.offsetY(imageRect, viewRect);
-        EXPECT_EQ(offset, 10.f);
-    }
+TEST_F(ImageContentPositionTest, OffsetX_RightWhenLeftEmpty) {
+    // right=20px means image right edge is inset 20px from view right edge.
+    // Reverse translation: viewWidth - imageWidth - 20 = 50 - 100 - 20 = -70
+    ImageContentPosition pos(empty(), empty(), px(20.0f), empty());
+    EXPECT_FLOAT_EQ(pos.offsetX(imageRect_, viewRect_), -70.0f);
+}
 
-    SECTION("offsetY with bottom position") {
-        ImageContentPosition pos;
+TEST_F(ImageContentPositionTest, OffsetX_DefaultCenters) {
+    // No left or right → default is center (reverse of 50%): (50-100)/2 = -25
+    ImageContentPosition pos(empty(), empty(), empty(), empty());
+    EXPECT_FLOAT_EQ(pos.offsetX(imageRect_, viewRect_), -25.0f);
+}
 
-        float offset;
+TEST_F(ImageContentPositionTest, OffsetY_TopTakesPrecedence) {
+    ImageContentPosition pos(px(10.0f), empty(), empty(), empty());
+    EXPECT_FLOAT_EQ(pos.offsetY(imageRect_, viewRect_), 10.0f);
+}
 
-        pos = ImageContentPosition({}, {10.f, false}, right, left);
-        offset = pos.offsetY(imageRect, viewRect);
-        EXPECT_EQ(offset, -60.f);
-    }
+TEST_F(ImageContentPositionTest, OffsetY_BottomWhenTopEmpty) {
+    // bottom=10 → reverse: viewH - imageH - 10 = 50 - 100 - 10 = -60
+    ImageContentPosition pos(empty(), px(10.0f), empty(), empty());
+    EXPECT_FLOAT_EQ(pos.offsetY(imageRect_, viewRect_), -60.0f);
+}
 
-    SECTION("offsetY without top or bottom positions") {
-        ImageContentPosition pos;
+TEST_F(ImageContentPositionTest, OffsetY_DefaultCenters) {
+    ImageContentPosition pos(empty(), empty(), empty(), empty());
+    EXPECT_FLOAT_EQ(pos.offsetY(imageRect_, viewRect_), -25.0f);
+}
 
-        float offset;
+TEST_F(ImageContentPositionTest, Percentage_LeftAtZero) {
+    // left=0% → 0
+    ImageContentPositionValue leftPct{0.0f, true};
+    ImageContentPosition pos(empty(), empty(), empty(), leftPct);
+    EXPECT_FLOAT_EQ(pos.offsetX(imageRect_, viewRect_), 0.0f);
+}
 
-        pos = ImageContentPosition({}, {}, right, left);
-        offset = pos.offsetY(imageRect, viewRect);
-        EXPECT_EQ(offset, -25.f);
-    }
+TEST_F(ImageContentPositionTest, Percentage_LeftAt100) {
+    // left=100% → viewW - imageW = 50 - 100 = -50
+    ImageContentPositionValue leftPct{100.0f, true};
+    ImageContentPosition pos(empty(), empty(), empty(), leftPct);
+    EXPECT_FLOAT_EQ(pos.offsetX(imageRect_, viewRect_), -50.0f);
 }
+
+}  // namespace
+}  // namespace expoimage

package/kepler/test/thumbhash/decode.cpp

@@ -1,18 +1,26 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ * Use is subject to license terms.
+ */
+
 #include "../../thumbhash/decode.h"
 
-#include <gmock/gmock-actions.h>
-#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include "catch.hpp"
+namespace expoimage {
+namespace {
 
-TEST_CASE("thumbhash") {
-    std::string hash = "1QcSHQRnh493V4dIh4eXh1h4kJUI";
+TEST(ThumbhashDecode, DecodesKnownDimensions) {
+    const std::string hash = "1QcSHQRnh493V4dIh4eXh1h4kJUI";
 
-    SECTION("decodeThumbhash") {
-        auto [width, height, pixelArray] = decodeThumbhash(hash);
+    auto result = decodeThumbhash(hash);
 
-        EXPECT_EQ(width, 23);
-        EXPECT_EQ(height, 32);
-    }
+    EXPECT_EQ(result.width, 23);
+    EXPECT_EQ(result.height, 32);
+    ASSERT_NE(result.pixelArray, nullptr);
 }
+
+}  // namespace
+}  // namespace expoimage

package/kepler/test/utils/Base64.cpp

@@ -0,0 +1,73 @@
+#include "../../utils/Base64.h"
+
+#include <gtest/gtest.h>
+
+#include <string>
+
+namespace expoimage {
+namespace {
+
+std::string decode(const std::string& in) {
+    std::string out;
+    EXPECT_TRUE(decodeBase64(in, out));
+    return out;
+}
+
+TEST(DecodeBase64, DecodesSvg) {
+    EXPECT_EQ(decode("PHN2Zy8+"), "<svg/>");
+}
+
+TEST(DecodeBase64, EmptyInput) {
+    std::string out;
+    EXPECT_TRUE(decodeBase64("", out));
+    EXPECT_EQ(out, "");
+}
+
+TEST(DecodeBase64, NoPadding) {
+    // "Man" -> "TWFu" (exact multiple of 4, no padding)
+    EXPECT_EQ(decode("TWFu"), "Man");
+}
+
+TEST(DecodeBase64, OnePadByte) {
+    // "Ma" -> "TWE=" (one '=' -> two output bytes)
+    EXPECT_EQ(decode("TWE="), "Ma");
+}
+
+TEST(DecodeBase64, TwoPadBytes) {
+    // "M" -> "TQ==" (two '=' -> one output byte)
+    EXPECT_EQ(decode("TQ=="), "M");
+}
+
+TEST(DecodeBase64, UnpaddedRemainder) {
+    // Same payloads as the padded cases but without '=' padding.
+    EXPECT_EQ(decode("TWE"), "Ma");
+    EXPECT_EQ(decode("TQ"), "M");
+}
+
+TEST(DecodeBase64, PlusAndSlash) {
+    // bytes {0xFB, 0xFF, 0xBF} -> "+/+/"
+    EXPECT_EQ(decode("+/+/"), std::string("\xFB\xFF\xBF", 3));
+}
+
+TEST(DecodeBase64, RejectsInvalidCharacter) {
+    std::string out;
+    EXPECT_FALSE(decodeBase64("TW*u", out));
+}
+
+TEST(DecodeBase64, RejectsWhitespace) {
+    std::string out;
+    EXPECT_FALSE(decodeBase64("TW Fu", out));
+}
+
+TEST(DecodeBase64, RejectsDataAfterPadding) {
+    std::string out;
+    EXPECT_FALSE(decodeBase64("TQ==A", out));
+}
+
+TEST(DecodeBase64, RejectsLoneRemainderByte) {
+    std::string out;
+    EXPECT_FALSE(decodeBase64("TWFuA", out));
+}
+
+}  // namespace
+}  // namespace expoimage

package/kepler/test/utils/ColorUtils.cpp

@@ -0,0 +1,53 @@
+#include "../../utils/ColorUtils.h"
+
+#include <gtest/gtest.h>
+
+namespace expoimage {
+namespace {
+
+using Color = apmf::iface::com::amazon::kepler::uitoolkit::graphics::Color;
+
+constexpr float kTolerance = 1.0f / 255.0f;
+
+TEST(IntToColor, FullyOpaqueBlack) {
+    Color c = intToColor(0xFF000000);
+    EXPECT_NEAR(c.a, 1.0f, kTolerance);
+    EXPECT_NEAR(c.r, 0.0f, kTolerance);
+    EXPECT_NEAR(c.g, 0.0f, kTolerance);
+    EXPECT_NEAR(c.b, 0.0f, kTolerance);
+}
+
+TEST(IntToColor, FullyOpaqueWhite) {
+    Color c = intToColor(0xFFFFFFFF);
+    EXPECT_NEAR(c.a, 1.0f, kTolerance);
+    EXPECT_NEAR(c.r, 1.0f, kTolerance);
+    EXPECT_NEAR(c.g, 1.0f, kTolerance);
+    EXPECT_NEAR(c.b, 1.0f, kTolerance);
+}
+
+TEST(IntToColor, TransparentBlack) {
+    Color c = intToColor(0x00000000);
+    EXPECT_NEAR(c.a, 0.0f, kTolerance);
+    EXPECT_NEAR(c.r, 0.0f, kTolerance);
+    EXPECT_NEAR(c.g, 0.0f, kTolerance);
+    EXPECT_NEAR(c.b, 0.0f, kTolerance);
+}
+
+TEST(IntToColor, ARGBChannelOrdering) {
+    Color c = intToColor(0x12345678);
+    EXPECT_NEAR(c.a, 0x12 / 255.0f, kTolerance);
+    EXPECT_NEAR(c.r, 0x34 / 255.0f, kTolerance);
+    EXPECT_NEAR(c.g, 0x56 / 255.0f, kTolerance);
+    EXPECT_NEAR(c.b, 0x78 / 255.0f, kTolerance);
+}
+
+TEST(IntToColor, SignBitSetIsWellDefined) {
+    Color c = intToColor(static_cast<int>(0xFF112233u));
+    EXPECT_NEAR(c.a, 1.0f, kTolerance);
+    EXPECT_NEAR(c.r, 0x11 / 255.0f, kTolerance);
+    EXPECT_NEAR(c.g, 0x22 / 255.0f, kTolerance);
+    EXPECT_NEAR(c.b, 0x33 / 255.0f, kTolerance);
+}
+
+}  // namespace
+}  // namespace expoimage

package/kepler/test/utils/SourceSelection.cpp

@@ -0,0 +1,87 @@
+#include "../../utils/SourceSelection.h"
+
+#include <gtest/gtest.h>
+
+namespace expoimage {
+namespace {
+
+using Size = apmf::iface::com::amazon::kepler::uitoolkit::graphics::Size;
+
+// ---- startsWith (ASCII case-insensitive) ----
+
+TEST(StartsWith, ExactPrefix) {
+    EXPECT_TRUE(startsWith("blurhash:abc", "blurhash"));
+    EXPECT_TRUE(startsWith("thumbhash:abc", "thumbhash"));
+}
+
+TEST(StartsWith, CaseInsensitive) {
+    EXPECT_TRUE(startsWith("BlurHash:abc", "blurhash"));
+    EXPECT_TRUE(startsWith("BLURHASH", "blurhash"));
+    EXPECT_TRUE(startsWith("blurhash", "BLURHASH"));
+    EXPECT_TRUE(startsWith("ThumbHash:abc", "thumbhash"));
+}
+
+TEST(StartsWith, NoMatch) {
+    EXPECT_FALSE(startsWith("https://example.com", "blurhash"));
+    EXPECT_FALSE(startsWith("", "blurhash"));
+    EXPECT_FALSE(startsWith("blur", "blurhash"));  // str shorter than prefix
+}
+
+TEST(StartsWith, EmptyPrefix) {
+    EXPECT_TRUE(startsWith("anything", ""));
+    EXPECT_TRUE(startsWith("", ""));
+}
+
+// ---- uriDecode ----
+
+TEST(UriDecode, PassthroughPlainAscii) {
+    EXPECT_EQ(uriDecode("hello"), "hello");
+    EXPECT_EQ(uriDecode(""), "");
+}
+
+TEST(UriDecode, DecodesHexEscapes) {
+    EXPECT_EQ(uriDecode("a%20b"), "a b");
+    EXPECT_EQ(uriDecode("%5E"), "^");
+    EXPECT_EQ(uriDecode("%2F"), "/");
+    EXPECT_EQ(uriDecode("%2f"), "/");
+}
+
+TEST(UriDecode, MixedContent) {
+    EXPECT_EQ(uriDecode("https://example.com/path%20with%20spaces?q=%3F"),
+              "https://example.com/path with spaces?q=?");
+}
+
+TEST(UriDecode, MalformedEscapeIsLeftAsIs) {
+    EXPECT_EQ(uriDecode("50%"), "50%");
+    EXPECT_EQ(uriDecode("%ZZ"), "%ZZ");
+    EXPECT_EQ(uriDecode("%2"), "%2");
+}
+
+// ---- getBestSource ----
+
+TEST(GetBestSource, EmptyReturnsNullopt) {
+    std::vector<ImageSourceInfo> sources;
+    auto result = getBestSource(sources, Size{100.0f, 100.0f});
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(GetBestSource, SingleSourceIsAlwaysReturned) {
+    std::vector<ImageSourceInfo> sources{{"uri", 50.0f, 50.0f}};
+    auto result = getBestSource(sources, Size{100.0f, 100.0f});
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->uri, "uri");
+}
+
+TEST(GetBestSource, PicksClosestPixelCountMatch) {
+    std::vector<ImageSourceInfo> sources{
+            {"small", 10.0f, 10.0f},
+            {"medium", 100.0f, 100.0f},
+            {"large", 500.0f, 500.0f}};
+
+    auto result = getBestSource(sources, Size{100.0f, 100.0f});
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->uri, "medium");
+}
+
+}  // namespace
+}  // namespace expoimage

package/kepler/thumbhash/decode.cpp

@@ -7,12 +7,10 @@
  */
 
 #include "decode.h"
-
-#include <mbedtls/base64.h>
+#include "../utils/Base64.h"
 
 #include <cmath>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 // Inspired by https://github.com/evanw/thumbhash/blob/main/java/com/madebyevan/thumbhash/ThumbHash.java
@@ -20,19 +18,12 @@
 namespace {
 
 std::string base64_decode(const std::string& in) {
-    size_t bufferSize;
-
-    mbedtls_base64_decode(nullptr, 0, &bufferSize, reinterpret_cast<const unsigned char*>(in.data()), in.size());
-
-    std::string buffer(bufferSize, ' ');
-
-    mbedtls_base64_decode(
-            reinterpret_cast<unsigned char*>(buffer.data()),
-            bufferSize,
-            &bufferSize,
-            reinterpret_cast<const unsigned char*>(in.data()),
-            in.size());
-
+    std::string buffer;
+    if (!expoimage::decodeBase64(in, buffer)) {
+        // Return empty on malformed input so the size check in the caller
+        // rejects the hash instead of decoding a partial buffer into garbage pixels
+        return "";
+    }
     return buffer;
 }
 

package/kepler/utils/Base64.cpp

@@ -0,0 +1,85 @@
+/*
+ * base64 decoding.
+ *
+ * Adapted from base64.cpp by René Nyffenegger (zlib license). Altered from the
+ * original: decode-only, strict RFC 4648 validation, and a bool success return.
+ *
+ * Copyright (C) 2004-2017 René Nyffenegger
+ *
+ * This source code is provided 'as-is', without any express or implied
+ * warranty. In no event will the author be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this source code must not be misrepresented; you must not
+ *    claim that you wrote the original source code. If you use this source code
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original source code.
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+ */
+
+#include "Base64.h"
+
+namespace expoimage {
+
+namespace {
+
+int decodeValue(unsigned char c) {
+    if (c >= 'A' && c <= 'Z') return c - 'A';
+    if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+    if (c >= '0' && c <= '9') return c - '0' + 52;
+    if (c == '+') return 62;
+    if (c == '/') return 63;
+    return -1;
+}
+
+}  // namespace
+
+bool decodeBase64(const std::string& input, std::string& output) {
+    output.clear();
+    output.reserve(input.size() / 4 * 3);
+
+    unsigned char block[4];
+    size_t filled = 0;
+    size_t padding = 0;
+
+    for (unsigned char c : input) {
+        if (c == '=') {
+            ++padding;
+            continue;
+        }
+        if (padding != 0) return false;
+
+        const int value = decodeValue(c);
+        if (value < 0) return false;
+
+        block[filled++] = static_cast<unsigned char>(value);
+        if (filled == 4) {
+            output.push_back(static_cast<char>((block[0] << 2) + ((block[1] & 0x30) >> 4)));
+            output.push_back(static_cast<char>(((block[1] & 0x0f) << 4) + ((block[2] & 0x3c) >> 2)));
+            output.push_back(static_cast<char>(((block[2] & 0x03) << 6) + block[3]));
+            filled = 0;
+        }
+    }
+
+    if (padding > 2) return false;
+    if (filled == 1) return false;
+
+    if (filled >= 2) {
+        output.push_back(static_cast<char>((block[0] << 2) + ((block[1] & 0x30) >> 4)));
+        if (filled == 3) {
+            output.push_back(static_cast<char>(((block[1] & 0x0f) << 4) + ((block[2] & 0x3c) >> 2)));
+        }
+    }
+
+    return true;
+}
+
+}  // namespace expoimage

package/kepler/utils/Base64.h

@@ -0,0 +1,36 @@
+/*
+ * base64 decoding.
+ *
+ * Adapted from base64.cpp by René Nyffenegger (zlib license). Altered from the
+ * original: decode-only, strict RFC 4648 validation, and a bool success return.
+ *
+ * Copyright (C) 2004-2017 René Nyffenegger
+ *
+ * This source code is provided 'as-is', without any express or implied
+ * warranty. In no event will the author be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this source code must not be misrepresented; you must not
+ *    claim that you wrote the original source code. If you use this source code
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original source code.
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+ */
+
+#pragma once
+
+#include <string>
+
+namespace expoimage {
+
+[[nodiscard]] bool decodeBase64(const std::string& input, std::string& output);
+
+}  // namespace expoimage

package/kepler/utils/ColorUtils.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include <apmf/iface/com/amazon/kepler/uitoolkit/graphics/Color.h>
+
+#include <cstdint>
+
+namespace expoimage {
+
+/** Converts an ARGB integer (from processColor in JS) to a stable Color struct. */
+inline apmf::iface::com::amazon::kepler::uitoolkit::graphics::Color intToColor(int argb) {
+    auto u = static_cast<uint32_t>(argb);
+    float a = ((u >> 24) & 0xFF) / 255.0f;
+    float r = ((u >> 16) & 0xFF) / 255.0f;
+    float g = ((u >> 8) & 0xFF) / 255.0f;
+    float b = (u & 0xFF) / 255.0f;
+    return {r, g, b, a};
+}
+
+}  // namespace expoimage