grk_initialize: make thread safe and optional for API

grk_deinitialize is still needed for API

Author: Grok Compression

examples/core/core_compress.cpp

@@ -99,16 +99,13 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
 
   uint64_t compressedLength = 0;
 
-  // 1. initialize library
-  grk_initialize(nullptr, 0, nullptr);
-
-  // 2. initialize compress parameters
+  // 1. initialize compress parameters
   grk_cparameters compressParams;
   grk_compress_set_default_params(&compressParams);
   compressParams.cod_format = GRK_FMT_JP2;
   compressParams.verbose = true;
 
-  // 3.initialize output stream
+  // 2.initialize output stream
   enum eStreamOutput
   {
     STREAM_OUTPUT_BUFFER, // output to buffer
@@ -144,7 +141,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
     safe_strcpy(outputStreamParams.file, outFile);
   }
 
-  // 4. create input image (blank)
+  // 3. create input image (blank)
   auto components = std::make_unique<grk_image_comp[]>(numComps);
   for(uint32_t i = 0; i < numComps; ++i)
   {
@@ -184,15 +181,15 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
     delete[] srcData;
   }
 
-  // 5. initialize compressor
+  // 4. initialize compressor
   codec = grk_compress_init(&outputStreamParams, &compressParams, inputImage);
   if(!codec)
   {
     fprintf(stderr, "Failed to initialize compressor\n");
     goto beach;
   }
 
-  // 6. compress
+  // 5. compress
   compressedLength = grk_compress(codec, nullptr);
   if(compressedLength == 0)
   {
@@ -201,7 +198,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
   }
   printf("Compression succeeded: %" PRIu64 " bytes used.\n", compressedLength);
 
-  // 7. write buffer to file if needed
+  // 6. write buffer to file if needed
   if(output == STREAM_OUTPUT_FILE)
   {
     auto fp = fopen(outFile, "wb");

examples/core/core_decompress.cpp

@@ -707,8 +707,6 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
     stream_params.buf = buf;
     stream_params.buf_len = len;
 
-    grk_initialize(nullptr, 0, nullptr);
-
     // Proceed with decompression
     codec = grk_decompress_init(&stream_params, &parameters);
     if(!codec)

examples/core/core_simple.cpp

@@ -49,10 +49,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
   bool images_equal = true;
   grk_stream_params decCompressedStream = {}; // compressed stream passed to decompressor
 
-  // 1. initialize library
-  grk_initialize(nullptr, 0, nullptr);
-
-  // 2. initialize compress and decompress parameters
+  // 1. initialize compress and decompress parameters
   grk_cparameters compressParams;
   grk_compress_set_default_params(&compressParams);
   compressParams.cod_format = GRK_FMT_JP2;
@@ -61,7 +58,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
 
   grk_decompress_parameters decompressParams = {};
 
-  // 3.initialize struct holding encoder compressed stream
+  // 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
@@ -72,7 +69,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
   encCompressedStream.buf = compressedData.get();
   encCompressedStream.buf_len = bufLen;
 
-  // 4. create image that will be passed to encoder
+  // 3. create image that will be passed to encoder
   auto components = std::make_unique<grk_image_comp[]>(numComps);
   for(uint32_t i = 0; i < numComps; ++i)
   {
@@ -124,7 +121,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
     }
   }
 
-  // 5. compress
+  // 4. compress
   codec = grk_compress_init(&encCompressedStream, &compressParams, encInputImage);
   if(!codec)
   {
@@ -141,11 +138,11 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
   grk_object_unref(codec);
   printf("Compression succeeded: %" PRIu64 " bytes used\n", compressedLength);
 
-  // 6. copy encCompressedStream to decCompressedStream to prepare for decompression
+  // 5. copy encCompressedStream to decCompressedStream to prepare for decompression
   decCompressedStream.buf = encCompressedStream.buf;
   decCompressedStream.buf_len = compressedLength;
 
-  // 7. decompress
+  // 6. decompress
   codec = grk_decompress_init(&decCompressedStream, &decompressParams);
   if(!grk_decompress_read_header(codec, &headerInfo))
   {
@@ -158,7 +155,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
     goto beach;
   }
 
-  // 8. retrieve decompressed image
+  // 7. retrieve decompressed image
   decOutputImage = grk_decompress_get_image(codec);
   if(!decOutputImage)
   {
@@ -167,7 +164,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char** argv)
   }
   printf("Decompression succeeded\n");
 
-  // 9. compare original uncompressedData to decompressed decInputmage
+  // 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 ||

src/lib/core/grok.cpp

@@ -24,8 +24,8 @@
 #include <sys/mman.h>
 #endif
 #include <fcntl.h>
-
 #include <filesystem>
+#include <mutex>
 
 #include "grk_includes.h"
 
@@ -108,6 +108,19 @@ static grk_object* grkDecompressCreate(grk::IStream* stream)
   return &codec->obj;
 }
 
