From d87a7b297a5bfc2bad3ba78ea97754d7894e82ef Mon Sep 17 00:00:00 2001
From: Michele Di Giorgio <michele.digiorgio@arm.com>
Date: Tue, 10 Sep 2019 10:42:27 +0100
Subject: COMPMID-2650: Add support for QASYMM16 in CLQuantizationLayer

Change-Id: I51dda621975f522a65d770304bed0ff0f30d1235
Signed-off-by: Michele Di Giorgio <michele.digiorgio@arm.com>
Reviewed-on: https://review.mlplatform.org/c/1902
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Georgios Pinitas <georgios.pinitas@arm.com>
---
 src/core/utils/quantization/AsymmHelpers.cpp | 59 +++++++++++++++++++++-------
 1 file changed, 45 insertions(+), 14 deletions(-)

(limited to 'src/core/utils/quantization/AsymmHelpers.cpp')

diff --git a/src/core/utils/quantization/AsymmHelpers.cpp b/src/core/utils/quantization/AsymmHelpers.cpp
index d606adba62..59052449af 100644
--- a/src/core/utils/quantization/AsymmHelpers.cpp
+++ b/src/core/utils/quantization/AsymmHelpers.cpp
@@ -27,14 +27,16 @@
 #include <limits>
 #include <numeric>
 
-using namespace arm_compute::quantization;
-
+namespace arm_compute
+{
+namespace quantization
+{
 constexpr int64_t fixed_point_one_Q0 = (1LL << 31);
 constexpr float   epsilon            = 0.00001f;
 
-arm_compute::Status arm_compute::quantization::calculate_quantized_multiplier_less_than_one(float multiplier,
-                                                                                            int *quant_multiplier,
-                                                                                            int *right_shift)
+Status calculate_quantized_multiplier_less_than_one(float multiplier,
+                                                    int *quant_multiplier,
+                                                    int *right_shift)
 {
     ARM_COMPUTE_RETURN_ERROR_ON(quant_multiplier == nullptr);
     ARM_COMPUTE_RETURN_ERROR_ON(right_shift == nullptr);
@@ -44,19 +46,19 @@ arm_compute::Status arm_compute::quantization::calculate_quantized_multiplier_le
     {
         *quant_multiplier = 1;
         *right_shift      = 0;
-        return arm_compute::Status{};
+        return Status{};
     }
 
     if(std::fabs(0.0f - multiplier) < epsilon)
     {
         *quant_multiplier = 0;
         *right_shift      = 0;
-        return arm_compute::Status{};
+        return Status{};
     }
 
     const double q = std::frexp(multiplier, right_shift);
     *right_shift *= -1;
-    auto q_fixed = static_cast<int64_t>(round(q * fixed_point_one_Q0));
+    auto q_fixed = static_cast<int64_t>(support::cpp11::round(q * fixed_point_one_Q0));
     ARM_COMPUTE_RETURN_ERROR_ON(q_fixed > fixed_point_one_Q0);
     if(q_fixed == fixed_point_one_Q0)
     {
@@ -67,18 +69,18 @@ arm_compute::Status arm_compute::quantization::calculate_quantized_multiplier_le
     ARM_COMPUTE_RETURN_ERROR_ON(q_fixed > std::numeric_limits<int32_t>::max());
     *quant_multiplier = static_cast<int32_t>(q_fixed);
 
-    return arm_compute::Status{};
+    return Status{};
 }
 
-arm_compute::Status arm_compute::quantization::calculate_quantized_multiplier_greater_than_one(float multiplier,
-                                                                                               int *quantized_multiplier,
-                                                                                               int *left_shift)
+Status calculate_quantized_multiplier_greater_than_one(float multiplier,
+                                                       int *quantized_multiplier,
+                                                       int *left_shift)
 {
     ARM_COMPUTE_RETURN_ERROR_ON(quantized_multiplier == nullptr);
     ARM_COMPUTE_RETURN_ERROR_ON(left_shift == nullptr);
     ARM_COMPUTE_RETURN_ERROR_ON(multiplier < 1.f);
     const double q       = std::frexp(multiplier, left_shift);
-    auto         q_fixed = static_cast<int64_t>(round(q * fixed_point_one_Q0));
+    auto         q_fixed = static_cast<int64_t>(support::cpp11::round(q * fixed_point_one_Q0));
     ARM_COMPUTE_RETURN_ERROR_ON(q_fixed > fixed_point_one_Q0);
     if(q_fixed == fixed_point_one_Q0)
     {
@@ -89,5 +91,34 @@ arm_compute::Status arm_compute::quantization::calculate_quantized_multiplier_gr
     ARM_COMPUTE_RETURN_ERROR_ON(q_fixed > std::numeric_limits<int32_t>::max());
     *quantized_multiplier = static_cast<int32_t>(q_fixed);
 
-    return arm_compute::Status{};
+    return Status{};
+}
+std::pair<int, int> get_min_max_values_from_quantized_data_type(DataType data_type)
+{
+    int min_quant_val = 0;
+    int max_quant_val = 0;
+    switch(data_type)
+    {
+        case DataType::QASYMM8:
+            min_quant_val = std::numeric_limits<uint8_t>::min();
+            max_quant_val = std::numeric_limits<uint8_t>::max();
+            break;
+        case DataType::QSYMM8:
+            min_quant_val = std::numeric_limits<int8_t>::min();
+            max_quant_val = std::numeric_limits<int8_t>::max();
+            break;
+        case DataType::QASYMM16:
+            min_quant_val = std::numeric_limits<uint16_t>::min();
+            max_quant_val = std::numeric_limits<uint16_t>::max();
+            break;
+        case DataType::QSYMM16:
+            min_quant_val = std::numeric_limits<int16_t>::min();
+            max_quant_val = std::numeric_limits<int16_t>::max();
+            break;
+        default:
+            ARM_COMPUTE_ERROR("Unsupported data type");
+    }
+    return std::make_pair(min_quant_val, max_quant_val);
 }
+} // quantization
+} // arm_compute
-- 
cgit v1.2.1