@amazon-devices/expo-image 2.0.9000000000 → 3.0.0

package/kepler/blurhash/common.h

@@ -11,22 +11,23 @@
 
 #include <cmath>
 
-int linearTosRGB(float value) {
+inline int linearTosRGB(float value) {
     float v = fmaxf(0, fminf(1, value));
-    if (v <= 0.0031308)
+    if (v <= 0.0031308) {
         return v * 12.92 * 255 + 0.5;
-    else
-        return (1.055 * powf(v, 1 / 2.4) - 0.055) * 255 + 0.5;
+    }
+    
+    return (1.055 * powf(v, 1 / 2.4) - 0.055) * 255 + 0.5;
 }
 
-float sRGBToLinear(int value) {
-    float v = (float) value / 255;
-    if (v <= 0.04045)
+inline float sRGBToLinear(int value) {
+    float v = static_cast<float>(value) / 255;
+    if (v <= 0.04045) {
         return v / 12.92;
-    else
-        return powf((v + 0.055) / 1.055, 2.4);
+    }
+    return powf((v + 0.055) / 1.055, 2.4);
 }
 
-float signPow(float value, float exp) {
+inline float signPow(float value, float exp) {
     return copysignf(powf(fabsf(value), exp), value);
 }

package/kepler/blurhash/decode.cpp

@@ -7,6 +7,10 @@
  */
 
 // Source: https://github.com/woltapp/blurhash/blob/master/C/decode.c
+
+#include <vector>
+#include <array>
+
 #include "decode.h"
 
 #include <unordered_map>
@@ -66,7 +70,7 @@ int decodeToInt(const std::string& string, int start, int end) {
 
 Size getImageSize(const std::string& blurhash) {
     int sizeFlag = decodeToInt(blurhash, 0);  // Get size from first character
-    int numY = (int) floorf(sizeFlag / 9) + 1;
+    int numY = static_cast<int>(floorf(sizeFlag / 9)) + 1;
     int numX = (sizeFlag % 9) + 1;
 
     return Size{numY, numX};
@@ -79,8 +83,7 @@ bool isValidBlurhash(const std::string& blurhash) {
     if (hashLength < MINIMAL_HASH_LENGTH) return false;
     auto size = getImageSize(blurhash);
 
-    if (hashLength != 4 + 2 * size.x * size.y) return false;
-    return true;
+    return hashLength == 4 + 2 * size.x * size.y;
 }
 
 Color decodeDC(int value) {
@@ -97,9 +100,9 @@ Color decodeAC(int value, float maximumValue) {
     int quantB = (int) value % 19;
 
     return std::make_tuple(
-            signPow(((float) quantR - 9) / 9, 2.0) * maximumValue,
-            signPow(((float) quantG - 9) / 9, 2.0) * maximumValue,
-            signPow(((float) quantB - 9) / 9, 2.0) * maximumValue);
+            signPow((static_cast<float>(quantR) - 9) / 9, 2.0) * maximumValue,
+            signPow((static_cast<float>(quantG) - 9) / 9, 2.0) * maximumValue,
+            signPow((static_cast<float>(quantB) - 9) / 9, 2.0) * maximumValue);
 }
 
 int decodeToArray(
@@ -117,21 +120,23 @@ int decodeToArray(
     int quantizedMaxValue = decodeToInt(blurhash, 1);
     if (quantizedMaxValue == -1) return -1;
 
-    float maxValue = ((float) (quantizedMaxValue + 1)) / 166;
+    float maxValue = (static_cast<float>(quantizedMaxValue + 1)) / 166;
 
-    int colors_size = size.x * size.y;
-    float colors[colors_size][3];
+    int colorsSize = size.x * size.y;
+    std::vector<std::array<float, 3>> colors(colorsSize);
 
-    for (int iter = 0; iter < colors_size; ++iter) {
-        float r = 0, g = 0, b = 0;
+    for (int iter = 0; iter < colorsSize; ++iter) {
+        float r = 0;
+        float g = 0;
+        float b = 0;
         if (iter == 0) {
             int value = decodeToInt(blurhash, 2, 6);
-            if (value == -1) return -1;
+            if (value == -1) { return -1;}
             std::tie(r, g, b) = decodeDC(value);
 
         } else {
             int value = decodeToInt(blurhash, 4 + iter * 2, 6 + iter * 2);
-            if (value == -1) return -1;
+            if (value == -1) { return -1;}
             std::tie(r, g, b) = decodeAC(value, maxValue * punch);
         }
         colors[iter][0] = r;
@@ -140,11 +145,15 @@ int decodeToArray(
     }
 
     int bytesPerRow = width * nChannels;
-    int intR = 0, intG = 0, intB = 0;
+    int intR = 0;
+    int intG = 0;
+    int intB = 0;
 
     for (int y = 0; y < height; ++y) {
         for (int x = 0; x < width; ++x) {
-            float r = 0, g = 0, b = 0;
+            float r = 0;
+            float g = 0;
+            float b = 0;
 
             for (int j = 0; j < size.y; ++j) {
                 for (int i = 0; i < size.x; ++i) {
@@ -164,9 +173,10 @@ int decodeToArray(
             pixelArray[nChannels * x + 1 + y * bytesPerRow] = clampToUByte(intG);
             pixelArray[nChannels * x + 2 + y * bytesPerRow] = clampToUByte(intB);
 
-            if (nChannels == 4)
+            if (nChannels == 4) {
                 pixelArray[nChannels * x + 3 + y * bytesPerRow] =
                         255;  // If nChannels=4, treat each pixel as RGBA instead of RGB
+            }
         }
     }
 

package/kepler/contentposition/ImageContentPosition.cpp

@@ -1,86 +1,67 @@
-/*
- * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * PROPRIETARY/CONFIDENTIAL
- *
- * Use is subject to license terms.
- */
-
 #include "ImageContentPosition.h"
 
-#include <JsonContainer/JsonContainer.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/JsType.h>
+
+#include "../utils/SourceSelection.h"
+
+namespace expoimage {
 
-float calcTranslation(
-        float value,
-        float imageRefValue,
-        float viewRefValue,
-        bool isPercentage = false,
-        bool isReverse = false) {
+using apmf::iface::com::amazon::kepler::uitoolkit::react::JsType;
+
+namespace {
+
+float calcTranslation(float value, float imageVal, float viewVal, bool isPercentage, bool isReverse) {
     if (isPercentage) {
-        float finalPercentage = isReverse ? 100.0f - value : value;
-        return (finalPercentage / 100.0f) * (viewRefValue - imageRefValue);
+        float pct = isReverse ? 100.0f - value : value;
+        return (pct / 100.0f) * (viewVal - imageVal);
     }
-
-    return isReverse ? viewRefValue - imageRefValue - value : value;
+    return isReverse ? viewVal - imageVal - value : value;
 }
 
-float calcXTranslation(
-        float value,
-        const volta::graphics::Size& imageRect,
-        const volta::graphics::Size& viewRect,
-        bool isPercentage = false,
-        bool isReverse = false) {
-    return calcTranslation(value, imageRect.width(), viewRect.width(), isPercentage, isReverse);
+float calcX(float value, const Size& imageRect, const Size& viewRect, bool isPercentage, bool isReverse) {
+    return calcTranslation(value, imageRect.width, viewRect.width, isPercentage, isReverse);
 }
 
-float calcYTranslation(
-        float value,
-        const volta::graphics::Size& imageRect,
-        const volta::graphics::Size& viewRect,
-        bool isPercentage = false,
-        bool isReverse = false) {
-    return calcTranslation(value, imageRect.height(), viewRect.height(), isPercentage, isReverse);
+float calcY(float value, const Size& imageRect, const Size& viewRect, bool isPercentage, bool isReverse) {
+    return calcTranslation(value, imageRect.height, viewRect.height, isPercentage, isReverse);
 }
 
-ImageContentPositionValue::ImageContentPositionValue() : value_(std::nullopt), isPercentage_(true) {}
+}  // namespace
 
-ImageContentPositionValue::ImageContentPositionValue(float value, bool isPercentage) :
-        value_(value),
-        isPercentage_(isPercentage) {}
-
-std::optional<float> ImageContentPositionValue::calcOffset(
-        bool isReverse,
-        const volta::graphics::Size& imageRect,
-        const volta::graphics::Size& viewRect,
-        std::function<float(float, const volta::graphics::Size&, const volta::graphics::Size&, bool, bool)>
-                calcAxisOffset) {
-    return value_ ? calcAxisOffset(value_.value(), imageRect, viewRect, isPercentage_, isReverse) : value_;
+float ImageContentPosition::offsetX(const Size& imageRect, const Size& viewRect) const {
+    return left_.calcOffset(false, imageRect, viewRect, &calcX)
+            .value_or(right_.calcOffset(true, imageRect, viewRect, &calcX)
+                              .value_or(calcX(50.0f, imageRect, viewRect, true, false)));
 }
 
-ImageContentPosition::ImageContentPosition() :
-        top_(ImageContentPositionValue()),
-        bottom_(ImageContentPositionValue()),
-        right_(ImageContentPositionValue()),
-        left_(ImageContentPositionValue()) {}
-
-ImageContentPosition::ImageContentPosition(
-        ImageContentPositionValue top,
-        ImageContentPositionValue bottom,
-        ImageContentPositionValue right,
-        ImageContentPositionValue left) :
-        top_(top),
-        bottom_(bottom),
-        right_(right),
-        left_(left) {}
-
-float ImageContentPosition::offsetX(const volta::graphics::Size& imageRect, const volta::graphics::Size& viewRect) {
-    return left_.calcOffset(false, imageRect, viewRect, &calcXTranslation)
-            .value_or(right_.calcOffset(true, imageRect, viewRect, &calcXTranslation)
-                              .value_or(calcXTranslation(50.0f, imageRect, viewRect, true)));
+float ImageContentPosition::offsetY(const Size& imageRect, const Size& viewRect) const {
+    return top_.calcOffset(false, imageRect, viewRect, &calcY)
+            .value_or(bottom_.calcOffset(true, imageRect, viewRect, &calcY)
+                              .value_or(calcY(50.0f, imageRect, viewRect, true, false)));
 }
 
-float ImageContentPosition::offsetY(const volta::graphics::Size& imageRect, const volta::graphics::Size& viewRect) {
-    return top_.calcOffset(false, imageRect, viewRect, &calcYTranslation)
-            .value_or(bottom_.calcOffset(true, imageRect, viewRect, &calcYTranslation)
-                              .value_or(calcYTranslation(50.0f, imageRect, viewRect, true)));
+ImageContentPositionValue parsePositionValue(View<IJsObject> obj, const std::string& key) {
+    ImageContentPositionValue result;
+    auto keys = obj->getAllKeys();
+    if (!hasKey(keys, key)) return result;
+    auto type = obj->getElementValueType(key);
+    if (type.value == JsType::STRING.value) {
+        std::string val = obj->getString(key);
+        if (!val.empty() && val.back() == '%') {
+            try {
+                result.value = std::stof(val);
+                result.isPercentage = true;
+            } catch (...) {
+            }
+        }
+    } else if (type.value == JsType::DOUBLE.value) {
+        result.value = static_cast<float>(obj->getDouble(key));
+        result.isPercentage = false;
+    } else if (type.value == JsType::INT.value) {
+        result.value = static_cast<float>(obj->getInt(key));
+        result.isPercentage = false;
+    }
+    return result;
 }
+
+}  // namespace expoimage

package/kepler/contentposition/ImageContentPosition.h

@@ -7,42 +7,52 @@
  */
 
 #pragma once
-#include <Volta/graphics/Size.h>
+
+#include <apmf/iface/com/amazon/kepler/uitoolkit/graphics/Size.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IJsObject.h>
 
 #include <functional>
 #include <optional>
 #include <string>
 
-class ImageContentPositionValue {
-public:
-    std::optional<float> value_;
-    bool isPercentage_;
-    ImageContentPositionValue();
-    ImageContentPositionValue(float value, bool isPercentage);
+namespace expoimage {
+
+using Size = apmf::iface::com::amazon::kepler::uitoolkit::graphics::Size;
+using apmf::detail::View;
+using apmf::iface::com::amazon::kepler::uitoolkit::react::IJsObject;
+
+struct ImageContentPositionValue {
+    std::optional<float> value;
+    bool isPercentage{true};
+
+    ImageContentPositionValue() = default;
+    ImageContentPositionValue(float v, bool pct) : value(v), isPercentage(pct) {}
+
     std::optional<float> calcOffset(
-            bool isReverse,
-            const volta::graphics::Size& imageRect,
-            const volta::graphics::Size& viewRect,
-            std::function<float(float, const volta::graphics::Size&, const volta::graphics::Size&, bool, bool)>
-                    calcAxisOffset);
+            bool isReverse, const Size& imageSize, const Size& viewSize,
+            std::function<float(float, const Size&, const Size&, bool, bool)> calc) const {
+        if (value) {
+            return calc(*value, imageSize, viewSize, isPercentage, isReverse);
+        }
+        return std::nullopt;
+    }
 };
 
 class ImageContentPosition {
 public:
-    ImageContentPosition();
+    ImageContentPosition() = default;
     ImageContentPosition(
-            ImageContentPositionValue top,
-            ImageContentPositionValue bottom,
-            ImageContentPositionValue right,
-            ImageContentPositionValue left);
-    float offsetX(const volta::graphics::Size& imageRect, const volta::graphics::Size& viewRect);
-    float offsetY(const volta::graphics::Size& imageRect, const volta::graphics::Size& viewRect);
-
-#ifndef UNIT_TEST
+            ImageContentPositionValue top, ImageContentPositionValue bottom,
+            ImageContentPositionValue right, ImageContentPositionValue left)
+        : top_(top), bottom_(bottom), right_(right), left_(left) {}
+
+    float offsetX(const Size& imageRect, const Size& viewRect) const;
+    float offsetY(const Size& imageRect, const Size& viewRect) const;
+
 private:
-#endif
-    ImageContentPositionValue top_;
-    ImageContentPositionValue bottom_;
-    ImageContentPositionValue right_;
-    ImageContentPositionValue left_;
+    ImageContentPositionValue top_, bottom_, right_, left_;
 };
+
+ImageContentPositionValue parsePositionValue(View<IJsObject> obj, const std::string& key);
+
+}  // namespace expoimage

package/kepler/enums/ImageContentFit.h

@@ -1,17 +1,49 @@
-/*
- * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * PROPRIETARY/CONFIDENTIAL
- *
- * Use is subject to license terms.
- */
-
 #pragma once
 
-enum ImageContentFit {
-    Cover,
-    Contain,
-    Fill,
-    None,
-    ScaleDown,
-};
+#include <apmf/iface/com/amazon/kepler/uitoolkit/graphics/Size.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/Fit.h>
+
+#include <string>
+
+namespace expoimage {
+
+using apmf::iface::com::amazon::kepler::uitoolkit::view::Fit;
+
+enum class ImageContentFit { Cover, Contain, Fill, None, ScaleDown };
+
+inline ImageContentFit parseContentFit(const std::string& value, ImageContentFit defaultFit = ImageContentFit::Cover) {
+    if (value == "contain") return ImageContentFit::Contain;
+    if (value == "fill") return ImageContentFit::Fill;
+    if (value == "scale-down") return ImageContentFit::ScaleDown;
+    if (value == "none") return ImageContentFit::None;
+    if (value == "cover") return ImageContentFit::Cover;
+    return defaultFit;
+}
+
+/** Maps ImageContentFit to stable Fit enum. All modes have direct platform support. */
+inline Fit toFit(ImageContentFit contentFit) {
+    switch (contentFit) {
+        case ImageContentFit::Cover: return Fit::COVER;
+        case ImageContentFit::Contain: return Fit::CONTAIN;
+        case ImageContentFit::Fill: return Fit::STRETCH;
+        case ImageContentFit::ScaleDown: return Fit::SCALE_DOWN;
+        case ImageContentFit::None: return Fit::NONE;
+    }
+    return Fit::COVER;
+}
+
+inline Fit resolveNativeFit(
+        ImageContentFit fit,
+        bool allowDownscaling,
+        apmf::iface::com::amazon::kepler::uitoolkit::graphics::Size imageSize,
+        apmf::iface::com::amazon::kepler::uitoolkit::graphics::Size viewSize) {
+    if (!allowDownscaling) return Fit::NONE;
+    if (fit != ImageContentFit::ScaleDown) return toFit(fit);
+    const bool imageSizeKnown = imageSize.width > 0 && imageSize.height > 0;
+    if (!imageSizeKnown) return Fit::CONTAIN;
+    const bool imageFitsInView =
+            imageSize.width <= viewSize.width && imageSize.height <= viewSize.height;
+    return imageFitsInView ? Fit::NONE : Fit::CONTAIN;
+}
+
+}  // namespace expoimage

package/kepler/enums/ImagePriority.h

@@ -1,17 +1,16 @@
-/*
- * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * PROPRIETARY/CONFIDENTIAL
- *
- * Use is subject to license terms.
- */
-
 #pragma once
 
 #include <cstdint>
+#include <string>
+
+namespace expoimage {
+
+enum class ImagePriority : uint8_t { Low = 1, Normal = 2, High = 3 };
+
+inline ImagePriority parsePriority(const std::string& value) {
+    if (value == "low") return ImagePriority::Low;
+    if (value == "high") return ImagePriority::High;
+    return ImagePriority::Normal;
+}
 
-enum class ImagePriority : uint8_t { 
-    Low, 
-    Normal, 
-    High
-};
+}  // namespace expoimage

package/kepler/test/blurhash/decode.cpp

@@ -1,39 +1,48 @@
 #include "../../blurhash/decode.h"
 
-#include <gmock/gmock-actions.h>
-#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include "catch.hpp"
+namespace expoimage {
+namespace {
 
-TEST_CASE("blurhash") {
-    std::string validBlurHash = "LGF5]+Yk^6#M@-5c,1J5@[or[Q6.";
-    std::string invalidBlurHash = "some invalid blurhash";
-    std::string pureBlackHash = "L0006Mp2p2p2fRfRfRfRfQfQfQfQ";
+TEST(BlurhashDecode, IsValidBlurhashAcceptsWellFormed) {
+    const std::string validBlurHash = "LGF5]+Yk^6#M@-5c,1J5@[or[Q6.";
+    EXPECT_TRUE(isValidBlurhash(validBlurHash));
+}
 
-    SECTION("decodeBlurHash") {
-        const int channels = 3;
-        const int width = 32;
-        const int height = 32;
+TEST(BlurhashDecode, IsValidBlurhashRejectsGarbage) {
+    EXPECT_FALSE(isValidBlurhash("some invalid blurhash"));
+    EXPECT_FALSE(isValidBlurhash(""));
+}
 
-        auto decoded = decodeBlurhash(pureBlackHash, width, height, 1, channels);
+TEST(BlurhashDecode, DecodeProducesExpectedBufferSize) {
+    const std::string nearBlackHash = "L0006Mp2p2p2fRfRfRfRfQfQfQfQ";
+    const int channels = 3;
+    const int width = 32;
+    const int height = 32;
 
-        // channels times pixels
-        int bytesPerRow = 32 * channels;
+    constexpr int kNearBlackThreshold = 64;
 
-        for (int i = 0; i < height; i++) {
-            for (int j = 0; j < width; j++) {
-                for (int ch = 0; i < channels; i++) {
-                    int part = decoded.get()[channels * j + ch + i * bytesPerRow];
-                    // expect each channel to be close to 0
-                    CHECK(part < 10);
-                }
-            }
-        }
-    }
+    auto decoded = decodeBlurhash(nearBlackHash, width, height, 1, channels);
+    ASSERT_NE(decoded, nullptr);
 
-    SECTION("isValidBlurHash") {
-        EXPECT_TRUE(isValidBlurhash(validBlurHash));
-        EXPECT_FALSE(isValidBlurhash(invalidBlurHash));
+    const int totalBytes = width * height * channels;
+    int maxByte = 0;
+    for (int i = 0; i < totalBytes; ++i) {
+        int byte = decoded.get()[i];
+        if (byte > maxByte) maxByte = byte;
     }
+    EXPECT_LT(maxByte, kNearBlackThreshold)
+            << "Decoded buffer unexpectedly bright for near-black hash; "
+               "brightest byte was "
+            << maxByte;
 }
+
+TEST(BlurhashDecode, DecodeReturnsNonNullForValidHash) {
+    const std::string validBlurHash = "LGF5]+Yk^6#M@-5c,1J5@[or[Q6.";
+    auto decoded = decodeBlurhash(validBlurHash, 16, 16, 1, 3);
+    EXPECT_NE(decoded, nullptr);
+}
+
+}  // namespace
+}  // namespace expoimage