int main(int argc, char **argv)
{
char
*xml;
const char
*acronym,
*data_type,
*description,
*endian,
*mask,
*mime_type,
*offset,
*pattern,
*priority,
*match_type,
*value;
ExceptionInfo
*exception;
size_t
length;
static char
*doc_type =
{
"<!DOCTYPE mimemap [\n"
" <!ELEMENT mimemap (mime+)>\n"
" <!ELEMENT mime (#PCDATA)>\n"
" <!ATTLIST mime type CDATA #REQUIRED>\n"
" <!ATTLIST mime acronym CDATA #IMPLIED>\n"
" <!ATTLIST mime description CDATA #IMPLIED>\n"
" <!ATTLIST mime pattern CDATA #IMPLIED>\n"
" <!ATTLIST mime offset CDATA #IMPLIED>\n"
" <!ATTLIST mime data-type (string|byte|short|ssize_t) #IMPLIED>\n"
" <!ATTLIST mime endian (lsb|msb) #IMPLIED>\n"
" <!ATTLIST mime magic CDATA #IMPLIED>\n"
" <!ATTLIST mime mask CDATA #IMPLIED>\n"
" <!ATTLIST mime priority CDATA #IMPLIED>\n"
"]>"
};
XMLTreeInfo
*comment,
*expanded_acronym,
*glob,
*magic,
*match,
*type,
*xml_info;
if (argc != 2)
return(fprintf(stderr,"usage: %s xml-file\n", argv[0]));
exception=AcquireExceptionInfo();
xml=(char *) FileToBlob(argv[1],~0UL,&length,exception);
if (xml == (char *) NULL)
return(fprintf(stderr,"%s: unable to read file\n",argv[1]));
xml_info=NewXMLTree(xml,exception);
xml=(char *) RelinquishWizardMemory(xml);
if (xml_info == (XMLTreeInfo *) NULL)
return(fprintf(stderr,"%s: unable to parse xml-file\n",argv[1]));
(void) printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
(void) printf("%s\n",doc_type);
(void) printf("<mimemap>\n");
type=GetXMLTreeChild(xml_info,"mime-type");
while (type != (XMLTreeInfo *) NULL)
{
mime_type=GetXMLTreeAttribute(type,"type");
acronym=(const char *) NULL;
expanded_acronym=GetXMLTreeChild(type,"acronym");
if (expanded_acronym != (XMLTreeInfo *) NULL)
acronym=GetXMLTreeContent(expanded_acronym);
expanded_acronym=GetXMLTreeChild(type,"expanded-acronym");
description=(const char *) NULL;
comment=GetXMLTreeChild(type,"comment");
if (comment != (XMLTreeInfo *) NULL)
description=GetXMLTreeContent(comment);
if (expanded_acronym != (XMLTreeInfo *) NULL)
description=GetXMLTreeContent(expanded_acronym);
magic=GetXMLTreeChild(type,"magic");
priority=(char *) NULL;
match=(XMLTreeInfo *) NULL;
if (magic != (XMLTreeInfo *) NULL)
{
priority=GetXMLTreeAttribute(magic,"priority");
match=GetXMLTreeChild(magic,"match");
}
while (match != (XMLTreeInfo *) NULL)
{
value=(char *) NULL;
match_type=(char *) NULL;
mask=(char *) NULL;
offset=(char *) NULL;
if (match != (XMLTreeInfo *) NULL)
{
value=GetXMLTreeAttribute(match,"value");
match_type=GetXMLTreeAttribute(match,"type");
offset=GetXMLTreeAttribute(match,"offset");
mask=GetXMLTreeAttribute(match,"mask");
}
(void) printf(" <mime");
if (mime_type != (const char *) NULL)
(void) printf(" type=\"%s\"",mime_type);
if (description != (const char *) NULL)
(void) printf(" description=\"%s\"",description);
if (match_type != (const char *) NULL)
{
data_type="string";
endian="undefined";
if (strncmp(match_type,"little",6) == 0)
endian="LSB";
if (strncmp(match_type,"big",3) == 0)
endian="MSB";
if (strcmp(match_type,"byte") == 0)
data_type="byte";
if (strcmp(match_type+strlen(match_type)-2,"16") == 0)
data_type="short";
if (strcmp(match_type+strlen(match_type)-2,"32") == 0)
data_type="ssize_t";
(void) printf(" data-type=\"%s\"",data_type);
if (strcmp(endian,"undefined") != 0)
(void) printf(" endian=\"%s\"",endian);
}
if (offset != (const char *) NULL)
(void) printf(" offset=\"%s\"",offset);
if (mask != (const char *) NULL)
(void) printf(" mask=\"%s\"",mask);
if (value != (const char *) NULL)
{
char
*magic;
magic=AcquireString(value);
SubstituteString(&magic,"<","<");
SubstituteString(&magic,">",">");
SubstituteString(&magic,"\"",""");
(void) printf(" magic=\"%s\"",magic);
magic=(char *) RelinquishWizardMemory(magic);
}
if (priority != (const char *) NULL)
(void) printf(" priority=\"%s\"",priority);
(void) printf(" />\n");
match=GetNextXMLTreeTag(match);
}
glob=GetXMLTreeChild(type,"glob");
while (glob != (XMLTreeInfo *) NULL)
{
pattern=GetXMLTreeAttribute(glob,"pattern");
value=(char *) NULL;
if (match)
value=GetXMLTreeAttribute(match,"value");
(void) printf(" <mime");
if (mime_type != (const char *) NULL)
(void) printf(" type=\"%s\"",mime_type);
if (acronym != (const char *) NULL)
(void) printf(" acronym=\"%s\"",acronym);
if (description != (const char *) NULL)
(void) printf(" description=\"%s\"",description);
(void) printf(" priority=\"100\"");
if (pattern != (const char *) NULL)
(void) printf(" pattern=\"%s\"",pattern);
(void) printf(" />\n");
glob=GetNextXMLTreeTag(glob);
}
type=GetNextXMLTreeTag(type);
}
(void) printf("</mimemap>\n");
xml=XMLTreeInfoToXML(xml_info);
(void) fprintf(stderr,"%s\n",xml);
xml=(char *) RelinquishWizardMemory(xml);
DestroyXMLTree(xml_info);
exception=DestroyExceptionInfo(exception);
return(0);
}
static MagickBooleanType WriteMPEGImage(const ImageInfo *image_info,
Image *image,ExceptionInfo *exception)
{
#define WriteMPEGIntermediateFormat "jpg"
char
basename[MagickPathExtent],
filename[MagickPathExtent];
double
delay;
Image
*coalesce_image;
ImageInfo
*write_info;
int
file;
MagickBooleanType
status;
register Image
*p;
register ssize_t
i;
size_t
count,
length,
scene;
unsigned char
*blob;
/*
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickCoreSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
(void) CloseBlob(image);
/*
Write intermediate files.
*/
coalesce_image=CoalesceImages(image,exception);
if (coalesce_image == (Image *) NULL)
return(MagickFalse);
file=AcquireUniqueFileResource(basename);
if (file != -1)
file=close(file)-1;
(void) FormatLocaleString(coalesce_image->filename,MagickPathExtent,"%s",
basename);
count=0;
write_info=CloneImageInfo(image_info);
*write_info->magick='\0';
for (p=coalesce_image; p != (Image *) NULL; p=GetNextImageInList(p))
{
char
previous_image[MagickPathExtent];
blob=(unsigned char *) NULL;
length=0;
scene=p->scene;
delay=100.0*p->delay/MagickMax(1.0*p->ticks_per_second,1.0);
for (i=0; i < (ssize_t) MagickMax((1.0*delay+1.0)/3.0,1.0); i++)
{
p->scene=count;
count++;
status=MagickFalse;
switch (i)
{
case 0:
{
Image
*frame;
(void) FormatLocaleString(p->filename,MagickPathExtent,"%s%.20g.%s",
basename,(double) p->scene,WriteMPEGIntermediateFormat);
(void) FormatLocaleString(filename,MagickPathExtent,"%s%.20g.%s",
basename,(double) p->scene,WriteMPEGIntermediateFormat);
(void) FormatLocaleString(previous_image,MagickPathExtent,
"%s%.20g.%s",basename,(double) p->scene,
WriteMPEGIntermediateFormat);
frame=CloneImage(p,0,0,MagickTrue,exception);
if (frame == (Image *) NULL)
break;
status=WriteImage(write_info,frame,exception);
frame=DestroyImage(frame);
break;
}
case 1:
{
blob=(unsigned char *) FileToBlob(previous_image,~0UL,&length,
exception);
}
default:
{
(void) FormatLocaleString(filename,MagickPathExtent,"%s%.20g.%s",
basename,(double) p->scene,WriteMPEGIntermediateFormat);
if (length > 0)
status=BlobToFile(filename,blob,length,exception);
break;
}
}
if (image->debug != MagickFalse)
{
if (status != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"%.20g. Wrote %s file for scene %.20g:",(double) i,
WriteMPEGIntermediateFormat,(double) p->scene);
else
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"%.20g. Failed to write %s file for scene %.20g:",(double) i,
WriteMPEGIntermediateFormat,(double) p->scene);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"%s",filename);
}
}
p->scene=scene;
if (blob != (unsigned char *) NULL)
blob=(unsigned char *) RelinquishMagickMemory(blob);
if (status == MagickFalse)
break;
}
/*
Convert JPEG to MPEG.
*/
(void) CopyMagickString(coalesce_image->magick_filename,basename,
MagickPathExtent);
(void) CopyMagickString(coalesce_image->filename,basename,MagickPathExtent);
GetPathComponent(image_info->filename,ExtensionPath,coalesce_image->magick);
if (*coalesce_image->magick == '\0')
(void) CopyMagickString(coalesce_image->magick,image->magick,
MagickPathExtent);
status=InvokeDelegate(write_info,coalesce_image,(char *) NULL,"mpeg:encode",
exception);
(void) FormatLocaleString(write_info->filename,MagickPathExtent,"%s.%s",
write_info->unique,coalesce_image->magick);
status=CopyDelegateFile(write_info->filename,image->filename);
(void) RelinquishUniqueFileResource(write_info->filename);
write_info=DestroyImageInfo(write_info);
/*
Relinquish resources.
*/
count=0;
for (p=coalesce_image; p != (Image *) NULL; p=GetNextImageInList(p))
{
delay=100.0*p->delay/MagickMax(1.0*p->ticks_per_second,1.0);
for (i=0; i < (ssize_t) MagickMax((1.0*delay+1.0)/3.0,1.0); i++)
{
(void) FormatLocaleString(p->filename,MagickPathExtent,"%s%.20g.%s",
basename,(double) count++,WriteMPEGIntermediateFormat);
(void) RelinquishUniqueFileResource(p->filename);
}
(void) CopyMagickString(p->filename,image_info->filename,MagickPathExtent);
}
(void) RelinquishUniqueFileResource(basename);
coalesce_image=DestroyImageList(coalesce_image);
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"exit");
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d M V G I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadMVGImage creates a gradient image and initializes it to
% the X server color range as specified by the filename. It allocates the
% memory necessary for the new Image structure and returns a pointer to the
% new image.
%
% The format of the ReadMVGImage method is:
%
% Image *ReadMVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: Method ReadMVGImage returns a pointer to the image after
% creating it. A null image is returned if there is a memory shortage
% or if the image cannot be read.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadMVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
#define BoundingBox "viewbox"
DrawInfo
*draw_info;
Image
*image;
size_t
length;
unsigned int
status;
/*
Open image.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
if ((image->columns == 0) || (image->rows == 0))
{
char
primitive[MaxTextExtent];
register char
*p;
SegmentInfo
bounds;
/*
Determine size of image canvas.
*/
while (ReadBlobString(image,primitive) != (char *) NULL)
{
for (p=primitive; (*p == ' ') || (*p == '\t'); p++);
if (LocaleNCompare(BoundingBox,p,strlen(BoundingBox)) != 0)
continue;
(void) sscanf(p,"viewbox %lf %lf %lf %lf",&bounds.x1,&bounds.y1,
&bounds.x2,&bounds.y2);
image->columns=(unsigned long) (bounds.x2-bounds.x1+0.5);
image->rows=(unsigned long) (bounds.y2-bounds.y1+0.5);
break;
}
}
if ((image->columns == 0) || (image->rows == 0))
ThrowReaderException(OptionError,MustSpecifyImageSize,image);
if (CheckImagePixelLimits(image, exception) != MagickPass)
ThrowReaderException(ResourceLimitError,ImagePixelLimitExceeded,image);
/*
Render drawing.
*/
(void) SetImage(image,OpaqueOpacity);
draw_info=CloneDrawInfo(image_info,(DrawInfo *) NULL);
draw_info->fill=image_info->pen;
if (GetBlobStreamData(image))
draw_info->primitive=AllocateString((char *) GetBlobStreamData(image));
else
draw_info->primitive=(char *) FileToBlob(image->filename,&length,exception);
if (draw_info->primitive == (char *) NULL)
{
DestroyDrawInfo(draw_info);
CloseBlob(image);
return (Image *) NULL;
}
(void) DrawImage(image,draw_info);
DestroyDrawInfo(draw_info);
CloseBlob(image);
return(image);
}
static MagickBooleanType WriteMPEGImage(const ImageInfo *image_info,
Image *image)
{
char
basename[MaxTextExtent],
filename[MaxTextExtent];
Image
*coalesce_image,
*next_image;
ImageInfo
*write_info;
int
file;
MagickBooleanType
status;
register Image
*p;
register long
i;
size_t
length;
unsigned char
*blob;
unsigned long
count,
delay,
scene;
/*
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
CloseBlob(image);
/*
Determine if the sequence of images have identical page info.
*/
coalesce_image=image;
for (next_image=image; next_image != (Image *) NULL; )
{
if ((image->columns != next_image->columns) ||
(image->rows != next_image->rows))
break;
if ((image->page.x != next_image->page.x) ||
(image->page.y != next_image->page.y))
break;
next_image=GetNextImageInList(next_image);
}
if (next_image != (Image *) NULL)
{
coalesce_image=CoalesceImages(image,&image->exception);
if (coalesce_image == (Image *) NULL)
return(MagickFalse);
}
/*
Write YUV files.
*/
file=AcquireUniqueFileResource(basename);
if (file != -1)
file=close(file)-1;
(void) FormatMagickString(coalesce_image->filename,MaxTextExtent,"%s",
basename);
write_info=CloneImageInfo(image_info);
status=WriteMPEGParameterFiles(write_info,coalesce_image,basename);
if (status == MagickFalse)
{
if (coalesce_image != image)
coalesce_image=DestroyImage(coalesce_image);
(void) remove(basename);
if (image->quality != UndefinedCompressionQuality)
{
(void) FormatMagickString(filename,MaxTextExtent,"%s.iqm",
basename);
(void) remove(filename);
(void) FormatMagickString(filename,MaxTextExtent,"%s.niq",
basename);
(void) remove(filename);
}
ThrowWriterException(CoderError,"UnableToWriteMPEGParameters");
}
count=0;
write_info->interlace=PlaneInterlace;
for (p=coalesce_image; p != (Image *) NULL; p=GetNextImageInList(p))
{
char
previous_image[MaxTextExtent];
blob=(unsigned char *) NULL;
length=0;
scene=p->scene;
delay=100*p->delay/Max(p->ticks_per_second,1);
for (i=0; i < (long) Max((delay+1)/3,1); i++)
{
p->scene=count;
count++;
status=MagickFalse;
switch (i)
{
case 0:
{
Image
*frame;
(void) FormatMagickString(p->filename,MaxTextExtent,"%s.%lu.yuv",
basename,p->scene);
(void) FormatMagickString(filename,MaxTextExtent,"%s.%lu.yuv",
basename,p->scene);
(void) FormatMagickString(previous_image,MaxTextExtent,
"%s.%lu.yuv",basename,p->scene);
frame=CloneImage(p,0,0,MagickTrue,&p->exception);
if (frame == (Image *) NULL)
break;
status=WriteImage(write_info,frame);
frame=DestroyImage(frame);
break;
}
case 1:
{
blob=(unsigned char *)
FileToBlob(previous_image,~0,&length,&image->exception);
}
default:
{
(void) FormatMagickString(filename,MaxTextExtent,"%s.%lu.yuv",
basename,p->scene);
if (length > 0)
status=BlobToFile(filename,blob,length,&image->exception);
break;
}
}
if (image->debug != MagickFalse)
{
if (status != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"%lu. Wrote YUV file for scene %lu:",i,p->scene);
else
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"%lu. Failed to write YUV file for scene %lu:",i,p->scene);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"%s",
filename);
}
}
p->scene=scene;
if (blob != (unsigned char *) NULL)
blob=(unsigned char *) RelinquishMagickMemory(blob);
if (status == MagickFalse)
break;
}
/*
Convert YUV to MPEG.
*/
(void) CopyMagickString(coalesce_image->filename,basename,MaxTextExtent);
status=InvokeDelegate(write_info,coalesce_image,(char *) NULL,"mpeg-encode",
&image->exception);
write_info=DestroyImageInfo(write_info);
/*
Free resources.
*/
count=0;
for (p=coalesce_image; p != (Image *) NULL; p=GetNextImageInList(p))
{
delay=100*p->delay/Max(p->ticks_per_second,1);
for (i=0; i < (long) Max((delay+1)/3,1); i++)
{
(void) FormatMagickString(p->filename,MaxTextExtent,"%s.%lu.yuv",
basename,count++);
(void) remove(p->filename);
}
(void) CopyMagickString(p->filename,image_info->filename,MaxTextExtent);
}
(void) RelinquishUniqueFileResource(basename);
(void) FormatMagickString(filename,MaxTextExtent,"%s.iqm",basename);
(void) remove(filename);
(void) FormatMagickString(filename,MaxTextExtent,"%s.niq",basename);
(void) remove(filename);
(void) FormatMagickString(filename,MaxTextExtent,"%s.log",basename);
(void) remove(filename);
if (coalesce_image != image)
coalesce_image=DestroyImage(coalesce_image);
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"exit");
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ R e a d C o n f i g u r e F i l e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadConfigureFile reads the color configuration file which maps
% color strings with a particular image format.
%
% The format of the ReadConfigureFile method is:
%
% unsigned int ReadConfigureFile(const char *basename,
% const unsigned long depth,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o status: Method ReadConfigureFile returns True if at least one color
% is defined otherwise False.
%
% o basename: The color configuration filename.
%
% o depth: depth of <include /> statements.
%
% o exception: Return any errors or warnings in this structure.
%
%
*/
#if defined(MSWINDOWS)
static void CatDelegatePath(char *path,
const char *binpath,
const char *command)
{
strcpy(path,binpath);
strcat(path,command);
if (IsAccessibleNoLogging(path))
return;
strcpy(path,command);
return;
}
#endif /* defined(MSWINDOWS) */
static unsigned int ReadConfigureFile(const char *basename,
const unsigned long depth,ExceptionInfo *exception)
{
char
keyword[MaxTextExtent],
path[MaxTextExtent],
*q,
*token,
*xml;
size_t
length;
/*
Read the delegates configure file.
*/
(void) strcpy(path,basename);
if (depth == 0)
xml=(char *) GetConfigureBlob(basename,path,&length,exception);
else
xml=(char *) FileToBlob(basename,&length,exception);
if (xml == (char *) NULL)
xml=AllocateString(DelegateMap);
token=AllocateString(xml);
for (q=xml; *q != '\0'; )
{
/*
Interpret XML.
*/
GetToken(q,&q,token);
if (*token == '\0')
break;
(void) strlcpy(keyword,token,MaxTextExtent);
if (LocaleNCompare(keyword,"<!--",4) == 0)
{
/*
Comment element.
*/
while ((LocaleNCompare(q,"->",2) != 0) && (*q != '\0'))
GetToken(q,&q,token);
continue;
}
if (LocaleCompare(keyword,"<include") == 0)
{
/*
Include element.
*/
while ((*token != '>') && (*q != '\0'))
{
(void) strlcpy(keyword,token,MaxTextExtent);
GetToken(q,&q,token);
if (*token != '=')
continue;
GetToken(q,&q,token);
if (LocaleCompare(keyword,"file") == 0)
{
if (depth > 200)
ThrowException(exception,ConfigureError,IncludeElementNestedTooDeeply,path);
else
{
char
filename[MaxTextExtent];
GetPathComponent(path,HeadPath,filename);
if (*filename != '\0')
(void) strlcat(filename,DirectorySeparator,MaxTextExtent);
(void) strlcat(filename,token,MaxTextExtent);
(void) ReadConfigureFile(filename,depth+1,exception);
}
if (delegate_list != (DelegateInfo *) NULL)
while (delegate_list->next != (DelegateInfo *) NULL)
delegate_list=delegate_list->next;
}
}
continue;
}
if (LocaleCompare(keyword,"<delegate") == 0)
{
DelegateInfo
*delegate_info;
/*
Allocate memory for the delegate list.
*/
delegate_info=MagickAllocateMemory(DelegateInfo *,sizeof(DelegateInfo));
if (delegate_info == (DelegateInfo *) NULL)
MagickFatalError3(ResourceLimitFatalError,MemoryAllocationFailed,
UnableToAllocateDelegateInfo);
(void) memset(delegate_info,0,sizeof(DelegateInfo));
delegate_info->path=AcquireString(path);
delegate_info->signature=MagickSignature;
if (delegate_list == (DelegateInfo *) NULL)
{
delegate_list=delegate_info;
continue;
}
delegate_list->next=delegate_info;
delegate_info->previous=delegate_list;
delegate_list=delegate_list->next;
continue;
}
if (delegate_list == (DelegateInfo *) NULL)
continue;
GetToken(q,(char **) NULL,token);
if (*token != '=')
continue;
GetToken(q,&q,token);
GetToken(q,&q,token);
switch (*keyword)
{
case 'C':
case 'c':
{
if (LocaleCompare((char *) keyword,"command") == 0)
{
delegate_list->commands=AllocateString(token);
#if defined(MSWINDOWS)
if (strchr(delegate_list->commands,'@') != (char *) NULL)
{
char
BinPath[MaxTextExtent],
path[MaxTextExtent];
BinPath[0]=0;
/* Substitute @PSDelegate@ with path to Ghostscript */
NTGhostscriptEXE(path,MaxTextExtent-1);
SubstituteString((char **) &delegate_list->commands,
"@PSDelegate@",path);
# if defined(UseInstalledMagick)
# if defined(MagickBinPath)
strcpy(BinPath,MagickBinPath);
# else
{
char
*key,
*key_value;
/* Obtain installation path from registry */
key="BinPath";
key_value=NTRegistryKeyLookup(key);
if (!key_value)
{
ThrowException(exception,ConfigureError,
RegistryKeyLookupFailed,key);
}
else
{
strcpy(BinPath,key_value);
MagickFreeMemory(key_value);
}
}
# endif /* defined(MagickBinPath) */
# else
/* Base path off of client path */
strcpy(BinPath,SetClientPath(NULL));
# endif /* defined(UseInstalledMagick) */
if ((BinPath[0] != 0) &&
(BinPath[strlen(BinPath)-1] != *DirectorySeparator))
strcat(BinPath,DirectorySeparator);
/* Substitute @GMDelegate@ with path to gm.exe */
CatDelegatePath(path,BinPath,"gm.exe");
SubstituteString((char **) &delegate_list->commands,
"@GMDelegate@",path);
/* Substitute @GMDisplayDelegate@ with path to
gmdisplay.exe */
CatDelegatePath(path,BinPath,"gmdisplay.exe");
SubstituteString((char **) &delegate_list->commands,
"@GMDisplayDelegate@",path);
/* Substitute @MPEGDecodeDelegate@ with path to
mpeg2dec.exe */
CatDelegatePath(path,BinPath,"mpeg2dec.exe");
SubstituteString((char **) &delegate_list->commands,
"@MPEGDecodeDelegate@",path);
/* Substitute @MPEGEncodeDelegate@ with path to
mpeg2enc.exe */
CatDelegatePath(path,BinPath,"mpeg2enc.exe");
SubstituteString((char **) &delegate_list->commands,
"@MPEGEncodeDelegate@",path);
/* Substitute @HPGLDecodeDelegate@ with path to
hp2xx.exe */
CatDelegatePath(path,BinPath,"hp2xx.exe");
SubstituteString((char **) &delegate_list->commands,
"@HPGLDecodeDelegate@",path);
}
#endif /* defined(MSWINDOWS) */
} /* LocaleCompare */
break;
}
case 'D':
case 'd':
{
if (LocaleCompare((char *) keyword,"decode") == 0)
{
delegate_list->decode=AcquireString(token);
delegate_list->mode=1;
break;
}
break;
}
case 'E':
case 'e':
{
if (LocaleCompare((char *) keyword,"encode") == 0)
{
delegate_list->encode=AcquireString(token);
delegate_list->mode=(-1);
break;
}
break;
}
case 'M':
case 'm':
{
if (LocaleCompare((char *) keyword,"mode") == 0)
{
delegate_list->mode=1;
if (LocaleCompare(token,"bi") == 0)
delegate_list->mode=0;
else
if (LocaleCompare(token,"encode") == 0)
delegate_list->mode=(-1);
break;
}
break;
}
case 'S':
case 's':
{
if (LocaleCompare((char *) keyword,"stealth") == 0)
{
delegate_list->stealth=LocaleCompare(token,"True") == 0;
break;
}
break;
}
default:
break;
}
}
