[serialization_lib] Fix Clamp and Pad Attributes

This patch implements following changes to attribute fields:
- PadAttribute: delete padding field, replace pad_const_int
	and pad_const_fp fields by pad_const, a field of
	ubyte array
- ClampAttribute: replace min_int, max_int, min_fp and max_fp
	fields by min_val and max_val, fields of ubyte arrays
- RescaleAttribute: delete multiplier and shift fields

Signed-off-by: Tai Ly <tai.ly@arm.com>
Change-Id: I5b075d29677cffca9ff2292708141d48410e7e72

3 files changed, 55 insertions, 211 deletions

diff --git a/python/tosa/ClampAttribute.py b/python/tosa/ClampAttribute.py
index 40e7d2e..6a41498 100644
--- a/python/tosa/ClampAttribute.py
+++ b/python/tosa/ClampAttribute.py
@@ -29,114 +29,88 @@ class ClampAttribute(object):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # ClampAttribute
-    def MinInt(self):
+    def MinVal(self, j):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
-        return 0
-
-    # ClampAttribute
-    def MaxInt(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
-        return 0
-
-    # ClampAttribute
-    def MinFp(self, j):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        if o != 0:
             a = self._tab.Vector(o)
             return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
         return 0
 
     # ClampAttribute
-    def MinFpAsNumpy(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+    def MinValAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
         return 0
 
     # ClampAttribute
-    def MinFpLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+    def MinValLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             return self._tab.VectorLen(o)
         return 0
 
     # ClampAttribute
-    def MinFpIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+    def MinValIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         return o == 0
 
     # ClampAttribute
-    def MaxFp(self, j):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+    def MaxVal(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             a = self._tab.Vector(o)
             return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
         return 0
 
     # ClampAttribute
-    def MaxFpAsNumpy(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+    def MaxValAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
         return 0
 
     # ClampAttribute
-    def MaxFpLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+    def MaxValLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             return self._tab.VectorLen(o)
         return 0
 
     # ClampAttribute
-    def MaxFpIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+    def MaxValIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         return o == 0
 
 def ClampAttributeStart(builder):
-    builder.StartObject(4)
+    builder.StartObject(2)
 
 def Start(builder):
     ClampAttributeStart(builder)
 
-def ClampAttributeAddMinInt(builder, minInt):
-    builder.PrependInt32Slot(0, minInt, 0)
-
-def AddMinInt(builder, minInt):
-    ClampAttributeAddMinInt(builder, minInt)
-
-def ClampAttributeAddMaxInt(builder, maxInt):
-    builder.PrependInt32Slot(1, maxInt, 0)
-
-def AddMaxInt(builder, maxInt):
-    ClampAttributeAddMaxInt(builder, maxInt)
-
-def ClampAttributeAddMinFp(builder, minFp):
-    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(minFp), 0)
+def ClampAttributeAddMinVal(builder, minVal):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(minVal), 0)
 
-def AddMinFp(builder, minFp):
-    ClampAttributeAddMinFp(builder, minFp)
+def AddMinVal(builder, minVal):
+    ClampAttributeAddMinVal(builder, minVal)
 
-def ClampAttributeStartMinFpVector(builder, numElems):
+def ClampAttributeStartMinValVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartMinFpVector(builder, numElems: int) -> int:
-    return ClampAttributeStartMinFpVector(builder, numElems)
+def StartMinValVector(builder, numElems: int) -> int:
+    return ClampAttributeStartMinValVector(builder, numElems)
 
-def ClampAttributeAddMaxFp(builder, maxFp):
-    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(maxFp), 0)
+def ClampAttributeAddMaxVal(builder, maxVal):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(maxVal), 0)
 
-def AddMaxFp(builder, maxFp):
-    ClampAttributeAddMaxFp(builder, maxFp)
+def AddMaxVal(builder, maxVal):
+    ClampAttributeAddMaxVal(builder, maxVal)
 
