/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% G e t I m a g e A r t i f a c t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% GetImageArtifact() gets a value associated with an image artifact.
% If the requested artifact is NULL return the first artifact, to
% prepare to iterate over all artifacts.
%
% The returned string is a constant string in the tree and should NOT be
% freed by the caller.
%
% The format of the GetImageArtifact method is:
%
% const char *GetImageArtifact(const Image *image,const char *key)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o key: the key.
%
*/
MagickExport const char *GetImageArtifact(const Image *image,
const char *artifact)
{
register const char
*p;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
p=(const char *) NULL;
if (image->artifacts != (void *) NULL)
{
if (artifact == (const char *) NULL)
return((const char *) GetRootValueFromSplayTree((SplayTreeInfo *)
image->artifacts));
p=(const char *) GetValueFromSplayTree((SplayTreeInfo *) image->artifacts,
artifact);
if (p != (const char *) NULL)
return(p);
}
if ((image->image_info != (ImageInfo *) NULL) &&
(image->image_info->options != (void *) NULL))
p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
image->image_info->options,artifact);
return(p);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% G e t I m a g e A r t i f a c t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% GetImageArtifact() gets a value associated with an image artifact.
%
% Note, the artifact is a constant. Do not attempt to free it.
%
% The format of the GetImageArtifact method is:
%
% const char *GetImageArtifact(const Image *image,const char *key)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o key: the key.
%
*/
MagickExport const char *GetImageArtifact(const Image *image,
const char *artifact)
{
register const char
*p;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
p=(const char *) NULL;
if (artifact == (const char *) NULL)
{
ResetSplayTreeIterator((SplayTreeInfo *) image->artifacts);
p=(const char *) GetNextValueInSplayTree((SplayTreeInfo *)
image->artifacts);
return(p);
}
if (image->artifacts != (void *) NULL)
{
p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
image->artifacts,artifact);
if (p != (const char *) NULL)
return(p);
}
return(p);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ G e t T y p e I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% GetTypeInfo searches the type list for the specified name and if found
% returns attributes for that type.
%
% The format of the GetTypeInfo method is:
%
% const TypeInfo *GetTypeInfo(const char *name,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o name: the type name.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport const TypeInfo *GetTypeInfo(const char *name,
ExceptionInfo *exception)
{
assert(exception != (ExceptionInfo *) NULL);
if ((type_list == (SplayTreeInfo *) NULL) ||
(instantiate_type == MagickFalse))
if (InitializeTypeList(exception) == MagickFalse)
return((const TypeInfo *) NULL);
if ((type_list == (SplayTreeInfo *) NULL) ||
(GetNumberOfNodesInSplayTree(type_list) == 0))
return((const TypeInfo *) NULL);
if ((name == (const char *) NULL) || (LocaleCompare(name,"*") == 0))
{
ResetSplayTreeIterator(type_list);
return((const TypeInfo *) GetNextValueInSplayTree(type_list));
}
return((const TypeInfo *) GetValueFromSplayTree(type_list,name));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ G e t L o c a l e I n f o _ %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% GetLocaleInfo_() searches the locale list for the specified tag and if
% found returns attributes for that element.
%
% The format of the GetLocaleInfo method is:
%
% const LocaleInfo *GetLocaleInfo_(const char *tag,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o tag: the locale tag.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport const LocaleInfo *GetLocaleInfo_(const char *tag,
ExceptionInfo *exception)
{
assert(exception != (ExceptionInfo *) NULL);
if ((locale_list == (SplayTreeInfo *) NULL) ||
(instantiate_locale == MagickFalse))
if (InitializeLocaleList(exception) == MagickFalse)
return((const LocaleInfo *) NULL);
if ((locale_list == (SplayTreeInfo *) NULL) ||
(GetNumberOfNodesInSplayTree(locale_list) == 0))
return((const LocaleInfo *) NULL);
if ((tag == (const char *) NULL) || (LocaleCompare(tag,"*") == 0))
{
ResetSplayTreeIterator(locale_list);
return((const LocaleInfo *) GetNextValueInSplayTree(locale_list));
}
return((const LocaleInfo *) GetValueFromSplayTree(locale_list,tag));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ G e t C o d e r I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% GetCoderInfo searches the coder list for the specified name and if found
% returns attributes for that coder.
%
% The format of the GetCoderInfo method is:
%
% const CoderInfo *GetCoderInfo(const char *name,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o name: the coder name.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport const CoderInfo *GetCoderInfo(const char *name,
ExceptionInfo *exception)
{
const CoderInfo
*coder_info;
assert(exception != (ExceptionInfo *) NULL);
if (IsCoderTreeInstantiated(exception) == MagickFalse)
return((const CoderInfo *) NULL);
LockSemaphoreInfo(coder_semaphore);
if ((name == (const char *) NULL) || (LocaleCompare(name,"*") == 0))
{
ResetSplayTreeIterator(coder_cache);
coder_info=(const CoderInfo *) GetNextValueInSplayTree(coder_cache);
UnlockSemaphoreInfo(coder_semaphore);
return(coder_info);
}
coder_info=(const CoderInfo *) GetValueFromSplayTree(coder_cache,name);
UnlockSemaphoreInfo(coder_semaphore);
return(coder_info);
}
static Image *ReadXPMImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
char
*grey,
key[MaxTextExtent],
target[MaxTextExtent],
*xpm_buffer;
Image
*image;
MagickBooleanType
active,
status;
register char
*next,
*p,
*q;
register IndexPacket
*indexes;
register ssize_t
x;
register PixelPacket
*r;
size_t
length;
SplayTreeInfo
*xpm_colors;
ssize_t
count,
j,
y;
unsigned long
colors,
columns,
rows,
width;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
Read XPM file.
*/
length=MaxTextExtent;
xpm_buffer=(char *) AcquireQuantumMemory((size_t) length,sizeof(*xpm_buffer));
if (xpm_buffer == (char *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
*xpm_buffer='\0';
p=xpm_buffer;
while (ReadBlobString(image,p) != (char *) NULL)
{
if ((*p == '#') && ((p == xpm_buffer) || (*(p-1) == '\n')))
continue;
if ((*p == '}') && (*(p+1) == ';'))
break;
p+=strlen(p);
if ((size_t) (p-xpm_buffer+MaxTextExtent) < length)
continue;
length<<=1;
xpm_buffer=(char *) ResizeQuantumMemory(xpm_buffer,length+MaxTextExtent,
sizeof(*xpm_buffer));
if (xpm_buffer == (char *) NULL)
break;
p=xpm_buffer+strlen(xpm_buffer);
}
if (xpm_buffer == (char *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
/*
Remove comments.
*/
count=0;
width=0;
for (p=xpm_buffer; *p != '\0'; p++)
{
if (*p != '"')
continue;
count=(ssize_t) sscanf(p+1,"%lu %lu %lu %lu",&columns,&rows,&colors,&width);
image->columns=columns;
image->rows=rows;
image->colors=colors;
if (count == 4)
break;
}
if ((count != 4) || (width > 10) || (image->columns == 0) ||
(image->rows == 0) || (image->colors == 0))
{
xpm_buffer=DestroyString(xpm_buffer);
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
}
/*
Remove unquoted characters.
*/
active=MagickFalse;
q=xpm_buffer;
while (*p != '\0')
{
if (*p++ == '"')
{
if (active != MagickFalse)
*q++='\n';
active=active != MagickFalse ? MagickFalse : MagickTrue;
}
if (active != MagickFalse)
*q++=(*p);
}
*q='\0';
/*
Initialize image structure.
*/
xpm_colors=NewSplayTree(CompareXPMColor,RelinquishMagickMemory,
(void *(*)(void *)) NULL);
if (AcquireImageColormap(image,image->colors) == MagickFalse)
{
xpm_buffer=DestroyString(xpm_buffer);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
/*
Read image colormap.
*/
image->depth=1;
next=NextXPMLine(xpm_buffer);
for (j=0; (j < (ssize_t) image->colors) && (next != (char *) NULL); j++)
{
MagickPixelPacket
pixel;
p=next;
next=NextXPMLine(p);
(void) CopyXPMColor(key,p,MagickMin((size_t) width,MaxTextExtent-1));
status=AddValueToSplayTree(xpm_colors,ConstantString(key),(void *) j);
/*
Parse color.
*/
(void) CopyMagickString(target,"gray",MaxTextExtent);
q=ParseXPMColor(p+width,MagickTrue);
if (q != (char *) NULL)
{
while ((isspace((int) ((unsigned char) *q)) == 0) && (*q != '\0'))
q++;
if ((next-q) < 0)
break;
if (next != (char *) NULL)
(void) CopyXPMColor(target,q,MagickMin((size_t) (next-q),
MaxTextExtent-1));
else
(void) CopyMagickString(target,q,MaxTextExtent);
q=ParseXPMColor(target,MagickFalse);
if (q != (char *) NULL)
*q='\0';
}
StripString(target);
grey=strstr(target,"grey");
if (grey != (char *) NULL)
grey[2]='a';
if (LocaleCompare(target,"none") == 0)
{
image->storage_class=DirectClass;
image->matte=MagickTrue;
}
status=QueryColorCompliance(target,XPMCompliance,&image->colormap[j],
exception);
if (status == MagickFalse)
break;
(void) QueryMagickColorCompliance(target,XPMCompliance,&pixel,exception);
if (image->depth < pixel.depth)
image->depth=pixel.depth;
}
if (j < (ssize_t) image->colors)
{
xpm_colors=DestroySplayTree(xpm_colors);
xpm_buffer=DestroyString(xpm_buffer);
ThrowReaderException(CorruptImageError,"CorruptImage");
}
j=0;
if (image_info->ping == MagickFalse)
{
/*
Read image pixels.
*/
status=SetImageExtent(image,image->columns,image->rows);
if (status == MagickFalse)
{
InheritException(exception,&image->exception);
return(DestroyImageList(image));
}
for (y=0; y < (ssize_t) image->rows; y++)
{
p=NextXPMLine(p);
if (p == (char *) NULL)
break;
r=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
ssize_t count=CopyXPMColor(key,p,MagickMin(width,MaxTextExtent-1));
if (count != (ssize_t) width)
break;
j=(ssize_t) GetValueFromSplayTree(xpm_colors,key);
if (image->storage_class == PseudoClass)
SetPixelIndex(indexes+x,j);
*r=image->colormap[j];
p+=count;
r++;
}
if (x < (ssize_t) image->columns)
break;
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
if (y < (ssize_t) image->rows)
{
xpm_colors=DestroySplayTree(xpm_colors);
xpm_buffer=DestroyString(xpm_buffer);
ThrowReaderException(CorruptImageError,"NotEnoughPixelData");
}
}
/*
Relinquish resources.
*/
xpm_colors=DestroySplayTree(xpm_colors);
xpm_buffer=DestroyString(xpm_buffer);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% G e t I m a g e R e g i s t r y %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% GetImageRegistry() returns a value associated with an image registry key.
%
% The format of the GetImageRegistry method is:
%
% void *GetImageRegistry(const RegistryType type,const char *key,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o type: the type.
%
% o key: the key.
%
% o exception: the exception.
%
*/
MagickExport void *GetImageRegistry(const RegistryType type,const char *key,
ExceptionInfo *exception)
{
void
*value;
RegistryInfo
*registry_info;
if (IsEventLogging() != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",key);
if (registry == (void *) NULL)
return((void *) NULL);
registry_info=(RegistryInfo *) GetValueFromSplayTree(registry,key);
if (registry_info == (void *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),RegistryError,
"UnableToGetRegistryID","`%s'",key);
return((void *) NULL);
}
value=(void *) NULL;
switch (type)
{
case ImageRegistryType:
{
if (type == registry_info->type)
value=(void *) CloneImageList((Image *) registry_info->value,exception);
break;
}
case ImageInfoRegistryType:
{
if (type == registry_info->type)
value=(void *) CloneImageInfo((ImageInfo *) registry_info->value);
break;
}
case StringRegistryType:
{
switch (registry_info->type)
{
case ImageRegistryType:
{
value=(Image *) ConstantString(((Image *)
registry_info->value)->filename);
break;
}
case ImageInfoRegistryType:
{
value=(Image *) ConstantString(((ImageInfo *)
registry_info->value)->filename);
break;
}
case StringRegistryType:
{
value=(void *) ConstantString((char *) registry_info->value);
break;
}
default:
break;
}
break;
}
default:
break;
}
return(value);
}
