attr/m47378: top-down raht

In order to support transform domain prediction of AC coefficients using
upsampled previously reconstructed transform levels, this commit
replaces the existing RAHT implementation with a descent based RAHT tree
traversal for both encoder and decoder with the transform performed in
units of 2×2×2 blocks.

tmc3/AttributeDecoder.cpp

@@ -413,11 +413,8 @@ AttributeDecoder::decodeReflectancesRaht(
   PCCPointSet3& pointCloud)
 {
   const int voxelCount = int(pointCloud.getPointCount());
-  uint64_t* weight = new uint64_t[voxelCount];
-  int* binaryLayer = new int[voxelCount];
   std::vector<MortonCodeWithIndex> packedVoxel(voxelCount);
   for (int n = 0; n < voxelCount; n++) {
-    weight[n] = 1;
     packedVoxel[n].mortonCode = mortonAddr(pointCloud[n], 0);
     packedVoxel[n].index = n;
   }
@@ -431,7 +428,7 @@ AttributeDecoder::decodeReflectancesRaht(
 
   // Entropy decode
   const int attribCount = 1;
-  int* integerizedAttributes = new int[attribCount * voxelCount];
+  int* coefficients = new int[attribCount * voxelCount];
   int zero_cnt = decoder.decodeZeroCnt(voxelCount);
   for (int n = 0; n < voxelCount; ++n) {
     uint32_t value = 0;
@@ -441,30 +438,27 @@ AttributeDecoder::decodeReflectancesRaht(
       value = decoder.decode();
       zero_cnt = decoder.decodeZeroCnt(voxelCount);
     }
-    integerizedAttributes[n] = UIntToInt(value);
+    coefficients[n] = UIntToInt(value);
   }
 
-  FixedPoint* attributes = new FixedPoint[attribCount * voxelCount];
+  int* attributes = new int[attribCount * voxelCount];
 
   regionAdaptiveHierarchicalInverseTransform(
-    FixedPoint(qstep[0]), mortonCode, attributes, weight, attribCount,
-    voxelCount, integerizedAttributes);
+    qstep, mortonCode, attributes, attribCount, voxelCount, coefficients);
 
   const int64_t maxReflectance = (1 << desc.attr_bitdepth) - 1;
   const int64_t minReflectance = 0;
   for (int n = 0; n < voxelCount; n++) {
-    int64_t val = attributes[attribCount * n].round();
+    int64_t val = attributes[attribCount * n];
     const uint16_t reflectance =
       (uint16_t)PCCClip(val, minReflectance, maxReflectance);
     pointCloud.setReflectance(packedVoxel[n].index, reflectance);
   }
 
   // De-allocate arrays.
-  delete[] binaryLayer;
   delete[] mortonCode;
   delete[] attributes;
-  delete[] integerizedAttributes;
-  delete[] weight;
+  delete[] coefficients;
 }
 
 //----------------------------------------------------------------------------
