From: cristy <urban-warrior@git.imagemagick.org>
Date: Sun, 16 Feb 2014 14:05:06 +0000 (+0000)
Subject: (no commit message)
X-Git-Tag: 7.0.1-0~2670
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=3d162a93f537cb7cbb6d9fa3b8e73e8f992a527a;p=imagemagick

---

diff --git a/MagickCore/annotate.c b/MagickCore/annotate.c
index 3f7fc5d3f..d945ccade 100644
--- a/MagickCore/annotate.c
+++ b/MagickCore/annotate.c
@@ -145,7 +145,7 @@ static MagickBooleanType
 */
 MagickPrivate MagickBooleanType AnnotateComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&annotate_semaphore);
+  annotate_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -170,8 +170,8 @@ MagickPrivate MagickBooleanType AnnotateComponentGenesis(void)
 MagickPrivate void AnnotateComponentTerminus(void)
 {
   if (annotate_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&annotate_semaphore);
-  DestroySemaphoreInfo(&annotate_semaphore);
+    annotate_semaphore=AcquireSemaphoreInfo();
+  RelinquishSemaphoreInfo(&annotate_semaphore);
 }
 
 /*
@@ -1904,7 +1904,7 @@ static MagickBooleanType RenderX11(Image *image,const DrawInfo *draw_info,
     status;
 
   if (annotate_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&annotate_semaphore);
+    annotate_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(annotate_semaphore);
   status=XRenderImage(image,draw_info,offset,metrics,exception);
   UnlockSemaphoreInfo(annotate_semaphore);
diff --git a/MagickCore/blob.c b/MagickCore/blob.c
index a034e4aec..7aaccba7b 100644
--- a/MagickCore/blob.c
+++ b/MagickCore/blob.c
@@ -652,7 +652,7 @@ MagickExport void DestroyBlob(Image *image)
       RelinquishMagickResource(MapResource,image->blob->length);
     }
   if (image->blob->semaphore != (SemaphoreInfo *) NULL)
-    DestroySemaphoreInfo(&image->blob->semaphore);
+    RelinquishSemaphoreInfo(&image->blob->semaphore);
   image->blob->signature=(~MagickSignature);
   image->blob=(BlobInfo *) RelinquishMagickMemory(image->blob);
 }
@@ -1283,7 +1283,7 @@ MagickPrivate void GetBlobInfo(BlobInfo *blob_info)
   blob_info->properties.st_ctime=time((time_t *) NULL);
   blob_info->debug=IsEventLogging();
   blob_info->reference_count=1;
-  blob_info->semaphore=AllocateSemaphoreInfo();
+  blob_info->semaphore=AcquireSemaphoreInfo();
   blob_info->signature=MagickSignature;
 }
 
diff --git a/MagickCore/cache.c b/MagickCore/cache.c
index d097c6996..290f054f8 100644
--- a/MagickCore/cache.c
+++ b/MagickCore/cache.c
@@ -201,9 +201,9 @@ MagickPrivate Cache AcquirePixelCache(const size_t number_threads)
       cache_info->synchronize=IsStringTrue(synchronize);
       synchronize=DestroyString(synchronize);
     }
-  cache_info->semaphore=AllocateSemaphoreInfo();
+  cache_info->semaphore=AcquireSemaphoreInfo();
   cache_info->reference_count=1;
-  cache_info->file_semaphore=AllocateSemaphoreInfo();
+  cache_info->file_semaphore=AcquireSemaphoreInfo();
   cache_info->debug=IsEventLogging();
   cache_info->signature=MagickSignature;
   return((Cache ) cache_info);
@@ -324,7 +324,7 @@ MagickPrivate const void *AcquirePixelCachePixels(const Image *image,
 */
 MagickPrivate MagickBooleanType CacheComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&cache_semaphore);
+  cache_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -349,11 +349,11 @@ MagickPrivate MagickBooleanType CacheComponentGenesis(void)
 MagickPrivate void CacheComponentTerminus(void)
 {
   if (cache_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&cache_semaphore);
+    cache_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(cache_semaphore);
   instantiate_cache=MagickFalse;
   UnlockSemaphoreInfo(cache_semaphore);
-  DestroySemaphoreInfo(&cache_semaphore);
+  RelinquishSemaphoreInfo(&cache_semaphore);
 }
 
 /*
@@ -911,9 +911,9 @@ MagickPrivate Cache DestroyPixelCache(Cache cache)
   if (cache_info->random_info != (RandomInfo *) NULL)
     cache_info->random_info=DestroyRandomInfo(cache_info->random_info);
   if (cache_info->file_semaphore != (SemaphoreInfo *) NULL)
-    DestroySemaphoreInfo(&cache_info->file_semaphore);
+    RelinquishSemaphoreInfo(&cache_info->file_semaphore);
   if (cache_info->semaphore != (SemaphoreInfo *) NULL)
-    DestroySemaphoreInfo(&cache_info->semaphore);
+    RelinquishSemaphoreInfo(&cache_info->semaphore);
   cache_info->signature=(~MagickSignature);
   cache_info=(CacheInfo *) RelinquishMagickMemory(cache_info);
   cache=(Cache) NULL;
@@ -1512,7 +1512,7 @@ static Cache GetImagePixelCache(Image *image,const MagickBooleanType clone,
             Clone pixel cache.
           */
           clone_image=(*image);
-          clone_image.semaphore=AllocateSemaphoreInfo();
+          clone_image.semaphore=AcquireSemaphoreInfo();
           clone_image.reference_count=1;
           clone_image.cache=ClonePixelCache(cache_info);
           clone_info=(CacheInfo *) clone_image.cache;
@@ -1530,7 +1530,7 @@ static Cache GetImagePixelCache(Image *image,const MagickBooleanType clone,
                   image->cache=clone_image.cache;
                 }
             }
-          DestroySemaphoreInfo(&clone_image.semaphore);
+          RelinquishSemaphoreInfo(&clone_image.semaphore);
         }
       UnlockSemaphoreInfo(cache_info->semaphore);
     }
diff --git a/MagickCore/coder.c b/MagickCore/coder.c
index 9ab4d95f1..2095db0d8 100644
--- a/MagickCore/coder.c
+++ b/MagickCore/coder.c
@@ -265,7 +265,7 @@ static MagickBooleanType
 */
 MagickPrivate MagickBooleanType CoderComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&coder_semaphore);
