43 #include "MagickCore/studio.h"
44 #include "MagickCore/annotate-private.h"
45 #include "MagickCore/blob.h"
46 #include "MagickCore/blob-private.h"
47 #include "MagickCore/cache.h"
48 #include "MagickCore/cache-private.h"
49 #include "MagickCore/coder-private.h"
50 #include "MagickCore/client.h"
51 #include "MagickCore/color-private.h"
52 #include "MagickCore/configure-private.h"
53 #include "MagickCore/constitute-private.h"
54 #include "MagickCore/delegate-private.h"
55 #include "MagickCore/draw.h"
56 #include "MagickCore/exception.h"
57 #include "MagickCore/exception-private.h"
58 #include "MagickCore/locale-private.h"
59 #include "MagickCore/log-private.h"
60 #include "MagickCore/magic-private.h"
61 #include "MagickCore/magick.h"
62 #include "MagickCore/magick-private.h"
63 #include "MagickCore/memory_.h"
64 #include "MagickCore/mime-private.h"
65 #include "MagickCore/monitor-private.h"
66 #include "MagickCore/module.h"
67 #include "MagickCore/module-private.h"
68 #include "MagickCore/mutex.h"
69 #include "MagickCore/nt-base-private.h"
70 #include "MagickCore/nt-feature.h"
71 #include "MagickCore/opencl-private.h"
72 #include "MagickCore/option-private.h"
73 #include "MagickCore/random-private.h"
74 #include "MagickCore/registry.h"
75 #include "MagickCore/registry-private.h"
76 #include "MagickCore/resource_.h"
77 #include "MagickCore/resource-private.h"
78 #include "MagickCore/policy.h"
79 #include "MagickCore/policy-private.h"
80 #include "MagickCore/mutex.h"
81 #include "MagickCore/semaphore.h"
82 #include "MagickCore/semaphore-private.h"
83 #include "MagickCore/signature-private.h"
84 #include "MagickCore/splay-tree.h"
85 #include "MagickCore/static.h"
86 #include "MagickCore/string_.h"
87 #include "MagickCore/string-private.h"
88 #include "MagickCore/thread_.h"
89 #include "MagickCore/thread-private.h"
90 #include "MagickCore/type-private.h"
91 #include "MagickCore/token.h"
92 #include "MagickCore/utility.h"
93 #include "MagickCore/utility-private.h"
94 #include "MagickCore/xwindow-private.h"
95 #if defined(MAGICKCORE_XML_DELEGATE)
96 # if defined(MAGICKCORE_WINDOWS_SUPPORT)
97 # if !defined(__MINGW32__)
98 # include <win32config.h>
101 # include <libxml/parser.h>
107 #if !defined(SIG_DFL)
108 # define SIG_DFL ((SignalHandler *) 0)
110 #if !defined(SIG_ERR)
111 # define SIG_ERR ((SignalHandler *) -1)
120 typedef void SignalHandler(
int);
129 *signal_handlers[SIGMAX] = { (SignalHandler *) NULL };
134 static volatile MagickBooleanType
135 magickcore_instantiated = MagickFalse,
136 magickcore_signal_in_progress = MagickFalse,
137 magick_list_initialized = MagickFalse;
140 magick_precision = 0;
145 static MagickBooleanType
179 MagickExport
MagickInfo *AcquireMagickInfo(
const char *magick_module,
180 const char *name,
const char *description)
185 assert(magick_module != (
const char *) NULL);
186 assert(name != (
const char *) NULL);
187 assert(description != (
const char *) NULL);
188 if (IsEventLogging() != MagickFalse)
189 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",name);
190 magick_info=(
MagickInfo *) AcquireCriticalMemory(
sizeof(*magick_info));
191 (void) memset(magick_info,0,
sizeof(*magick_info));
192 magick_info->magick_module=ConstantString(magick_module);
193 magick_info->name=ConstantString(name);
194 magick_info->description=ConstantString(description);
195 magick_info->flags=CoderAdjoinFlag | CoderBlobSupportFlag |
196 CoderDecoderThreadSupportFlag | CoderEncoderThreadSupportFlag |
197 CoderUseExtensionFlag;
198 magick_info->signature=MagickCoreSignature;
224 MagickExport DecodeImageHandler *GetImageDecoder(
const MagickInfo *magick_info)
227 return((DecodeImageHandler *) NULL);
228 assert(magick_info->signature == MagickCoreSignature);
229 return(magick_info->decoder);
254 MagickExport EncodeImageHandler *GetImageEncoder(
const MagickInfo *magick_info)
257 return((EncodeImageHandler *) NULL);
258 assert(magick_info->signature == MagickCoreSignature);
259 return(magick_info->encoder);
291 MagickExport MagickBooleanType GetImageMagick(
const unsigned char *magick,
292 const size_t length,
char *format)
303 assert(magick != (
const unsigned char *) NULL);
304 if (IsEventLogging() != MagickFalse)
305 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
306 exception=AcquireExceptionInfo();
307 p=GetMagickInfo(
"*",exception);
308 exception=DestroyExceptionInfo(exception);
312 LockSemaphoreInfo(magick_semaphore);
313 ResetSplayTreeIterator(magick_list);
314 p=(
const MagickInfo *) GetNextValueInSplayTree(magick_list);
317 if ((p->magick != (IsImageFormatHandler *) NULL) &&
318 (p->magick(magick,length) != 0))
321 (void) CopyMagickString(format,p->name,MagickPathExtent);
324 p=(
const MagickInfo *) GetNextValueInSplayTree(magick_list);
326 UnlockSemaphoreInfo(magick_semaphore);
352 MagickExport MagickBooleanType GetMagickAdjoin(
const MagickInfo *magick_info)
355 assert(magick_info->signature == MagickCoreSignature);
356 return(((magick_info->flags & CoderAdjoinFlag) == 0) ? MagickFalse :
382 MagickExport MagickBooleanType GetMagickBlobSupport(
386 assert(magick_info->signature == MagickCoreSignature);
387 return(((magick_info->flags & CoderBlobSupportFlag) == 0) ? MagickFalse :
415 MagickExport MagickBooleanType GetMagickDecoderSeekableStream(
419 assert(magick_info->signature == MagickCoreSignature);
420 if ((magick_info->flags & CoderDecoderSeekableStreamFlag) == 0)
449 MagickExport MagickBooleanType GetMagickDecoderThreadSupport(
453 assert(magick_info->signature == MagickCoreSignature);
454 return(((magick_info->flags & CoderDecoderThreadSupportFlag) == 0) ?
455 MagickFalse : MagickTrue);
480 MagickExport
const char *GetMagickDescription(
const MagickInfo *magick_info)
483 assert(magick_info->signature == MagickCoreSignature);
484 return(magick_info->description);
511 MagickExport MagickBooleanType GetMagickEncoderSeekableStream(
515 assert(magick_info->signature == MagickCoreSignature);
516 if ((magick_info->flags & CoderEncoderSeekableStreamFlag) == 0)
545 MagickExport MagickBooleanType GetMagickEncoderThreadSupport(
549 assert(magick_info->signature == MagickCoreSignature);
550 return(((magick_info->flags & CoderDecoderThreadSupportFlag) == 0) ?
551 MagickFalse : MagickTrue);
577 MagickExport MagickBooleanType GetMagickEndianSupport(
581 assert(magick_info->signature == MagickCoreSignature);
582 return(((magick_info->flags & CoderEndianSupportFlag) == 0) ? MagickFalse :
612 MagickExport
const MagickInfo *GetMagickInfo(
const char *name,
622 if (IsMagickTreeInstantiated(exception) == MagickFalse)
625 if ((name != (
const char *) NULL) && (*name !=
'\0'))
627 LockSemaphoreInfo(magick_semaphore);
628 if (LocaleCompare(name,
"*") == 0)
629 #if defined(MAGICKCORE_BUILD_MODULES)
630 (void) OpenModules(exception);
632 RegisterStaticModules();
636 magick_info=(
const MagickInfo *) GetValueFromSplayTree(magick_list,
639 #
if defined(MAGICKCORE_BUILD_MODULES)
640 (void) OpenModule(name,exception);
642 (void) RegisterStaticModule(name,exception);
645 UnlockSemaphoreInfo(magick_semaphore);
647 if ((name == (
const char *) NULL) || (LocaleCompare(name,
"*") == 0))
648 return((
const MagickInfo *) GetRootValueFromSplayTree(magick_list));
650 magick_info=(
const MagickInfo *) GetValueFromSplayTree(magick_list,name);
683 #if defined(__cplusplus) || defined(c_plusplus)
687 static int MagickInfoCompare(
const void *x,
const void *y)
695 return(LocaleCompare((*p)->name,(*q)->name));
698 #if defined(__cplusplus) || defined(c_plusplus)
702 MagickExport
const MagickInfo **GetMagickInfoList(
const char *pattern,
717 assert(pattern != (
char *) NULL);
718 assert(number_formats != (
size_t *) NULL);
719 if (IsEventLogging() != MagickFalse)
720 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",pattern);
722 p=GetMagickInfo(
"*",exception);
725 formats=(
const MagickInfo **) AcquireQuantumMemory((
size_t)
726 GetNumberOfNodesInSplayTree(magick_list)+1UL,
sizeof(*formats));
732 LockSemaphoreInfo(magick_semaphore);
733 ResetSplayTreeIterator(magick_list);
734 p=(
const MagickInfo *) GetNextValueInSplayTree(magick_list);
737 if ((GetMagickStealth(p) == MagickFalse) &&
738 (GlobExpression(p->name,pattern,MagickFalse) != MagickFalse))
740 p=(
const MagickInfo *) GetNextValueInSplayTree(magick_list);
742 UnlockSemaphoreInfo(magick_semaphore);
743 qsort((
void *) formats,(
size_t) i,
sizeof(*formats),MagickInfoCompare);
745 *number_formats=(size_t) i;
777 #if defined(__cplusplus) || defined(c_plusplus)
781 static int MagickCompare(
const void *x,
const void *y)
789 return(LocaleCompare(*p,*q));
792 #if defined(__cplusplus) || defined(c_plusplus)
796 MagickExport
char **GetMagickList(
const char *pattern,
811 assert(pattern != (
char *) NULL);
812 assert(number_formats != (
size_t *) NULL);
813 if (IsEventLogging() != MagickFalse)
814 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",pattern);
816 p=GetMagickInfo(
"*",exception);
818 return((
char **) NULL);
819 formats=(
char **) AcquireQuantumMemory((
size_t)
820 GetNumberOfNodesInSplayTree(magick_list)+1UL,
sizeof(*formats));
821 if (formats == (
char **) NULL)
822 return((
char **) NULL);
823 LockSemaphoreInfo(magick_semaphore);
824 ResetSplayTreeIterator(magick_list);
825 p=(
const MagickInfo *) GetNextValueInSplayTree(magick_list);
828 if ((GetMagickStealth(p) == MagickFalse) &&
829 (GlobExpression(p->name,pattern,MagickFalse) != MagickFalse))
830 formats[i++]=ConstantString(p->name);
831 p=(
const MagickInfo *) GetNextValueInSplayTree(magick_list);
833 UnlockSemaphoreInfo(magick_semaphore);
834 qsort((
void *) formats,(
size_t) i,
sizeof(*formats),MagickCompare);
835 formats[i]=(
char *) NULL;
836 *number_formats=(size_t) i;
862 MagickExport
const char *GetMagickMimeType(
const MagickInfo *magick_info)
865 assert(magick_info->signature == MagickCoreSignature);
866 return(magick_info->mime_type);
891 MagickExport
const char *GetMagickModuleName(
const MagickInfo *magick_info)
894 assert(magick_info->signature == MagickCoreSignature);
895 return(magick_info->magick_module);
920 MagickExport
const char *GetMagickName(
const MagickInfo *magick_info)
923 assert(magick_info->signature == MagickCoreSignature);
924 return(magick_info->name);
946 MagickExport
int GetMagickPrecision(
void)
948 if (IsEventLogging() != MagickFalse)
949 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
950 return(SetMagickPrecision(0));
975 MagickExport MagickBooleanType GetMagickRawSupport(
979 assert(magick_info->signature == MagickCoreSignature);
980 return(((magick_info->flags & CoderRawSupportFlag) == 0) ? MagickFalse :
1007 MagickExport MagickBooleanType GetMagickStealth(
const MagickInfo *magick_info)
1010 assert(magick_info->signature == MagickCoreSignature);
1011 return(((magick_info->flags & CoderStealthFlag) == 0) ? MagickFalse :
1040 MagickExport MagickBooleanType GetMagickUseExtension(
1044 assert(magick_info->signature == MagickCoreSignature);
1045 return(((magick_info->flags & CoderUseExtensionFlag) == 0) ? MagickFalse :
1073 static void *DestroyMagickNode(
void *magick_info)
1079 if (p->magick_module != (
char *) NULL)
1080 p->magick_module=DestroyString(p->magick_module);
1081 if (p->note != (
char *) NULL)
1082 p->note=DestroyString(p->note);
1083 if (p->mime_type != (
char *) NULL)
1084 p->mime_type=DestroyString(p->mime_type);
1085 if (p->version != (
char *) NULL)
1086 p->version=DestroyString(p->version);
1087 if (p->description != (
char *) NULL)
1088 p->description=DestroyString(p->description);
1089 if (p->name != (
char *) NULL)
1090 p->name=DestroyString(p->name);
1092 RelinquishSemaphoreInfo(&p->semaphore);
1093 return(RelinquishMagickMemory(p));
1096 static MagickBooleanType IsMagickTreeInstantiated(
ExceptionInfo *exception)
1099 if (magick_list_initialized == MagickFalse)
1102 ActivateSemaphoreInfo(&magick_semaphore);
1103 LockSemaphoreInfo(magick_semaphore);
1104 if (magick_list_initialized == MagickFalse)
1106 magick_list=NewSplayTree(CompareSplayTreeString,(
void *(*)(
void *))
1107 NULL,DestroyMagickNode);
1108 #if defined(MAGICKCORE_MODULES_SUPPORT)
1109 (void) GetModuleInfo((
char *) NULL,exception);
1111 magick_list_initialized=MagickTrue;
1113 UnlockSemaphoreInfo(magick_semaphore);
1115 return(magick_list != (
SplayTreeInfo *) NULL ? MagickTrue : MagickFalse);
1141 MagickPrivate MagickBooleanType IsMagickConflict(
const char *magick)
1143 assert(magick != (
char *) NULL);
1145 return(VMSIsMagickConflict(magick));
1146 #elif defined(MAGICKCORE_WINDOWS_SUPPORT)
1147 return(NTIsMagickConflict(magick));
1149 return(MagickFalse);
1177 MagickExport MagickBooleanType ListMagickInfo(FILE *file,
1192 if (file == (FILE *) NULL)
1194 magick_info=GetMagickInfoList(
"*",&number_formats,exception);
1195 if (magick_info == (
const MagickInfo **) NULL)
1196 return(MagickFalse);
1197 ClearMagickException(exception);
1198 #if !defined(MAGICKCORE_MODULES_SUPPORT)
1199 (void) FormatLocaleFile(file,
" Format Mode Description\n");
1201 (void) FormatLocaleFile(file,
" Format Module Mode Description\n");
1203 (void) FormatLocaleFile(file,
1204 "--------------------------------------------------------"
1205 "-----------------------\n");
1206 for (i=0; i < (ssize_t) number_formats; i++)
1208 if (GetMagickStealth(magick_info[i]) != MagickFalse)
1210 (void) FormatLocaleFile(file,
"%9s%c ",
1211 magick_info[i]->name != (
char *) NULL ? magick_info[i]->name :
"",
1212 GetMagickBlobSupport(magick_info[i]) != MagickFalse ?
'*' :
' ');
1213 #if defined(MAGICKCORE_MODULES_SUPPORT)
1216 magick_module[MagickPathExtent];
1218 *magick_module=
'\0';
1219 if (magick_info[i]->magick_module != (
char *) NULL)
1220 (
void) CopyMagickString(magick_module,magick_info[i]->magick_module,
1222 (void) ConcatenateMagickString(magick_module,
" ",
1224 magick_module[9]=
'\0';
1225 (void) FormatLocaleFile(file,
"%9s ",magick_module);
1228 (void) FormatLocaleFile(file,
"%c%c%c ",magick_info[i]->decoder ?
'r' :
'-',
1229 magick_info[i]->encoder ?
'w' :
'-',magick_info[i]->encoder != NULL &&
1230 GetMagickAdjoin(magick_info[i]) != MagickFalse ?
'+' :
'-');
1231 if (magick_info[i]->description != (
char *) NULL)
1232 (
void) FormatLocaleFile(file,
" %s",magick_info[i]->description);
1233 if (magick_info[i]->version != (
char *) NULL)
1234 (void) FormatLocaleFile(file,
" (%s)",magick_info[i]->version);
1235 (void) FormatLocaleFile(file,
"\n");
1236 if (magick_info[i]->note != (
char *) NULL)
1241 text=StringToList(magick_info[i]->note);
1242 if (text != (
char **) NULL)
1244 for (j=0; text[j] != (
char *) NULL; j++)
1246 (void) FormatLocaleFile(file,
" %s\n",text[j]);
1247 text[j]=DestroyString(text[j]);
1249 text=(
char **) RelinquishMagickMemory(text);
1253 (void) FormatLocaleFile(file,
"\n* native blob support\n");
1254 (void) FormatLocaleFile(file,
"r read support\n");
1255 (void) FormatLocaleFile(file,
"w write support\n");
1256 (void) FormatLocaleFile(file,
"+ support for multiple images\n");
1257 (void) fflush(file);
1258 magick_info=(
const MagickInfo **) RelinquishMagickMemory((
void *)
1284 MagickExport MagickBooleanType IsMagickCoreInstantiated(
void)
1286 return(magickcore_instantiated);
1307 MagickPrivate MagickBooleanType MagickComponentGenesis(
void)
1310 magick_semaphore=AcquireSemaphoreInfo();
1332 MagickPrivate
void MagickComponentTerminus(
void)
1335 ActivateSemaphoreInfo(&magick_semaphore);
1336 LockSemaphoreInfo(magick_semaphore);
1339 magick_list=DestroySplayTree(magick_list);
1340 magick_list_initialized=MagickFalse;
1342 UnlockSemaphoreInfo(magick_semaphore);
1343 RelinquishSemaphoreInfo(&magick_semaphore);
1373 static SignalHandler *SetMagickSignalHandler(
int signal_number,
1374 SignalHandler *handler)
1376 #if defined(MAGICKCORE_HAVE_SIGACTION) && defined(MAGICKCORE_HAVE_SIGEMPTYSET)
1388 sigaddset(&mask,signal_number);
1389 sigprocmask(SIG_BLOCK,&mask,NULL);
1390 action.sa_mask=mask;
1391 action.sa_handler=handler;
1393 #if defined(SA_INTERRUPT)
1394 action.sa_flags|=SA_INTERRUPT;
1396 #if defined(SA_ONSTACK)
1397 action.sa_flags|=SA_ONSTACK;
1399 previous_action.sa_handler=SIG_DFL;
1400 status=sigaction(signal_number,&action,&previous_action);
1403 sigprocmask(SIG_UNBLOCK,&mask,NULL);
1404 return(previous_action.sa_handler);
1406 return(signal(signal_number,handler));
1410 static void MagickSignalHandler(
int signal_number)
1412 if (magickcore_signal_in_progress != MagickFalse)
1413 (void) SetMagickSignalHandler(signal_number,signal_handlers[signal_number]);
1414 magickcore_signal_in_progress=MagickTrue;
1415 AsynchronousResourceComponentTerminus();
1416 #if defined(SIGQUIT)
1417 if (signal_number == SIGQUIT)
1420 #if defined(SIGABRT)
1421 if (signal_number == SIGABRT)
1425 if (signal_number == SIGBUS)
1429 if (signal_number == SIGFPE)
1432 #if defined(SIGSEGV)
1433 if (signal_number == SIGSEGV)
1436 #if !defined(MAGICKCORE_HAVE__EXIT)
1437 exit(signal_number);
1440 if (signal_number == SIGHUP)
1441 _exit(signal_number);
1444 if (signal_number == SIGINT)
1445 _exit(signal_number);
1447 #if defined(MAGICKCORE_HAVE_RAISE)
1448 if (signal_handlers[signal_number] != MagickSignalHandler)
1449 raise(signal_number);
1451 _exit(signal_number);
1455 static SignalHandler *RegisterMagickSignalHandler(
int signal_number)
1460 handler=SetMagickSignalHandler(signal_number,MagickSignalHandler);
1461 if (handler == SIG_ERR)
1463 if (handler != SIG_DFL)
1464 handler=SetMagickSignalHandler(signal_number,handler);
1466 (
void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
1467 "Register handler for signal: %d",signal_number);
1471 MagickExport
void MagickCoreGenesis(
const char *path,
1472 const MagickBooleanType establish_signal_handlers)
1476 execution_path[MagickPathExtent],
1477 filename[MagickPathExtent];
1482 #if defined(__has_feature)
1483 #if __has_feature(address_sanitizer)
1484 (void) putenv(
"MAGICK_THREAD_LIMIT=1");
1487 InitializeMagickMutex();
1489 if (magickcore_instantiated != MagickFalse)
1491 UnlockMagickMutex();
1494 (void) SemaphoreComponentGenesis();
1495 (void) ExceptionComponentGenesis();
1496 (void) LogComponentGenesis();
1497 (void) LocaleComponentGenesis();
1498 (void) RandomComponentGenesis();
1499 events=GetEnvironmentValue(
"MAGICK_DEBUG");
1500 if (events != (
char *) NULL)
1502 (void) SetLogEventMask(events);
1503 events=DestroyString(events);
1505 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
1511 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
1512 if ((path != (
const char *) NULL) && (IsPathAccessible(path) != MagickFalse))
1514 if ((path != (
const char *) NULL) && (*path == *DirectorySeparator) &&
1515 (IsPathAccessible(path) != MagickFalse))
1517 (void) CopyMagickString(execution_path,path,MagickPathExtent);
1519 (
void) GetExecutionPath(execution_path,MagickPathExtent);
1520 GetPathComponent(execution_path,TailPath,filename);
1521 (void) SetClientName(filename);
1522 GetPathComponent(execution_path,HeadPath,execution_path);
1523 (void) SetClientPath(execution_path);
1524 if (establish_signal_handlers != MagickFalse)
1529 #if defined(SIGABRT)
1530 if (signal_handlers[SIGABRT] == (SignalHandler *) NULL)
1531 signal_handlers[SIGABRT]=RegisterMagickSignalHandler(SIGABRT);
1534 if (signal_handlers[SIGBUS] == (SignalHandler *) NULL)
1535 signal_handlers[SIGBUS]=RegisterMagickSignalHandler(SIGBUS);
1537 #if defined(SIGSEGV)
1538 if (signal_handlers[SIGSEGV] == (SignalHandler *) NULL)
1539 signal_handlers[SIGSEGV]=RegisterMagickSignalHandler(SIGSEGV);
1542 if (signal_handlers[SIGFPE] == (SignalHandler *) NULL)
1543 signal_handlers[SIGFPE]=RegisterMagickSignalHandler(SIGFPE);
1546 if (signal_handlers[SIGHUP] == (SignalHandler *) NULL)
1547 signal_handlers[SIGHUP]=RegisterMagickSignalHandler(SIGHUP);
1550 if (signal_handlers[SIGINT] == (SignalHandler *) NULL)
1551 signal_handlers[SIGINT]=RegisterMagickSignalHandler(SIGINT);
1553 #if defined(SIGQUIT)
1554 if (signal_handlers[SIGQUIT] == (SignalHandler *) NULL)
1555 signal_handlers[SIGQUIT]=RegisterMagickSignalHandler(SIGQUIT);
1557 #if defined(SIGTERM)
1558 if (signal_handlers[SIGTERM] == (SignalHandler *) NULL)
1559 signal_handlers[SIGTERM]=RegisterMagickSignalHandler(SIGTERM);
1561 #if defined(SIGXCPU)
1562 if (signal_handlers[SIGXCPU] == (SignalHandler *) NULL)
1563 signal_handlers[SIGXCPU]=RegisterMagickSignalHandler(SIGXCPU);
1565 #if defined(SIGXFSZ)
1566 if (signal_handlers[SIGXFSZ] == (SignalHandler *) NULL)
1567 signal_handlers[SIGXFSZ]=RegisterMagickSignalHandler(SIGXFSZ);
1573 (void) ConfigureComponentGenesis();
1574 (void) PolicyComponentGenesis();
1575 #if MAGICKCORE_ZERO_CONFIGURATION_SUPPORT
1576 (void) ZeroConfigurationPolicy;
1578 (void) CacheComponentGenesis();
1579 (void) ResourceComponentGenesis();
1580 (void) CoderComponentGenesis();
1581 (void) MagickComponentGenesis();
1582 #if defined(MAGICKCORE_MODULES_SUPPORT)
1583 (void) ModuleComponentGenesis();
1585 (void) DelegateComponentGenesis();
1586 (void) MagicComponentGenesis();
1587 (void) ColorComponentGenesis();
1588 (void) TypeComponentGenesis();
1589 (void) MimeComponentGenesis();
1590 (void) AnnotateComponentGenesis();
1591 #if defined(MAGICKCORE_X11_DELEGATE)
1592 (void) XComponentGenesis();
1594 (void) RegistryComponentGenesis();
1595 (void) MonitorComponentGenesis();
1596 magickcore_instantiated=MagickTrue;
1597 UnlockMagickMutex();
1618 MagickExport
void MagickCoreTerminus(
void)
1620 if (magickcore_instantiated == MagickFalse)
1622 MonitorComponentTerminus();
1623 RegistryComponentTerminus();
1624 #if defined(MAGICKCORE_X11_DELEGATE)
1625 XComponentTerminus();
1627 #if defined(MAGICKCORE_XML_DELEGATE)
1630 AnnotateComponentTerminus();
1631 MimeComponentTerminus();
1632 TypeComponentTerminus();
1633 #if defined(MAGICKCORE_OPENCL_SUPPORT)
1636 ColorComponentTerminus();
1637 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
1638 NTWindowsTerminus();
1640 MagicComponentTerminus();
1641 DelegateComponentTerminus();
1642 MagickComponentTerminus();
1643 #if !defined(MAGICKCORE_BUILD_MODULES)
1644 UnregisterStaticModules();
1646 #if defined(MAGICKCORE_MODULES_SUPPORT)
1647 ModuleComponentTerminus();
1649 CoderComponentTerminus();
1650 ResourceComponentTerminus();
1651 CacheComponentTerminus();
1652 PolicyComponentTerminus();
1653 ConfigureComponentTerminus();
1654 RandomComponentTerminus();
1655 LocaleComponentTerminus();
1656 LogComponentTerminus();
1657 ExceptionComponentTerminus();
1658 SemaphoreComponentTerminus();
1659 magickcore_instantiated=MagickFalse;
1688 MagickExport MagickBooleanType RegisterMagickInfo(
MagickInfo *magick_info)
1697 assert(magick_info->signature == MagickCoreSignature);
1698 if (IsEventLogging() != MagickFalse)
1699 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",magick_info->name);
1701 return(MagickFalse);
1702 if ((GetMagickDecoderThreadSupport(magick_info) == MagickFalse) ||
1703 (GetMagickEncoderThreadSupport(magick_info) == MagickFalse))
1704 magick_info->semaphore=AcquireSemaphoreInfo();
1705 status=AddValueToSplayTree(magick_list,magick_info->name,magick_info);
1727 MagickPrivate
void ResetMagickPrecision(
void)
1761 MagickExport
int SetMagickPrecision(
const int precision)
1763 #define MagickPrecision (MAGICKCORE_QUANTUM_DEPTH/8+4)
1765 if (IsEventLogging() != MagickFalse)
1766 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
1768 magick_precision=precision;
1769 if ((precision < 0) || (magick_precision == 0))
1775 *exception = AcquireExceptionInfo();
1777 magick_precision=MagickPrecision;
1778 limit=(
char *) GetImageRegistry(StringRegistryType,
"precision",exception);
1779 exception=DestroyExceptionInfo(exception);
1780 if (limit == (
char *) NULL)
1781 limit=GetEnvironmentValue(
"MAGICK_PRECISION");
1782 if (limit == (
char *) NULL)
1783 limit=GetPolicyValue(
"system:precision");
1784 if (limit != (
char *) NULL)
1786 magick_precision=StringToInteger(limit);
1787 limit=DestroyString(limit);
1790 return(magick_precision);
1817 MagickExport MagickBooleanType UnregisterMagickInfo(
const char *name)
1825 assert(name != (
const char *) NULL);
1827 return(MagickFalse);
1828 if (GetNumberOfNodesInSplayTree(magick_list) == 0)
1829 return(MagickFalse);
1830 LockSemaphoreInfo(magick_semaphore);
1831 ResetSplayTreeIterator(magick_list);
1832 p=(
const MagickInfo *) GetNextValueInSplayTree(magick_list);
1835 if (LocaleCompare(p->name,name) == 0)
1837 p=(
const MagickInfo *) GetNextValueInSplayTree(magick_list);
1839 status=DeleteNodeByValueFromSplayTree(magick_list,p);
1840 UnlockSemaphoreInfo(magick_semaphore);