minor tweaks to the code

diff --git a/src/lib/openjp2/mct.c b/src/lib/openjp2/mct.c
index 6b67834565492c2567e4a0bca834530c9e293182..02259679c2135570cb974d45d6bd25535d499931 100644 (file)
--- a/src/lib/openjp2/mct.c
+++ b/src/lib/openjp2/mct.c
@@ -82,9 +82,9 @@ void opj_mct_encode(
        OPJ_SIZE_T i;
        const OPJ_SIZE_T len = n;
        /* buffer are aligned on 16 bytes */
-       assert( ((uintptr_t)c0 & 0xf) == 0 );
-       assert( ((uintptr_t)c1 & 0xf) == 0 );
-       assert( ((uintptr_t)c2 & 0xf) == 0 );
+       assert( ((size_t)c0 & 0xf) == 0 );
+       assert( ((size_t)c1 & 0xf) == 0 );
+       assert( ((size_t)c2 & 0xf) == 0 );
        
        for(i = 0; i < (len & ~3U); i += 4) {
                __m128i y, u, v;

diff --git a/src/lib/openjp2/opj_malloc.c b/src/lib/openjp2/opj_malloc.c
index 85a5716b717c43ae85706ca192b2ef8cc166bcf1..30d892587eb23e076c2d6d19d310c10abaa1d7da 100644 (file)
--- a/src/lib/openjp2/opj_malloc.c
+++ b/src/lib/openjp2/opj_malloc.c
@@ -34,14 +34,15 @@
 #include <stdlib.h>
 #include <string.h>
 #include <inttypes.h>
+#include <assert.h>
 
 static inline void *opj_aligned_alloc_n(size_t alignment, size_t size)
 {
 #if defined(HAVE_POSIX_MEMALIGN)
-  // aligned_alloc requires c11, restrict to posix_memalign for now. Quote:
-  // This function was introduced in POSIX 1003.1d. Although this function is
-  // superseded by aligned_alloc, it is more portable to older POSIX systems
-  // that do not support ISO C11.
+  /* aligned_alloc requires c11, restrict to posix_memalign for now. Quote:
+   * This function was introduced in POSIX 1003.1d. Although this function is
+   * superseded by aligned_alloc, it is more portable to older POSIX systems
+   * that do not support ISO C11.  */
   void* ptr;
   if (posix_memalign (&ptr, alignment, size))
   {
@@ -50,7 +51,7 @@ static inline void *opj_aligned_alloc_n(size_t alignment, size_t size)
   return ptr;
   /* older linux */
 #elif defined(HAVE_MEMALIGN)
-  assert( size % alignment == 0 );
+  assert( size & (alignment - 1u) == 0 );
   return memalign( alignment, size );
 /* _MSC_VER */
 #elif defined(HAVE__ALIGNED_MALLOC)
@@ -62,18 +63,22 @@ static inline void *opj_aligned_alloc_n(size_t alignment, size_t size)
 }
 static inline void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t size)
 {
+  void *a_ptr;
 /* no portable aligned realloc */
 #if defined(HAVE_POSIX_MEMALIGN) || defined(HAVE_MEMALIGN)
   /* glibc doc states one can mixed aligned malloc with realloc */
   void *r_ptr = realloc( ptr, size );
+  assert( alignment > 0 );
   /* fast path */
-  if( ((uintptr_t)r_ptr & alignment) == 0 )
+  /* we simply use `size_t` to cast, since we are only interest in binary AND
+   * operator */
+  if( ((size_t)r_ptr & (alignment - 1u)) == 0 )
     return r_ptr;
   /* this is non-trivial to implement a portable aligned realloc, so use a
    * simple approach where we do not need a function that return the size of an
    * allocated array (eg. _msize on Windows, malloc_size on MacOS,
    * malloc_usable_size on systems with glibc) */
-  void *a_ptr = opj_aligned_alloc_n(alignment, size);
+  a_ptr = opj_aligned_alloc_n(alignment, size);
   /* memory may overlap, do not use memcpy */
   memmove(a_ptr, r_ptr, size);
   free( r_ptr );