+  coder_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -290,13 +290,13 @@ MagickPrivate MagickBooleanType CoderComponentGenesis(void)
 MagickPrivate void CoderComponentTerminus(void)
 {
   if (coder_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&coder_semaphore);
+    coder_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(coder_semaphore);
   if (coder_list != (SplayTreeInfo *) NULL)
     coder_list=DestroySplayTree(coder_list);
   instantiate_coder=MagickFalse;
   UnlockSemaphoreInfo(coder_semaphore);
-  DestroySemaphoreInfo(&coder_semaphore);
+  RelinquishSemaphoreInfo(&coder_semaphore);
 }
 
 /*
@@ -542,7 +542,7 @@ static MagickBooleanType InitializeCoderList(ExceptionInfo *exception)
       (instantiate_coder == MagickFalse))
     {
       if (coder_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&coder_semaphore);
+        coder_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(coder_semaphore);
       if ((coder_list == (SplayTreeInfo *) NULL) &&
           (instantiate_coder == MagickFalse))
diff --git a/MagickCore/color.c b/MagickCore/color.c
index 6a45629e2..08fbed799 100644
--- a/MagickCore/color.c
+++ b/MagickCore/color.c
@@ -820,7 +820,7 @@ static MagickBooleanType
 */
 MagickPrivate MagickBooleanType ColorComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&color_semaphore);
+  color_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -863,13 +863,13 @@ static void *DestroyColorElement(void *color_info)
 MagickPrivate void ColorComponentTerminus(void)
 {
   if (color_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&color_semaphore);
+    color_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(color_semaphore);
   if (color_list != (LinkedListInfo *) NULL)
     color_list=DestroyLinkedList(color_list,DestroyColorElement);
   instantiate_color=MagickFalse;
   UnlockSemaphoreInfo(color_semaphore);
-  DestroySemaphoreInfo(&color_semaphore);
+  RelinquishSemaphoreInfo(&color_semaphore);
 }
 
 /*
@@ -1519,7 +1519,7 @@ static MagickBooleanType InitializeColorList(ExceptionInfo *exception)
       IfMagickFalse(instantiate_color))
     {
       if (color_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&color_semaphore);
+        color_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(color_semaphore);
       if ((color_list == (LinkedListInfo *) NULL) &&
           IfMagickFalse(instantiate_color))
diff --git a/MagickCore/configure.c b/MagickCore/configure.c
index 1b8747eb1..028ea7972 100644
--- a/MagickCore/configure.c
+++ b/MagickCore/configure.c
@@ -142,7 +142,7 @@ static MagickBooleanType
 */
 MagickPrivate MagickBooleanType ConfigureComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&configure_semaphore);
+  configure_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -187,14 +187,14 @@ static void *DestroyConfigureElement(void *configure_info)
 MagickPrivate void ConfigureComponentTerminus(void)
 {
   if (configure_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&configure_semaphore);
+    configure_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(configure_semaphore);
   if (configure_list != (LinkedListInfo *) NULL)
     configure_list=DestroyLinkedList(configure_list,DestroyConfigureElement);
   configure_list=(LinkedListInfo *) NULL;
   instantiate_configure=MagickFalse;
   UnlockSemaphoreInfo(configure_semaphore);
-  DestroySemaphoreInfo(&configure_semaphore);
+  RelinquishSemaphoreInfo(&configure_semaphore);
 }
 
 /*
@@ -906,7 +906,7 @@ static MagickBooleanType InitializeConfigureList(ExceptionInfo *exception)
       (instantiate_configure == MagickFalse))
     {
       if (configure_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&configure_semaphore);
+        configure_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(configure_semaphore);
       if ((configure_list == (LinkedListInfo *) NULL) &&
           (instantiate_configure == MagickFalse))
diff --git a/MagickCore/constitute.c b/MagickCore/constitute.c
index 77a518b61..28a231556 100644
--- a/MagickCore/constitute.c
+++ b/MagickCore/constitute.c
@@ -103,7 +103,7 @@ static SemaphoreInfo
 */
 MagickPrivate MagickBooleanType ConstituteComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&constitute_semaphore);
+  constitute_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -128,8 +128,8 @@ MagickPrivate MagickBooleanType ConstituteComponentGenesis(void)
 MagickPrivate void ConstituteComponentTerminus(void)
 {
   if (constitute_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&constitute_semaphore);
-  DestroySemaphoreInfo(&constitute_semaphore);
+    constitute_semaphore=AcquireSemaphoreInfo();
+  RelinquishSemaphoreInfo(&constitute_semaphore);
 }
 
 /*
@@ -528,7 +528,7 @@ MagickExport Image *ReadImage(const ImageInfo *image_info,
     }
   image=NewImageList();
   if (constitute_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&constitute_semaphore);
+    constitute_semaphore=AcquireSemaphoreInfo();
   if ((magick_info == (const MagickInfo *) NULL) ||
       (GetImageDecoder(magick_info) == (DecodeImageHandler *) NULL))
     {
@@ -1142,7 +1142,7 @@ MagickExport MagickBooleanType WriteImage(const ImageInfo *image_info,
         }
     }
   if (constitute_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&constitute_semaphore);
+    constitute_semaphore=AcquireSemaphoreInfo();
   if ((magick_info != (const MagickInfo *) NULL) &&
       (GetImageEncoder(magick_info) != (EncodeImageHandler *) NULL))
     {
diff --git a/MagickCore/delegate.c b/MagickCore/delegate.c
index cce4df45a..a7d7a63ec 100644
--- a/MagickCore/delegate.c
+++ b/MagickCore/delegate.c
@@ -163,7 +163,7 @@ static MagickBooleanType
 */
 MagickPrivate MagickBooleanType DelegateComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&delegate_semaphore);
