t1: improve namespacing II

Author: Grok Compression

src/lib/core/canvas/tile/TileComponent.h

@@ -325,21 +325,23 @@ struct TileComponent : public Rect32
    * @param block @ref DecompressBlockExec
    */
   template<typename T>
-  void postProcess(T* srcData, DecompressBlockExec* block)
+  void postProcess(T* srcData, t1::DecompressBlockExec* block)
   {
     if(block->roishift)
     {
       if(block->qmfbid == 1)
-        postDecompressImpl<T, RoiShiftFilter<T>>(srcData, block, (uint16_t)block->cblk->width());
+        postDecompressImpl<T, t1::RoiShiftFilter<T>>(srcData, block,
+                                                     (uint16_t)block->cblk->width());
       else
-        postDecompressImpl<T, RoiScaleFilter<T>>(srcData, block, (uint16_t)block->cblk->width());
+        postDecompressImpl<T, t1::RoiScaleFilter<T>>(srcData, block,
+                                                     (uint16_t)block->cblk->width());
     }
     else
     {
       if(block->qmfbid == 1)
-        postDecompressImpl<T, ShiftFilter<T>>(srcData, block, (uint16_t)block->cblk->width());
+        postDecompressImpl<T, t1::ShiftFilter<T>>(srcData, block, (uint16_t)block->cblk->width());
       else
-        postDecompressImpl<T, ScaleFilter<T>>(srcData, block, (uint16_t)block->cblk->width());
+        postDecompressImpl<T, t1::ScaleFilter<T>>(srcData, block, (uint16_t)block->cblk->width());
     }
   }
 
@@ -351,7 +353,7 @@ struct TileComponent : public Rect32
    * @param stride source data stride
    */
   template<typename T>