-def ClampAttributeStartMaxFpVector(builder, numElems):
+def ClampAttributeStartMaxValVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartMaxFpVector(builder, numElems: int) -> int:
-    return ClampAttributeStartMaxFpVector(builder, numElems)
+def StartMaxValVector(builder, numElems: int) -> int:
+    return ClampAttributeStartMaxValVector(builder, numElems)
 
 def ClampAttributeEnd(builder):
     return builder.EndObject()
diff --git a/python/tosa/PadAttribute.py b/python/tosa/PadAttribute.py
index fc843bb..301bf17 100644
--- a/python/tosa/PadAttribute.py
+++ b/python/tosa/PadAttribute.py
@@ -29,101 +29,49 @@ class PadAttribute(object):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # PadAttribute
-    def Padding(self, j):
+    def PadConst(self, j):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             a = self._tab.Vector(o)
-            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
         return 0
 
     # PadAttribute
-    def PaddingAsNumpy(self):
+    def PadConstAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
-            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
         return 0
 
     # PadAttribute
-    def PaddingLength(self):
+    def PadConstLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             return self._tab.VectorLen(o)
         return 0
 
     # PadAttribute
-    def PaddingIsNone(self):
+    def PadConstIsNone(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         return o == 0
 
-    # PadAttribute
-    def PadConstInt(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
-        return 0
-
-    # PadAttribute
-    def PadConstFp(self, j):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        if o != 0:
-            a = self._tab.Vector(o)
-            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
-        return 0
-
-    # PadAttribute
-    def PadConstFpAsNumpy(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        if o != 0:
-            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-        return 0
-
-    # PadAttribute
-    def PadConstFpLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        return 0
-
-    # PadAttribute
-    def PadConstFpIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        return o == 0
-
 def PadAttributeStart(builder):
-    builder.StartObject(3)
+    builder.StartObject(1)
 
 def Start(builder):
     PadAttributeStart(builder)
 
-def PadAttributeAddPadding(builder, padding):
-    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0)
-
-def AddPadding(builder, padding):
-    PadAttributeAddPadding(builder, padding)
-
-def PadAttributeStartPaddingVector(builder, numElems):
-    return builder.StartVector(4, numElems, 4)
-
-def StartPaddingVector(builder, numElems: int) -> int:
-    return PadAttributeStartPaddingVector(builder, numElems)
-
-def PadAttributeAddPadConstInt(builder, padConstInt):
-    builder.PrependInt32Slot(1, padConstInt, 0)
-
-def AddPadConstInt(builder, padConstInt):
-    PadAttributeAddPadConstInt(builder, padConstInt)
-
-def PadAttributeAddPadConstFp(builder, padConstFp):
-    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(padConstFp), 0)
+def PadAttributeAddPadConst(builder, padConst):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(padConst), 0)
 
-def AddPadConstFp(builder, padConstFp):
-    PadAttributeAddPadConstFp(builder, padConstFp)
+def AddPadConst(builder, padConst):
+    PadAttributeAddPadConst(builder, padConst)
 
-def PadAttributeStartPadConstFpVector(builder, numElems):
+def PadAttributeStartPadConstVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartPadConstFpVector(builder, numElems: int) -> int:
-    return PadAttributeStartPadConstFpVector(builder, numElems)
+def StartPadConstVector(builder, numElems: int) -> int:
+    return PadAttributeStartPadConstVector(builder, numElems)
 
 def PadAttributeEnd(builder):
     return builder.EndObject()
diff --git a/python/tosa/RescaleAttribute.py b/python/tosa/RescaleAttribute.py
index 320c119..12e7ced 100644
--- a/python/tosa/RescaleAttribute.py
+++ b/python/tosa/RescaleAttribute.py
@@ -43,96 +43,42 @@ class RescaleAttribute(object):
         return 0
 
     # RescaleAttribute