+  delegate_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -207,13 +207,13 @@ static void *DestroyDelegate(void *delegate_info)
 MagickPrivate void DelegateComponentTerminus(void)
 {
   if (delegate_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&delegate_semaphore);
+    delegate_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(delegate_semaphore);
   if (delegate_list != (LinkedListInfo *) NULL)
     delegate_list=DestroyLinkedList(delegate_list,DestroyDelegate);
   instantiate_delegate=MagickFalse;
   UnlockSemaphoreInfo(delegate_semaphore);
-  DestroySemaphoreInfo(&delegate_semaphore);
+  RelinquishSemaphoreInfo(&delegate_semaphore);
 }
 
 /*
@@ -713,7 +713,7 @@ static MagickBooleanType InitializeDelegateList(ExceptionInfo *exception)
       IfMagickFalse(instantiate_delegate))
     {
       if (delegate_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&delegate_semaphore);
+        delegate_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(delegate_semaphore);
       if ((delegate_list == (LinkedListInfo *) NULL) &&
           IfMagickFalse(instantiate_delegate))
diff --git a/MagickCore/exception.c b/MagickCore/exception.c
index f034d2632..f08afba16 100644
--- a/MagickCore/exception.c
+++ b/MagickCore/exception.c
@@ -414,7 +414,7 @@ MagickExport ExceptionInfo *DestroyExceptionInfo(ExceptionInfo *exception)
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
   if (exception->semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&exception->semaphore);
+    exception->semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(exception->semaphore);
   exception->severity=UndefinedException;
   if (exception->exceptions != (void *) NULL)
@@ -424,7 +424,7 @@ MagickExport ExceptionInfo *DestroyExceptionInfo(ExceptionInfo *exception)
   if (exception->relinquish != MagickFalse)
     exception->signature=(~MagickSignature);
   UnlockSemaphoreInfo(exception->semaphore);
-  DestroySemaphoreInfo(&exception->semaphore);
+  RelinquishSemaphoreInfo(&exception->semaphore);
   if (relinquish != MagickFalse)
     exception=(ExceptionInfo *) RelinquishMagickMemory(exception);
   return(exception);
@@ -458,7 +458,7 @@ MagickExport void GetExceptionInfo(ExceptionInfo *exception)
   (void) ResetMagickMemory(exception,0,sizeof(*exception));
   exception->severity=UndefinedException;
   exception->exceptions=(void *) NewLinkedList(0);
-  exception->semaphore=AllocateSemaphoreInfo();
+  exception->semaphore=AcquireSemaphoreInfo();
   exception->signature=MagickSignature;
 }
 
diff --git a/MagickCore/hashmap.c b/MagickCore/hashmap.c
index 31b855c18..28bbad6f3 100644
--- a/MagickCore/hashmap.c
+++ b/MagickCore/hashmap.c
@@ -358,7 +358,7 @@ MagickExport HashmapInfo *DestroyHashmap(HashmapInfo *hashmap_info)
     hashmap_info->map);
   hashmap_info->signature=(~MagickSignature);
   UnlockSemaphoreInfo(hashmap_info->semaphore);
-  DestroySemaphoreInfo(&hashmap_info->semaphore);
+  RelinquishSemaphoreInfo(&hashmap_info->semaphore);
   hashmap_info=(HashmapInfo *) RelinquishMagickMemory(hashmap_info);
   return(hashmap_info);
 }
@@ -411,7 +411,7 @@ MagickExport LinkedListInfo *DestroyLinkedList(LinkedListInfo *list_info,
   }
   list_info->signature=(~MagickSignature);
   UnlockSemaphoreInfo(list_info->semaphore);
-  DestroySemaphoreInfo(&list_info->semaphore);
+  RelinquishSemaphoreInfo(&list_info->semaphore);
   list_info=(LinkedListInfo *) RelinquishMagickMemory(list_info);
   return(list_info);
 }
@@ -1326,7 +1326,7 @@ MagickExport HashmapInfo *NewHashmap(const size_t capacity,
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(hashmap_info->map,0,(size_t) capacity*
     sizeof(*hashmap_info->map));
-  hashmap_info->semaphore=AllocateSemaphoreInfo();
+  hashmap_info->semaphore=AcquireSemaphoreInfo();
   hashmap_info->signature=MagickSignature;
   return(hashmap_info);
 }
@@ -1368,7 +1368,7 @@ MagickExport LinkedListInfo *NewLinkedList(const size_t capacity)
   list_info->head=(ElementInfo *) NULL;
   list_info->tail=(ElementInfo *) NULL;
   list_info->next=(ElementInfo *) NULL;
-  list_info->semaphore=AllocateSemaphoreInfo();
+  list_info->semaphore=AcquireSemaphoreInfo();
   list_info->signature=MagickSignature;
   return(list_info);
 }
@@ -1474,7 +1474,7 @@ static MagickBooleanType IncreaseHashmapCapacity(HashmapInfo *hashmap_info)
     }
     list_info->signature=(~MagickSignature);
     UnlockSemaphoreInfo(list_info->semaphore);
-    DestroySemaphoreInfo(&list_info->semaphore);
+    RelinquishSemaphoreInfo(&list_info->semaphore);
     list_info=(LinkedListInfo *) RelinquishMagickMemory(list_info);
   }
   hashmap_info->map=(LinkedListInfo **) RelinquishMagickMemory(
diff --git a/MagickCore/image.c b/MagickCore/image.c
index 29f195610..b58339737 100644
--- a/MagickCore/image.c
+++ b/MagickCore/image.c
@@ -208,7 +208,7 @@ MagickExport Image *AcquireImage(const ImageInfo *image_info,
   image->timestamp=time((time_t *) NULL);
   image->debug=IsEventLogging();
   image->reference_count=1;
-  image->semaphore=AllocateSemaphoreInfo();
+  image->semaphore=AcquireSemaphoreInfo();
   image->signature=MagickSignature;
   if (image_info == (ImageInfo *) NULL)
     return(image);
@@ -873,7 +873,7 @@ MagickExport Image *CloneImage(const Image *image,const size_t columns,
     }
   clone_image->ping=image->ping;
   clone_image->debug=IsEventLogging();
-  clone_image->semaphore=AllocateSemaphoreInfo();
+  clone_image->semaphore=AcquireSemaphoreInfo();
   if ((columns == 0) && (rows == 0))
     {
       if (image->montage != (char *) NULL)
@@ -1052,7 +1052,7 @@ MagickExport Image *DestroyImage(Image *image)
     image->ascii85=(Ascii85Info *) RelinquishMagickMemory(image->ascii85);
   DestroyBlob(image);
   if (image->semaphore != (SemaphoreInfo *) NULL)
-    DestroySemaphoreInfo(&image->semaphore);
+    RelinquishSemaphoreInfo(&image->semaphore);
   image->signature=(~MagickSignature);
   image=(Image *) RelinquishMagickMemory(image);
   return(image);
diff --git a/MagickCore/locale.c b/MagickCore/locale.c
index 5e92cc1df..7033e1c81 100644
--- a/MagickCore/locale.c
+++ b/MagickCore/locale.c
@@ -817,7 +817,7 @@ static MagickBooleanType InitializeLocaleList(ExceptionInfo *exception)
       (instantiate_locale == MagickFalse))
     {
       if (locale_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&locale_semaphore);
+        locale_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(locale_semaphore);
       if ((locale_list == (SplayTreeInfo *) NULL) &&
           (instantiate_locale == MagickFalse))
@@ -1392,7 +1392,7 @@ static MagickBooleanType LoadLocaleLists(const char *filename,
 */
 MagickPrivate MagickBooleanType LocaleComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&locale_semaphore);
+  locale_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -1417,7 +1417,7 @@ MagickPrivate MagickBooleanType LocaleComponentGenesis(void)
 MagickPrivate void LocaleComponentTerminus(void)
 {
   if (locale_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&locale_semaphore);
+    locale_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(locale_semaphore);
   if (locale_list != (SplayTreeInfo *) NULL)
     locale_list=DestroySplayTree(locale_list);
@@ -1426,5 +1426,5 @@ MagickPrivate void LocaleComponentTerminus(void)
 #endif
   instantiate_locale=MagickFalse;
   UnlockSemaphoreInfo(locale_semaphore);
-  DestroySemaphoreInfo(&locale_semaphore);
+  RelinquishSemaphoreInfo(&locale_semaphore);
 }
