Rename quantized data types to remove ambiguity for signed/unsigned payloads

!android-nn-driver:2572

Change-Id: I8fe52ceb09987b3d05c539409510f535165455cc
Signed-off-by: Derek Lamberti <derek.lamberti@arm.com>
diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp
index ebcd1f6..4767aa0 100644
--- a/src/backends/reference/RefLayerSupport.cpp
+++ b/src/backends/reference/RefLayerSupport.cpp
@@ -75,8 +75,8 @@
         {
             DataType::Float32,
             DataType::Float16,
-            DataType::QuantisedAsymm8,
-            DataType::QuantisedSymm16
+            DataType::QAsymmU8,
+            DataType::QSymmS16
         };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -105,8 +105,8 @@
     std::array<DataType,4> supportedTypes = {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -168,8 +168,8 @@
     std::array<DataType,4> supportedTypes = {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
@@ -202,8 +202,8 @@
     std::array<DataType, 4> supportedTypes =
     {
         DataType::Float32,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16,
+        DataType::QAsymmU8,
+        DataType::QSymmS16,
         DataType::Signed32
     };
 
@@ -232,8 +232,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     bool supported = true;
@@ -280,8 +280,8 @@
     {
             DataType::Float32,
             DataType::Float16,
-            DataType::QuantisedAsymm8,
-            DataType::QuantisedSymm16
+            DataType::QAsymmU8,
+            DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -322,8 +322,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     bool supported = true;
@@ -351,8 +351,8 @@
     {
             DataType::Float32,
             DataType::Float16,
-            DataType::QuantisedAsymm8,
-            DataType::QuantisedSymm16
+            DataType::QAsymmU8,
+            DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
@@ -377,8 +377,8 @@
     {
         DataType::Float32,
         DataType::Signed32,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
@@ -439,8 +439,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -453,11 +453,11 @@
                                   "Reference convolution2d: input and output types mismatched.");
 
     const DataType inputType = input.GetDataType();
-    if (inputType == DataType::QuantisedAsymm8)
+    if (inputType == DataType::QAsymmU8)
     {
         std::array<DataType, 2> supportedWeightTypes =
         {
-            DataType::QuantisedAsymm8,
+            DataType::QAsymmU8,
             DataType::QuantizedSymm8PerAxis
         };
 
@@ -500,8 +500,8 @@
     {
         DataType::Float16,
         DataType::Float32,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -528,8 +528,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -558,8 +558,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -572,11 +572,11 @@
                                   "Reference DepthwiseConvolution2d: input and output types mismatched.");
 
     const DataType inputType = input.GetDataType();
-    if (inputType == DataType::QuantisedAsymm8)
+    if (inputType == DataType::QAsymmU8)
     {
         std::array<DataType, 2> supportedWeightTypes =
         {
-            DataType::QuantisedAsymm8,
+            DataType::QAsymmU8,
             DataType::QuantizedSymm8PerAxis
         };
 
@@ -616,9 +616,9 @@
    bool supported = true;
 
     std::array<DataType,3> supportedInputTypes = {
-        DataType::QuantisedAsymm8,
+        DataType::QAsymmU8,
         DataType::QSymmS8,
-        DataType::QuantisedSymm16
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
@@ -655,8 +655,8 @@
     std::array<DataType,3> supportedInputTypes =
     {
         DataType::Float32,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
@@ -688,8 +688,8 @@
     std::array<DataType,4> supportedTypes = {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
@@ -754,7 +754,7 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedSymm16
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -780,8 +780,8 @@
     {
             DataType::Float32,
             DataType::Float16,
-            DataType::QuantisedAsymm8,
-            DataType::QuantisedSymm16
+            DataType::QAsymmU8,
+            DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -834,8 +834,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
@@ -913,8 +913,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     bool supported = true;
@@ -979,7 +979,7 @@
 
     std::array<DataType,2> supportedTypes = {
         DataType::Float32,
-        DataType::QuantisedSymm16
+        DataType::QSymmS16
     };
 
     // check inputs and outputs
@@ -1081,8 +1081,8 @@
     std::array<DataType,4> supportedTypes = {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
@@ -1119,8 +1119,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1185,8 +1185,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16,
+        DataType::QAsymmU8,
+        DataType::QSymmS16,
         DataType::Boolean
     };
 
@@ -1212,8 +1212,8 @@
     std::array<DataType,4> supportedTypes = {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
@@ -1247,8 +1247,8 @@
     std::array<DataType,4> supportedTypes = {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
@@ -1284,8 +1284,8 @@
     {
         DataType::Float16,
         DataType::Float32,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     bool supported = true;
@@ -1322,8 +1322,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1350,8 +1350,8 @@
     std::array<DataType,3> supportedTypes =
     {
         DataType::Float32,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1379,8 +1379,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1411,9 +1411,9 @@
 
     // Define supported output types.
     std::array<DataType,3> supportedOutputTypes = {
-        DataType::QuantisedAsymm8,
+        DataType::QAsymmU8,
         DataType::QSymmS8,
-        DataType::QuantisedSymm16
+        DataType::QSymmS16
     };
     supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
                                   "Reference quantize: output type not supported.");
@@ -1435,8 +1435,8 @@
         DataType::Float32,
         DataType::Float16,
         DataType::Signed32,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
     return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
         "Reference reshape: input type not supported.");
@@ -1451,8 +1451,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1478,8 +1478,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1503,8 +1503,8 @@
     {
             DataType::Float32,
             DataType::Float16,
-            DataType::QuantisedAsymm8,
-            DataType::QuantisedSymm16
+            DataType::QAsymmU8,
+            DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1533,8 +1533,8 @@
     std::array<DataType, 3> supportedTypes =
     {
         DataType::Float32,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1560,8 +1560,8 @@
     {
             DataType::Float32,
             DataType::Float16,
-            DataType::QuantisedAsymm8,
-            DataType::QuantisedSymm16
+            DataType::QAsymmU8,
+            DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1587,8 +1587,8 @@
     {
             DataType::Float32,
             DataType::Float16,
-            DataType::QuantisedAsymm8,
-            DataType::QuantisedSymm16
+            DataType::QAsymmU8,
+            DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1616,8 +1616,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1642,8 +1642,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1663,8 +1663,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1693,8 +1693,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
@@ -1723,8 +1723,8 @@
     std::array<DataType,3> supportedTypes =
     {
         DataType::Float32,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1749,8 +1749,8 @@
     std::array<DataType,4> supportedTypes = {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
@@ -1785,8 +1785,8 @@
     {
         DataType::Float32,
         DataType::Float16,
-        DataType::QuantisedAsymm8,
-        DataType::QuantisedSymm16
+        DataType::QAsymmU8,
+        DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1821,8 +1821,8 @@
     {
             DataType::Float32,
             DataType::Float16,
-            DataType::QuantisedAsymm8,
-            DataType::QuantisedSymm16
+            DataType::QAsymmU8,
+            DataType::QSymmS16
     };
 
     supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
@@ -1836,11 +1836,11 @@
 
 
     const DataType inputType = input.GetDataType();
-    if (inputType == DataType::QuantisedAsymm8)
+    if (inputType == DataType::QAsymmU8)
     {
         std::array<DataType, 2> supportedWeightTypes =
         {
-            DataType::QuantisedAsymm8,
+            DataType::QAsymmU8,
             DataType::QuantizedSymm8PerAxis
         };