cache: add common cache state interface

Author: Aaron Boxer

src/lib/jp2/CMakeLists.txt

@@ -56,6 +56,7 @@ include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/tile
   ${CMAKE_CURRENT_SOURCE_DIR}/filters
   ${CMAKE_CURRENT_SOURCE_DIR}/../highway
+  ${CMAKE_CURRENT_SOURCE_DIR}/cache
 )
 
 # Defines the source code for executables
@@ -76,8 +77,6 @@ set(GROK_LIBRARY_SRCS
   ${CMAKE_CURRENT_SOURCE_DIR}/util/MemStream.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/util/MemStream.h
   ${CMAKE_CURRENT_SOURCE_DIR}/util/grk_intmath.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/util/MemManager.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/util/MemManager.h
   ${CMAKE_CURRENT_SOURCE_DIR}/util/util.h
   ${CMAKE_CURRENT_SOURCE_DIR}/util/util.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/util/CPUArch.h
@@ -132,8 +131,11 @@ set(GROK_LIBRARY_SRCS
   ${CMAKE_CURRENT_SOURCE_DIR}/codestream/markers/PPMMarker.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/codestream/markers/SOTMarker.h
   ${CMAKE_CURRENT_SOURCE_DIR}/codestream/markers/SOTMarker.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/codestream/TileCache.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/codestream/TileCache.h
+  
+  ${CMAKE_CURRENT_SOURCE_DIR}/cache/TileCache.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/cache/TileCache.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/cache/MemManager.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/cache/MemManager.h
 
   ${CMAKE_CURRENT_SOURCE_DIR}/point_transform/mct.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/point_transform/mct.h

src/lib/jp2/cache/ICacheable.h

@@ -0,0 +1,51 @@
+/*
+ *    Copyright (C) 2016-2021 Grok Image Compression Inc.
+ *
+ *    This source code is free software: you can redistribute it and/or  modify
+ *    it under the terms of the GNU Affero General Public License, version 3,
+ *    as published by the Free Software Foundation.
+ *
+ *    This source code is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Affero General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Affero General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+namespace grk {
+
+enum GrkCacheState {
+	GRK_CACHE_STATE_CLOSED,
+	GRK_CACHE_STATE_OPEN,
+	GRK_CACHE_STATE_ERROR
+};
+
+
+class ICacheable {
+public:
+	ICacheable() : m_state(GRK_CACHE_STATE_CLOSED)
+	{}
+	virtual ~ICacheable() = default;
+	bool isOpen(void){
+		return m_state == GRK_CACHE_STATE_OPEN;
+	}
+	bool isClosed(void){
+		return m_state == GRK_CACHE_STATE_CLOSED;
+	}
+	bool isError(void){
+		return m_state == GRK_CACHE_STATE_ERROR;
+	}
+	void setCacheState(GrkCacheState state){
+		m_state = state;
+	}
+private:
+	GrkCacheState m_state;
+
+};
+
+}
+

src/lib/jp2/util/MemManager.cpp renamed to src/lib/jp2/cache/MemManager.cpp

@@ -35,14 +35,13 @@
 
 namespace grk {
 
-const uint32_t grk_alignment = 32;
+const uint32_t GrkAlignment = 32;
 
 uint32_t grkMakeAlignedWidth(uint32_t width){
 	assert(width);
-	return (uint32_t)((((uint64_t)width + grk_alignment - 1)/grk_alignment) * grk_alignment);
+	return (uint32_t)((((uint64_t)width + GrkAlignment - 1)/GrkAlignment) * GrkAlignment);
 }
-
-static inline void* grk_aligned_alloc_n(size_t alignment, size_t size) {
+static inline void* grkAlignedAllocN(size_t alignment, size_t size) {
 	void *ptr;
 
 	/* alignment shall be power of 2 */
@@ -102,24 +101,22 @@ static inline void* grk_aligned_alloc_n(size_t alignment, size_t size) {
 #endif
 	return ptr;
 }
-void* grk_malloc(size_t size) {
+void* grkMalloc(size_t size) {
 	if (size == 0U) /* prevent implementation defined behavior of realloc */
 		return nullptr;
 
 	return malloc(size);
 }
-void* grk_calloc(size_t num, size_t size) {
+void* grkCalloc(size_t num, size_t size) {
 	if (num == 0 || size == 0)
 		/* prevent implementation defined behavior of realloc */
 		return nullptr;
 
 	return calloc(num, size);
 }
-
 void* grkAlignedMalloc(size_t size) {
-	return grk_aligned_alloc_n(default_align, size);
+	return grkAlignedAllocN(default_align, size);
 }
-
 void grkAlignedFree(void *ptr) {
 #if defined(GROK_HAVE_POSIX_MEMALIGN) || defined(GROK_HAVE_ALIGNED_ALLOC) ||  defined(GROK_HAVE_MEMALIGN)
 	free(ptr);
@@ -131,14 +128,13 @@ void grkAlignedFree(void *ptr) {
         free(((void**) ptr)[-1]);
 #endif
 }
-
-void* grk_realloc(void *ptr, size_t new_size) {
+void* grkRealloc(void *ptr, size_t new_size) {
 	if (new_size == 0U)/* prevent implementation defined behavior of realloc */
 		return nullptr;
 
 	return realloc(ptr, new_size);
 }
-void grk_free(void *ptr) {
+void grkFree(void *ptr) {
 	if (ptr)
 		free(ptr);
 }

src/lib/jp2/util/MemManager.h renamed to src/lib/jp2/cache/MemManager.h

@@ -25,55 +25,46 @@
 
 namespace grk {
 
-
-
-
 const size_t default_align = 64;
 
 uint32_t grkMakeAlignedWidth(uint32_t width);
-
 /**
  Allocate an uninitialized memory block
  @param size Bytes to allocate
  @return a void pointer to the allocated space, or nullptr if there is insufficient memory available
  */
-void* grk_malloc(size_t size);
-
+void* grkMalloc(size_t size);
 /**
  Allocate a memory block with elements initialized to 0
  @param numOfElements  Blocks to allocate
  @param sizeOfElements Bytes per block to allocate
  @return a void pointer to the allocated space, or nullptr if there is insufficient memory available
  */
-void* grk_calloc(size_t numOfElements, size_t sizeOfElements);
-
+void* grkCalloc(size_t numOfElements, size_t sizeOfElements);
 /**
  Allocate memory aligned to a 16 byte boundary
  @param size Bytes to allocate
  @return a void pointer to the allocated space, or nullptr if there is insufficient memory available
  */
 void* grkAlignedMalloc(size_t size);
 void grkAlignedFree(void *ptr);
-
 /**
  Reallocate memory blocks.
  @param m Pointer to previously allocated memory block
  @param s New size in bytes
  @return a void pointer to the reallocated (and possibly moved) memory block
  */
-void* grk_realloc(void *m, size_t s);
-
+void* grkRealloc(void *m, size_t s);
 /**
  Deallocates or frees a memory block.
  @param m Previously allocated memory block to be freed
  */
-void grk_free(void *m);
+void grkFree(void *m);
 
 #if defined(__GNUC__) && !defined(GROK_SKIP_POISON)
 #pragma GCC poison malloc calloc realloc free
 #endif
 
-
 template<typename T> struct AllocatorVanilla{
 	T* alloc(size_t length) {
 		return new T[length];
@@ -193,7 +184,8 @@ template <typename T, template <typename TT> typename A > struct grkBuffer : A<T
     size_t offset;	/* current offset into array */
     size_t len;		/* length of array */
     bool owns_data;	/* true if buffer manages the buf array */
-} ;
+};
+
 using grkBufferU8 = grkBuffer<uint8_t, AllocatorVanilla >;
 using grkBufferU8Aligned = grkBuffer<uint8_t, AllocatorAligned >;
 
@@ -296,11 +288,4 @@ template <typename T, template <typename TT> typename A> struct grkBuffer2d : pu
     uint32_t stride;
 } ;
 
-
-
-/* ----------------------------------------------------------------------- */
-/*@}*/
-
-/*@}*/
-
 }

src/lib/jp2/codestream/TileCache.cpp renamed to src/lib/jp2/cache/TileCache.cpp

@@ -39,7 +39,6 @@ TileCache::~TileCache() {
 bool TileCache::empty(){
 	return m_cache.empty();
 }
-
 TileCacheEntry*  TileCache::put(uint16_t tileIndex, TileProcessor *processor){
 	TileCacheEntry *entry = nullptr;
 	if (m_cache.find(tileIndex) != m_cache.end()) {
@@ -59,7 +58,6 @@ TileCacheEntry* TileCache::get(uint16_t tileIndex){
 
 	return nullptr;
 }
-
 void TileCache::setStrategy(GRK_TILE_CACHE_STRATEGY strategy){
 	m_strategy = strategy;
 }

src/lib/jp2/codestream/TileCache.h renamed to src/lib/jp2/cache/TileCache.h

@@ -38,15 +38,15 @@ CodeStream::~CodeStream(){
 		grk_object_unref(&m_headerImage->obj);
 	m_cp.destroy();
 	if (cstr_index) {
-		grk_free(cstr_index->marker);
+		grkFree(cstr_index->marker);
 		if (cstr_index->tile_index) {
 			for (uint32_t i = 0; i < cstr_index->nb_of_tiles; i++) {
-				grk_free(cstr_index->tile_index[i].tp_index);
-				grk_free(cstr_index->tile_index[i].marker);
+				grkFree(cstr_index->tile_index[i].tp_index);
+				grkFree(cstr_index->tile_index[i].marker);
 			}
-			grk_free(cstr_index->tile_index);
+			grkFree(cstr_index->tile_index);
 		}
-		grk_free(cstr_index);
+		grkFree(cstr_index);
 	}
 }
 CodingParams* CodeStream::getCodingParams(void){