diff --git a/MagickCore/log.c b/MagickCore/log.c
index a95613045..60186eb34 100644
--- a/MagickCore/log.c
+++ b/MagickCore/log.c
@@ -537,7 +537,7 @@ static MagickBooleanType InitializeLogList(ExceptionInfo *exception)
   if ((log_list == (LinkedListInfo *) NULL) && (instantiate_log == MagickFalse))
     {
       if (log_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&log_semaphore);
+        log_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(log_semaphore);
       if ((log_list == (LinkedListInfo *) NULL) &&
           (instantiate_log == MagickFalse))
@@ -708,7 +708,7 @@ MagickPrivate MagickBooleanType LogComponentGenesis(void)
   ExceptionInfo
     *exception;
 
-  AcquireSemaphoreInfo(&log_semaphore);
+  log_semaphore=AcquireSemaphoreInfo();
   exception=AcquireExceptionInfo();
   (void) GetLogInfo("*",exception);
   exception=DestroyExceptionInfo(exception);
@@ -759,13 +759,13 @@ static void *DestroyLogElement(void *log_info)
 MagickPrivate void LogComponentTerminus(void)
 {
   if (log_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&log_semaphore);
+    log_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(log_semaphore);
   if (log_list != (LinkedListInfo *) NULL)
     log_list=DestroyLinkedList(log_list,DestroyLogElement);
   instantiate_log=MagickFalse;
   UnlockSemaphoreInfo(log_semaphore);
-  DestroySemaphoreInfo(&log_semaphore);
+  RelinquishSemaphoreInfo(&log_semaphore);
 }
 
 /*
diff --git a/MagickCore/magic.c b/MagickCore/magic.c
index c4b0a2e8b..0ec0b3730 100644
--- a/MagickCore/magic.c
+++ b/MagickCore/magic.c
@@ -533,7 +533,7 @@ static MagickBooleanType InitializeMagicList(ExceptionInfo *exception)
       (instantiate_magic == MagickFalse))
     {
       if (magic_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&magic_semaphore);
+        magic_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(magic_semaphore);
       if ((magic_list == (LinkedListInfo *) NULL) &&
           (instantiate_magic == MagickFalse))
@@ -1024,7 +1024,7 @@ static MagickBooleanType LoadMagicLists(const char *filename,
 */
 MagickPrivate MagickBooleanType MagicComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&magic_semaphore);
+  magic_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -1071,11 +1071,11 @@ static void *DestroyMagicElement(void *magic_info)
 MagickPrivate void MagicComponentTerminus(void)
 {
   if (magic_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&magic_semaphore);
+    magic_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(magic_semaphore);
   if (magic_list != (LinkedListInfo *) NULL)
     magic_list=DestroyLinkedList(magic_list,DestroyMagicElement);
   instantiate_magic=MagickFalse;
   UnlockSemaphoreInfo(magic_semaphore);
-  DestroySemaphoreInfo(&magic_semaphore);
+  RelinquishSemaphoreInfo(&magic_semaphore);
 }
diff --git a/MagickCore/magick.c b/MagickCore/magick.c
index 70e4e4825..5dba4c697 100644
--- a/MagickCore/magick.c
+++ b/MagickCore/magick.c
@@ -844,7 +844,7 @@ static MagickBooleanType InitializeMagickList(ExceptionInfo *exception)
       (instantiate_magick == MagickFalse))
     {
       if (magick_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&magick_semaphore);
+        magick_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(magick_semaphore);
       if ((magick_list == (SplayTreeInfo *) NULL) &&
           (instantiate_magick == MagickFalse))
@@ -1075,7 +1075,7 @@ MagickExport MagickBooleanType IsMagickCoreInstantiated(void)
 */
 MagickPrivate MagickBooleanType MagickComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&magick_semaphore);
+  magick_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -1100,13 +1100,13 @@ MagickPrivate MagickBooleanType MagickComponentGenesis(void)
 MagickPrivate void MagickComponentTerminus(void)
 {
   if (magick_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&magick_semaphore);
+    magick_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(magick_semaphore);
   if (magick_list != (SplayTreeInfo *) NULL)
     magick_list=DestroySplayTree(magick_list);
   instantiate_magick=MagickFalse;
   UnlockSemaphoreInfo(magick_semaphore);
-  DestroySemaphoreInfo(&magick_semaphore);
+  RelinquishSemaphoreInfo(&magick_semaphore);
 }
 
 /*
diff --git a/MagickCore/memory.c b/MagickCore/memory.c
index d90fa4b2c..119f5f647 100644
--- a/MagickCore/memory.c
+++ b/MagickCore/memory.c
@@ -463,7 +463,7 @@ MagickExport void *AcquireMagickMemory(const size_t size)
   memory=memory_methods.acquire_memory_handler(size == 0 ? 1UL : size);
 #else
   if (memory_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&memory_semaphore);
+    memory_semaphore=AcquireSemaphoreInfo();
   if (free_segments == (DataSegmentInfo *) NULL)
     {
       LockSemaphoreInfo(memory_semaphore);
@@ -724,7 +724,7 @@ MagickExport void DestroyMagickMemory(void)
     i;
 
   if (memory_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&memory_semaphore);
+    memory_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(memory_semaphore);
   UnlockSemaphoreInfo(memory_semaphore);
   for (i=0; i < (ssize_t) memory_pool.number_segments; i++)
@@ -736,7 +736,7 @@ MagickExport void DestroyMagickMemory(void)
         memory_pool.segments[i]->length);
   free_segments=(DataSegmentInfo *) NULL;
   (void) ResetMagickMemory(&memory_pool,0,sizeof(memory_pool));
-  DestroySemaphoreInfo(&memory_semaphore);
+  RelinquishSemaphoreInfo(&memory_semaphore);
 #endif
 }
 
diff --git a/MagickCore/mime.c b/MagickCore/mime.c
index 9a24a1959..fed83d996 100644
--- a/MagickCore/mime.c
+++ b/MagickCore/mime.c
@@ -608,7 +608,7 @@ static MagickBooleanType InitializeMimeList(ExceptionInfo *exception)
       (instantiate_mime == MagickFalse))
     {
       if (mime_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&mime_semaphore);
+        mime_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(mime_semaphore);
       if ((mime_list == (LinkedListInfo *) NULL) &&
           (instantiate_mime == MagickFalse))
@@ -1056,7 +1056,7 @@ MagickExport char *MagickToMime(const char *magick)
 */
 MagickPrivate MagickBooleanType MimeComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&mime_semaphore);
+  mime_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -1102,11 +1102,11 @@ static void *DestroyMimeElement(void *mime_info)
 MagickPrivate void MimeComponentTerminus(void)
 {
   if (mime_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&mime_semaphore);
+    mime_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(mime_semaphore);
   if (mime_list != (LinkedListInfo *) NULL)
     mime_list=DestroyLinkedList(mime_list,DestroyMimeElement);
   instantiate_mime=MagickFalse;
   UnlockSemaphoreInfo(mime_semaphore);
-  DestroySemaphoreInfo(&mime_semaphore);
+  RelinquishSemaphoreInfo(&mime_semaphore);
 }
