core_simple: refactor into two methods, one for compress and one for decompress

Author: Grok Compression

examples/core/core_simple.cpp

@@ -32,42 +32,27 @@ with memory buffers as source and destination
 
 // template parameter T determines the type of input data: uint8_t, uint16_t etc
 template<typename T>
-int core_simple(uint32_t dimX, uint32_t dimY, uint8_t precision,
-                std::vector<std::unique_ptr<T[]>>& uncompressedData)
+int core_compress(uint32_t dimX, uint32_t dimY, uint8_t precision,
+                  std::vector<std::unique_ptr<T[]>>& uncompressedData,
+                  std::vector<uint8_t>& compressedData)
 {
   const uint16_t numComps = (uint16_t)uncompressedData.size();
   const auto colourSpace = numComps == 3 ? GRK_CLRSPC_SRGB : GRK_CLRSPC_GRAY;
 
-  grk_object* codec = nullptr; // compression/decompression codec object
-  grk_image* encInputImage = nullptr; // uncompressed image passed into compressor
-  grk_image* decOutputImage = nullptr; // uncompressed image created by decompressor
-  grk_header_info headerInfo = {}; // compressed image header info
+  grk_object* codec = nullptr; // compression codec object
   int32_t rc = EXIT_FAILURE;
+  size_t compressedLength = 0;
+  grk_stream_params encCompressedStream = {};
 
-  uint64_t compressedLength = 0; // length of compressed stream
-
-  bool images_equal = true;
-  grk_stream_params decCompressedStream = {}; // compressed stream passed to decompressor
-
-  // 1. initialize compress and decompress parameters
+  // 1. initialize compress parameters
   grk_cparameters compressParams;
   grk_compress_set_default_params(&compressParams);
   compressParams.cod_format = GRK_FMT_JP2;
   compressParams.verbose = true;
   compressParams.irreversible = false; // Enable reversible (lossless) compression
 
-  grk_decompress_parameters decompressParams = {};
-
-  // 2.initialize struct holding encoder compressed stream
-  std::unique_ptr<uint8_t[]> compressedData;
-  // allocate size of input image, assuming that compressed stream
-  // is smaller than input
-  size_t bufLen = (size_t)numComps * ((precision + 7) / 8) * dimX * dimY;
-  compressedData = std::make_unique<uint8_t[]>(bufLen);
-
-  grk_stream_params encCompressedStream = {};
-  encCompressedStream.buf = compressedData.get();
-  encCompressedStream.buf_len = bufLen;
+  encCompressedStream.buf = compressedData.data();
+  encCompressedStream.buf_len = compressedData.size();
 
   // 3. create image that will be passed to encoder
   auto components = std::make_unique<grk_image_comp[]>(numComps);
@@ -79,9 +64,9 @@ int core_simple(uint32_t dimX, uint32_t dimY, uint8_t precision,
     c->h = dimY;
     c->prec = precision;
   }
-  encInputImage = grk_image_new(numComps, components.get(), colourSpace, true);
+  auto encInputImage = grk_image_new(numComps, components.get(), colourSpace, true);
 
-  // fill in component data: see grok.h header for full details of image structure
+  // 4. fill in component data: see grok.h header for full details of image structure
   for(uint16_t compno = 0; compno < encInputImage->numcomps; ++compno)
   {
     auto comp = encInputImage->comps + compno;
@@ -107,7 +92,7 @@ int core_simple(uint32_t dimX, uint32_t dimY, uint8_t precision,
     }
   }
 
-  // 4. compress
+  // 5. compress
   codec = grk_compress_init(&encCompressedStream, &compressParams, encInputImage);
   if(!codec)
   {
@@ -120,16 +105,41 @@ int core_simple(uint32_t dimX, uint32_t dimY, uint8_t precision,
     fprintf(stderr, "Failed to compress\n");
     goto beach;
   }
-  // destroy compression codec
-  grk_object_unref(codec);
+  compressedData.resize(compressedLength);
+
   printf("Compression succeeded: %" PRIu64 " bytes used\n", compressedLength);
 
-  // 5. copy encCompressedStream to decCompressedStream to prepare for decompression
-  decCompressedStream.buf = encCompressedStream.buf;
-  decCompressedStream.buf_len = compressedLength;
+  rc = EXIT_SUCCESS;
+
+beach:
+  grk_object_unref(codec);
+  if(encInputImage)
+    grk_object_unref(&encInputImage->obj);
+  return rc;
+}
+
+// template parameter T determines the type of input data: uint8_t, uint16_t etc
+template<typename T>
+int core_decompress(uint32_t dimX, uint32_t dimY, uint8_t precision,
+                    std::vector<std::unique_ptr<T[]>>& uncompressedData,
+                    std::vector<uint8_t>& compressedData)
+{
+  const uint16_t numComps = (uint16_t)uncompressedData.size();
+  const auto colourSpace = numComps == 3 ? GRK_CLRSPC_SRGB : GRK_CLRSPC_GRAY;
+
+  grk_header_info headerInfo = {}; // compressed image header info
+  int32_t rc = EXIT_FAILURE;
+  bool images_equal = true;
+
+  grk_stream_params decCompressedStream = {};
+  decCompressedStream.buf = compressedData.data();
+  decCompressedStream.buf_len = compressedData.size();
 
-  // 6. decompress
-  codec = grk_decompress_init(&decCompressedStream, &decompressParams);
+  grk_decompress_parameters decompressParams = {};
+  grk_image* decOutputImage = nullptr; // uncompressed image created by decompressor
+
+  // 1. decompress
+  auto codec = grk_decompress_init(&decCompressedStream, &decompressParams);
   if(!grk_decompress_read_header(codec, &headerInfo))
   {
     fprintf(stderr, "Failed to read the header\n");
@@ -141,7 +151,7 @@ int core_simple(uint32_t dimX, uint32_t dimY, uint8_t precision,
     goto beach;
   }
 
-  // 7. retrieve decompressed image
+  // 2. retrieve decompressed image
   decOutputImage = grk_decompress_get_image(codec);
   if(!decOutputImage)
   {
@@ -150,36 +160,31 @@ int core_simple(uint32_t dimX, uint32_t dimY, uint8_t precision,
   }
   printf("Decompression succeeded\n");
 
-  // 8. compare original uncompressedData to decompressed decInputmage
-  if(encInputImage->numcomps != decOutputImage->numcomps ||
-     encInputImage->x0 != decOutputImage->x0 || encInputImage->y0 != decOutputImage->y0 ||
-     encInputImage->x1 != decOutputImage->x1 || encInputImage->y1 != decOutputImage->y1 ||
-     encInputImage->color_space != decOutputImage->color_space)
+  // 3. compare original uncompressedData to decompressed decOutputImage
+  if(numComps != decOutputImage->numcomps || colourSpace != decOutputImage->color_space)
   {
     images_equal = false;
   }
   else
   {
-    for(uint32_t compno = 0; compno < encInputImage->numcomps; ++compno)
+    for(uint32_t compno = 0; compno < numComps; ++compno)
     {
-      auto encImageComp = encInputImage->comps + compno;
       auto decImageComp = decOutputImage->comps + compno;
-      if(encImageComp->dx != decImageComp->dx || encImageComp->dy != decImageComp->dy ||
-         encImageComp->w != decImageComp->w || encImageComp->h != decImageComp->h ||
-         encImageComp->prec != decImageComp->prec || encImageComp->sgnd != decImageComp->sgnd)
+      if(1 != decImageComp->dx || 1 != decImageComp->dy || dimX != decImageComp->w ||
+         dimY != decImageComp->h || precision != decImageComp->prec || false != decImageComp->sgnd)
       {
         images_equal = false;
         break;
       }
       auto in_data = uncompressedData[compno].get();
-      auto in_stride = encImageComp->w;
+      auto in_stride = dimX;
       auto out_data = (int32_t*)decImageComp->data;
       auto out_stride = decImageComp->stride;
       bool comp_equal = true;
-      for(uint32_t j = 0; j < encImageComp->h; ++j)
+      for(uint32_t j = 0; j < dimY; ++j)
       {
         bool row_equal = true;
-        for(uint32_t i = 0; i < encImageComp->w; ++i)
+        for(uint32_t i = 0; i < dimX; ++i)
         {
           if((int32_t)in_data[i] != out_data[i])
           {
@@ -205,39 +210,46 @@ int core_simple(uint32_t dimX, uint32_t dimY, uint8_t precision,
   if(images_equal)
     printf("Input and output data buffers are identical\n");
   else
-    printf("Input and output data bufffers differ\n");
+    printf("Input and output data buffers differ\n");
 
   rc = EXIT_SUCCESS;
 
 beach:
-  // cleanup
   grk_object_unref(codec);
-  if(encInputImage)
-    grk_object_unref(&encInputImage->obj);
   // note: since decImage was allocated by library, it will be cleaned up by library
 
   return rc;
 }
 
 int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
 {
-  // 1. create uncompressed buffer
-  auto compWidth = 640U;
-  auto compHeight = 480U;
-  uint32_t precision = sizeof(uint16_t) * 8;
-
-  std::vector<std::unique_ptr<uint16_t[]>> uncompressedData(1);
-  // allocate and fill uncompressedData buffer with grid pattern (contiguous)
-  uncompressedData[0] = std::make_unique<uint16_t[]>((size_t)compWidth * compHeight);
-  auto srcPtr = uncompressedData[0].get();
-  const uint16_t white = (uint16_t)((1 << precision) - 1);
-  for(uint32_t j = 0; j < compHeight; ++j)
+  const uint16_t numComps = 1U;
+  const auto dimX = 640U;
+  const auto dimY = 480U;
+  const uint8_t precision = 16;
+
+  // 1. allocate and fill uncompressedData buffer with grid pattern
+  std::vector<std::unique_ptr<uint16_t[]>> uncompressedData(numComps);
+  for(uint16_t comp = 0; comp < numComps; ++comp)
   {
-    for(uint32_t i = 0; i < compWidth; ++i)
-      srcPtr[i] = (i % 32 == 0 || j % 32 == 0) ? white : 0;
-    srcPtr += compWidth;
+    uncompressedData[comp] = std::make_unique<uint16_t[]>((size_t)dimX * dimY);
+    auto srcPtr = uncompressedData[comp].get();
+    const auto white = (uint16_t)((1 << precision) - 1);
+    for(uint32_t j = 0; j < dimY; ++j)
+    {
+      for(uint32_t i = 0; i < dimX; ++i)
+        srcPtr[i] = (i % 32 == 0 || j % 32 == 0) ? white : 0;
+      srcPtr += dimX;
+    }
   }
 
-  // run compress and the decompress and compare output with original
-  return core_simple<uint16_t>(compWidth, compHeight, precision, uncompressedData);
+  // 2. run compress and then decompress and compare output with original
+  std::vector<uint8_t> compressedData;
+  size_t bufLen = (size_t)numComps * ((precision + 7) / 8) * dimX * dimY;
+  compressedData.resize(bufLen);
+  int rc = core_compress<uint16_t>(dimX, dimY, precision, uncompressedData, compressedData);
+  if(rc == 0)
+    rc = core_decompress<uint16_t>(dimX, dimY, precision, uncompressedData, compressedData);
+
+  return rc;
 }