*/
MagickPrivate MagickBooleanType AnnotateComponentGenesis(void)
{
- AcquireSemaphoreInfo(&annotate_semaphore);
+ annotate_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
MagickPrivate void AnnotateComponentTerminus(void)
{
if (annotate_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&annotate_semaphore);
- DestroySemaphoreInfo(&annotate_semaphore);
+ annotate_semaphore=AcquireSemaphoreInfo();
+ RelinquishSemaphoreInfo(&annotate_semaphore);
}
\f
/*
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);
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);
}
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;
}
\f
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);
*/
MagickPrivate MagickBooleanType CacheComponentGenesis(void)
{
- AcquireSemaphoreInfo(&cache_semaphore);
+ cache_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
}
\f
/*
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;
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;
image->cache=clone_image.cache;
}
}
- DestroySemaphoreInfo(&clone_image.semaphore);
+ RelinquishSemaphoreInfo(&clone_image.semaphore);
}
UnlockSemaphoreInfo(cache_info->semaphore);
}
*/
MagickPrivate MagickBooleanType CoderComponentGenesis(void)
{
- AcquireSemaphoreInfo(&coder_semaphore);
+ coder_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
}
\f
/*
(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))
*/
MagickPrivate MagickBooleanType ColorComponentGenesis(void)
{
- AcquireSemaphoreInfo(&color_semaphore);
+ color_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
}
\f
/*
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))
*/
MagickPrivate MagickBooleanType ConfigureComponentGenesis(void)
{
- AcquireSemaphoreInfo(&configure_semaphore);
+ configure_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
}
\f
/*
(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))
*/
MagickPrivate MagickBooleanType ConstituteComponentGenesis(void)
{
- AcquireSemaphoreInfo(&constitute_semaphore);
+ constitute_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
MagickPrivate void ConstituteComponentTerminus(void)
{
if (constitute_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&constitute_semaphore);
- DestroySemaphoreInfo(&constitute_semaphore);
+ constitute_semaphore=AcquireSemaphoreInfo();
+ RelinquishSemaphoreInfo(&constitute_semaphore);
}
\f
/*
}
image=NewImageList();
if (constitute_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&constitute_semaphore);
+ constitute_semaphore=AcquireSemaphoreInfo();
if ((magick_info == (const MagickInfo *) NULL) ||
(GetImageDecoder(magick_info) == (DecodeImageHandler *) NULL))
{
}
}
if (constitute_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&constitute_semaphore);
+ constitute_semaphore=AcquireSemaphoreInfo();
if ((magick_info != (const MagickInfo *) NULL) &&
(GetImageEncoder(magick_info) != (EncodeImageHandler *) NULL))
{
*/
MagickPrivate MagickBooleanType DelegateComponentGenesis(void)
{
- AcquireSemaphoreInfo(&delegate_semaphore);
+ delegate_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
}
\f
/*
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))
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)
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);
(void) ResetMagickMemory(exception,0,sizeof(*exception));
exception->severity=UndefinedException;
exception->exceptions=(void *) NewLinkedList(0);
- exception->semaphore=AllocateSemaphoreInfo();
+ exception->semaphore=AcquireSemaphoreInfo();
exception->signature=MagickSignature;
}
\f
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);
}
}
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);
}
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);
}
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);
}
}
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(
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);
}
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)
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);
(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))
*/
MagickPrivate MagickBooleanType LocaleComponentGenesis(void)
{
- AcquireSemaphoreInfo(&locale_semaphore);
+ locale_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
#endif
instantiate_locale=MagickFalse;
UnlockSemaphoreInfo(locale_semaphore);
- DestroySemaphoreInfo(&locale_semaphore);
+ RelinquishSemaphoreInfo(&locale_semaphore);
}
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))
ExceptionInfo
*exception;
- AcquireSemaphoreInfo(&log_semaphore);
+ log_semaphore=AcquireSemaphoreInfo();
exception=AcquireExceptionInfo();
(void) GetLogInfo("*",exception);
exception=DestroyExceptionInfo(exception);
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);
}
\f
/*
(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))
*/
MagickPrivate MagickBooleanType MagicComponentGenesis(void)
{
- AcquireSemaphoreInfo(&magic_semaphore);
+ magic_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
}
(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))
*/
MagickPrivate MagickBooleanType MagickComponentGenesis(void)
{
- AcquireSemaphoreInfo(&magick_semaphore);
+ magick_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
}
\f
/*
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);
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++)
memory_pool.segments[i]->length);
free_segments=(DataSegmentInfo *) NULL;
(void) ResetMagickMemory(&memory_pool,0,sizeof(memory_pool));
- DestroySemaphoreInfo(&memory_semaphore);
+ RelinquishSemaphoreInfo(&memory_semaphore);
#endif
}
\f
(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))
*/
MagickPrivate MagickBooleanType MimeComponentGenesis(void)
{
- AcquireSemaphoreInfo(&mime_semaphore);
+ mime_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
}
(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))
MagickBooleanType
status;
- AcquireSemaphoreInfo(&module_semaphore);
+ module_semaphore=AcquireSemaphoreInfo();
exception=AcquireExceptionInfo();
status=InitializeModuleList(exception);
exception=DestroyExceptionInfo(exception);
MagickPrivate void ModuleComponentTerminus(void)
{
if (module_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&module_semaphore);
+ module_semaphore=AcquireSemaphoreInfo();
DestroyModuleList();
- DestroySemaphoreInfo(&module_semaphore);
+ RelinquishSemaphoreInfo(&module_semaphore);
}
\f
/*
if (clEnv != NULL)
{
memset(clEnv, 0, sizeof(struct _MagickCLEnv));
- AcquireSemaphoreInfo(&clEnv->lock);
+ clEnv->lock=AcquireSemaphoreInfo();
}
return clEnv;
}
{
if (defaultCLEnvLock == NULL)
{
- AcquireSemaphoreInfo(&defaultCLEnvLock);
+ defaultCLEnvLock=AcquireSemaphoreInfo();
}
LockSemaphoreInfo(defaultCLEnvLock);
defaultCLEnv = AcquireMagickOpenCLEnv();
static void LockDefaultOpenCLEnv() {
if (defaultCLEnvLock == NULL)
{
- AcquireSemaphoreInfo(&defaultCLEnvLock);
+ defaultCLEnvLock=AcquireSemaphoreInfo();
}
LockSemaphoreInfo(defaultCLEnvLock);
}
static void UnlockDefaultOpenCLEnv() {
if (defaultCLEnvLock == NULL)
{
- AcquireSemaphoreInfo(&defaultCLEnvLock);
+ defaultCLEnvLock=AcquireSemaphoreInfo();
}
else
UnlockSemaphoreInfo(defaultCLEnvLock);
if (openclCachedFilesDirectory == NULL) {
if (openclCachedFilesDirectoryLock == NULL)
{
- AcquireSemaphoreInfo(&openclCachedFilesDirectoryLock);
+ openclCachedFilesDirectoryLock=AcquireSemaphoreInfo();
}
LockSemaphoreInfo(openclCachedFilesDirectoryLock);
if (openclCachedFilesDirectory == NULL) {
(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))
*/
MagickPrivate MagickBooleanType PolicyComponentGenesis(void)
{
- AcquireSemaphoreInfo(&policy_semaphore);
+ policy_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
}
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);
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;
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;
/*
(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);
}
*/
MagickPrivate MagickBooleanType RandomComponentGenesis(void)
{
- AcquireSemaphoreInfo(&random_semaphore);
+ random_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
MagickPrivate void RandomComponentTerminus(void)
{
if (random_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&random_semaphore);
- DestroySemaphoreInfo(&random_semaphore);
+ random_semaphore=AcquireSemaphoreInfo();
+ RelinquishSemaphoreInfo(&random_semaphore);
}
\f
/*
*/
MagickPrivate MagickBooleanType RegistryComponentGenesis(void)
{
- AcquireSemaphoreInfo(®istry_semaphore);
+ registry_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
MagickPrivate void RegistryComponentTerminus(void)
{
if (registry_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(®istry_semaphore);
+ registry_semaphore=AcquireSemaphoreInfo();
LockSemaphoreInfo(registry_semaphore);
if (IsEventLogging() != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
registry=DestroySplayTree(registry);
instantiate_registry=MagickFalse;
UnlockSemaphoreInfo(registry_semaphore);
- DestroySemaphoreInfo(®istry_semaphore);
+ RelinquishSemaphoreInfo(®istry_semaphore);
}
\f
/*
(instantiate_registry == MagickFalse))
{
if (registry_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(®istry_semaphore);
+ registry_semaphore=AcquireSemaphoreInfo();
LockSemaphoreInfo(registry_semaphore);
if ((registry == (SplayTreeInfo *) NULL) &&
(instantiate_registry == MagickFalse))
status=MagickFalse;
(void) FormatMagickSize(size,MagickFalse,resource_request);
if (resource_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&resource_semaphore);
+ resource_semaphore=AcquireSemaphoreInfo();
LockSemaphoreInfo(resource_semaphore);
switch (type)
{
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,
resource=0;
if (resource_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&resource_semaphore);
+ resource_semaphore=AcquireSemaphoreInfo();
LockSemaphoreInfo(resource_semaphore);
switch (type)
{
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);
(void) FormatMagickSize(size,MagickFalse,resource_request);
if (resource_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&resource_semaphore);
+ resource_semaphore=AcquireSemaphoreInfo();
LockSemaphoreInfo(resource_semaphore);
switch (type)
{
/*
Set Magick resource limits.
*/
- AcquireSemaphoreInfo(&resource_semaphore);
+ resource_semaphore=AcquireSemaphoreInfo();
pagesize=GetMagickPageSize();
pages=(-1);
#if defined(MAGICKCORE_HAVE_SYSCONF) && defined(_SC_PHYS_PAGES)
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);
}
\f
/*
*value;
if (resource_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&resource_semaphore);
+ resource_semaphore=AcquireSemaphoreInfo();
LockSemaphoreInfo(resource_semaphore);
value=(char *) NULL;
switch (type)
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% 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();
- }
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% 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)
%
*/
return(NULL);
}
-MagickExport SemaphoreInfo *AllocateSemaphoreInfo(void)
+MagickExport SemaphoreInfo *AcquireSemaphoreInfo(void)
{
SemaphoreInfo
*semaphore_info;
% %
% %
% %
-% 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();
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% L o c k S e m a p h o r e I n f o %
% %
% %
% %
% %
% %
-% 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();
}
\f
/*
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)
}
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);
}
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);
}
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);
}
\f
(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))
*/
MagickPrivate MagickBooleanType TypeComponentGenesis(void)
{
- AcquireSemaphoreInfo(&type_semaphore);
+ type_semaphore=AcquireSemaphoreInfo();
return(MagickTrue);
}
\f
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);
}
id = 0;
if (wand_semaphore == (SemaphoreInfo *) NULL)
- AcquireSemaphoreInfo(&wand_semaphore);
+ wand_semaphore=AcquireSemaphoreInfo();
LockSemaphoreInfo(wand_semaphore);
if ((wand_ids == (SplayTreeInfo *) NULL) && IsMagickFalse(instantiate_wand))
{
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);
}
\f
/*
(void) RegisterMagickInfo(entry);
#ifdef PNG_SETJMP_NOT_THREAD_SAFE
- ping_semaphore=AllocateSemaphoreInfo();
+ ping_semaphore=AcquireSemaphoreInfo();
#endif
return(MagickImageCoderSignature);
#ifdef PNG_SETJMP_NOT_THREAD_SAFE
if (ping_semaphore != (SemaphoreInfo *) NULL)
- DestroySemaphoreInfo(&ping_semaphore);
+ RelinquishSemaphoreInfo(&ping_semaphore);
#endif
}
\f
*entry;
if (tiff_semaphore == (SemaphoreInfo *) NULL)
- tiff_semaphore=AllocateSemaphoreInfo();
+ tiff_semaphore=AcquireSemaphoreInfo();
LockSemaphoreInfo(tiff_semaphore);
if (instantiate_key == MagickFalse)
{
(void) UnregisterMagickInfo("TIF");
(void) UnregisterMagickInfo("PTIF");
if (tiff_semaphore == (SemaphoreInfo *) NULL)
- tiff_semaphore=AllocateSemaphoreInfo();
+ tiff_semaphore=AcquireSemaphoreInfo();
LockSemaphoreInfo(tiff_semaphore);
if (instantiate_key != MagickFalse)
{
instantiate_key=MagickFalse;
}
UnlockSemaphoreInfo(tiff_semaphore);
- DestroySemaphoreInfo(&tiff_semaphore);
+ RelinquishSemaphoreInfo(&tiff_semaphore);
}
\f
#if defined(MAGICKCORE_TIFF_DELEGATE)