diff --git a/MagickCore/module.c b/MagickCore/module.c
index e6fe7303e..9a182120e 100644
--- a/MagickCore/module.c
+++ b/MagickCore/module.c
@@ -869,7 +869,7 @@ static MagickBooleanType InitializeModuleList(
       (instantiate_module == MagickFalse))
     {
       if (module_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&module_semaphore);
+        module_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(module_semaphore);
       if ((module_list == (SplayTreeInfo *) NULL) &&
           (instantiate_module == MagickFalse))
@@ -1164,7 +1164,7 @@ MagickPrivate MagickBooleanType ModuleComponentGenesis(void)
   MagickBooleanType
     status;
 
-  AcquireSemaphoreInfo(&module_semaphore);
+  module_semaphore=AcquireSemaphoreInfo();
   exception=AcquireExceptionInfo();
   status=InitializeModuleList(exception);
   exception=DestroyExceptionInfo(exception);
@@ -1192,9 +1192,9 @@ MagickPrivate MagickBooleanType ModuleComponentGenesis(void)
 MagickPrivate void ModuleComponentTerminus(void)
 {
   if (module_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&module_semaphore);
+    module_semaphore=AcquireSemaphoreInfo();
   DestroyModuleList();
-  DestroySemaphoreInfo(&module_semaphore);
+  RelinquishSemaphoreInfo(&module_semaphore);
 }
 
 /*
diff --git a/MagickCore/opencl.c b/MagickCore/opencl.c
index e9cd08a2b..c9614d090 100644
--- a/MagickCore/opencl.c
+++ b/MagickCore/opencl.c
@@ -126,7 +126,7 @@ MagickExport MagickCLEnv AcquireMagickOpenCLEnv()
   if (clEnv != NULL)
   {
     memset(clEnv, 0, sizeof(struct _MagickCLEnv));
-    AcquireSemaphoreInfo(&clEnv->lock);
+    clEnv->lock=AcquireSemaphoreInfo();
   }
   return clEnv;
 }
@@ -203,7 +203,7 @@ MagickExport MagickCLEnv GetDefaultOpenCLEnv()
   {
     if (defaultCLEnvLock == NULL)
     {
-      AcquireSemaphoreInfo(&defaultCLEnvLock);
+      defaultCLEnvLock=AcquireSemaphoreInfo();
     }
     LockSemaphoreInfo(defaultCLEnvLock);
     defaultCLEnv = AcquireMagickOpenCLEnv();
@@ -215,7 +215,7 @@ MagickExport MagickCLEnv GetDefaultOpenCLEnv()
 static void LockDefaultOpenCLEnv() {
   if (defaultCLEnvLock == NULL)
   {
-    AcquireSemaphoreInfo(&defaultCLEnvLock);
+    defaultCLEnvLock=AcquireSemaphoreInfo();
   }
   LockSemaphoreInfo(defaultCLEnvLock);
 }
@@ -223,7 +223,7 @@ static void LockDefaultOpenCLEnv() {
 static void UnlockDefaultOpenCLEnv() {
   if (defaultCLEnvLock == NULL)
   {
-    AcquireSemaphoreInfo(&defaultCLEnvLock);
+    defaultCLEnvLock=AcquireSemaphoreInfo();
   }
   else
     UnlockSemaphoreInfo(defaultCLEnvLock);
@@ -2543,7 +2543,7 @@ const char* GetOpenCLCachedFilesDirectory() {
   if (openclCachedFilesDirectory == NULL) {
     if (openclCachedFilesDirectoryLock == NULL)
     {
-      AcquireSemaphoreInfo(&openclCachedFilesDirectoryLock);
+      openclCachedFilesDirectoryLock=AcquireSemaphoreInfo();
     }
     LockSemaphoreInfo(openclCachedFilesDirectoryLock);
     if (openclCachedFilesDirectory == NULL) {
diff --git a/MagickCore/policy.c b/MagickCore/policy.c
index c53151611..e30197768 100644
--- a/MagickCore/policy.c
+++ b/MagickCore/policy.c
@@ -429,7 +429,7 @@ static MagickBooleanType InitializePolicyList(ExceptionInfo *exception)
       (instantiate_policy == MagickFalse))
     {
       if (policy_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&policy_semaphore);
+        policy_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(policy_semaphore);
       if ((policy_list == (LinkedListInfo *) NULL) &&
           (instantiate_policy == MagickFalse))
@@ -969,7 +969,7 @@ static MagickBooleanType LoadPolicyLists(const char *filename,
 */
 MagickPrivate MagickBooleanType PolicyComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&policy_semaphore);
+  policy_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -1016,11 +1016,11 @@ static void *DestroyPolicyElement(void *policy_info)
 MagickPrivate void PolicyComponentTerminus(void)
 {
   if (policy_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&policy_semaphore);
+    policy_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(policy_semaphore);
   if (policy_list != (LinkedListInfo *) NULL)
     policy_list=DestroyLinkedList(policy_list,DestroyPolicyElement);
   instantiate_policy=MagickFalse;
   UnlockSemaphoreInfo(policy_semaphore);
-  DestroySemaphoreInfo(&policy_semaphore);
+  RelinquishSemaphoreInfo(&policy_semaphore);
 }
diff --git a/MagickCore/quantum.c b/MagickCore/quantum.c
index 386474df2..914e4aefb 100644
--- a/MagickCore/quantum.c
+++ b/MagickCore/quantum.c
@@ -218,7 +218,7 @@ MagickExport QuantumInfo *DestroyQuantumInfo(QuantumInfo *quantum_info)
   if (quantum_info->pixels != (unsigned char **) NULL)
     DestroyQuantumPixels(quantum_info);
   if (quantum_info->semaphore != (SemaphoreInfo *) NULL)
-    DestroySemaphoreInfo(&quantum_info->semaphore);
+    RelinquishSemaphoreInfo(&quantum_info->semaphore);
   quantum_info->signature=(~MagickSignature);
   quantum_info=(QuantumInfo *) RelinquishMagickMemory(quantum_info);
   return(quantum_info);
@@ -421,7 +421,7 @@ MagickExport void GetQuantumInfo(const ImageInfo *image_info,
   quantum_info->maximum=1.0;
   quantum_info->scale=QuantumRange;
   quantum_info->pack=MagickTrue;
-  quantum_info->semaphore=AllocateSemaphoreInfo();
+  quantum_info->semaphore=AcquireSemaphoreInfo();
   quantum_info->signature=MagickSignature;
   if (image_info == (const ImageInfo *) NULL)
     return;
diff --git a/MagickCore/random.c b/MagickCore/random.c
index 0ab657122..b9990724f 100644
--- a/MagickCore/random.c
+++ b/MagickCore/random.c
@@ -192,7 +192,7 @@ MagickExport RandomInfo *AcquireRandomInfo(void)
   random_info->secret_key=secret_key;
   random_info->protocol_major=RandomProtocolMajorVersion;
   random_info->protocol_minor=RandomProtocolMinorVersion;
-  random_info->semaphore=AllocateSemaphoreInfo();
+  random_info->semaphore=AcquireSemaphoreInfo();
   random_info->timestamp=(ssize_t) time(0);
   random_info->signature=MagickSignature;
   /*
@@ -292,7 +292,7 @@ MagickExport RandomInfo *DestroyRandomInfo(RandomInfo *random_info)
   (void) ResetMagickMemory(random_info->seed,0,sizeof(*random_info->seed));
   random_info->signature=(~MagickSignature);
   UnlockSemaphoreInfo(random_info->semaphore);
-  DestroySemaphoreInfo(&random_info->semaphore);
+  RelinquishSemaphoreInfo(&random_info->semaphore);
   random_info=(RandomInfo *) RelinquishMagickMemory(random_info);
   return(random_info);
 }
@@ -737,7 +737,7 @@ MagickExport double GetRandomValue(RandomInfo *random_info)
 */
 MagickPrivate MagickBooleanType RandomComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&random_semaphore);
