(no commit message)

diff --git a/coders/djvu.c b/coders/djvu.c
index 424618dda981332f30d6eebdbc76d0d68041f2da..7b31ff16f9132119777c0da46bd586b76a7e6e61 100644 (file)
--- a/coders/djvu.c
+++ b/coders/djvu.c
@@ -794,7 +794,7 @@ static Image *ReadDJVUImage(const ImageInfo *image_info,
   /*
    * Allocate a LoadContext structure.
    */
-  lc = (LoadContext *) AcquireMagickMemory(sizeof(*lc));
+  lc = (LoadContext *) AcquireAlignedMemory(1,sizeof(*lc));
   if (lc == NULL)
     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 

diff --git a/coders/gif.c b/coders/gif.c
index 8dde617c3ba95a2cfed289c659f7e7264341d83f..bc65fab0700bdd54cb867515bc243392d60481a1 100644 (file)
--- a/coders/gif.c
+++ b/coders/gif.c
@@ -194,7 +194,7 @@ static LZWInfo *AcquireLZWInfo(Image *image,const unsigned long data_size)
   register long
     i;
 
-  lzw_info=(LZWInfo *) AcquireMagickMemory(sizeof(*lzw_info));
+  lzw_info=(LZWInfo *) AcquireAlignedMemory(1,sizeof(*lzw_info));
   if (lzw_info == (LZWInfo *) NULL)
     return((LZWInfo *) NULL);
   (void) ResetMagickMemory(lzw_info,0,sizeof(*lzw_info));
@@ -225,7 +225,7 @@ static LZWInfo *AcquireLZWInfo(Image *image,const unsigned long data_size)
   lzw_info->code_info.bit=8*lzw_info->code_info.count;
   lzw_info->code_info.eof=MagickFalse;
   lzw_info->genesis=MagickTrue;
-  lzw_info->stack=(LZWStack *) AcquireMagickMemory(sizeof(*lzw_info->stack));
+  lzw_info->stack=(LZWStack *) AcquireAlignedMemory(1,sizeof(*lzw_info->stack));
   if (lzw_info->stack == (LZWStack *) NULL)
     {
       lzw_info=RelinquishLZWInfo(lzw_info);

diff --git a/coders/msl.c b/coders/msl.c
index e8dc984c2bab46619bba34bb1c5c41fbfffab1f2..d2346db292ce305a54001d3980776352a60c5c34 100644 (file)
--- a/coders/msl.c
+++ b/coders/msl.c
@@ -7590,7 +7590,7 @@ static MagickBooleanType ProcessMSLScript(const ImageInfo *image_info,Image **im
   msl_info.draw_info=(DrawInfo **) AcquireMagickMemory(
     sizeof(*msl_info.draw_info));
   /* top of the stack is the MSL file itself */
-  msl_info.image=(Image **) AcquireMagickMemory(sizeof(*msl_info.image));
+  msl_info.image=(Image **) AcquireAlignedMemory(1,sizeof(*msl_info.image));
   msl_info.attributes=(Image **) AcquireMagickMemory(
     sizeof(*msl_info.attributes));
   msl_info.group_info=(MSLGroupInfo *) AcquireMagickMemory(

diff --git a/coders/png.c b/coders/png.c
index 11f34e14676abbc1df36bc7ba0ec14a3f35f8f75..69ed1d96aafa2e71ad69b371e5c0f0155a3ca7cb 100644 (file)
--- a/coders/png.c
+++ b/coders/png.c
@@ -2801,7 +2801,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
             create a new object buffer.
           */
           mng_info->ob[object_id]=(MngBuffer *)
-            AcquireMagickMemory(sizeof(MngBuffer));
+            AcquireAlignedMemory(1,sizeof(MngBuffer));
           if (mng_info->ob[object_id] != (MngBuffer *) NULL)
             {
               mng_info->ob[object_id]->image=(Image *) NULL;
@@ -2944,7 +2944,7 @@ static Image *ReadPNGImage(const ImageInfo *image_info,ExceptionInfo *exception)
     Allocate a MngInfo structure.
   */
   have_mng_structure=MagickFalse;
-  mng_info=(MngInfo *) AcquireMagickMemory(sizeof(MngInfo));
+  mng_info=(MngInfo *) AcquireAlignedMemory(1,sizeof(MngInfo));
   if (mng_info == (MngInfo *) NULL)
     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
   /*
@@ -3241,7 +3241,7 @@ static Image *ReadOneJNGImage(MngInfo *mng_info,
                open alpha_blob, attached to alpha_image
         */
 
-        color_image_info=(ImageInfo *)AcquireMagickMemory(sizeof(ImageInfo));
+        color_image_info=(ImageInfo *)AcquireAlignedMemory(1,sizeof(ImageInfo));
         if (color_image_info == (ImageInfo *) NULL)
           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
         GetImageInfo(color_image_info);
@@ -3261,7 +3261,7 @@ static Image *ReadOneJNGImage(MngInfo *mng_info,
         if ((image_info->ping == MagickFalse) && (jng_color_type >= 12))
           {
             alpha_image_info=(ImageInfo *)
-              AcquireMagickMemory(sizeof(ImageInfo));
+              AcquireAlignedMemory(1,sizeof(ImageInfo));
             if (alpha_image_info == (ImageInfo *) NULL)
               ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
             GetImageInfo(alpha_image_info);
@@ -3709,7 +3709,7 @@ static Image *ReadJNGImage(const ImageInfo *image_info,ExceptionInfo *exception)
     Allocate a MngInfo structure.
   */
   have_mng_structure=MagickFalse;
-  mng_info=(MngInfo *) AcquireMagickMemory(sizeof(*mng_info));
+  mng_info=(MngInfo *) AcquireAlignedMemory(1,sizeof(*mng_info));
   if (mng_info == (MngInfo *) NULL)
     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
   /*
@@ -3881,7 +3881,7 @@ static Image *ReadMNGImage(const ImageInfo *image_info,ExceptionInfo *exception)
   /*
     Allocate a MngInfo structure.
   */
-  mng_info=(MngInfo *) AcquireMagickMemory(sizeof(MngInfo));
+  mng_info=(MngInfo *) AcquireAlignedMemory(1,sizeof(MngInfo));
   if (mng_info == (MngInfo *) NULL)
     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
   /*
@@ -7981,7 +7981,7 @@ static MagickBooleanType WritePNGImage(const ImageInfo *image_info,
     Allocate a MngInfo structure.
   */
   have_mng_structure=MagickFalse;
-  mng_info=(MngInfo *) AcquireMagickMemory(sizeof(MngInfo));
+  mng_info=(MngInfo *) AcquireAlignedMemory(1,sizeof(MngInfo));
   if (mng_info == (MngInfo *) NULL)
     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
   /*
@@ -8629,7 +8629,7 @@ static MagickBooleanType WriteJNGImage(const ImageInfo *image_info,Image *image)
     Allocate a MngInfo structure.
   */
   have_mng_structure=MagickFalse;
-  mng_info=(MngInfo *) AcquireMagickMemory(sizeof(MngInfo));
+  mng_info=(MngInfo *) AcquireAlignedMemory(1,sizeof(MngInfo));
   if (mng_info == (MngInfo *) NULL)
     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
   /*
@@ -8725,7 +8725,7 @@ static MagickBooleanType WriteMNGImage(const ImageInfo *image_info,Image *image)
     Allocate a MngInfo structure.
   */
   have_mng_structure=MagickFalse;
-  mng_info=(MngInfo *) AcquireMagickMemory(sizeof(MngInfo));
+  mng_info=(MngInfo *) AcquireAlignedMemory(1,sizeof(MngInfo));
   if (mng_info == (MngInfo *) NULL)
     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
   /*

diff --git a/coders/svg.c b/coders/svg.c
index 413d5afe0adb29e75fa4f5aae61d7bfd9169c9ec..eb9224fb0b5d862860ac216e34b87c0b926c7220 100644 (file)
--- a/coders/svg.c
+++ b/coders/svg.c
@@ -259,12 +259,12 @@ static SVGInfo *AcquireSVGInfo(void)
   SVGInfo
     *svg_info;
 
-  svg_info=(SVGInfo *) AcquireMagickMemory(sizeof(*svg_info));
+  svg_info=(SVGInfo *) AcquireAlignedMemory(1,sizeof(*svg_info));
   if (svg_info == (SVGInfo *) NULL)
     return((SVGInfo *) NULL);
   (void) ResetMagickMemory(svg_info,0,sizeof(*svg_info));
   svg_info->text=AcquireString("");
-  svg_info->scale=(double *) AcquireMagickMemory(sizeof(*svg_info->scale));
+  svg_info->scale=(double *) AcquireAlignedMemory(1,sizeof(*svg_info->scale));
   if (svg_info->scale == (double *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   GetAffineMatrix(&svg_info->affine);

diff --git a/coders/vid.c b/coders/vid.c
index 68cd0d0506803fa70b10c859528ec8fc2684c1aa..60a62ee8e4256222eaf84cc834ee3b4527a9d601 100644 (file)
--- a/coders/vid.c
+++ b/coders/vid.c
@@ -139,7 +139,7 @@ static Image *ReadVIDImage(const ImageInfo *image_info,ExceptionInfo *exception)
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
   image=AcquireImage(image_info);
-  filelist=(char **) AcquireMagickMemory(sizeof(*filelist));
+  filelist=(char **) AcquireAlignedMemory(1,sizeof(*filelist));
   if (filelist == (char **) NULL)
     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
   filelist[0]=ConstantString(image_info->filename);

diff --git a/coders/xwd.c b/coders/xwd.c
index b8deaf4c999626f175335ac2a3c908932e12835e..6d53ba36b49297ba4944c2218cf05bf7f78213ad 100644 (file)
--- a/coders/xwd.c
+++ b/coders/xwd.c
@@ -255,7 +255,7 @@ static Image *ReadXWDImage(const ImageInfo *image_info,ExceptionInfo *exception)
   /*
     Initialize the X image.
   */
-  ximage=(XImage *) AcquireMagickMemory(sizeof(*ximage));
+  ximage=(XImage *) AcquireAlignedMemory(1,sizeof(*ximage));
   if (ximage == (XImage *) NULL)
     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
   ximage->depth=(int) header.pixmap_depth;

diff --git a/config/configure.xml b/config/configure.xml
index 68723960d6e9f9303b083fee640d1dc4b9a43ac1..fcc0c88dc8b0812750b9126a1d2ce5dd57f48b10 100644 (file)
--- a/config/configure.xml
+++ b/config/configure.xml
@@ -9,7 +9,7 @@
   <configure name="NAME" value="ImageMagick"/>
   <configure name="LIB_VERSION" value="0x658"/>
   <configure name="LIB_VERSION_NUMBER" value="6,5,8,6"/>
-  <configure name="RELEASE_DATE" value="2009-12-11"/>
+  <configure name="RELEASE_DATE" value="2009-12-12"/>
   <configure name="CONFIGURE" value="./configure "/>
   <configure name="PREFIX" value="/usr/local"/>
   <configure name="EXEC-PREFIX" value="/usr/local"/>

diff --git a/magick/PreRvIcccm.c b/magick/PreRvIcccm.c
index 034cef5cc26345f1214f70d89fc5379627dbd8b5..2b0a2b5549dddfbd9bdbd818b3df9152b539f53d 100644 (file)
--- a/magick/PreRvIcccm.c
+++ b/magick/PreRvIcccm.c
@@ -127,17 +127,17 @@ Bool XSupportsLocale()
 */
 XClassHint *XAllocClassHint)
 {
-  return((XClassHint *) AcquireMagickMemory(sizeof(XClassHint)));
+  return((XClassHint *) AcquireAlignedMemory(1,sizeof(XClassHint)));
 }
 
 XIconSize *XAllocIconSize)
 {
-  return((XIconSize *) AcquireMagickMemory(sizeof(XIconSize)));
+  return((XIconSize *) AcquireAlignedMemory(1,sizeof(XIconSize)));
 }
 
 XSizeHints *XAllocSizeHints)
 {
-  return((XSizeHints *) AcquireMagickMemory(sizeof(XSizeHints)));
+  return((XSizeHints *) AcquireAlignedMemory(1,sizeof(XSizeHints)));
 }
 
 Status XReconfigureWMWindow(Display *display,Window window,int screen_number,
@@ -148,12 +148,12 @@ Status XReconfigureWMWindow(Display *display,Window window,int screen_number,
 
 XStandardColormap *XAllocStandardColormap)
 {
-  return((XStandardColormap *) AcquireMagickMemory(sizeof(XStandardColormap)));
+  return((XStandardColormap *) AcquireAlignedMemory(1,sizeof(XStandardColormap)));
 }
 
 XWMHints *XAllocWMHints)
 {
-  return((XWMHints *) AcquireMagickMemory(sizeof(XWMHints)));
+  return((XWMHints *) AcquireAlignedMemory(1,sizeof(XWMHints)));
 }
 
 Status XGetGCValues(Display *display,GC gc,unsigned long mask,

diff --git a/magick/animate.c b/magick/animate.c
index ee74d5b78ce1b5edccdd6cf5f9e8c1c53422930b..031d7ea10d90879634fe06171140ec6706ed9d45 100644 (file)
--- a/magick/animate.c
+++ b/magick/animate.c
@@ -413,7 +413,7 @@ static Image *XMagickCommand(Display *display,XResourceInfo *resource_info,
       /*
         Expand the filenames.
       */
-      filelist=(char **) AcquireMagickMemory(sizeof(char *));
+      filelist=(char **) AcquireAlignedMemory(1,sizeof(char *));
       if (filelist == (char **) NULL)
         {
           ThrowXWindowException(ResourceLimitError,"MemoryAllocationFailed",

diff --git a/magick/blob.c b/magick/blob.c
index 8ba3c3563c872e81d6e0060cc9b04e90d9cf1fde..3d60657336dd62e47a049cc75bbaf73d21326014 100644 (file)
--- a/magick/blob.c
+++ b/magick/blob.c
@@ -415,7 +415,7 @@ MagickExport BlobInfo *CloneBlobInfo(const BlobInfo *blob_info)
   BlobInfo
     *clone_info;
 
-  clone_info=(BlobInfo *) AcquireMagickMemory(sizeof(*clone_info));
+  clone_info=(BlobInfo *) AcquireAlignedMemory(1,sizeof(*clone_info));
   if (clone_info == (BlobInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   GetBlobInfo(clone_info);

diff --git a/magick/cipher.c b/magick/cipher.c
index 8c9f7e6d92420051833bb9077bf598638f28281e..f1ad73cad43ad0c01853c6a1a4d1aeeb65ef7732 100644 (file)
--- a/magick/cipher.c
+++ b/magick/cipher.c
@@ -190,7 +190,7 @@ static AESInfo *AcquireAESInfo(void)
   AESInfo
     *aes_info;
 
-  aes_info=(AESInfo *) AcquireMagickMemory(sizeof(*aes_info));
+  aes_info=(AESInfo *) AcquireAlignedMemory(1,sizeof(*aes_info));
   if (aes_info == (AESInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(aes_info,0,sizeof(*aes_info));

diff --git a/magick/coder.c b/magick/coder.c
index df81b6e0a1a43745862e46cfd6887990c8330b26..d7b2a85e47b810350b3b75b8b1f9cd4b86b20325 100644 (file)
--- a/magick/coder.c
+++ b/magick/coder.c
@@ -780,7 +780,7 @@ static MagickBooleanType LoadCoderList(const char *xml,const char *filename,
         /*
           Coder element.
         */
-        coder_info=(CoderInfo *) AcquireMagickMemory(sizeof(*coder_info));
+        coder_info=(CoderInfo *) AcquireAlignedMemory(1,sizeof(*coder_info));
         if (coder_info == (CoderInfo *) NULL)
           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
         (void) ResetMagickMemory(coder_info,0,sizeof(*coder_info));
@@ -911,7 +911,7 @@ static MagickBooleanType LoadCoderLists(const char *filename,
       *p;
 
     p=CoderMap+i;
-    coder_info=(CoderInfo *) AcquireMagickMemory(sizeof(*coder_info));
+    coder_info=(CoderInfo *) AcquireAlignedMemory(1,sizeof(*coder_info));
     if (coder_info == (CoderInfo *) NULL)
       {
         (void) ThrowMagickException(exception,GetMagickModule(),

diff --git a/magick/color.c b/magick/color.c
index c1ad4e90e2b65cb97c75ff59284a7f802e6256ee..76fc71b0d70c572721b14529140a08bda71c0a2e 100644 (file)
--- a/magick/color.c
+++ b/magick/color.c
@@ -2035,7 +2035,7 @@ static MagickBooleanType LoadColorList(const char *xml,const char *filename,
         /*
           Color element.
         */
-        color_info=(ColorInfo *) AcquireMagickMemory(sizeof(*color_info));
+        color_info=(ColorInfo *) AcquireAlignedMemory(1,sizeof(*color_info));
         if (color_info == (ColorInfo *) NULL)
           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
         (void) ResetMagickMemory(color_info,0,sizeof(*color_info));
@@ -2183,7 +2183,7 @@ static MagickBooleanType LoadColorLists(const char *filename,
       *p;
 
     p=ColorMap+i;
-    color_info=(ColorInfo *) AcquireMagickMemory(sizeof(*color_info));
+    color_info=(ColorInfo *) AcquireAlignedMemory(1,sizeof(*color_info));
     if (color_info == (ColorInfo *) NULL)
       {
         (void) ThrowMagickException(exception,GetMagickModule(),

diff --git a/magick/compress.c b/magick/compress.c
index 60fa115dea6f488b3364d4ec5aca207226aaa608..07b84220dc253e6edc32b4fe4977c1bbc34e75bb 100644 (file)
--- a/magick/compress.c
+++ b/magick/compress.c
@@ -274,7 +274,7 @@ MagickExport void Ascii85Initialize(Image *image)
     Allocate image structure.
   */
   if (image->ascii85 == (Ascii85Info *) NULL)
-    image->ascii85=(Ascii85Info *) AcquireMagickMemory(sizeof(*image->ascii85));
+    image->ascii85=(Ascii85Info *) AcquireAlignedMemory(1,sizeof(*image->ascii85));
   if (image->ascii85 == (Ascii85Info *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(image->ascii85,0,sizeof(*image->ascii85));

diff --git a/magick/deprecate.c b/magick/deprecate.c
index 0b90a30dfa4720884e62d0cddb850abe3b412116..ece228f81123d07f24ef34db5d8db0a761e293b7 100644 (file)
--- a/magick/deprecate.c
+++ b/magick/deprecate.c
@@ -2339,7 +2339,7 @@ MagickExport const ImageAttribute *GetImageAttribute(const Image *image,
       if (attribute != (const ImageAttribute *) NULL)
         return(attribute);
     }
-  attribute=(ImageAttribute *) AcquireMagickMemory(sizeof(*attribute));
+  attribute=(ImageAttribute *) AcquireAlignedMemory(1,sizeof(*attribute));
   if (attribute == (ImageAttribute *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(attribute,0,sizeof(*attribute));

diff --git a/magick/display.c b/magick/display.c
index 7bc1af7f538b214a2775b98cf9a3fcb5e36420c7..7bb046320bcda3a7506cbbb8f4ff2cd14c0fbd77 100644 (file)
--- a/magick/display.c
+++ b/magick/display.c
@@ -2233,7 +2233,7 @@ static MagickBooleanType XAnnotateEditImage(Display *display,
   /*
     Initialize annotate structure.
   */
-  annotate_info=(XAnnotateInfo *) AcquireMagickMemory(sizeof(*annotate_info));
+  annotate_info=(XAnnotateInfo *) AcquireAlignedMemory(1,sizeof(*annotate_info));
   if (annotate_info == (XAnnotateInfo *) NULL)
     return(MagickFalse);
   XGetAnnotateInfo(annotate_info);
@@ -13421,7 +13421,7 @@ static Image *XVisualDirectoryImage(Display *display,
   /*
     Expand the filenames.
   */
-  filelist=(char **) AcquireMagickMemory(sizeof(*filelist));
+  filelist=(char **) AcquireAlignedMemory(1,sizeof(*filelist));
   if (filelist == (char **) NULL)
     {
       ThrowXWindowFatalException(ResourceLimitError,"MemoryAllocationFailed",

diff --git a/magick/draw.c b/magick/draw.c
index ae5ccebd25f4180c310beb1b6808bc1fcf5435c6..9458ea4f091f4faccd9dcf614d4a33084d387b40 100644 (file)
--- a/magick/draw.c
+++ b/magick/draw.c
@@ -196,7 +196,7 @@ MagickExport DrawInfo *AcquireDrawInfo(void)
   DrawInfo
     *draw_info;
 
-  draw_info=(DrawInfo *) AcquireMagickMemory(sizeof(*draw_info));
+  draw_info=(DrawInfo *) AcquireAlignedMemory(1,sizeof(*draw_info));
   if (draw_info == (DrawInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   GetDrawInfo((ImageInfo *) NULL,draw_info);
@@ -236,7 +236,7 @@ MagickExport DrawInfo *CloneDrawInfo(const ImageInfo *image_info,
   DrawInfo
     *clone_info;
 
-  clone_info=(DrawInfo *) AcquireMagickMemory(sizeof(*clone_info));
+  clone_info=(DrawInfo *) AcquireAlignedMemory(1,sizeof(*clone_info));
   if (clone_info == (DrawInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   GetDrawInfo(image_info,clone_info);
@@ -478,7 +478,7 @@ static PolygonInfo *ConvertPathToPolygon(
   /*
     Convert a path to the more efficient sorted rendering form.
   */
-  polygon_info=(PolygonInfo *) AcquireMagickMemory(sizeof(*polygon_info));
+  polygon_info=(PolygonInfo *) AcquireAlignedMemory(1,sizeof(*polygon_info));
   if (polygon_info == (PolygonInfo *) NULL)
     return((PolygonInfo *) NULL);
   number_edges=16;
@@ -1764,7 +1764,7 @@ MagickExport MagickBooleanType DrawImage(Image *image,const DrawInfo *draw_info)
   /*
     Allocate primitive info memory.
   */
-  graphic_context=(DrawInfo **) AcquireMagickMemory(sizeof(*graphic_context));
+  graphic_context=(DrawInfo **) AcquireAlignedMemory(1,sizeof(*graphic_context));
   if (graphic_context == (DrawInfo **) NULL)
     {
       primitive=DestroyString(primitive);

diff --git a/magick/exception.c b/magick/exception.c
index 9be7f685d56eee2ceba07e38e9bc7106723f9b1b..0e46466c8b94f96b4e7a67d2562c2164cbebb7f9 100644 (file)
--- a/magick/exception.c
+++ b/magick/exception.c
@@ -103,7 +103,7 @@ MagickExport ExceptionInfo *AcquireExceptionInfo(void)
   ExceptionInfo
     *exception;
 
-  exception=(ExceptionInfo *) AcquireMagickMemory(sizeof(*exception));
+  exception=(ExceptionInfo *) AcquireAlignedMemory(1,sizeof(*exception));
   if (exception == (ExceptionInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   GetExceptionInfo(exception);
@@ -875,7 +875,7 @@ MagickExport MagickBooleanType ThrowException(ExceptionInfo *exception,
       (LocaleCompare(exception->reason,reason) == 0) &&
       (LocaleCompare(exception->description,description) == 0))
     return(MagickTrue);
-  p=(ExceptionInfo *) AcquireMagickMemory(sizeof(*p));
+  p=(ExceptionInfo *) AcquireAlignedMemory(1,sizeof(*p));
   if (p == (ExceptionInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(p,0,sizeof(*p));

diff --git a/magick/fx.c b/magick/fx.c
index fbe60f6fc3ef11adc9560d15fbfa85299282a737..4cf1778224940084b11e3de1a30d2098f05692d1 100644 (file)
--- a/magick/fx.c
+++ b/magick/fx.c
@@ -158,7 +158,7 @@ MagickExport FxInfo *AcquireFxInfo(const Image *image,const char *expression)
   register long
     i;
 
-  fx_info=(FxInfo *) AcquireMagickMemory(sizeof(*fx_info));
+  fx_info=(FxInfo *) AcquireAlignedMemory(1,sizeof(*fx_info));
   if (fx_info == (FxInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(fx_info,0,sizeof(*fx_info));

diff --git a/magick/hashmap.c b/magick/hashmap.c
index 690ab76b76ae566d87d1c87a1b46a1254194d9a3..db4d8e9a51c0461ddf7123ad9bda53be0b644c8d 100644 (file)
--- a/magick/hashmap.c
+++ b/magick/hashmap.c
@@ -165,7 +165,7 @@ MagickExport MagickBooleanType AppendValueToLinkedList(
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
   if (list_info->elements == list_info->capacity)
     return(MagickFalse);
-  next=(ElementInfo *) AcquireMagickMemory(sizeof(*next));
+  next=(ElementInfo *) AcquireAlignedMemory(1,sizeof(*next));
   if (next == (ElementInfo *) NULL)
     return(MagickFalse);
   next->value=(void *) value;
@@ -1035,7 +1035,7 @@ MagickExport MagickBooleanType InsertValueInLinkedList(
   if ((index > list_info->elements) ||
       (list_info->elements == list_info->capacity))
     return(MagickFalse);
-  next=(ElementInfo *) AcquireMagickMemory(sizeof(*next));
+  next=(ElementInfo *) AcquireAlignedMemory(1,sizeof(*next));
   if (next == (ElementInfo *) NULL)
     return(MagickFalse);
   next->value=(void *) value;
@@ -1142,7 +1142,7 @@ MagickExport MagickBooleanType InsertValueInSortedLinkedList(
     return(MagickFalse);
   if (list_info->elements == list_info->capacity)
     return(MagickFalse);
-  next=(ElementInfo *) AcquireMagickMemory(sizeof(*next));
+  next=(ElementInfo *) AcquireAlignedMemory(1,sizeof(*next));
   if (next == (ElementInfo *) NULL)
     return(MagickFalse);
   next->value=(void *) value;
@@ -1350,7 +1350,7 @@ MagickExport HashmapInfo *NewHashmap(const unsigned long capacity,
   HashmapInfo
     *hashmap_info;
 
-  hashmap_info=(HashmapInfo *) AcquireMagickMemory(sizeof(*hashmap_info));
+  hashmap_info=(HashmapInfo *) AcquireAlignedMemory(1,sizeof(*hashmap_info));
   if (hashmap_info == (HashmapInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(hashmap_info,0,sizeof(*hashmap_info));
@@ -1406,7 +1406,7 @@ MagickExport LinkedListInfo *NewLinkedList(const unsigned long capacity)
   LinkedListInfo
     *list_info;
 
-  list_info=(LinkedListInfo *) AcquireMagickMemory(sizeof(*list_info));
+  list_info=(LinkedListInfo *) AcquireAlignedMemory(1,sizeof(*list_info));
   if (list_info == (LinkedListInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(list_info,0,sizeof(*list_info));
@@ -1551,7 +1551,7 @@ MagickExport MagickBooleanType PutEntryInHashmap(HashmapInfo *hashmap_info,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
   if ((key == (void *) NULL) || (value == (void *) NULL))
     return(MagickFalse);
-  next=(EntryInfo *) AcquireMagickMemory(sizeof(*next));
+  next=(EntryInfo *) AcquireAlignedMemory(1,sizeof(*next));
   if (next == (EntryInfo *) NULL)
     return(MagickFalse);
   (void) LockSemaphoreInfo(hashmap_info->semaphore);

diff --git a/magick/histogram.c b/magick/histogram.c
index 8539606015806594eba60eb0a668568c2ecb4804..94c198462b075ec385657fd010613a3bab89fba2 100644 (file)
--- a/magick/histogram.c
+++ b/magick/histogram.c
@@ -480,7 +480,7 @@ static CubeInfo *GetCubeInfo(void)
   /*
     Initialize tree to describe color cube.
   */
-  cube_info=(CubeInfo *) AcquireMagickMemory(sizeof(*cube_info));
+  cube_info=(CubeInfo *) AcquireAlignedMemory(1,sizeof(*cube_info));
   if (cube_info == (CubeInfo *) NULL)
     return((CubeInfo *) NULL);
   (void) ResetMagickMemory(cube_info,0,sizeof(*cube_info));
@@ -591,7 +591,7 @@ static NodeInfo *GetNodeInfo(CubeInfo *cube_info,const unsigned long level)
       /*
         Allocate a new nodes of nodes.
       */
-      nodes=(Nodes *) AcquireMagickMemory(sizeof(*nodes));
+      nodes=(Nodes *) AcquireAlignedMemory(1,sizeof(*nodes));
       if (nodes == (Nodes *) NULL)
         return((NodeInfo *) NULL);
       nodes->next=cube_info->node_queue;

diff --git a/magick/image.c b/magick/image.c
index 5a7692b7a6f138023fc3b95a4b5434f748a45ca7..e2cbfaca0516ff5e072b1f9e21834fa1aaea6f9f 100644 (file)
--- a/magick/image.c
+++ b/magick/image.c
@@ -153,7 +153,7 @@ MagickExport Image *AcquireImage(const ImageInfo *image_info)
     Allocate image structure.
   */
   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
-  image=(Image *) AcquireMagickMemory(sizeof(*image));
+  image=(Image *) AcquireAlignedMemory(1,sizeof(*image));
   if (image == (Image *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(image,0,sizeof(*image));
@@ -369,7 +369,7 @@ MagickExport ImageInfo *AcquireImageInfo(void)
   ImageInfo
     *image_info;
 
-  image_info=(ImageInfo *) AcquireMagickMemory(sizeof(*image_info));
+  image_info=(ImageInfo *) AcquireAlignedMemory(1,sizeof(*image_info));
   if (image_info == (ImageInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   GetImageInfo(image_info);
@@ -820,7 +820,7 @@ MagickExport Image *CloneImage(const Image *image,const unsigned long columns,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
-  clone_image=(Image *) AcquireMagickMemory(sizeof(*clone_image));
+  clone_image=(Image *) AcquireAlignedMemory(1,sizeof(*clone_image));
   if (clone_image == (Image *) NULL)
     ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(clone_image,0,sizeof(*clone_image));

diff --git a/magick/locale.c b/magick/locale.c
index 25fa05e6b76ab54abc8f264607b0845330cc32e2..d5c4fbae82412a03f205fe4dc107081166778ce4 100644 (file)
--- a/magick/locale.c
+++ b/magick/locale.c
@@ -918,7 +918,7 @@ static MagickBooleanType LoadLocaleList(const char *xml,const char *filename,
         while ((isspace((int) ((unsigned char) *q)) != 0) && (q > p))
           q--;
         (void) CopyMagickString(message,p,(size_t) (q-p+2));
-        locale_info=(LocaleInfo *) AcquireMagickMemory(sizeof(*locale_info));
+        locale_info=(LocaleInfo *) AcquireAlignedMemory(1,sizeof(*locale_info));
         if (locale_info == (LocaleInfo *) NULL)
           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
         (void) ResetMagickMemory(locale_info,0,sizeof(*locale_info));

diff --git a/magick/log.c b/magick/log.c
index cf8f2ee791faa3815de4563cf1d0c879ef825d0f..6b172494f048359d2f772ca19390bdea1e7ca670 100644 (file)
--- a/magick/log.c
+++ b/magick/log.c
@@ -1378,7 +1378,7 @@ static MagickBooleanType LoadLogList(const char *xml,const char *filename,
         /*
           Allocate memory for the log list.
         */
-        log_info=(LogInfo *) AcquireMagickMemory(sizeof(*log_info));
+        log_info=(LogInfo *) AcquireAlignedMemory(1,sizeof(*log_info));
         if (log_info == (LogInfo *) NULL)
           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
         (void) ResetMagickMemory(log_info,0,sizeof(*log_info));
@@ -1552,7 +1552,7 @@ static MagickBooleanType LoadLogLists(const char *filename,
       *p;
 
     p=LogMap+i;
-    log_info=(LogInfo *) AcquireMagickMemory(sizeof(*log_info));
+    log_info=(LogInfo *) AcquireAlignedMemory(1,sizeof(*log_info));
     if (log_info == (LogInfo *) NULL)
       {
         (void) ThrowMagickException(exception,GetMagickModule(),

diff --git a/magick/mac.c b/magick/mac.c
index 71d039255eb740363a5529843dfe14e7a403fc1d..126753f41b77eca5a8babebb780e27fd0ab2358d 100644 (file)
--- a/magick/mac.c
+++ b/magick/mac.c
@@ -1028,7 +1028,7 @@ MagickExport DIR *opendir(const char *path)
       errno=error;
       return((DIR *) NULL);
     }
-  entry=(DIR *) AcquireMagickMemory(sizeof(DIR));
+  entry=(DIR *) AcquireAlignedMemory(1,sizeof(DIR));
   if (entry == (DIR *) NULL)
     return((DIR *) NULL);
   entry->d_VRefNum=search_info.hFileInfo.ioVRefNum;

diff --git a/magick/magic.c b/magick/magic.c
index 415d516318d061713a0cf5bddfa140e10049d3b3..25b1bff24a297e4d6ee878a3b200620f53427316 100644 (file)
--- a/magick/magic.c
+++ b/magick/magic.c
@@ -762,7 +762,7 @@ static MagickBooleanType LoadMagicList(const char *xml,const char *filename,
         /*
           Magic element.
         */
-        magic_info=(MagicInfo *) AcquireMagickMemory(sizeof(*magic_info));
+        magic_info=(MagicInfo *) AcquireAlignedMemory(1,sizeof(*magic_info));
         if (magic_info == (MagicInfo *) NULL)
           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
         (void) ResetMagickMemory(magic_info,0,sizeof(*magic_info));
@@ -954,7 +954,7 @@ static MagickBooleanType LoadMagicLists(const char *filename,
       *p;
 
     p=MagicMap+i;
-    magic_info=(MagicInfo *) AcquireMagickMemory(sizeof(*magic_info));
+    magic_info=(MagicInfo *) AcquireAlignedMemory(1,sizeof(*magic_info));
     if (magic_info == (MagicInfo *) NULL)
       {
         (void) ThrowMagickException(exception,GetMagickModule(),

diff --git a/magick/magick.c b/magick/magick.c
index a4e0db9efc4ff4753040edb06b612210fa394d40..fb5681f4ca3ebe329305bb55ccd644b83d0c6c0e 100644 (file)
--- a/magick/magick.c
+++ b/magick/magick.c
@@ -1414,7 +1414,7 @@ MagickExport MagickInfo *SetMagickInfo(const char *name)
 
   assert(name != (const char *) NULL);
   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",name);
-  magick_info=(MagickInfo *) AcquireMagickMemory(sizeof(*magick_info));
+  magick_info=(MagickInfo *) AcquireAlignedMemory(1,sizeof(*magick_info));
   if (magick_info == (MagickInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(magick_info,0,sizeof(*magick_info));

diff --git a/magick/mime.c b/magick/mime.c
index c0b2b6a839c79b088e4698d3f93d6d8c3fd83ee5..bb8a0a38b6f6e82bce0642dd68cae6b5cafca79e 100644 (file)
--- a/magick/mime.c
+++ b/magick/mime.c
@@ -814,7 +814,7 @@ static MagickBooleanType LoadMimeList(const char *xml,const char *filename,
     /*
       Process mime element.
     */
-    mime_info=(MimeInfo *) AcquireMagickMemory(sizeof(*mime_info));
+    mime_info=(MimeInfo *) AcquireAlignedMemory(1,sizeof(*mime_info));
     if (mime_info == (MimeInfo *) NULL)
       ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
     (void) ResetMagickMemory(mime_info,0,sizeof(*mime_info));

diff --git a/magick/module.c b/magick/module.c
index 6f049f952c24750fc1178e234f83f5ea9f2a90f0..35157b3d276308df5f96c79adaf159b7f7b0f7ca 100644 (file)
--- a/magick/module.c
+++ b/magick/module.c
@@ -138,7 +138,7 @@ MagickExport ModuleInfo *AcquireModuleInfo(const char *path,const char *tag)
   ModuleInfo
     *module_info;
 
-  module_info=(ModuleInfo *) AcquireMagickMemory(sizeof(*module_info));
+  module_info=(ModuleInfo *) AcquireAlignedMemory(1,sizeof(*module_info));
   if (module_info == (ModuleInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(module_info,0,sizeof(*module_info));
@@ -447,7 +447,7 @@ MagickExport char **GetModuleList(const char *pattern,
       modules=(char **) RelinquishMagickMemory(modules);
       return((char **) NULL);
     }
-  buffer=(struct dirent *) AcquireMagickMemory(sizeof(*buffer)+FILENAME_MAX+1);
+  buffer=(struct dirent *) AcquireAlignedMemory(1,sizeof(*buffer)+FILENAME_MAX+1);
   if (buffer == (struct dirent *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   i=0;

diff --git a/magick/montage.c b/magick/montage.c
index 1884b57c4cb8d794a6d3429f8917774f26c4132a..5b8a92973d44e3d846060751df0000506afa504d 100644 (file)
--- a/magick/montage.c
+++ b/magick/montage.c
@@ -104,7 +104,7 @@ MagickExport MontageInfo *CloneMontageInfo(const ImageInfo *image_info,
   MontageInfo
     *clone_info;
 
-  clone_info=(MontageInfo *) AcquireMagickMemory(sizeof(*clone_info));
+  clone_info=(MontageInfo *) AcquireAlignedMemory(1,sizeof(*clone_info));
   if (clone_info == (MontageInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   GetMontageInfo(image_info,clone_info);

diff --git a/magick/nt-base.c b/magick/nt-base.c
index 4e1aa7dcd606298250811677c147509a3fa0bb83..799477069ed0e7774c3833db37f73ec224b36873 100644 (file)
--- a/magick/nt-base.c
+++ b/magick/nt-base.c
@@ -1313,7 +1313,7 @@ MagickExport DIR *NTOpenDirectory(const char *path)
     MaxTextExtent);
   if (length >= MaxTextExtent)
     return((DIR *) NULL);
-  entry=(DIR *) AcquireMagickMemory(sizeof(DIR));
+  entry=(DIR *) AcquireAlignedMemory(1,sizeof(DIR));
   if (entry != (DIR *) NULL)
     {
       entry->firsttime=TRUE;

diff --git a/magick/nt-feature.c b/magick/nt-feature.c
index 7f15539499cbc6f4cff327d9e34b4a593be07bb1..0b6bda9e7014638342a82edf1dd520f32c3747bc 100644 (file)
--- a/magick/nt-feature.c
+++ b/magick/nt-feature.c
@@ -382,7 +382,7 @@ MagickExport MagickBooleanType NTLoadTypeLists(SplayTreeInfo *type_list,
           continue;
         *pos='\0'; /* Remove (TrueType) from string */
 
-        type_info=(TypeInfo *) AcquireMagickMemory(sizeof(*type_info));
+        type_info=(TypeInfo *) AcquireAlignedMemory(1,sizeof(*type_info));
         if (type_info == (TypeInfo *) NULL)
           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
         (void) ResetMagickMemory(type_info,0,sizeof(TypeInfo));

diff --git a/magick/pixel-private.h b/magick/pixel-private.h
index 36e2cd0e6717466f728128eacacadce79d08f368..a3a5ee6c40ba885d248a7930a91eb3c0003660ff 100644 (file)
--- a/magick/pixel-private.h
+++ b/magick/pixel-private.h
@@ -34,7 +34,7 @@ static inline MagickPixelPacket *CloneMagickPixelPacket(
   MagickPixelPacket
     *clone_pixel;
 
-  clone_pixel=(MagickPixelPacket *) AcquireMagickMemory(sizeof(*clone_pixel));
+  clone_pixel=(MagickPixelPacket *) AcquireAlignedMemory(1,sizeof(*clone_pixel));
   if (clone_pixel == (MagickPixelPacket *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   *clone_pixel=(*pixel);

diff --git a/magick/policy.c b/magick/policy.c
index 0485af09e4f4f90c8f2d6925de828d16d925bb4a..02a2915ed965f34d33eb1c68e0a163c854c5d311 100644 (file)
--- a/magick/policy.c
+++ b/magick/policy.c
@@ -746,7 +746,7 @@ static MagickBooleanType LoadPolicyList(const char *xml,const char *filename,
         /*
           Policy element.
         */
-        policy_info=(PolicyInfo *) AcquireMagickMemory(sizeof(*policy_info));
+        policy_info=(PolicyInfo *) AcquireAlignedMemory(1,sizeof(*policy_info));
         if (policy_info == (PolicyInfo *) NULL)
           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
         (void) ResetMagickMemory(policy_info,0,sizeof(*policy_info));
@@ -907,7 +907,7 @@ static MagickBooleanType LoadPolicyLists(const char *filename,
       *p;
 
     p=PolicyMap+i;
-    policy_info=(PolicyInfo *) AcquireMagickMemory(sizeof(*policy_info));
+    policy_info=(PolicyInfo *) AcquireAlignedMemory(1,sizeof(*policy_info));
     if (policy_info == (PolicyInfo *) NULL)
       {
         (void) ThrowMagickException(exception,GetMagickModule(),

diff --git a/magick/quantize.c b/magick/quantize.c
index 7b1510db3ddb4238b7efa604fb678a1da97c4d1a..97c2432576ff60cc8f9666d86ec314d1207bf38b 100644 (file)
--- a/magick/quantize.c
+++ b/magick/quantize.c
@@ -361,7 +361,7 @@ MagickExport QuantizeInfo *AcquireQuantizeInfo(const ImageInfo *image_info)
   QuantizeInfo
     *quantize_info;
 
-  quantize_info=(QuantizeInfo *) AcquireMagickMemory(sizeof(*quantize_info));
+  quantize_info=(QuantizeInfo *) AcquireAlignedMemory(1,sizeof(*quantize_info));
   if (quantize_info == (QuantizeInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   GetQuantizeInfo(quantize_info);
@@ -969,7 +969,7 @@ MagickExport QuantizeInfo *CloneQuantizeInfo(const QuantizeInfo *quantize_info)
   QuantizeInfo
     *clone_info;
 
-  clone_info=(QuantizeInfo *) AcquireMagickMemory(sizeof(*clone_info));
+  clone_info=(QuantizeInfo *) AcquireAlignedMemory(1,sizeof(*clone_info));
   if (clone_info == (QuantizeInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   GetQuantizeInfo(clone_info);
@@ -1842,7 +1842,7 @@ static CubeInfo *GetCubeInfo(const QuantizeInfo *quantize_info,
   /*
     Initialize tree to describe color cube_info.
   */
-  cube_info=(CubeInfo *) AcquireMagickMemory(sizeof(*cube_info));
+  cube_info=(CubeInfo *) AcquireAlignedMemory(1,sizeof(*cube_info));
   if (cube_info == (CubeInfo *) NULL)
     return((CubeInfo *) NULL);
   (void) ResetMagickMemory(cube_info,0,sizeof(*cube_info));
@@ -1942,7 +1942,7 @@ static NodeInfo *GetNodeInfo(CubeInfo *cube_info,const unsigned long id,
       /*
         Allocate a new queue of nodes.
       */
-      nodes=(Nodes *) AcquireMagickMemory(sizeof(*nodes));
+      nodes=(Nodes *) AcquireAlignedMemory(1,sizeof(*nodes));
       if (nodes == (Nodes *) NULL)
         return((NodeInfo *) NULL);
       nodes->nodes=(NodeInfo *) AcquireQuantumMemory(NodesInAList,

diff --git a/magick/quantum.c b/magick/quantum.c
index 3233728ef08cfd0be2780a4697d68587836ad30c..32fedc5f62910010853853b327f5223ef7628404 100644 (file)
--- a/magick/quantum.c
+++ b/magick/quantum.c
@@ -119,7 +119,7 @@ MagickExport QuantumInfo *AcquireQuantumInfo(const ImageInfo *image_info,
   QuantumInfo
     *quantum_info;
 
-  quantum_info=(QuantumInfo *) AcquireMagickMemory(sizeof(*quantum_info));
+  quantum_info=(QuantumInfo *) AcquireAlignedMemory(1,sizeof(*quantum_info));
   if (quantum_info == (QuantumInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   quantum_info->signature=MagickSignature;

diff --git a/magick/registry.c b/magick/registry.c
index 3f24800218a382f217d4e480a8571956fa06d229..f74bbc8c483ad10b6ffa51345c56f77979f3b44e 100644 (file)
--- a/magick/registry.c
+++ b/magick/registry.c
@@ -514,7 +514,7 @@ MagickExport MagickBooleanType SetImageRegistry(const RegistryType type,
   }
   if (clone_value == (void *) NULL)
     return(MagickFalse);
-  registry_info=(RegistryInfo *) AcquireMagickMemory(sizeof(*registry_info));
+  registry_info=(RegistryInfo *) AcquireAlignedMemory(1,sizeof(*registry_info));
   if (registry_info == (RegistryInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(registry_info,0,sizeof(*registry_info));

diff --git a/magick/resize.c b/magick/resize.c
index 4695d80c4f09cf4cf0661c9a4e8685c2b5634d64..8f4d19fec06ccdf1dcdbeb81b52efe8eac73b20d 100644 (file)
--- a/magick/resize.c
+++ b/magick/resize.c
@@ -583,7 +583,7 @@ MagickExport ResizeFilter *AcquireResizeFilter(const Image *image,
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
 
-  resize_filter=(ResizeFilter *) AcquireMagickMemory(sizeof(*resize_filter));
+  resize_filter=(ResizeFilter *) AcquireAlignedMemory(1,sizeof(*resize_filter));
   if (resize_filter == (ResizeFilter *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 

diff --git a/magick/segment.c b/magick/segment.c
index c42227e2271d75b1982a9429a7faf6a63132f0d7..eea376f668cb10b6034da315438d8607e14f907f 100644 (file)
--- a/magick/segment.c
+++ b/magick/segment.c
@@ -305,7 +305,7 @@ static MagickBooleanType Classify(Image *image,short **extrema,
           }
         else
           {
-            cluster=(Cluster *) AcquireMagickMemory(sizeof(*cluster));
+            cluster=(Cluster *) AcquireAlignedMemory(1,sizeof(*cluster));
             head=cluster;
           }
         if (cluster == (Cluster *) NULL)
@@ -327,7 +327,7 @@ static MagickBooleanType Classify(Image *image,short **extrema,
       /*
         No classes were identified-- create one.
       */
-      cluster=(Cluster *) AcquireMagickMemory(sizeof(*cluster));
+      cluster=(Cluster *) AcquireAlignedMemory(1,sizeof(*cluster));
       if (cluster == (Cluster *) NULL)
         ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
           image->filename);
@@ -1035,7 +1035,7 @@ MagickExport MagickBooleanType GetImageDynamicThreshold(const Image *image,
           }
         else
           {
-            cluster=(Cluster *) AcquireMagickMemory(sizeof(*cluster));
+            cluster=(Cluster *) AcquireAlignedMemory(1,sizeof(*cluster));
             head=cluster;
           }
         if (cluster == (Cluster *) NULL)
@@ -1061,7 +1061,7 @@ MagickExport MagickBooleanType GetImageDynamicThreshold(const Image *image,
       /*
         No classes were identified-- create one.
       */
-      cluster=(Cluster *) AcquireMagickMemory(sizeof(*cluster));
+      cluster=(Cluster *) AcquireAlignedMemory(1,sizeof(*cluster));
       if (cluster == (Cluster *) NULL)
         {
           (void) ThrowMagickException(exception,GetMagickModule(),
@@ -1370,7 +1370,7 @@ static IntervalTree *InitializeIntervalTree(const ZeroCrossing *zero_crossing,
   /*
     The root is the entire histogram.
   */
-  root=(IntervalTree *) AcquireMagickMemory(sizeof(*root));
+  root=(IntervalTree *) AcquireAlignedMemory(1,sizeof(*root));
   root->child=(IntervalTree *) NULL;
   root->sibling=(IntervalTree *) NULL;
   root->tau=0.0;

diff --git a/magick/shear.c b/magick/shear.c
index a3b1f12ebd101f7a927ac20f812fcf7870b4d54c..705a26c8589d0eb63ede94fb46ebe3f0778b31aa 100644 (file)
--- a/magick/shear.c
+++ b/magick/shear.c
@@ -368,7 +368,7 @@ static RadonInfo *AcquireRadonInfo(const Image *image,const unsigned long width,
   RadonInfo
     *radon_info;
 
-  radon_info=(RadonInfo *) AcquireMagickMemory(sizeof(*radon_info));
+  radon_info=(RadonInfo *) AcquireAlignedMemory(1,sizeof(*radon_info));
   if (radon_info == (RadonInfo *) NULL)
     return((RadonInfo *) NULL);
   (void) ResetMagickMemory(radon_info,0,sizeof(*radon_info));

diff --git a/magick/signature.c b/magick/signature.c
index dd1a0076371212185df85c1f573b6438870ebd75..9e957b4e29ba3d7fbea4c5f1b8f2ff865266459f 100644 (file)
--- a/magick/signature.c
+++ b/magick/signature.c
@@ -120,7 +120,7 @@ MagickExport SignatureInfo *AcquireSignatureInfo(void)
   unsigned int
     lsb_first;
 
-  signature_info=(SignatureInfo *) AcquireMagickMemory(sizeof(*signature_info));
+  signature_info=(SignatureInfo *) AcquireAlignedMemory(1,sizeof(*signature_info));
   if (signature_info == (SignatureInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(signature_info,0,sizeof(*signature_info));

diff --git a/magick/splay-tree.c b/magick/splay-tree.c
index 6b92d848c527746fee57095222bbece27eb77e73..94ef0885915a7e45bacdc4ade2ebf0d03c8d3ab9 100644 (file)
--- a/magick/splay-tree.c
+++ b/magick/splay-tree.c
@@ -182,7 +182,7 @@ MagickExport MagickBooleanType AddValueToSplayTree(SplayTreeInfo *splay_tree,
           return(MagickTrue);
         }
     }
-  node=(NodeInfo *) AcquireMagickMemory(sizeof(*node));
+  node=(NodeInfo *) AcquireAlignedMemory(1,sizeof(*node));
   if (node == (NodeInfo *) NULL)
     {
       (void) UnlockSemaphoreInfo(splay_tree->semaphore);
@@ -1127,7 +1127,7 @@ MagickExport SplayTreeInfo *NewSplayTree(
   SplayTreeInfo
     *splay_tree;
 
-  splay_tree=(SplayTreeInfo *) AcquireMagickMemory(sizeof(*splay_tree));
+  splay_tree=(SplayTreeInfo *) AcquireAlignedMemory(1,sizeof(*splay_tree));
   if (splay_tree == (SplayTreeInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(splay_tree,0,sizeof(*splay_tree));

diff --git a/magick/stream.c b/magick/stream.c
index 4131154ee1df4bfd827e2d03d54a545c01035882..5508bf26f6281bfd1929914c9f897208f3b889d9 100644 (file)
--- a/magick/stream.c
+++ b/magick/stream.c
@@ -151,7 +151,7 @@ MagickExport StreamInfo *AcquireStreamInfo(const ImageInfo *image_info)
   StreamInfo
     *stream_info;
 
-  stream_info=(StreamInfo *) AcquireMagickMemory(sizeof(*stream_info));
+  stream_info=(StreamInfo *) AcquireAlignedMemory(1,sizeof(*stream_info));
   if (stream_info == (StreamInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(stream_info,0,sizeof(*stream_info));

diff --git a/magick/string.c b/magick/string.c
index 6ff58855dc4bbddb1d52a8fb62d9b1e19cdf326b..98df848537816098d392d27cf20dc88066061e9c 100644 (file)
--- a/magick/string.c
+++ b/magick/string.c
@@ -157,7 +157,7 @@ MagickExport StringInfo *AcquireStringInfo(const size_t length)
   StringInfo
     *string_info;
 
-  string_info=(StringInfo *) AcquireMagickMemory(sizeof(*string_info));
+  string_info=(StringInfo *) AcquireAlignedMemory(1,sizeof(*string_info));
   if (string_info == (StringInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(string_info,0,sizeof(*string_info));

diff --git a/magick/thread.c b/magick/thread.c
index 1514be3cb5522f8352bebf43644f4280ad26ea1d..6de531b56102ed3dba03cb7a728df39a0a159e6a 100644 (file)
--- a/magick/thread.c
+++ b/magick/thread.c
@@ -69,7 +69,7 @@ MagickExport MagickBooleanType MagickCreateThreadKey(MagickThreadKey *key)
   *key=TlsAlloc();
   return(*key != TLS_OUT_OF_INDEXES ? MagickTrue : MagickFalse);
 #else
-  *key=AcquireMagickMemory(sizeof(key));
+  *key=AcquireAlignedMemory(1,sizeof(key));
   return(*key != (void *) NULL ? MagickTrue : MagickFalse);
 #endif
 }

diff --git a/magick/threshold.c b/magick/threshold.c
index cf9497746c12ae4ff0e4c21416a253e2013c1d3e..7f149eeb3a1e0c4870b66e216dd608b4277fabc7 100644 (file)
--- a/magick/threshold.c
+++ b/magick/threshold.c
@@ -923,7 +923,7 @@ MagickExport ThresholdMap *GetThresholdMapFile(const char *xml,
   }
 
   /* The map has been found -- Allocate a Threshold Map to return */
-  map = (ThresholdMap *)AcquireMagickMemory(sizeof(ThresholdMap));
+  map = (ThresholdMap *)AcquireAlignedMemory(1,sizeof(ThresholdMap));
   if ( map == (ThresholdMap *)NULL )
     ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireThresholdMap");
   map->map_id = (char *)NULL;

diff --git a/magick/timer.c b/magick/timer.c
index d003bbc2ca0c952ad49023e02a646b7197d38c77..4adc2d23ce61a2c2c4c5aa5bfe32573002d9343b 100644 (file)
--- a/magick/timer.c
+++ b/magick/timer.c
@@ -90,7 +90,7 @@ MagickExport TimerInfo *AcquireTimerInfo(void)
   TimerInfo
     *timer_info;
 
-  timer_info=(TimerInfo *) AcquireMagickMemory(sizeof(*timer_info));
+  timer_info=(TimerInfo *) AcquireAlignedMemory(1,sizeof(*timer_info));
   if (timer_info == (TimerInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
   (void) ResetMagickMemory(timer_info,0,sizeof(*timer_info));

diff --git a/magick/token.c b/magick/token.c
index 2f443d548f151b8ac4f592f00e4d025eda8d0245..c2fcc148a7248d132ab6ba7090bcfa042fc80258 100644 (file)
--- a/magick/token.c
+++ b/magick/token.c
@@ -94,7 +94,7 @@ MagickExport TokenInfo *AcquireTokenInfo(void)
   TokenInfo
     *token_info;
 
-  token_info=(TokenInfo *) AcquireMagickMemory(sizeof(*token_info));
+  token_info=(TokenInfo *) AcquireAlignedMemory(1,sizeof(*token_info));
   if (token_info == (TokenInfo *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   token_info->signature=MagickSignature;

diff --git a/magick/type.c b/magick/type.c
index 1b097dc93c8f6675ee226d228ec45770a7a2f806..a79ed2469ab7a38753675b6e27b0dff76ba917d1 100644 (file)
--- a/magick/type.c
+++ b/magick/type.c
@@ -694,7 +694,7 @@ MagickExport MagickBooleanType LoadFontConfigFonts(SplayTreeInfo *type_list,
     GetPathComponent((const char *) file,ExtensionPath,extension);
     if ((*extension != '\0') && (LocaleCompare(extension,"gz") == 0))
       continue;
-    type_info=(TypeInfo *) AcquireMagickMemory(sizeof(*type_info));
+    type_info=(TypeInfo *) AcquireAlignedMemory(1,sizeof(*type_info));
     if (type_info == (TypeInfo *) NULL)
       continue;
     (void) ResetMagickMemory(type_info,0,sizeof(*type_info));
@@ -1062,7 +1062,7 @@ static MagickBooleanType LoadTypeList(const char *xml,const char *filename,
         /*
           Type element.
         */
-        type_info=(TypeInfo *) AcquireMagickMemory(sizeof(*type_info));
+        type_info=(TypeInfo *) AcquireAlignedMemory(1,sizeof(*type_info));
         if (type_info == (TypeInfo *) NULL)
           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
         (void) ResetMagickMemory(type_info,0,sizeof(*type_info));

diff --git a/magick/utility.c b/magick/utility.c
index 105d87130006d8801365c9d1155f9b59c7d690e1..c8963cdb16da4ec0d9a5ac425a6cb2073d7c3432 100644 (file)
--- a/magick/utility.c
+++ b/magick/utility.c
@@ -1673,7 +1673,7 @@ MagickExport char **ListFiles(const char *directory,const char *pattern,
   /*
     Save the current and change to the new directory.
   */
-  buffer=(struct dirent *) AcquireMagickMemory(sizeof(*buffer)+FILENAME_MAX+1);
+  buffer=(struct dirent *) AcquireAlignedMemory(1,sizeof(*buffer)+FILENAME_MAX+1);
   if (buffer == (struct dirent *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   while ((MagickReadDirectory(current_directory,buffer,&entry) == 0) &&

diff --git a/magick/version.h b/magick/version.h
index 976c74d057c1c13ab96b2175e82eb0cc0c7d630d..470597e26b10212fe18cecb181e8d44ec184c40a 100644 (file)
--- a/magick/version.h
+++ b/magick/version.h
@@ -31,7 +31,7 @@ extern "C" {
 #define MagickLibVersionText  "6.5.8"
 #define MagickLibVersionNumber  2,0,1
 #define MagickLibSubversion  "-6"
-#define MagickReleaseDate  "2009-12-11"
+#define MagickReleaseDate  "2009-12-12"
 #define MagickChangeDate   "20091209"
 #define MagickAuthoritativeURL  "http://www.imagemagick.org"
 #define MagickHomeURL  "file:///usr/local/share/doc/ImageMagick-6.5.8/index.html"

diff --git a/magick/vms.c b/magick/vms.c
index d3c836feb67929e73d68844d70a78df4758f373a..150e544440bba6184423d4aabff7f9a635e82745 100644 (file)
--- a/magick/vms.c
+++ b/magick/vms.c
@@ -111,7 +111,7 @@ DIR *opendir(char *name)
   /*
     Allocate memory for handle and the pattern.
   */
-  directory=(DIR *) AcquireMagickMemory(sizeof(DIR));
+  directory=(DIR *) AcquireAlignedMemory(1,sizeof(DIR));
   if (directory == (DIR *) NULL)
     {
       errno=ENOMEM;

diff --git a/magick/xml-tree.c b/magick/xml-tree.c
index e8faf8f60796d33a187f14dfbace56c296979408..a9b6fd9eb7cdc7f42271582c719b17a4fa6667b8 100644 (file)
--- a/magick/xml-tree.c
+++ b/magick/xml-tree.c
@@ -165,7 +165,7 @@ MagickExport XMLTreeInfo *AddChildToXMLTree(XMLTreeInfo *xml_info,
 
   if (xml_info == (XMLTreeInfo *) NULL)
     return((XMLTreeInfo *) NULL);
-  child=(XMLTreeInfo *) AcquireMagickMemory(sizeof(*child));
+  child=(XMLTreeInfo *) AcquireAlignedMemory(1,sizeof(*child));
   if (child == (XMLTreeInfo *) NULL)
     return((XMLTreeInfo *) NULL);
   (void) ResetMagickMemory(child,0,sizeof(*child));
@@ -1460,7 +1460,7 @@ static void ParseProcessingInstructions(XMLTreeRoot *root,char *xml,
     }
   if (root->processing_instructions[0] == (char **) NULL)
     {
-      root->processing_instructions=(char ***) AcquireMagickMemory(sizeof(
+      root->processing_instructions=(char ***) AcquireAlignedMemory(1,sizeof(
         *root->processing_instructions));
       if (root->processing_instructions ==(char ***) NULL)
         ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
@@ -1526,7 +1526,7 @@ static MagickBooleanType ParseInternalDoctype(XMLTreeRoot *root,char *xml,
     i;
 
   n=(char *) NULL;
-  predefined_entitites=(char **) AcquireMagickMemory(sizeof(sentinel));
+  predefined_entitites=(char **) AcquireAlignedMemory(1,sizeof(sentinel));
   if (predefined_entitites == (char **) NULL)
     ThrowFatalException(ResourceLimitError,"MemoryAllocationFailed");
   (void) CopyMagickMemory(predefined_entitites,sentinel,sizeof(sentinel));
@@ -2125,7 +2125,7 @@ MagickExport XMLTreeInfo *NewXMLTreeTag(const char *tag)
   XMLTreeRoot
     *root;
 
-  root=(XMLTreeRoot *) AcquireMagickMemory(sizeof(*root));
+  root=(XMLTreeRoot *) AcquireAlignedMemory(1,sizeof(*root));
   if (root == (XMLTreeRoot *) NULL)
     return((XMLTreeInfo *) NULL);
   (void) ResetMagickMemory(root,0,sizeof(*root));
@@ -2134,7 +2134,7 @@ MagickExport XMLTreeInfo *NewXMLTreeTag(const char *tag)
     root->root.tag=ConstantString(tag);
   root->node=(&root->root);
   root->root.content=ConstantString("");
-  root->entities=(char **) AcquireMagickMemory(sizeof(predefined_entities));
+  root->entities=(char **) AcquireAlignedMemory(1,sizeof(predefined_entities));
   if (root->entities == (char **) NULL)
     return((XMLTreeInfo *) NULL);
   (void) CopyMagickMemory(root->entities,predefined_entities,

diff --git a/magick/xwindow.c b/magick/xwindow.c
index 7eb7dd8763c83b35c2677126106ec21180b35943..a7b9aa60c3ee1ea74c2ee633844e766e2cb24de7 100644 (file)
--- a/magick/xwindow.c
+++ b/magick/xwindow.c
@@ -4291,7 +4291,7 @@ static Image *XGetWindowImage(Display *display,const Window window,
                 /*
                   Append colormap to colormap list.
                 */
-                p=(ColormapInfo *) AcquireMagickMemory(sizeof(*p));
+                p=(ColormapInfo *) AcquireAlignedMemory(1,sizeof(*p));
                 if (p == (ColormapInfo *) NULL)
                   return((Image *) NULL);
                 p->colormap=window_info[id].colormap;
@@ -5104,7 +5104,7 @@ MagickExport XWindows *XInitializeWindows(Display *display,
   /*
     Allocate windows structure.
   */
-  windows=(XWindows *) AcquireMagickMemory(sizeof(*windows));
+  windows=(XWindows *) AcquireAlignedMemory(1,sizeof(*windows));
   if (windows == (XWindows *) NULL)
     {
       ThrowXWindowFatalException(XServerFatalError,"MemoryAllocationFailed",

diff --git a/wand/deprecate.c b/wand/deprecate.c
index cd0aa09b61a03256b915e2104b2ae526744ede22..660c6a663ff2c7076508f449efc66b46d21eac75 100644 (file)
--- a/wand/deprecate.c
+++ b/wand/deprecate.c
@@ -430,7 +430,7 @@ static MagickWand *CloneMagickWandFromImages(const MagickWand *wand,
   assert(wand->signature == WandSignature);
   if (wand->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
-  clone_wand=(MagickWand *) AcquireMagickMemory(sizeof(*clone_wand));
+  clone_wand=(MagickWand *) AcquireAlignedMemory(1,sizeof(*clone_wand));
   if (clone_wand == (MagickWand *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       images->filename);

diff --git a/wand/drawing-wand.c b/wand/drawing-wand.c
index d66b5797525b10f04ce7b52a48622166855c5796..adb3b6f8243caae36f4ae56491cca1171d7092a5 100644 (file)
--- a/wand/drawing-wand.c
+++ b/wand/drawing-wand.c
@@ -555,7 +555,7 @@ WandExport DrawingWand *CloneDrawingWand(const DrawingWand *wand)
   assert(wand->signature == WandSignature);
   if (wand->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
-  clone_wand=(DrawingWand *) AcquireMagickMemory(sizeof(*clone_wand));
+  clone_wand=(DrawingWand *) AcquireAlignedMemory(1,sizeof(*clone_wand));
   if (clone_wand == (DrawingWand *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,
       "MemoryAllocationFailed",GetExceptionMessage(errno));
@@ -6571,7 +6571,7 @@ WandExport DrawingWand *NewDrawingWand(void)
   quantum=GetMagickQuantumDepth(&depth);
   if (depth != MAGICKCORE_QUANTUM_DEPTH)
     ThrowWandFatalException(WandError,"QuantumDepthMismatch",quantum);
-  wand=(DrawingWand *) AcquireMagickMemory(sizeof(*wand));
+  wand=(DrawingWand *) AcquireAlignedMemory(1,sizeof(*wand));
   if (wand == (DrawingWand *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       GetExceptionMessage(errno));
@@ -6592,7 +6592,7 @@ WandExport DrawingWand *NewDrawingWand(void)
   wand->pattern_bounds.width=0;
   wand->pattern_bounds.height=0;
   wand->index=0;
-  wand->graphic_context=(DrawInfo **) AcquireMagickMemory(sizeof(
+  wand->graphic_context=(DrawInfo **) AcquireAlignedMemory(1,sizeof(
     *wand->graphic_context));
   if (wand->graphic_context == (DrawInfo **) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",

diff --git a/wand/magick-image.c b/wand/magick-image.c
index 6af2a5bb630de7510e047fcccdf0fd38f5baa330..91334d586d48214a248849e12d7cce9b81f720bb 100644 (file)
--- a/wand/magick-image.c
+++ b/wand/magick-image.c
@@ -99,7 +99,7 @@ static MagickWand *CloneMagickWandFromImages(const MagickWand *wand,
   assert(wand->signature == WandSignature);
   if (wand->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
-  clone_wand=(MagickWand *) AcquireMagickMemory(sizeof(*clone_wand));
+  clone_wand=(MagickWand *) AcquireAlignedMemory(1,sizeof(*clone_wand));
   if (clone_wand == (MagickWand *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       images->filename);

diff --git a/wand/magick-wand.c b/wand/magick-wand.c
index 81d26c40e0b14a7196a6347a1fb3e2f67403a6dd..82f6ce8c7baccc8ddf4ce74b926e40a5fa76ab32 100644 (file)
--- a/wand/magick-wand.c
+++ b/wand/magick-wand.c
@@ -129,7 +129,7 @@ WandExport MagickWand *CloneMagickWand(const MagickWand *wand)
   assert(wand->signature == WandSignature);
   if (wand->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
-  clone_wand=(MagickWand *) AcquireMagickMemory(sizeof(*clone_wand));
+  clone_wand=(MagickWand *) AcquireAlignedMemory(1,sizeof(*clone_wand));
   if (clone_wand == (MagickWand *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       wand->name);
@@ -1028,7 +1028,7 @@ WandExport MagickWand *NewMagickWand(void)
   quantum=GetMagickQuantumDepth(&depth);
   if (depth != MAGICKCORE_QUANTUM_DEPTH)
     ThrowWandFatalException(WandError,"QuantumDepthMismatch",quantum);
-  wand=(MagickWand *) AcquireMagickMemory(sizeof(*wand));
+  wand=(MagickWand *) AcquireAlignedMemory(1,sizeof(*wand));
   if (wand == (MagickWand *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       GetExceptionMessage(errno));

diff --git a/wand/pixel-iterator.c b/wand/pixel-iterator.c
index 9d2d4b64ba51174efa297c4d6aec19b3ba4b2e94..e0f8cd1597c85ff4a323175ff02a22b041320629 100644 (file)
--- a/wand/pixel-iterator.c
+++ b/wand/pixel-iterator.c
@@ -162,7 +162,7 @@ WandExport PixelIterator *ClonePixelIterator(const PixelIterator *iterator)
   assert(iterator->signature == WandSignature);
   if (iterator->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",iterator->name);
-  clone_iterator=(PixelIterator *) AcquireMagickMemory(sizeof(*clone_iterator));
+  clone_iterator=(PixelIterator *) AcquireAlignedMemory(1,sizeof(*clone_iterator));
   if (clone_iterator == (PixelIterator *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       iterator->name);
@@ -312,7 +312,7 @@ WandExport PixelIterator *NewPixelIterator(MagickWand *wand)
   view=AcquireCacheView(image);
   if (view == (CacheView *) NULL)
     return((PixelIterator *) NULL);
-  iterator=(PixelIterator *) AcquireMagickMemory(sizeof(*iterator));
+  iterator=(PixelIterator *) AcquireAlignedMemory(1,sizeof(*iterator));
   if (iterator == (PixelIterator *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       GetExceptionMessage(errno));
@@ -427,7 +427,7 @@ WandExport PixelIterator *NewPixelRegionIterator(MagickWand *wand,const long x,
   view=AcquireCacheView(image);
   if (view == (CacheView *) NULL)
     return((PixelIterator *) NULL);
-  iterator=(PixelIterator *) AcquireMagickMemory(sizeof(*iterator));
+  iterator=(PixelIterator *) AcquireAlignedMemory(1,sizeof(*iterator));
   if (iterator == (PixelIterator *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       wand->name);

diff --git a/wand/pixel-view.c b/wand/pixel-view.c
index 98249369a51a058533ddcc17440302a18751be98..de049e7907c47f95afac797c825cda307f8bbfc8 100644 (file)
--- a/wand/pixel-view.c
+++ b/wand/pixel-view.c
@@ -127,7 +127,7 @@ WandExport PixelView *ClonePixelView(const PixelView *pixel_view)
   assert(pixel_view->signature == WandSignature);
   if (pixel_view->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",pixel_view->name);
-  clone_view=(PixelView *) AcquireMagickMemory(sizeof(*clone_view));
+  clone_view=(PixelView *) AcquireAlignedMemory(1,sizeof(*clone_view));
   if (clone_view == (PixelView *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       pixel_view->name);
@@ -838,7 +838,7 @@ WandExport PixelView *NewPixelView(MagickWand *wand)
 
   assert(wand != (MagickWand *) NULL);
   assert(wand->signature == MagickSignature);
-  pixel_view=(PixelView *) AcquireMagickMemory(sizeof(*pixel_view));
+  pixel_view=(PixelView *) AcquireAlignedMemory(1,sizeof(*pixel_view));
   if (pixel_view == (PixelView *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       GetExceptionMessage(errno));
@@ -897,7 +897,7 @@ WandExport PixelView *NewPixelViewRegion(MagickWand *wand,const long x,
 
   assert(wand != (MagickWand *) NULL);
   assert(wand->signature == MagickSignature);
-  pixel_view=(PixelView *) AcquireMagickMemory(sizeof(*pixel_view));
+  pixel_view=(PixelView *) AcquireAlignedMemory(1,sizeof(*pixel_view));
   if (pixel_view == (PixelView *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       GetExceptionMessage(errno));

diff --git a/wand/pixel-wand.c b/wand/pixel-wand.c
index 4d7b4f47cba48b5b40a1ac90efc74f2ddfccb54c..af1d2612cb348befc2afca8d19a4a8966f594845 100644 (file)
--- a/wand/pixel-wand.c
+++ b/wand/pixel-wand.c
@@ -148,7 +148,7 @@ WandExport PixelWand *ClonePixelWand(const PixelWand *wand)
   assert(wand->signature == WandSignature);
   if (wand->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
-  clone_wand=(PixelWand *) AcquireMagickMemory(sizeof(*clone_wand));
+  clone_wand=(PixelWand *) AcquireAlignedMemory(1,sizeof(*clone_wand));
   if (clone_wand == (PixelWand *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       wand->name);
@@ -400,7 +400,7 @@ WandExport PixelWand *NewPixelWand(void)
   quantum=GetMagickQuantumDepth(&depth);
   if (depth != MAGICKCORE_QUANTUM_DEPTH)
     ThrowWandFatalException(WandError,"QuantumDepthMismatch",quantum);
-  wand=(PixelWand *) AcquireMagickMemory(sizeof(*wand));
+  wand=(PixelWand *) AcquireAlignedMemory(1,sizeof(*wand));
   if (wand == (PixelWand *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
       GetExceptionMessage(errno));