@@ -478,11 +472,8 @@ AttributeDecoder::decodeColorsRaht(
   PCCPointSet3& pointCloud)
 {
   const int voxelCount = int(pointCloud.getPointCount());
-  uint64_t* weight = new uint64_t[voxelCount];
-  int* binaryLayer = new int[voxelCount];
   std::vector<MortonCodeWithIndex> packedVoxel(voxelCount);
   for (int n = 0; n < voxelCount; n++) {
-    weight[n] = 1;
     packedVoxel[n].mortonCode = mortonAddr(pointCloud[n], 0);
     packedVoxel[n].index = n;
   }
@@ -497,7 +488,7 @@ AttributeDecoder::decodeColorsRaht(
   // Entropy decode
   const int attribCount = 3;
   int zero_cnt = decoder.decodeZeroCnt(voxelCount);
-  int* integerizedAttributes = new int[attribCount * voxelCount];
+  int* coefficients = new int[attribCount * voxelCount];
 
   for (int n = 0; n < voxelCount; ++n) {
     uint32_t values[3];
@@ -509,21 +500,20 @@ AttributeDecoder::decodeColorsRaht(
       zero_cnt = decoder.decodeZeroCnt(voxelCount);
     }
     for (int d = 0; d < attribCount; ++d) {
-      integerizedAttributes[voxelCount * d + n] = UIntToInt(values[d]);
+      coefficients[voxelCount * d + n] = UIntToInt(values[d]);
     }
   }
 
-  FixedPoint* attributes = new FixedPoint[attribCount * voxelCount];
+  int* attributes = new int[attribCount * voxelCount];
 
   regionAdaptiveHierarchicalInverseTransform(
-    FixedPoint(qstep[0]), mortonCode, attributes, weight, attribCount,
-    voxelCount, integerizedAttributes);
+    qstep, mortonCode, attributes, attribCount, voxelCount, coefficients);
 
   const int clipMax = (1 << desc.attr_bitdepth) - 1;
   for (int n = 0; n < voxelCount; n++) {
-    const int r = attributes[attribCount * n].round();
-    const int g = attributes[attribCount * n + 1].round();
-    const int b = attributes[attribCount * n + 2].round();
+    const int r = attributes[attribCount * n];
+    const int g = attributes[attribCount * n + 1];
+    const int b = attributes[attribCount * n + 2];
     Vec3<uint8_t> color;
     color[0] = uint8_t(PCCClip(r, 0, clipMax));
     color[1] = uint8_t(PCCClip(g, 0, clipMax));
@@ -532,11 +522,9 @@ AttributeDecoder::decodeColorsRaht(
   }
 
   // De-allocate arrays.
-  delete[] binaryLayer;
   delete[] mortonCode;
   delete[] attributes;
-  delete[] integerizedAttributes;
-  delete[] weight;
+  delete[] coefficients;
 }
 
 //----------------------------------------------------------------------------

tmc3/AttributeEncoder.cpp

@@ -773,14 +773,11 @@ AttributeEncoder::encodeReflectancesTransformRaht(
   // Allocate arrays.
   int64_t* mortonCode = new int64_t[voxelCount];
   const int attribCount = 1;
-  FixedPoint* attributes = new FixedPoint[attribCount * voxelCount];
-  int* integerizedAttributes = new int[attribCount * voxelCount];
-  uint64_t* weight = new uint64_t[voxelCount];
-  int* binaryLayer = new int[voxelCount];
+  int* attributes = new int[attribCount * voxelCount];
+  int* coefficients = new int[attribCount * voxelCount];
 
   // Populate input arrays.
   for (int n = 0; n < voxelCount; n++) {
-    weight[n] = 1;
     mortonCode[n] = packedVoxel[n].mortonCode;
     const auto reflectance = pointCloud.getReflectance(packedVoxel[n].index);
     attributes[attribCount * n] = reflectance;
@@ -788,14 +785,13 @@ AttributeEncoder::encodeReflectancesTransformRaht(
 
   // Transform.
   regionAdaptiveHierarchicalTransform(
-    FixedPoint(qstep[0]), mortonCode, attributes, weight, binaryLayer,
-    attribCount, voxelCount, integerizedAttributes);
+    qstep, mortonCode, attributes, attribCount, voxelCount, coefficients);
 
   // Entropy encode.
   int zero_cnt = 0;
   uint32_t value;
   for (int n = 0; n < voxelCount; ++n) {
-    const int64_t detail = IntToUInt(integerizedAttributes[n]);
+    const int64_t detail = IntToUInt(coefficients[n]);
     assert(detail < std::numeric_limits<uint32_t>::max());
     value = uint32_t(detail);
     if (!value)
@@ -808,32 +804,19 @@ AttributeEncoder::encodeReflectancesTransformRaht(
   }
   encoder.encodeZeroCnt(zero_cnt, voxelCount);
 
-  // local decode
-  std::fill_n(attributes, attribCount * voxelCount, FixedPoint(0));
-  for (int n = 0; n < voxelCount; n++) {
-    mortonCode[n] = packedVoxel[n].mortonCode;
-    weight[n] = 1;
-  }
-
-  regionAdaptiveHierarchicalInverseTransform(
-    FixedPoint(qstep[0]), mortonCode, attributes, weight, attribCount,
-    voxelCount, integerizedAttributes);
-
   const int64_t maxReflectance = (1 << desc.attr_bitdepth) - 1;
   const int64_t minReflectance = 0;
   for (int n = 0; n < voxelCount; n++) {
-    int64_t val = attributes[attribCount * n].round();
+    int64_t val = attributes[attribCount * n];
     const uint16_t reflectance =
       (uint16_t)PCCClip(val, minReflectance, maxReflectance);
     pointCloud.setReflectance(packedVoxel[n].index, reflectance);
   }
 
   // De-allocate arrays.
-  delete[] binaryLayer;
   delete[] mortonCode;
   delete[] attributes;
-  delete[] integerizedAttributes;
-  delete[] weight;
+  delete[] coefficients;
 }
 
 //----------------------------------------------------------------------------
@@ -857,14 +840,11 @@ AttributeEncoder::encodeColorsTransformRaht(
   // Allocate arrays.
   int64_t* mortonCode = new int64_t[voxelCount];
   const int attribCount = 3;
-  FixedPoint* attributes = new FixedPoint[attribCount * voxelCount];
-  int* integerizedAttributes = new int[attribCount * voxelCount];
-  uint64_t* weight = new uint64_t[voxelCount];
-  int* binaryLayer = new int[voxelCount];
+  int* attributes = new int[attribCount * voxelCount];
+  int* coefficients = new int[attribCount * voxelCount];
 
   // Populate input arrays.
   for (int n = 0; n < voxelCount; n++) {
-    weight[n] = 1;
     mortonCode[n] = packedVoxel[n].mortonCode;
     const auto color = pointCloud.getColor(packedVoxel[n].index);
     attributes[attribCount * n] = color[0];
@@ -874,16 +854,14 @@ AttributeEncoder::encodeColorsTransformRaht(
 
   // Transform.
   regionAdaptiveHierarchicalTransform(
-    FixedPoint(qstep[0]), mortonCode, attributes, weight, binaryLayer,
-    attribCount, voxelCount, integerizedAttributes);
+    qstep, mortonCode, attributes, attribCount, voxelCount, coefficients);
 
   // Entropy encode.
   uint32_t values[attribCount];
   int zero_cnt = 0;
   for (int n = 0; n < voxelCount; ++n) {
     for (int d = 0; d < attribCount; ++d) {
-      const int64_t detail =
-        IntToUInt(integerizedAttributes[voxelCount * d + n]);
+      const int64_t detail = IntToUInt(coefficients[voxelCount * d + n]);
       assert(detail < std::numeric_limits<uint32_t>::max());
       values[d] = uint32_t(detail);
     }
@@ -895,25 +873,13 @@ AttributeEncoder::encodeColorsTransformRaht(
       zero_cnt = 0;
     }
   }
-
   encoder.encodeZeroCnt(zero_cnt, voxelCount);
 
-  // local decode
-  std::fill_n(attributes, attribCount * voxelCount, FixedPoint(0));
-  for (int n = 0; n < voxelCount; n++) {
-    weight[n] = 1;
-    mortonCode[n] = packedVoxel[n].mortonCode;
-  }
-
-  regionAdaptiveHierarchicalInverseTransform(
-    FixedPoint(qstep[0]), mortonCode, attributes, weight, attribCount,
-    voxelCount, integerizedAttributes);
-
   const int clipMax = (1 << desc.attr_bitdepth) - 1;
   for (int n = 0; n < voxelCount; n++) {
-    const int r = attributes[attribCount * n].round();
-    const int g = attributes[attribCount * n + 1].round();
-    const int b = attributes[attribCount * n + 2].round();
+    const int r = attributes[attribCount * n];
+    const int g = attributes[attribCount * n + 1];
+    const int b = attributes[attribCount * n + 2];
     Vec3<uint8_t> color;
     color[0] = uint8_t(PCCClip(r, 0, clipMax));
     color[1] = uint8_t(PCCClip(g, 0, clipMax));
@@ -922,11 +888,9 @@ AttributeEncoder::encodeColorsTransformRaht(
   }
 
   // De-allocate arrays.
-  delete[] binaryLayer;
   delete[] mortonCode;
   delete[] attributes;
-  delete[] integerizedAttributes;
-  delete[] weight;
+  delete[] coefficients;
 }
 //----------------------------------------------------------------------------
 

tmc3/FixedPoint.h

@@ -57,6 +57,8 @@ public:
   FixedPoint& operator=(FixedPoint&&) = default;
 
   FixedPoint(int val) { this->operator=(int64_t(val)); }
+  FixedPoint(int64_t val) { this->operator=(val); }
+  FixedPoint(double val) { this->val = int64_t(val * (1 << kFracBits)); }
 
   // return the rounded integer value
   int64_t round();

tmc3/PCCMisc.h

@@ -174,7 +174,7 @@ ceillog2(uint32_t x)
 //---------------------------------------------------------------------------
 // Compute an approximation of \left\floor \sqrt{x} \right\floor
 
-uint32_t isqrt(uint64_t x);
+uint32_t isqrt(uint64_t x) __attribute__((const));
 
 //---------------------------------------------------------------------------
 // Decrement the @axis-th dimension of 3D morton code @x.
@@ -186,6 +186,23 @@ morton3dAxisDec(int64_t val, int axis)
   return ((val & mask0) - 1 & mask0) | (val & ~mask0);
 }
 
+//---------------------------------------------------------------------------
+// add the three dimentional addresses @a + @b;
+//
+inline uint64_t
+morton3dAdd(uint64_t a, uint64_t b)
+{
+  uint64_t mask = 0x9249249249249249llu;
+  uint64_t val = 0;
+
+  for (int i = 0; i < 3; i++) {
+    val |= (a | ~mask) + (b & mask) & mask;
+    mask <<= 1;
+  }
+
+  return val;
+}
+
 //---------------------------------------------------------------------------
 // Sort the elements in range [@first, @last) using a counting sort.
 //

tmc3/RAHT.h

@@ -38,26 +38,24 @@
 #include <cstdint>
 
 #include "FixedPoint.h"
+#include "quantization.h"
 
 namespace pcc {
 
 void regionAdaptiveHierarchicalTransform(
-  FixedPoint quantStepSizeLuma,
+  const Quantizers& qstep,
   int64_t* mortonCode,
-  FixedPoint* attributes,
-  uint64_t* weight,
-  int* binaryLayer,
+  int* attributes,
   const int attribCount,
   const int voxelCount,
-  int* integerizedAttributes);
+  int* coefficients);
 
 void regionAdaptiveHierarchicalInverseTransform(
-  FixedPoint quantStepSizeLuma,
+  const Quantizers& qstep,
   int64_t* mortonCode,
-  FixedPoint* attributes,
-  uint64_t* weight,
+  int* attributes,
   const int attribCount,
   const int voxelCount,
-  int* integerizedAttributes);
+  int* coefficients);
 
 } /* namespace pcc */

tmc3/TMC3.cpp

@@ -549,9 +549,6 @@ ParseParameters(int argc, char* argv[], Parameters& params)
     if (attr_aps.attr_encoding == AttributeEncoding::kRAHTransform) {
       attr_aps.num_detail_levels = 0;
       attr_aps.adaptive_prediction_threshold = 0;
-
-      // todo(df): suggest chroma quant_step_size for raht
-      attr_aps.aps_chroma_qp_offset = 0;
     }
   }
 

tmc3/io_hls.cpp

@@ -262,7 +262,6 @@ write(const AttributeParameterSet& aps)
   bs.writeUe(aps.attr_encoding);
 
   bs.writeUe(aps.init_qp);
-  // todo(?): raht chroma qp support?
   bs.writeSe(aps.aps_chroma_qp_offset);
   bs.write(aps.aps_slice_qp_deltas_present_flag);
 
@@ -311,7 +310,6 @@ parseAps(const PayloadBuffer& buf)
   bs.readUe(&aps.attr_encoding);
 
   bs.readUe(&aps.init_qp);
-  // todo(?): raht chroma qp support?
   bs.readSe(&aps.aps_chroma_qp_offset);
   bs.read(&aps.aps_slice_qp_deltas_present_flag);