+  random_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -762,8 +762,8 @@ MagickPrivate MagickBooleanType RandomComponentGenesis(void)
 MagickPrivate void RandomComponentTerminus(void)
 {
   if (random_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&random_semaphore);
-  DestroySemaphoreInfo(&random_semaphore);
+    random_semaphore=AcquireSemaphoreInfo();
+  RelinquishSemaphoreInfo(&random_semaphore);
 }
 
 /*
diff --git a/MagickCore/registry.c b/MagickCore/registry.c
index 0c39f5903..f0592b7e9 100644
--- a/MagickCore/registry.c
+++ b/MagickCore/registry.c
@@ -300,7 +300,7 @@ MagickExport char *GetNextImageRegistry(void)
 */
 MagickPrivate MagickBooleanType RegistryComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&registry_semaphore);
+  registry_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -325,7 +325,7 @@ MagickPrivate MagickBooleanType RegistryComponentGenesis(void)
 MagickPrivate void RegistryComponentTerminus(void)
 {
   if (registry_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&registry_semaphore);
+    registry_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(registry_semaphore);
   if (IsEventLogging() != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
@@ -333,7 +333,7 @@ MagickPrivate void RegistryComponentTerminus(void)
     registry=DestroySplayTree(registry);
   instantiate_registry=MagickFalse;
   UnlockSemaphoreInfo(registry_semaphore);
-  DestroySemaphoreInfo(&registry_semaphore);
+  RelinquishSemaphoreInfo(&registry_semaphore);
 }
 
 /*
@@ -528,7 +528,7 @@ MagickExport MagickBooleanType SetImageRegistry(const RegistryType type,
       (instantiate_registry == MagickFalse))
     {
       if (registry_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&registry_semaphore);
+        registry_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(registry_semaphore);
       if ((registry == (SplayTreeInfo *) NULL) &&
           (instantiate_registry == MagickFalse))
diff --git a/MagickCore/resource.c b/MagickCore/resource.c
index 1e95728a0..9f99b64a1 100644
--- a/MagickCore/resource.c
+++ b/MagickCore/resource.c
@@ -167,7 +167,7 @@ MagickExport MagickBooleanType AcquireMagickResource(const ResourceType type,
   status=MagickFalse;
   (void) FormatMagickSize(size,MagickFalse,resource_request);
   if (resource_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&resource_semaphore);
+    resource_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -501,7 +501,7 @@ MagickExport int AcquireUniqueFileResource(char *path)
   if (file == -1)
     return(file);
   if (resource_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&resource_semaphore);
+    resource_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(resource_semaphore);
   if (temporary_resources == (SplayTreeInfo *) NULL)
     temporary_resources=NewSplayTree(CompareSplayTreeString,
@@ -619,7 +619,7 @@ MagickExport MagickSizeType GetMagickResourceLimit(const ResourceType type)
 
   resource=0;
   if (resource_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&resource_semaphore);
+    resource_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -708,7 +708,7 @@ MagickExport MagickBooleanType ListMagickResourceInfo(FILE *file,
   if (file == (const FILE *) NULL)
     file=stdout;
   if (resource_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&resource_semaphore);
+    resource_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(resource_semaphore);
   (void) FormatMagickSize(resource_info.area_limit,MagickFalse,area_limit);
   (void) FormatMagickSize(resource_info.memory_limit,MagickTrue,memory_limit);
@@ -770,7 +770,7 @@ MagickExport void RelinquishMagickResource(const ResourceType type,
 
   (void) FormatMagickSize(size,MagickFalse,resource_request);
   if (resource_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&resource_semaphore);
+    resource_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(resource_semaphore);
   switch (type)
   {
@@ -958,7 +958,7 @@ MagickPrivate MagickBooleanType ResourceComponentGenesis(void)
   /*
     Set Magick resource limits.
   */
-  AcquireSemaphoreInfo(&resource_semaphore);
+  resource_semaphore=AcquireSemaphoreInfo();
   pagesize=GetMagickPageSize();
   pages=(-1);
 #if defined(MAGICKCORE_HAVE_SYSCONF) && defined(_SC_PHYS_PAGES)
@@ -1075,14 +1075,14 @@ MagickPrivate MagickBooleanType ResourceComponentGenesis(void)
 MagickPrivate void ResourceComponentTerminus(void)
 {
   if (resource_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&resource_semaphore);
+    resource_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(resource_semaphore);
   if (temporary_resources != (SplayTreeInfo *) NULL)
     temporary_resources=DestroySplayTree(temporary_resources);
   if (random_info != (RandomInfo *) NULL)
     random_info=DestroyRandomInfo(random_info);
   UnlockSemaphoreInfo(resource_semaphore);
-  DestroySemaphoreInfo(&resource_semaphore);
+  RelinquishSemaphoreInfo(&resource_semaphore);
 }
 
 /*
@@ -1126,7 +1126,7 @@ MagickExport MagickBooleanType SetMagickResourceLimit(const ResourceType type,
     *value;
 
   if (resource_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&resource_semaphore);
+    resource_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(resource_semaphore);
   value=(char *) NULL;
   switch (type)
diff --git a/MagickCore/semaphore.c b/MagickCore/semaphore.c
index 5e327975c..033a0acc1 100644
--- a/MagickCore/semaphore.c
+++ b/MagickCore/semaphore.c
@@ -81,46 +81,11 @@ struct SemaphoreInfo
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  AcquireSemaphoreInfo() acquires a semaphore.
+%  AcquireSemaphoreInfo() initializes the SemaphoreInfo structure.
 %
 %  The format of the AcquireSemaphoreInfo method is:
 %
-%      void AcquireSemaphoreInfo(SemaphoreInfo **semaphore_info)
-%
-%  A description of each parameter follows:
-%
-%    o semaphore_info: Specifies a pointer to an SemaphoreInfo structure.
-%
-*/
-MagickExport void AcquireSemaphoreInfo(SemaphoreInfo **semaphore_info)
-{
-  assert(semaphore_info != (SemaphoreInfo **) NULL);
-  if (*semaphore_info == (SemaphoreInfo *) NULL)
-    {
-      InitializeMagickMutex();
-      LockMagickMutex();
-      if (*semaphore_info == (SemaphoreInfo *) NULL)
-        *semaphore_info=AllocateSemaphoreInfo();
-      UnlockMagickMutex();
-    }
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%   A l l o c a t e S e m a p h o r e I n f o                                 %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  AllocateSemaphoreInfo() initializes the SemaphoreInfo structure.
-%
-%  The format of the AllocateSemaphoreInfo method is:
-%
-%      SemaphoreInfo *AllocateSemaphoreInfo(void)
+%      SemaphoreInfo *AcquireSemaphoreInfo(void)
 %
 */
 
@@ -187,7 +152,7 @@ static void *RelinquishSemaphoreMemory(void *memory)
   return(NULL);
 }
 
-MagickExport SemaphoreInfo *AllocateSemaphoreInfo(void)
+MagickExport SemaphoreInfo *AcquireSemaphoreInfo(void)
 {
   SemaphoreInfo
     *semaphore_info;
@@ -271,58 +236,6 @@ MagickExport SemaphoreInfo *AllocateSemaphoreInfo(void)
 %                                                                             %
 %                                                                             %
 %                                                                             %
-%   D e s t r o y S e m a p h o r e I n f o                                   %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  DestroySemaphoreInfo() destroys a semaphore.
-%
-%  The format of the DestroySemaphoreInfo method is:
-%
-%      void DestroySemaphoreInfo(SemaphoreInfo **semaphore_info)
-%
-%  A description of each parameter follows:
-%
-%    o semaphore_info: Specifies a pointer to an SemaphoreInfo structure.
-%
-*/
-MagickExport void DestroySemaphoreInfo(SemaphoreInfo **semaphore_info)
-{
-  assert(semaphore_info != (SemaphoreInfo **) NULL);
-  assert((*semaphore_info) != (SemaphoreInfo *) NULL);
-  assert((*semaphore_info)->signature == MagickSignature);
-  InitializeMagickMutex();
-  LockMagickMutex();
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
-  omp_destroy_lock((omp_lock_t *) &(*semaphore_info)->mutex);
-#elif defined(MAGICKCORE_THREAD_SUPPORT)
-  {
-    int
-      status;
-
-    status=pthread_mutex_destroy(&(*semaphore_info)->mutex);
-    if (status != 0)
-      {
-        errno=status;
-        perror("unable to destroy mutex");
-        _exit(1);
-      }
-  }
-#elif defined(MAGICKCORE_HAVE_WINTHREADS)
-  DeleteCriticalSection(&(*semaphore_info)->mutex);
-#endif
-  (*semaphore_info)->signature=(~MagickSignature);
-  *semaphore_info=(SemaphoreInfo *) RelinquishSemaphoreMemory(*semaphore_info);
-  UnlockMagickMutex();
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
 %   L o c k S e m a p h o r e I n f o                                         %
 %                                                                             %
 %                                                                             %
@@ -379,28 +292,51 @@ MagickExport void LockSemaphoreInfo(SemaphoreInfo *semaphore_info)
 %                                                                             %
 %                                                                             %
 %                                                                             %
-%   R e l i n g u i s h S e m a p h o r e I n f o                             %
+%   R e l i n q u i s h S  e m a p h o r e I n f o                            %
 %                                                                             %
 %                                                                             %
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  RelinquishSemaphoreInfo() relinquishes a semaphore.
+%  RelinquishSemaphoreInfo() destroys a semaphore.
 %
 %  The format of the RelinquishSemaphoreInfo method is:
 %
-%      RelinquishSemaphoreInfo(SemaphoreInfo *semaphore_info)
+%      void RelinquishSemaphoreInfo(SemaphoreInfo **semaphore_info)
 %
 %  A description of each parameter follows:
 %
 %    o semaphore_info: Specifies a pointer to an SemaphoreInfo structure.
 %
 */
-MagickExport void RelinquishSemaphoreInfo(SemaphoreInfo *semaphore_info)
+MagickExport void RelinquishSemaphoreInfo(SemaphoreInfo **semaphore_info)
 {
-  assert(semaphore_info != (SemaphoreInfo *) NULL);
-  assert(semaphore_info->signature == MagickSignature);
-  UnlockSemaphoreInfo(semaphore_info);
+  assert(semaphore_info != (SemaphoreInfo **) NULL);
+  assert((*semaphore_info) != (SemaphoreInfo *) NULL);
+  assert((*semaphore_info)->signature == MagickSignature);
+  InitializeMagickMutex();
+  LockMagickMutex();
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+  omp_destroy_lock((omp_lock_t *) &(*semaphore_info)->mutex);
+#elif defined(MAGICKCORE_THREAD_SUPPORT)
+  {
+    int
+      status;
+
+    status=pthread_mutex_destroy(&(*semaphore_info)->mutex);
+    if (status != 0)
+      {
+        errno=status;
+        perror("unable to destroy mutex");
+        _exit(1);
+      }
+  }
+#elif defined(MAGICKCORE_HAVE_WINTHREADS)
+  DeleteCriticalSection(&(*semaphore_info)->mutex);
+#endif
+  (*semaphore_info)->signature=(~MagickSignature);
+  *semaphore_info=(SemaphoreInfo *) RelinquishSemaphoreMemory(*semaphore_info);
+  UnlockMagickMutex();
 }
 
 /*
diff --git a/MagickCore/semaphore.h b/MagickCore/semaphore.h
index 63c5318f7..80e5ee0bb 100644
--- a/MagickCore/semaphore.h
+++ b/MagickCore/semaphore.h
@@ -26,13 +26,11 @@ typedef struct SemaphoreInfo
   SemaphoreInfo;
 
 extern MagickExport SemaphoreInfo
-  *AllocateSemaphoreInfo(void);
+  *AcquireSemaphoreInfo(void);
 
 extern MagickExport void
-  AcquireSemaphoreInfo(SemaphoreInfo **),
-  DestroySemaphoreInfo(SemaphoreInfo **),
   LockSemaphoreInfo(SemaphoreInfo *),
-  RelinquishSemaphoreInfo(SemaphoreInfo *),
+  RelinquishSemaphoreInfo(SemaphoreInfo **),
   UnlockSemaphoreInfo(SemaphoreInfo *);
 
 #if defined(__cplusplus) || defined(c_plusplus)
diff --git a/MagickCore/splay-tree.c b/MagickCore/splay-tree.c
index 6c6c115e2..aaf1e68b8 100644
--- a/MagickCore/splay-tree.c
+++ b/MagickCore/splay-tree.c
@@ -735,7 +735,7 @@ MagickExport SplayTreeInfo *DestroySplayTree(SplayTreeInfo *splay_tree)
     }
   splay_tree->signature=(~MagickSignature);
   UnlockSemaphoreInfo(splay_tree->semaphore);
-  DestroySemaphoreInfo(&splay_tree->semaphore);
+  RelinquishSemaphoreInfo(&splay_tree->semaphore);
   splay_tree=(SplayTreeInfo *) RelinquishMagickMemory(splay_tree);
   return(splay_tree);
 }
@@ -1115,7 +1115,7 @@ MagickExport SplayTreeInfo *NewSplayTree(
   splay_tree->next=(void *) NULL;
   splay_tree->nodes=0;
   splay_tree->debug=IsEventLogging();
-  splay_tree->semaphore=AllocateSemaphoreInfo();
+  splay_tree->semaphore=AcquireSemaphoreInfo();
   splay_tree->signature=MagickSignature;
   return(splay_tree);
 }
diff --git a/MagickCore/stream.c b/MagickCore/stream.c
index 3fafba1ff..d32ae859d 100644
--- a/MagickCore/stream.c
+++ b/MagickCore/stream.c
@@ -236,9 +236,9 @@ static void DestroyPixelStream(Image *image)
     cache_info->nexus_info=DestroyPixelCacheNexus(cache_info->nexus_info,
       cache_info->number_threads);
   if (cache_info->file_semaphore != (SemaphoreInfo *) NULL)
-    DestroySemaphoreInfo(&cache_info->file_semaphore);
+    RelinquishSemaphoreInfo(&cache_info->file_semaphore);
   if (cache_info->semaphore != (SemaphoreInfo *) NULL)
-    DestroySemaphoreInfo(&cache_info->semaphore);
+    RelinquishSemaphoreInfo(&cache_info->semaphore);
   cache_info=(CacheInfo *) RelinquishMagickMemory(cache_info);
 }
 
diff --git a/MagickCore/type.c b/MagickCore/type.c
index 8e8f79d03..6d4879104 100644
--- a/MagickCore/type.c
+++ b/MagickCore/type.c
@@ -786,7 +786,7 @@ static MagickBooleanType InitializeTypeList(ExceptionInfo *exception)
       (instantiate_type == MagickFalse))
     {
       if (type_semaphore == (SemaphoreInfo *) NULL)
-        AcquireSemaphoreInfo(&type_semaphore);
+        type_semaphore=AcquireSemaphoreInfo();
       LockSemaphoreInfo(type_semaphore);
       if ((type_list == (SplayTreeInfo *) NULL) &&
           (instantiate_type == MagickFalse))
@@ -1365,7 +1365,7 @@ static MagickBooleanType LoadTypeLists(const char *filename,
 */
 MagickPrivate MagickBooleanType TypeComponentGenesis(void)
 {
-  AcquireSemaphoreInfo(&type_semaphore);
+  type_semaphore=AcquireSemaphoreInfo();
   return(MagickTrue);
 }
 
@@ -1390,11 +1390,11 @@ MagickPrivate MagickBooleanType TypeComponentGenesis(void)
 MagickPrivate void TypeComponentTerminus(void)
 {
   if (type_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&type_semaphore);
+    type_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(type_semaphore);
   if (type_list != (SplayTreeInfo *) NULL)
     type_list=DestroySplayTree(type_list);
   instantiate_type=MagickFalse;
   UnlockSemaphoreInfo(type_semaphore);
-  DestroySemaphoreInfo(&type_semaphore);
+  RelinquishSemaphoreInfo(&type_semaphore);
 }
diff --git a/MagickWand/wand.c b/MagickWand/wand.c
index ad3017e83..560e017c6 100644
--- a/MagickWand/wand.c
+++ b/MagickWand/wand.c
@@ -77,7 +77,7 @@ WandExport size_t AcquireWandId(void)
     id = 0;
 
   if (wand_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&wand_semaphore);
+    wand_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(wand_semaphore);
   if ((wand_ids == (SplayTreeInfo *) NULL) && IsMagickFalse(instantiate_wand))
     {
@@ -114,13 +114,13 @@ WandExport size_t AcquireWandId(void)
 WandExport void DestroyWandIds(void)
 {
   if (wand_semaphore == (SemaphoreInfo *) NULL)
-    AcquireSemaphoreInfo(&wand_semaphore);
+    wand_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(wand_semaphore);
   if (wand_ids != (SplayTreeInfo *) NULL)
     wand_ids=DestroySplayTree(wand_ids);
   instantiate_wand=MagickFalse;
   UnlockSemaphoreInfo(wand_semaphore);
-  DestroySemaphoreInfo(&wand_semaphore);
+  RelinquishSemaphoreInfo(&wand_semaphore);
 }
 
 /*
diff --git a/coders/png.c b/coders/png.c
index 37ac82d2f..d6b1d1363 100644
--- a/coders/png.c
+++ b/coders/png.c
@@ -7659,7 +7659,7 @@ ModuleExport size_t RegisterPNGImage(void)
   (void) RegisterMagickInfo(entry);
 
 #ifdef PNG_SETJMP_NOT_THREAD_SAFE
-  ping_semaphore=AllocateSemaphoreInfo();
+  ping_semaphore=AcquireSemaphoreInfo();
 #endif
 
   return(MagickImageCoderSignature);
@@ -7698,7 +7698,7 @@ ModuleExport void UnregisterPNGImage(void)
 
 #ifdef PNG_SETJMP_NOT_THREAD_SAFE
   if (ping_semaphore != (SemaphoreInfo *) NULL)
-    DestroySemaphoreInfo(&ping_semaphore);
+    RelinquishSemaphoreInfo(&ping_semaphore);
 #endif
 }
 
diff --git a/coders/tiff.c b/coders/tiff.c
index 4ed39fc5f..8a771e852 100644
--- a/coders/tiff.c
+++ b/coders/tiff.c
@@ -1873,7 +1873,7 @@ ModuleExport size_t RegisterTIFFImage(void)
     *entry;
 
   if (tiff_semaphore == (SemaphoreInfo *) NULL)
-    tiff_semaphore=AllocateSemaphoreInfo();
+    tiff_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(tiff_semaphore);
   if (instantiate_key == MagickFalse)
     {
@@ -2006,7 +2006,7 @@ ModuleExport void UnregisterTIFFImage(void)
   (void) UnregisterMagickInfo("TIF");
   (void) UnregisterMagickInfo("PTIF");
   if (tiff_semaphore == (SemaphoreInfo *) NULL)
-    tiff_semaphore=AllocateSemaphoreInfo();
+    tiff_semaphore=AcquireSemaphoreInfo();
   LockSemaphoreInfo(tiff_semaphore);
   if (instantiate_key != MagickFalse)
     {
@@ -2019,7 +2019,7 @@ ModuleExport void UnregisterTIFFImage(void)
       instantiate_key=MagickFalse;
     }
   UnlockSemaphoreInfo(tiff_semaphore);
-  DestroySemaphoreInfo(&tiff_semaphore);
+  RelinquishSemaphoreInfo(&tiff_semaphore);
 }
 
 #if defined(MAGICKCORE_TIFF_DELEGATE)