static size_t PingStream(const Image *magick_unused(image),
const void *magick_unused(pixels),const size_t columns)
{
magick_unreferenced(image);
magick_unreferenced(pixels);
return(columns);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C r e a t e M a g i c k T h r e a d K e y %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% CreateMagickThreadKey() creates a thread-specific data key visible to all
% threads in the process.
%
% The format of the CreateMagickThreadKey method is:
%
% MagickThreadKey CreateMagickThreadKey(MagickThreadKey *key)
%
% A description of each parameter follows:
%
% o key: opaque objects used to locate thread-specific data.
%
% o destructor: associate an optional destructor with each key value.
%
*/
MagickExport MagickBooleanType CreateMagickThreadKey(MagickThreadKey *key,
void (*destructor)(void *))
{
#if defined(MAGICKCORE_THREAD_SUPPORT)
return(pthread_key_create(key,destructor) == 0 ? MagickTrue : MagickFalse);
#elif defined(MAGICKCORE_WINDOWS_SUPPORT)
magick_unreferenced(destructor);
*key=TlsAlloc();
return(*key != TLS_OUT_OF_INDEXES ? MagickTrue : MagickFalse);
#else
{
MagickThreadValue
**keys;
keys=(MagickThreadValue **) key;
*keys=(MagickThreadValue *) AcquireQuantumMemory(1,sizeof(*keys));
if (*keys != (MagickThreadValue *) NULL)
{
(*keys)->number_threads=GetOpenMPMaximumThreads();
(*keys)->values=AcquireQuantumMemory((*keys)->number_threads,
sizeof(void *));
if ((*keys)->values == (void *) NULL)
*keys=RelinquishMagickMemory(*keys);
else
(void) memset((*keys)->values,0,(*keys)->number_threads*
sizeof(void *));
(*keys)->destructor=destructor;
}
return((*keys != (MagickThreadValue *) NULL) ? MagickTrue : MagickFalse);
}
#endif
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% A c q u i r e V i r t u a l C a c h e V i e w %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% AcquireVirtualCacheView() acquires a virtual view into the pixel cache,
% using the VirtualPixelMethod that is defined within the given image itself.
% It always succeeds but may return a warning or informational exception.
%
% The format of the AcquireVirtualCacheView method is:
%
% CacheView *AcquireVirtualCacheView(const Image *image,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport CacheView *AcquireVirtualCacheView(const Image *image,
ExceptionInfo *exception)
{
CacheView
*magick_restrict cache_view;
magick_unreferenced(exception);
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
#if defined(MAGICKCORE_OPENCL_SUPPORT)
SyncAuthenticOpenCLBuffer(image);
#endif
cache_view=(CacheView *) MagickAssumeAligned(AcquireAlignedMemory(1,
sizeof(*cache_view)));
if (cache_view == (CacheView *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) memset(cache_view,0,sizeof(*cache_view));
cache_view->image=ReferenceImage((Image *) image);
cache_view->number_threads=GetOpenMPMaximumThreads();
if (GetMagickResourceLimit(ThreadResource) > cache_view->number_threads)
cache_view->number_threads=(size_t) GetMagickResourceLimit(ThreadResource);
if (cache_view->number_threads == 0)
cache_view->number_threads=1;
cache_view->nexus_info=AcquirePixelCacheNexus(cache_view->number_threads);
cache_view->virtual_pixel_method=GetImageVirtualPixelMethod(image);
cache_view->debug=IsEventLogging();
cache_view->signature=MagickCoreSignature;
if (cache_view->nexus_info == (NexusInfo **) NULL)
ThrowFatalException(CacheFatalError,"UnableToAcquireCacheView");
return(cache_view);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% L i s t M a g i c k R e s o u r c e I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ListMagickResourceInfo() lists the resource info to a file.
%
% The format of the ListMagickResourceInfo method is:
%
% MagickBooleanType ListMagickResourceInfo(FILE *file,
% ExceptionInfo *exception)
%
% A description of each parameter follows.
%
% o file: An pointer to a FILE.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport MagickBooleanType ListMagickResourceInfo(FILE *file,
ExceptionInfo *magick_unused(exception))
{
char
area_limit[MagickFormatExtent],
disk_limit[MagickFormatExtent],
height_limit[MagickFormatExtent],
map_limit[MagickFormatExtent],
memory_limit[MagickFormatExtent],
time_limit[MagickFormatExtent],
width_limit[MagickFormatExtent];
magick_unreferenced(exception);
if (file == (const FILE *) NULL)
file=stdout;
if (resource_semaphore == (SemaphoreInfo *) NULL)
ActivateSemaphoreInfo(&resource_semaphore);
LockSemaphoreInfo(resource_semaphore);
(void) FormatMagickSize(resource_info.width_limit,MagickFalse,"P",
MagickFormatExtent,width_limit);
(void) FormatMagickSize(resource_info.height_limit,MagickFalse,"P",
MagickFormatExtent,height_limit);
(void) FormatMagickSize(resource_info.area_limit,MagickFalse,"B",
MagickFormatExtent,area_limit);
(void) FormatMagickSize(resource_info.memory_limit,MagickTrue,"B",
MagickFormatExtent,memory_limit);
(void) FormatMagickSize(resource_info.map_limit,MagickTrue,"B",
MagickFormatExtent,map_limit);
(void) CopyMagickString(disk_limit,"unlimited",MagickFormatExtent);
if (resource_info.disk_limit != MagickResourceInfinity)
(void) FormatMagickSize(resource_info.disk_limit,MagickTrue,"B",
MagickFormatExtent,disk_limit);
(void) CopyMagickString(time_limit,"unlimited",MagickFormatExtent);
if (resource_info.time_limit != MagickResourceInfinity)
(void) FormatLocaleString(time_limit,MagickFormatExtent,"%.20g",(double)
((MagickOffsetType) resource_info.time_limit));
(void) FormatLocaleFile(file,"Resource limits:\n");
(void) FormatLocaleFile(file," Width: %s\n",width_limit);
(void) FormatLocaleFile(file," Height: %s\n",height_limit);
(void) FormatLocaleFile(file," Area: %s\n",area_limit);
(void) FormatLocaleFile(file," Memory: %s\n",memory_limit);
(void) FormatLocaleFile(file," Map: %s\n",map_limit);
(void) FormatLocaleFile(file," Disk: %s\n",disk_limit);
(void) FormatLocaleFile(file," File: %.20g\n",(double) ((MagickOffsetType)
resource_info.file_limit));
(void) FormatLocaleFile(file," Thread: %.20g\n",(double) ((MagickOffsetType)
resource_info.thread_limit));
(void) FormatLocaleFile(file," Throttle: %.20g\n",(double)
((MagickOffsetType) resource_info.throttle_limit));
(void) FormatLocaleFile(file," Time: %s\n",time_limit);
(void) fflush(file);
UnlockSemaphoreInfo(resource_semaphore);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ D e f a u l t W a r n i n g H a n d l e r %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% DefaultWarningHandler() displays a warning reason.
%
% The format of the DefaultWarningHandler method is:
%
% void DefaultWarningHandler(const ExceptionType severity,
% const char *reason,const char *description)
%
% A description of each parameter follows:
%
% o severity: Specifies the numeric warning category.
%
% o reason: Specifies the reason to display before terminating the
% program.
%
% o description: Specifies any description to the reason.
%
*/
static void DefaultWarningHandler(const ExceptionType magick_unused(severity),
const char *reason,const char *description)
{
magick_unreferenced(severity);
if (reason == (char *) NULL)
return;
(void) FormatLocaleFile(stderr,"%s: %s",GetClientName(),reason);
if (description != (char *) NULL)
(void) FormatLocaleFile(stderr," (%s)",description);
(void) FormatLocaleFile(stderr,".\n");
(void) fflush(stderr);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e M P R I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WriteMPRImage() writes an image into the Magick Persistent Registry
% image as a blob from memory. It allocates the memory necessary for the
% new Image structure and returns a pointer to the new image.
%
% The format of the WriteMPRImage method is:
%
% MagickBooleanType WriteMPRImage(const ImageInfo *image_info,
% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
% o image_info: the image info.
%
% o image: The image.
%
% o exception: return any errors or warnings in this structure.
%
*/
static MagickBooleanType WriteMPRImage(const ImageInfo *image_info,Image *image,
ExceptionInfo *exception)
{
MagickBooleanType
status;
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickCoreSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
magick_unreferenced(image_info);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=SetImageRegistry(ImageRegistryType,image->filename,image,exception);
return(status);
}
MagickExport MagickBooleanType SetMagickSecurityPolicyValue(
const PolicyDomain domain,const char *name,const char *value,
ExceptionInfo *exception)
{
char
*current_value;
magick_unreferenced(exception);
assert(exception != (ExceptionInfo *) NULL);
if ((name == (const char *) NULL) || (value == (const char *) NULL))
return(MagickFalse);
switch(domain)
{
case CachePolicyDomain:
{
if (LocaleCompare(name,"memory-map") == 0)
{
if (LocaleCompare(value,"anonymous") != 0)
return(MagickFalse);
ResetCacheAnonymousMemory();
ResetStreamAnonymousMemory();
return(SetPolicyValue(domain,name,value));
}
if (LocaleCompare(name,"synchronize") == 0)
return(SetPolicyValue(domain,name,value));
break;
}
case ResourcePolicyDomain:
{
ssize_t
type;
if (LocaleCompare(name,"temporary-path") == 0)
return(SetPolicyValue(domain,name,value));
type=ParseCommandOption(MagickResourceOptions,MagickFalse,name);
if (type >= 0)
{
MagickSizeType
limit;
limit=MagickResourceInfinity;
if (LocaleCompare("unlimited",value) != 0)
limit=StringToMagickSizeType(value,100.0);
return(SetMagickResourceLimit((ResourceType) type,limit));
}
break;
}
case SystemPolicyDomain:
{
if (LocaleCompare(name,"max-memory-request") == 0)
{
current_value=GetPolicyValue("system:max-memory-request");
if ((current_value == (char *) NULL) ||
(StringToSizeType(value,100.0) < StringToSizeType(current_value,100.0)))
{
ResetMaxMemoryRequest();
return(SetPolicyValue(domain,name,value));
}
}
if (LocaleCompare(name,"memory-map") == 0)
{
if (LocaleCompare(value,"anonymous") != 0)
return(MagickFalse);
ResetVirtualAnonymousMemory();
return(SetPolicyValue(domain,name,value));
}
if (LocaleCompare(name,"precision") == 0)
{
ResetMagickPrecision();
return(SetPolicyValue(domain,name,value));
}
if (LocaleCompare(name,"shred") == 0)
{
current_value=GetPolicyValue("system:shred");
if ((current_value == (char *) NULL) ||
(StringToInteger(value) > StringToInteger(current_value)))
return(SetPolicyValue(domain,name,value));
}
break;
}
case CoderPolicyDomain:
case DelegatePolicyDomain:
case FilterPolicyDomain:
case ModulePolicyDomain:
case PathPolicyDomain:
default:
break;
}
return(MagickFalse);
}