-  void postProcessHT(T* srcData, DecompressBlockExec* block, uint16_t stride)
+  void postProcessHT(T* srcData, t1::DecompressBlockExec* block, uint16_t stride)
   {
     if(block->roishift)
     {
@@ -405,7 +407,7 @@ struct TileComponent : public Rect32
    * @param stride source data stride
    */
   template<typename T, typename F>
-  void postDecompressImpl(T* srcData, DecompressBlockExec* block, uint16_t stride)
+  void postDecompressImpl(T* srcData, t1::DecompressBlockExec* block, uint16_t stride)
   {
     auto cblk = block->cblk;
     bool empty = cblk->dataChunksEmpty();

src/lib/core/canvas/tile/TileComponentWindow.h

@@ -205,7 +205,7 @@ struct TileComponentWindow : public TileComponentWindowBase<T>
   }
   template<typename F>
   void postProcess(Buf2dAligned& src, uint8_t resno, eBandOrientation bandOrientation,
-                   DecompressBlockExec* block)
+                   t1::DecompressBlockExec* block)
   {
     Buffer2d<int32_t, AllocatorAligned> dst;
     dst = getCodeBlockDestWindowREL(resno, bandOrientation);

src/lib/core/codestream/CodingParams.cpp

@@ -292,7 +292,7 @@ TileCodingParams::TileCodingParams(const TileCodingParams& rhs)
     // Or recreate
     bool reversible = (rhs.tccps_[0].qmfbid_ == 1);
     uint8_t guardBits = rhs.tccps_[0].numgbits_;
-    qcd_ = CoderFactory::makeQuantizer(rhs.ht_, reversible, guardBits);
+    qcd_ = t1::CoderFactory::makeQuantizer(rhs.ht_, reversible, guardBits);
   }
 
   // Deep copy other pointers if necessary, e.g. packets_, mct_norms_, mctCodingMatrix_,
@@ -404,7 +404,7 @@ bool TileCodingParams::readQcd(bool fromTileHeader, uint8_t* headerData, uint16_
     {
       dest->qntsty_ = src->qntsty_;
       dest->numgbits_ = src->numgbits_;
-      auto size = GRK_MAXBANDS * sizeof(grk_stepsize);
+      auto size = GRK_MAXBANDS * sizeof(t1::grk_stepsize);
       memcpy(dest->stepsizes_, src->stepsizes_, size);
     }
   }
@@ -1761,7 +1761,7 @@ void TileCodingParams::setIsHT(bool ht, bool reversible, uint8_t guardBits)
 {
   ht_ = ht;
   if(!qcd_)
-    qcd_ = CoderFactory::makeQuantizer(ht, reversible, guardBits);
+    qcd_ = t1::CoderFactory::makeQuantizer(ht, reversible, guardBits);
 }
 
 bool TileCodingParams::isHT(void)

src/lib/core/codestream/CodingParams.h

@@ -74,7 +74,7 @@ struct TileComponentCodingParams
   /** quantisation style */
   uint8_t qntsty_;
   /** stepsizes used for quantization */
-  grk_stepsize stepsizes_[GRK_MAXBANDS];
+  t1::grk_stepsize stepsizes_[GRK_MAXBANDS];
   // number of step sizes read from QCC marker
   uint8_t numStepSizes_;
   /** number of guard bits */
@@ -321,7 +321,7 @@ struct TileCodingParams
   uint32_t cod_ = 0;
   /** If ppt == true --> there was a PPT marker for the present tile */
   bool ppt_ = false;
-  Quantizer* qcd_ = nullptr;
+  t1::Quantizer* qcd_ = nullptr;
   uint16_t numComps_ = 0;
 
 private:

src/lib/core/codestream/decompress/CodeStreamDecompress_ReadMarkers.cpp

@@ -179,14 +179,14 @@ bool CodeStreamDecompress::readHeader(grk_header_info* headerInfo)
     headerImage_->copyHeaderTo(multiTileComposite_.get());
     multiTileComposite_->validateColourSpace();
     uint32_t num_threads = (uint32_t)ExecSingleton::num_threads();
-    coderPool_.makeCoders(num_threads, 6, 6, [this]() -> std::shared_ptr<ICoder> {
-      return std::shared_ptr<ICoder>(
-          CoderFactory::makeCoder(isHT_, false, 64, 64, tileCache_->getStrategy()));
+    coderPool_.makeCoders(num_threads, 6, 6, [this]() -> std::shared_ptr<t1::ICoder> {
+      return std::shared_ptr<t1::ICoder>(
+          t1::CoderFactory::makeCoder(isHT_, false, 64, 64, tileCache_->getStrategy()));
     });
 
-    coderPool_.makeCoders(num_threads, 5, 5, [this]() -> std::shared_ptr<ICoder> {
-      return std::shared_ptr<ICoder>(
-          CoderFactory::makeCoder(isHT_, false, 32, 32, tileCache_->getStrategy()));
+    coderPool_.makeCoders(num_threads, 5, 5, [this]() -> std::shared_ptr<t1::ICoder> {
+      return std::shared_ptr<t1::ICoder>(
+          t1::CoderFactory::makeCoder(isHT_, false, 32, 32, tileCache_->getStrategy()));
     });
     defaultTcp_->finalizePocs();
     if(isHT_)
@@ -473,7 +473,7 @@ bool CodeStreamDecompress::readSIZ(uint8_t* headerData, uint16_t headerSize)
     headerImage_->has_multiple_tiles = numTilesToDecompress > 1;
   }
   auto maxDim = std::max(cp_.t_width_, cp_.t_height_);
-  WaveletReverse::allocPoolData(maxDim);
+  t1::WaveletReverse::allocPoolData(maxDim);
 
   return rc;
 }

src/lib/core/debug/debug_context.cpp

@@ -44,7 +44,7 @@ DebugContext& DebugContext::getInstance()
 }
 
 // Handling the mqcoder
-bool DebugContext::handle(const mqcoder& mq, uint8_t passno, uint8_t position, uint16_t i,
+bool DebugContext::handle(const t1::mqcoder& mq, uint8_t passno, uint8_t position, uint16_t i,
                           uint16_t k)
 {
   uint16_t layer = static_cast<uint16_t>(mq.cur_buffer_index);
@@ -58,9 +58,9 @@ bool DebugContext::handle(const mqcoder& mq, uint8_t passno, uint8_t position, u
   }
   else if(!queue.empty())
   {
-    if(mq.backup_->i != BACKUP_DISABLED)
+    if(mq.backup_->i != t1::BACKUP_DISABLED)
       return true;
-    mqcoder ref = queue.front();
+    t1::mqcoder ref = queue.front();
     queue.pop();
     bool isEqual = (mq == ref);
     logProbe(true, layer, queue.size(), ref.c, passno, position, i, k);
@@ -113,7 +113,7 @@ void DebugContext::checkEmpty() const
 }
 
 // Getting the queue for a specific layer
-std::queue<mqcoder>& DebugContext::getQueue(uint16_t layer)
+std::queue<t1::mqcoder>& DebugContext::getQueue(uint16_t layer)
 {
   return referenceCoders_[{resno_, layer}];
 }

src/lib/core/debug/debug_context.h

@@ -26,14 +26,14 @@ namespace grk
 {
 
 using ResolutionLayerKey = std::pair<uint8_t, uint16_t>;
-using QueueMap = std::map<ResolutionLayerKey, std::queue<mqcoder>>;
+using QueueMap = std::map<ResolutionLayerKey, std::queue<t1::mqcoder>>;
 
 struct BackupCache
 {
-  BackupCache(const mqcoder& coder, uint8_t passno, uint8_t position, uint16_t i, uint16_t k)
+  BackupCache(const t1::mqcoder& coder, uint8_t passno, uint8_t position, uint16_t i, uint16_t k)
       : coder_(coder), passno_(passno), position_(position), i_(i), k_(k)
   {}
-  mqcoder coder_;
+  t1::mqcoder coder_;
   uint8_t passno_;
   uint8_t position_;
   uint16_t i_;
@@ -58,7 +58,7 @@ class DebugContext
 public:
   static DebugContext& getInstance();
 
-  bool handle(const mqcoder& mq, uint8_t passno, uint8_t position, uint16_t i, uint16_t k);
+  bool handle(const t1::mqcoder& mq, uint8_t passno, uint8_t position, uint16_t i, uint16_t k);
   void incrementDifferentialLayer();
   void restoreBackup(void);
 
@@ -76,7 +76,7 @@ class DebugContext
 private:
   DebugContext();
   void checkEmpty() const;
-  std::queue<mqcoder>& getQueue(uint16_t layer);
+  std::queue<t1::mqcoder>& getQueue(uint16_t layer);
   void logProbe(bool differential, uint16_t layer, size_t order, uint32_t c, uint8_t passno,
                 uint8_t position, uint16_t i, uint16_t k) const;
 

src/lib/core/scheduling/CodecScheduler.h

@@ -121,7 +121,7 @@ class CodecScheduler : public FlowComponent
    * @brief pool of @ref ICoder
    *
    */
-  std::vector<ICoder*> coders_;
+  std::vector<t1::ICoder*> coders_;
 
   /**
    * @brief @ref tf::Future<void> resulting from running scheduler

src/lib/core/scheduling/CoderPool.cpp

@@ -27,16 +27,17 @@ bool CoderPool::contains(uint8_t maxCblkWExp, uint8_t maxCblkHExp)
 }
 
 void CoderPool::makeCoders(uint32_t numCoders, uint8_t maxCblkWExp, uint8_t maxCblkHExp,
-                           std::function<std::shared_ptr<ICoder>()> creator)
+                           std::function<std::shared_ptr<t1::ICoder>()> creator)
 {
   if(contains(maxCblkWExp, maxCblkHExp))
     return;
-  std::vector<std::shared_ptr<ICoder>> coders;
+  std::vector<std::shared_ptr<t1::ICoder>> coders;
   for(uint32_t i = 0; i < numCoders; ++i)
     coders.push_back(creator());
   coderMap_[{maxCblkWExp, maxCblkHExp}] = std::move(coders);
 }
-std::shared_ptr<ICoder> CoderPool::getCoder(size_t worker, uint8_t maxCblkWExp, uint8_t maxCblkHExp)
+std::shared_ptr<t1::ICoder> CoderPool::getCoder(size_t worker, uint8_t maxCblkWExp,
+                                                uint8_t maxCblkHExp)
 {
   auto it = coderMap_.find({maxCblkWExp, maxCblkHExp});
   if(it == coderMap_.end())

src/lib/core/scheduling/CoderPool.h

@@ -43,17 +43,18 @@ struct CoderKeyHash
   }
 };
 
-typedef std::unordered_map<CoderKey, std::vector<std::shared_ptr<ICoder>>, CoderKeyHash> CODERMAP;
+typedef std::unordered_map<CoderKey, std::vector<std::shared_ptr<t1::ICoder>>, CoderKeyHash>
+    CODERMAP;
 
 struct CoderPool
 {
 public:
   CoderPool(void) = default;
   ~CoderPool(void) = default;
   void makeCoders(uint32_t numCoders, uint8_t maxCblkWExp, uint8_t maxCblkHExp,
-                  std::function<std::shared_ptr<ICoder>()> creator);
+                  std::function<std::shared_ptr<t1::ICoder>()> creator);
   bool contains(uint8_t maxCblkWExp, uint8_t maxCblkHExp);
-  std::shared_ptr<ICoder> getCoder(size_t worker, uint8_t maxCblkWExp, uint8_t maxCblkHExp);
+  std::shared_ptr<t1::ICoder> getCoder(size_t worker, uint8_t maxCblkWExp, uint8_t maxCblkHExp);
 
 private:
   CODERMAP coderMap_;