+static inline bool areStringsEqual(const char* lhs, const char* rhs)
+{
+  if(lhs == nullptr && rhs == nullptr)
+  {
+    return true;
+  }
+  if(lhs == nullptr || rhs == nullptr)
+  {
+    return false;
+  }
+  return std::strcmp(lhs, rhs) == 0;
+}
+
 struct InitState
 {
   InitState(const char* pluginPath, uint32_t numThreads)
@@ -117,7 +130,7 @@ struct InitState
   InitState(void) : InitState(nullptr, 0) {}
   bool operator==(const InitState& rhs) const
   {
-    return pluginPath_ == rhs.pluginPath_ && numThreads_ == rhs.numThreads_;
+    return areStringsEqual(pluginPath_, rhs.pluginPath_) && numThreads_ == rhs.numThreads_;
   }
   const char* pluginPath_;
   uint32_t numThreads_;
@@ -126,6 +139,8 @@ struct InitState
 };
 
 static InitState initState_;
+static std::mutex initMutex;
+
 void grk_initialize(const char* pluginPath, uint32_t numThreads, bool* plugin_initialized)
 {
   const char* singleThreadEnv = std::getenv("GRK_TEST_SINGLE");
@@ -134,50 +149,54 @@ void grk_initialize(const char* pluginPath, uint32_t numThreads, bool* plugin_in
     numThreads = 1; // Force single-threaded execution
   }
   InitState newState(pluginPath, numThreads);
-  if(initState_.initialized_ && newState == initState_)
   {
-    if(plugin_initialized)
-      *plugin_initialized = initState_.pluginInitialized_;
-    return;
-  }
-  // 1. set up executor
-  ExecSingleton::create(numThreads);
+    std::lock_guard<std::mutex> guard(initMutex);
+    if(initState_.initialized_ && newState == initState_)
+    {
+      if(plugin_initialized)
+        *plugin_initialized = initState_.pluginInitialized_;
+      return;
+    }
+    // 1. set up executor
+    ExecSingleton::create(numThreads);
 
-  if(!Logger::logger_.info_handler)
-  {
-    grk_msg_handlers handlers = {};
-    const char* debug_env = std::getenv("GRK_DEBUG");
-    if(debug_env)
+    if(!Logger::logger_.info_handler)
     {
-      int level = std::atoi(debug_env);
-      if(level >= 1)
-        handlers.error_callback = errorCallback;
-      if(level >= 2)
-        handlers.warn_callback = warningCallback;
-      if(level >= 3)
-        handlers.info_callback = infoCallback;
-      if(level >= 4)
-        handlers.debug_callback = debugCallback;
-      if(level >= 5)
-        handlers.trace_callback = traceCallback;
+      grk_msg_handlers handlers = {};
+      const char* debug_env = std::getenv("GRK_DEBUG");
+      if(debug_env)
+      {
+        int level = std::atoi(debug_env);
+        if(level >= 1)
+          handlers.error_callback = errorCallback;
+        if(level >= 2)
+          handlers.warn_callback = warningCallback;
+        if(level >= 3)
+          handlers.info_callback = infoCallback;
+        if(level >= 4)
+          handlers.debug_callback = debugCallback;
+        if(level >= 5)
+          handlers.trace_callback = traceCallback;
+      }
+      grk_set_msg_handlers(handlers);
     }
-    grk_set_msg_handlers(handlers);
-  }
 
-  initState_ = newState;
+    initState_ = newState;
 
-  // 2. try to load plugin
-  if(!initState_.pluginInitialized_)
-  {
-    grk_plugin_load_info info;
-    info.pluginPath = pluginPath;
-    initState_.pluginInitialized_ = grk_plugin_load(info);
-    if(initState_.pluginInitialized_)
+    // 2. try to load plugin
+    if(!initState_.pluginInitialized_)
     {
-      grklog.info("Plugin loaded");
-      if(plugin_initialized)
-        *plugin_initialized = true;
+      grk_plugin_load_info info;
+      info.pluginPath = pluginPath;
+      initState_.pluginInitialized_ = grk_plugin_load(info);
+      if(initState_.pluginInitialized_)
+      {
+        grklog.info("Plugin loaded");
+        if(plugin_initialized)
+          *plugin_initialized = true;
+      }
     }
+    initState_.initialized_ = true;
   }
 }
 
@@ -353,6 +372,7 @@ void grk_decompress_wait(grk_object* codecWrapper, grk_wait_swath* swath)
 }
 bool grk_decompress(grk_object* codecWrapper, grk_plugin_tile* tile)
 {
+  grk_initialize(nullptr, 0, nullptr);
   if(codecWrapper)
   {
     auto codec = Codec::getImpl(codecWrapper);
@@ -546,6 +566,7 @@ grk_object* grk_compress_init(grk_stream_params* streamParams, grk_cparameters*
 
 uint64_t grk_compress(grk_object* codecWrapper, grk_plugin_tile* tile)
 {
+  grk_initialize(nullptr, 0, nullptr);
   if(codecWrapper)
   {
     auto codec = Codec::getImpl(codecWrapper);