-    def Multiplier(self, j):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        if o != 0:
-            a = self._tab.Vector(o)
-            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
-        return 0
-
-    # RescaleAttribute
-    def MultiplierAsNumpy(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        if o != 0:
-            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
-        return 0
-
-    # RescaleAttribute
-    def MultiplierLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        return 0
-
-    # RescaleAttribute
-    def MultiplierIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        return o == 0
-
-    # RescaleAttribute
-    def Shift(self, j):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
-        if o != 0:
-            a = self._tab.Vector(o)
-            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
-        return 0
-
-    # RescaleAttribute
-    def ShiftAsNumpy(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
-        if o != 0:
-            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
-        return 0
-
-    # RescaleAttribute
-    def ShiftLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        return 0
-
-    # RescaleAttribute
-    def ShiftIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
-        return o == 0
-
-    # RescaleAttribute
     def Scale32(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         if o != 0:
             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
         return False
 
     # RescaleAttribute
     def DoubleRound(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
         if o != 0:
             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
         return False
 
     # RescaleAttribute
     def PerChannel(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         if o != 0:
             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
         return False
 
     # RescaleAttribute
     def InputUnsigned(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
         return False
 
     # RescaleAttribute
     def OutputUnsigned(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
         if o != 0:
             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
         return False
 
 def RescaleAttributeStart(builder):
-    builder.StartObject(9)
+    builder.StartObject(7)
 
 def Start(builder):
     RescaleAttributeStart(builder)
@@ -149,56 +95,32 @@ def RescaleAttributeAddOutputZp(builder, outputZp):
 def AddOutputZp(builder, outputZp):
     RescaleAttributeAddOutputZp(builder, outputZp)
 
-def RescaleAttributeAddMultiplier(builder, multiplier):
-    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(multiplier), 0)
-
-def AddMultiplier(builder, multiplier):
-    RescaleAttributeAddMultiplier(builder, multiplier)
-
-def RescaleAttributeStartMultiplierVector(builder, numElems):
-    return builder.StartVector(4, numElems, 4)
-
-def StartMultiplierVector(builder, numElems: int) -> int:
-    return RescaleAttributeStartMultiplierVector(builder, numElems)
-
-def RescaleAttributeAddShift(builder, shift):
-    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(shift), 0)
-
-def AddShift(builder, shift):
-    RescaleAttributeAddShift(builder, shift)
-
-def RescaleAttributeStartShiftVector(builder, numElems):
-    return builder.StartVector(4, numElems, 4)
-
-def StartShiftVector(builder, numElems: int) -> int:
-    return RescaleAttributeStartShiftVector(builder, numElems)
-
 def RescaleAttributeAddScale32(builder, scale32):
-    builder.PrependBoolSlot(4, scale32, 0)
+    builder.PrependBoolSlot(2, scale32, 0)
 
 def AddScale32(builder, scale32):
     RescaleAttributeAddScale32(builder, scale32)
 
 def RescaleAttributeAddDoubleRound(builder, doubleRound):
-    builder.PrependBoolSlot(5, doubleRound, 0)
+    builder.PrependBoolSlot(3, doubleRound, 0)
 
 def AddDoubleRound(builder, doubleRound):
     RescaleAttributeAddDoubleRound(builder, doubleRound)
 
 def RescaleAttributeAddPerChannel(builder, perChannel):
-    builder.PrependBoolSlot(6, perChannel, 0)
+    builder.PrependBoolSlot(4, perChannel, 0)
 
 def AddPerChannel(builder, perChannel):
     RescaleAttributeAddPerChannel(builder, perChannel)
 
 def RescaleAttributeAddInputUnsigned(builder, inputUnsigned):
-    builder.PrependBoolSlot(7, inputUnsigned, 0)
+    builder.PrependBoolSlot(5, inputUnsigned, 0)
 
 def AddInputUnsigned(builder, inputUnsigned):
     RescaleAttributeAddInputUnsigned(builder, inputUnsigned)
 
 def RescaleAttributeAddOutputUnsigned(builder, outputUnsigned):
-    builder.PrependBoolSlot(8, outputUnsigned, 0)
+    builder.PrependBoolSlot(6, outputUnsigned, 0)
 
 def AddOutputUnsigned(builder, outputUnsigned):
     RescaleAttributeAddOutputUnsigned(builder, outputUnsigned)