Merge branch 'master' into coc-qcc

CMakeLists.txt

@@ -301,8 +301,8 @@ if(BUILD_TESTING)
     include(CTest)
 
     # Search openjpeg data needed for the tests
-    # They could be found via svn on the OpenJPEG google code project
+    # They could be found via git on the OpenJPEG GitHub code project
-    # svn checkout http://openjpeg.googlecode.com/svn/data (about 70 Mo)
+    # git clone https://github.com/uclouvain/openjpeg-data.git
     find_path(OPJ_DATA_ROOT README-OPJ-Data
       PATHS $ENV{OPJ_DATA_ROOT} ${CMAKE_SOURCE_DIR}/../data
       NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH

INSTALL

@@ -44,7 +44,7 @@ Main available cmake flags:
     cmake . -DBUILD_TESTING:BOOL=ON -DOPJ_DATA_ROOT:PATH='path/to/the/data/directory'
     make
     make Experimental
-  Note : JPEG2000 test files are available with 'svn checkout http://openjpeg.googlecode.com/svn/data' (about 70 Mo).
+  Note : JPEG2000 test files are available with 'git clone https://github.com/uclouvain/openjpeg-data.git'.
   If '-DOPJ_DATA_ROOT:PATH' option is omitted, test files will be automatically searched in '${CMAKE_SOURCE_DIR}/../data',
   corresponding to the location of the data directory when compiling from the trunk (and assuming the data directory has
   been checked out of course).

src/lib/openjp2/dwt.c

@@ -795,7 +795,7 @@ static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k, OPJ_IN
 /* <summary>                             */
 /* Inverse 9-7 wavelet transform in 1-D. */
 /* </summary>                            */
-void opj_v4dwt_decode(opj_v4dwt_t* restrict dwt)
+static void opj_v4dwt_decode(opj_v4dwt_t* restrict dwt)
 {
 	OPJ_INT32 a, b;
 	if(dwt->cas == 0) {

src/lib/openjp2/opj_malloc.c

@@ -32,12 +32,18 @@
 #define OPJ_SKIP_POISON
 #include "opj_includes.h"
 
+#ifndef SIZE_MAX
+# define SIZE_MAX ((size_t) -1)
+#endif
+
 static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size)
 {
   void* ptr;
 
   /* alignment shall be power of 2 */
   assert( (alignment != 0U) && ((alignment & (alignment - 1U)) == 0U));
+  /* alignment shall be at least sizeof(void*) */
+  assert( alignment >= sizeof(void*));
 
   if (size == 0U) { /* prevent implementation defined behavior of realloc */
     return NULL;
@@ -59,8 +65,38 @@ static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size)
 #elif defined(HAVE__ALIGNED_MALLOC)
   ptr = _aligned_malloc(size, alignment);
 #else
-/* TODO: _mm_malloc(x,y) */
+  /*
-#error missing aligned alloc function
+   * Generic aligned malloc implementation.
+   * Uses size_t offset for the integer manipulation of the pointer,
+   * as uintptr_t is not available in C89 to do 
+   * bitwise operations on the pointer itself.
+   */
+  alignment--;
+  {
+    size_t offset;
+    OPJ_UINT8 *mem;
+
+    /* Room for padding and extra pointer stored in front of allocated area */
+    size_t overhead = alignment + sizeof(void *);
+		
+    /* let's be extra careful */
+    assert(alignment <= (SIZE_MAX - sizeof(void *)));
+
+    /* Avoid integer overflow */
+    if (size > (SIZE_MAX - overhead)) {
+      return NULL;
+    }
+
+    mem = (OPJ_UINT8*)malloc(size + overhead);
+    if (mem == NULL) {
+      return mem;
+    }
+    /* offset = ((alignment + 1U) - ((size_t)(mem + sizeof(void*)) & alignment)) & alignment; */
+    /* Use the fact that alignment + 1U is a power of 2 */
+    offset = ((alignment ^ ((size_t)(mem + sizeof(void*)) & alignment)) + 1U) & alignment;
+    ptr = (void *)(mem + sizeof(void*) + offset);
+    ((void**) ptr)[-1] = mem;
+  }
 #endif
   return ptr;
 }
@@ -70,6 +106,8 @@ static INLINE void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t ne
 
   /* alignment shall be power of 2 */
   assert( (alignment != 0U) && ((alignment & (alignment - 1U)) == 0U));
+  /* alignment shall be at least sizeof(void*) */
+  assert( alignment >= sizeof(void*));
 
   if (new_size == 0U) { /* prevent implementation defined behavior of realloc */
     return NULL;
@@ -97,8 +135,51 @@ static INLINE void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t ne
 #elif defined(HAVE__ALIGNED_MALLOC)
   r_ptr = _aligned_realloc( ptr, new_size, alignment );
 #else
-/* TODO: _mm_malloc(x,y) */
+  if (ptr == NULL) {
-#error missing aligned realloc function
+    return opj_aligned_alloc_n(alignment, new_size);
+  }
+  alignment--;
+  {
+    void *oldmem;
+    OPJ_UINT8 *newmem;
+    size_t overhead = alignment + sizeof(void *);
+
+    /* let's be extra careful */
+    assert(alignment <= (SIZE_MAX - sizeof(void *)));
+
+    /* Avoid integer overflow */
+    if (new_size > SIZE_MAX - overhead) {
+      return NULL;
+    }
+		
+    oldmem = ((void**) ptr)[-1];
+    newmem = (OPJ_UINT8*)realloc(oldmem, new_size + overhead);
+    if (newmem == NULL) {
+      return newmem;
+    }
+
+    if (newmem == oldmem) {
+      r_ptr = ptr;
+    }
+    else {
+      size_t old_offset;
+      size_t new_offset;
+
+      /* realloc created a new copy, realign the copied memory block */
+      old_offset = (size_t)((OPJ_UINT8*)ptr - (OPJ_UINT8*)oldmem);
+
+      /* offset = ((alignment + 1U) - ((size_t)(mem + sizeof(void*)) & alignment)) & alignment; */
+      /* Use the fact that alignment + 1U is a power of 2 */
+      new_offset  = ((alignment ^ ((size_t)(newmem + sizeof(void*)) & alignment)) + 1U) & alignment;
+			new_offset += sizeof(void*);
+      r_ptr = (void *)(newmem + new_offset);
+
+      if (new_offset != old_offset) {
+        memmove(newmem + new_offset, newmem + old_offset, new_size);
+      }
+      ((void**) r_ptr)[-1] = newmem;
+    }
+  }
 #endif
 	return r_ptr;
 }
@@ -129,10 +210,15 @@ void * opj_aligned_realloc(void *ptr, size_t size)
 
 void opj_aligned_free(void* ptr)
 {
-#ifdef HAVE__ALIGNED_MALLOC
+#if defined(HAVE_POSIX_MEMALIGN) || defined(HAVE_MEMALIGN)
+  free( ptr );
+#elif defined(HAVE__ALIGNED_MALLOC)
   _aligned_free( ptr );
 #else
-  free( ptr );
+  /* Generic implementation has malloced pointer stored in front of used area */
+  if (ptr != NULL) {
+    free(((void**) ptr)[-1]);
+  }
 #endif
 }
 

src/lib/openjp2/t2.c

@@ -1338,7 +1338,7 @@ static OPJ_BOOL opj_t2_skip_packet_data(   opj_t2_t* p_t2,
 }
 
 
-OPJ_BOOL opj_t2_init_seg(   opj_tcd_cblk_dec_t* cblk,
+static OPJ_BOOL opj_t2_init_seg(   opj_tcd_cblk_dec_t* cblk,
                             OPJ_UINT32 index, 
                             OPJ_UINT32 cblksty, 
                             OPJ_UINT32 first)