(no commit message)

diff --git a/coders/ps.c b/coders/ps.c
index 6f646a407662000416d2b75b1e047d5a355fc486..c0f47c370736bcb0e59eda7e5b53281828bc27b3 100644 (file)
--- a/coders/ps.c
+++ b/coders/ps.c
@@ -1345,10 +1345,6 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
   IndexPacket
     index;
 
-  ssize_t
-    j,
-    y;
-
   MagickBooleanType
     status;
 
@@ -1388,7 +1384,15 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
     bounds;
 
   size_t
-    length;
+    bit,
+    byte,
+    length,
+    page,
+    text_size;
+
+  ssize_t
+    j,
+    y;
 
   time_t
     timer;
@@ -1396,12 +1400,6 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
   unsigned char
     pixels[2048];
 
-  size_t
-    bit,
-    byte,
-    page,
-    text_size;
-
   /*
     Open output image file.
   */
@@ -1589,15 +1587,15 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
             Image
               *preview_image;
 
-            ssize_t
-              y;
-
             Quantum
               pixel;
 
             register ssize_t
               x;
 
+            ssize_t
+              y;
+
             /*
               Create preview image.
             */
@@ -1848,8 +1846,8 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
                 };
               if (image->previous == (Image *) NULL)
                 {
-                  status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+                  status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) 
+                    y,image->rows);
                   if (status == MagickFalse)
                     break;
                 }
@@ -1890,10 +1888,11 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
                 length=255;
                 for (x=0; x < (ssize_t) image->columns; x++)
                 {
-                  if ((GetRedPixelComponent(p) == pixel.red) && (GetGreenPixelComponent(p) == pixel.green) &&
+                  if ((GetRedPixelComponent(p) == pixel.red) &&
+                      (GetGreenPixelComponent(p) == pixel.green) &&
                       (GetBluePixelComponent(p) == pixel.blue) &&
-                      (GetOpacityPixelComponent(p) == pixel.opacity) && (length < 255) &&
-                      (x < (ssize_t) (image->columns-1)))
+                      (GetOpacityPixelComponent(p) == pixel.opacity) &&
+                      (length < 255) && (x < (ssize_t) (image->columns-1)))
                     length++;
                   else
                     {
@@ -1921,8 +1920,8 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
                   }
                 if (image->previous == (Image *) NULL)
                   {
-                    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+                    status=SetImageProgress(image,SaveImageTag,
+                      (MagickOffsetType) y,image->rows);
                     if (status == MagickFalse)
                       break;
                   }
@@ -1958,9 +1957,12 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
                     }
                   else
                     {
-                      q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetRedPixelComponent(p)),q);
-                      q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
-                      q=PopHexPixel(hex_digits,ScaleQuantumToChar(GetBluePixelComponent(p)),q);
+                      q=PopHexPixel(hex_digits,ScaleQuantumToChar(
+                        GetRedPixelComponent(p)),q);
+                      q=PopHexPixel(hex_digits,ScaleQuantumToChar(
+                        GetGreenPixelComponent(p)),q);
+                      q=PopHexPixel(hex_digits,ScaleQuantumToChar(
+                        GetBluePixelComponent(p)),q);
                     }
                   if ((q-pixels+6) >= 80)
                     {
@@ -1972,8 +1974,8 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
                 }
                 if (image->previous == (Image *) NULL)
                   {
-                    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+                    status=SetImageProgress(image,SaveImageTag,
+                      (MagickOffsetType) y,image->rows);
                     if (status == MagickFalse)
                       break;
                   }
@@ -2027,12 +2029,12 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
                 if (p == (const PixelPacket *) NULL)
                   break;
                 indexes=GetVirtualIndexQueue(image);
-                index=(*indexes);
+                index=GetIndexPixelComponent(indexes);
                 length=255;
                 for (x=0; x < (ssize_t) image->columns; x++)
                 {
-                  if ((index == indexes[x]) && (length < 255) &&
-                      (x < ((ssize_t) image->columns-1)))
+                  if ((index == GetIndexPixelComponent(indexes+x)) &&
+                      (length < 255) && (x < ((ssize_t) image->columns-1)))
                     length++;
                   else
                     {
@@ -2051,8 +2053,11 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
                         }
                       length=0;
                     }
-                  index=indexes[x];
-                  pixel=(*p);
+                  index=GetIndexPixelComponent(indexes+x);
+                  pixel.red=GetRedPixelComponent(p);
+                  pixel.green=GetGreenPixelComponent(p);
+                  pixel.blue=GetBluePixelComponent(p);
+                  pixel.opacity=GetOpacityPixelComponent(p);
                   p++;
                 }
                 q=PopHexPixel(hex_digits,(size_t) index,q);
@@ -2089,7 +2094,8 @@ static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
                 indexes=GetVirtualIndexQueue(image);
                 for (x=0; x < (ssize_t) image->columns; x++)
                 {
-                  q=PopHexPixel(hex_digits,(size_t) indexes[x],q);
+                  q=PopHexPixel(hex_digits,(size_t) GetIndexPixelComponent(
+                    indexes+x),q);
                   if ((q-pixels+4) >= 80)
                     {
                       *q++='\n';

diff --git a/coders/ps2.c b/coders/ps2.c
index a9391b386705a2b1d5b359e1e8515bdae202beb9..d1c23e68738086ab2cd95a415e3ded38e9fa26f4 100644 (file)
--- a/coders/ps2.c
+++ b/coders/ps2.c
@@ -391,10 +391,6 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
   GeometryInfo
     geometry_info;
 
-  ssize_t
-    j,
-    y;
-
   MagickOffsetType
     scene,
     start,
@@ -439,7 +435,13 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
     bounds;
 
   size_t
-    length;
+    length,
+    page,
+    text_size;
+
+  ssize_t
+    j,
+    y;
 
   time_t
     timer;
@@ -447,10 +449,6 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
   unsigned char
     *pixels;
 
-  size_t
-    page,
-    text_size;
-
   /*
     Open output image file.
   */
@@ -790,7 +788,8 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
                 *q++=ScaleQuantumToChar(PixelIntensityToQuantum(p));
                 p++;
               }
-              progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
+              progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+                image->rows);
               if (progress == MagickFalse)
                 break;
             }
@@ -821,8 +820,8 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
                 break;
               for (x=0; x < (ssize_t) image->columns; x++)
               {
-                Ascii85Encode(image,
-                  ScaleQuantumToChar(PixelIntensityToQuantum(p)));
+                Ascii85Encode(image,ScaleQuantumToChar(
+                  PixelIntensityToQuantum(p)));
                 p++;
               }
               progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
@@ -903,11 +902,13 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
                         *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
                         *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
                         *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
-                        *q++=ScaleQuantumToChar(indexes[x]);
+                        *q++=ScaleQuantumToChar(GetIndexPixelComponent(
+                          indexes+x));
                       }
                   p++;
                 }
-                progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
+                progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
+                  y,image->rows);
                 if (progress == MagickFalse)
                   break;
               }
@@ -952,20 +953,27 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
                   else
                     if (image->colorspace != CMYKColorspace)
                       {
-                        Ascii85Encode(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
-                        Ascii85Encode(image,ScaleQuantumToChar(GetGreenPixelComponent(p)));
-                        Ascii85Encode(image,ScaleQuantumToChar(GetBluePixelComponent(p)));
+                        Ascii85Encode(image,ScaleQuantumToChar(
+                          GetRedPixelComponent(p)));
+                        Ascii85Encode(image,ScaleQuantumToChar(
+                          GetGreenPixelComponent(p)));
+                        Ascii85Encode(image,ScaleQuantumToChar(
+                          GetBluePixelComponent(p)));
                       }
                     else
                       {
-                        Ascii85Encode(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
-                        Ascii85Encode(image,ScaleQuantumToChar(GetGreenPixelComponent(p)));
-                        Ascii85Encode(image,ScaleQuantumToChar(GetBluePixelComponent(p)));
+                        Ascii85Encode(image,ScaleQuantumToChar(
+                          GetRedPixelComponent(p)));
+                        Ascii85Encode(image,ScaleQuantumToChar(
+                          GetGreenPixelComponent(p)));
+                        Ascii85Encode(image,ScaleQuantumToChar(
+                          GetBluePixelComponent(p)));
                         Ascii85Encode(image,ScaleQuantumToChar(indexes[x]));
                       }
                   p++;
                 }
-                progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
+                progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
+                  y,image->rows);
                 if (progress == MagickFalse)
                   break;
               }
@@ -1027,7 +1035,8 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
                 indexes=GetVirtualIndexQueue(image);
                 for (x=0; x < (ssize_t) image->columns; x++)
                   *q++=(unsigned char) GetIndexPixelComponent(indexes+x);
-                progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
+                progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
+                  y,image->rows);
                 if (progress == MagickFalse)
                   break;
               }
@@ -1058,8 +1067,10 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
                   break;
                 indexes=GetVirtualIndexQueue(image);
                 for (x=0; x < (ssize_t) image->columns; x++)
-                  Ascii85Encode(image,(unsigned char) indexes[x]);
-                progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
+                  Ascii85Encode(image,(unsigned char) GetIndexPixelComponent(
+                    indexes+x));
+                progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
+                  y,image->rows);
                 if (progress == MagickFalse)
                   break;
               }

diff --git a/coders/ps3.c b/coders/ps3.c
index be4416bafcdaa46b7dc03685b28fc1f1b91e8bf2..521c78f4bd34a0b952eda0cfe328e3e470442188 100644 (file)
--- a/coders/ps3.c
+++ b/coders/ps3.c
@@ -230,13 +230,9 @@ static MagickBooleanType Huffman2DEncodeImage(const ImageInfo *image_info,
   return(status);
 }
 
-
 static MagickBooleanType SerializeImage(const ImageInfo *image_info,
   Image *image,unsigned char **pixels,size_t *length)
 {
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -252,13 +248,16 @@ static MagickBooleanType SerializeImage(const ImageInfo *image_info,
   register unsigned char
     *q;
 
+  ssize_t
+    y;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   status=MagickTrue;
-  *length=(image->colorspace == CMYKColorspace ? 4 : 3)*
-    (size_t) image->columns*image->rows;
+  *length=(image->colorspace == CMYKColorspace ? 4 : 3)*(size_t)
+    image->columns*image->rows;
   *pixels=(unsigned char *) AcquireQuantumMemory(*length,sizeof(**pixels));
   if (*pixels == (unsigned char *) NULL)
     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
@@ -283,13 +282,13 @@ static MagickBooleanType SerializeImage(const ImageInfo *image_info,
         *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
         *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
         *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
-        *q++=ScaleQuantumToChar(indexes[x]);
+        *q++=ScaleQuantumToChar(GetIndexPixelComponent(indexes+x));
         p++;
       }
     if (image->previous == (Image *) NULL)
       {
         status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+          image->rows);
         if (status == MagickFalse)
           break;
       }
@@ -302,9 +301,6 @@ static MagickBooleanType SerializeImage(const ImageInfo *image_info,
 static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,
   Image *image,unsigned char **pixels,size_t *length)
 {
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -317,14 +313,17 @@ static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,
   register unsigned char
     *q;
 
-  unsigned char
-    code,
-    bit;
-
   size_t
     pack,
     padded_columns;
 
+  ssize_t
+    y;
+
+  unsigned char
+    code,
+    bit;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -355,8 +354,8 @@ static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,
         {
           bit=(unsigned char) 0x00;
           if (x < (ssize_t) image->columns)
-            bit=(unsigned char) (PixelIntensityToQuantum(p) ==
-              (Quantum) TransparentOpacity ? 0x01 : 0x00);
+            bit=(unsigned char) (PixelIntensityToQuantum(p) == (Quantum)
+              TransparentOpacity ? 0x01 : 0x00);
           code=(code << 1)+bit;
           if (((x+1) % pack) == 0)
             {
@@ -367,7 +366,7 @@ static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,
         }
       }
     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
@@ -379,9 +378,6 @@ static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,
 static MagickBooleanType SerializeImageIndexes(const ImageInfo *image_info,
   Image *image,unsigned char **pixels,size_t *length)
 {
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -397,6 +393,9 @@ static MagickBooleanType SerializeImageIndexes(const ImageInfo *image_info,
   register unsigned char
     *q;
 
+  ssize_t
+    y;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -418,7 +417,7 @@ static MagickBooleanType SerializeImageIndexes(const ImageInfo *image_info,
     if (image->previous == (Image *) NULL)
       {
         status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+          image->rows);
         if (status == MagickFalse)
           break;
       }
@@ -467,8 +466,8 @@ static MagickBooleanType WritePS3MaskImage(const ImageInfo *image_info,
   */
   start=TellBlob(image);
   (void) FormatMagickString(buffer,MaxTextExtent,
-    "%%%%BeginData:%13ld %s Bytes\n",0L,
-    compression == NoCompression ? "ASCII" : "BINARY");
+    "%%%%BeginData:%13ld %s Bytes\n",0L,compression == NoCompression ?
+    "ASCII" : "BINARY");
   (void) WriteBlobString(image,buffer);
   stop=TellBlob(image);
   /*
@@ -814,9 +813,6 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image)
   GeometryInfo
     geometry_info;
 
-  ssize_t
-    j;
-
   MagickBooleanType
     status;
 
@@ -846,7 +842,13 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image)
     bounds;
 
   size_t
-    length;
+    length,
+    page,
+    pixel,
+    text_size;
+
+  ssize_t
+    j;
 
   time_t
     timer;
@@ -854,11 +856,6 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image)
   unsigned char
     *pixels;
 
-  size_t
-    page,
-    pixel,
-    text_size;
-
   /*
     Open output image file.
   */
@@ -1218,9 +1215,8 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image)
       Image columns, rows, and color space.
     */
     (void) FormatMagickString(buffer,MaxTextExtent,"%.20g %.20g\n%s\n",
-      (double) image->columns,(double) image->rows,
-      image->colorspace == CMYKColorspace ? PS3_CMYKColorspace :
-      PS3_RGBColorspace);
+      (double) image->columns,(double) image->rows,image->colorspace ==
+      CMYKColorspace ? PS3_CMYKColorspace : PS3_RGBColorspace);
     (void) WriteBlobString(image,buffer);
     /*
       Masked image?

diff --git a/coders/psd.c b/coders/psd.c
index 5c1aca895b0c4316aee8a4a683b0c2a6b77e706c..21adfcb129b6814afd2235a5cc8e0bad77df4f8a 100644 (file)
--- a/coders/psd.c
+++ b/coders/psd.c
@@ -59,6 +59,7 @@
 #include "magick/memory_.h"
 #include "magick/module.h"
 #include "magick/monitor-private.h"
+#include "magick/pixel.h"
 #include "magick/profile.h"
 #include "magick/property.h"
 #include "magick/quantum-private.h"
@@ -256,12 +257,12 @@ static ssize_t DecodePSDPixels(const size_t number_compact_pixels,
     i,
     j;
 
-  ssize_t
-    packets;
-
   size_t
     length;
 
+  ssize_t
+    packets;
+
   packets=(ssize_t) number_compact_pixels;
   for (i=0; (packets > 1) && (i < (ssize_t) number_pixels); )
   {
@@ -635,12 +636,12 @@ static MagickBooleanType ReadPSDLayer(Image *image,const size_t channels,
       {
         case -1:
         {
-          q->opacity=(Quantum) (QuantumRange-pixel);
+          SetOpacityPixelComponent(q,QuantumRange-pixel);
           break;
         }
         case 0:
         {
-          q->red=pixel;
+          SetRedPixelComponent(q,pixel);
           if (channels == 1)
             {
               SetGreenPixelComponent(q,GetRedPixelComponent(q));
@@ -649,12 +650,15 @@ static MagickBooleanType ReadPSDLayer(Image *image,const size_t channels,
           if (image->storage_class == PseudoClass)
             {
               if (packet_size == 1)
-                indexes[x]=(IndexPacket) ScaleQuantumToChar(pixel);
+                SetIndexPixelComponent(indexes+x,ScaleQuantumToChar(pixel));
               else
-                indexes[x]=(IndexPacket) ScaleQuantumToShort(pixel);
-              q->red=image->colormap[(ssize_t) indexes[x]].red;
-              q->green=image->colormap[(ssize_t) indexes[x]].green;
-              q->blue=image->colormap[(ssize_t) indexes[x]].blue;
+                SetIndexPixelComponent(indexes+x,ScaleQuantumToShort(pixel));
+              SetRedPixelComponent(q,image->colormap[(ssize_t)
+                GetIndexPixelComponent(indexes+x)].red);
+              SetGreenPixelComponent(q,image->colormap[(ssize_t)
+                GetIndexPixelComponent(indexes+x)].green);
+              SetBluePixelComponent(q,image->colormap[(ssize_t)
+                GetIndexPixelComponent(indexes+x)].blue);
               if (image->depth == 1)
                 {
                   ssize_t
@@ -666,11 +670,14 @@ static MagickBooleanType ReadPSDLayer(Image *image,const size_t channels,
                     number_bits=8;
                   for (bit=0; bit < number_bits; bit++)
                   {
-                    indexes[x]=((((unsigned char) pixel) & (0x01 << (7-bit)))
-                      != 0 ? 0 : 255);
-                    q->red=image->colormap[(ssize_t) indexes[x]].red;
-                    q->green=image->colormap[(ssize_t) indexes[x]].green;
-                    q->blue=image->colormap[(ssize_t) indexes[x]].blue;
+                    SetIndexPixelComponent(indexes+x,(((unsigned char) pixel) &
+                      (0x01 << (7-bit))) != 0 ? 0 : 255);
+                    SetRedPixelComponent(q,image->colormap[(ssize_t)
+                      GetIndexPixelComponent(indexes+x)].red);
+                    SetGreenPixelComponent(q,image->colormap[(ssize_t)
+                      GetIndexPixelComponent(indexes+x)].green);
+                    SetBluePixelComponent(q,image->colormap[(ssize_t)
+                      GetIndexPixelComponent(indexes+x)].blue);
                     q++;
                     x++;
                   }
@@ -683,32 +690,32 @@ static MagickBooleanType ReadPSDLayer(Image *image,const size_t channels,
         case 1:
         {
           if (image->storage_class == PseudoClass)
-            q->opacity=(Quantum) (QuantumRange-pixel);
+            SetOpacityPixelComponent(q,QuantumRange-pixel);
           else
-            q->green=pixel;
+            SetGreenPixelComponent(q,pixel);
           break;
         }
         case 2:
         {
           if (image->storage_class == PseudoClass)
-            q->opacity=(Quantum) (QuantumRange-pixel);
+            SetOpacityPixelComponent(q,QuantumRange-pixel);
           else
-            q->blue=pixel;
+            SetBluePixelComponent(q,pixel);
           break;
         }
         case 3:
         {
           if (image->colorspace == CMYKColorspace)
-            indexes[x]=(IndexPacket) pixel;
+            SetIndexPixelComponent(indexes+x,pixel);
           else
-            q->opacity=(Quantum) (QuantumRange-pixel);
+            SetOpacityPixelComponent(q,QuantumRange-pixel);
           break;
         }
         case 4:
         {
           if ((image->colorspace == RGBColorspace) && (channels > 3))
             break;
-          q->opacity=(Quantum) (QuantumRange-pixel);
+          SetOpacityPixelComponent(q,QuantumRange-pixel);
           break;
         }
         default:
@@ -1144,14 +1151,13 @@ static Image *ReadPSDImage(const ImageInfo *image_info,ExceptionInfo *exception)
             Adjustment layers and other stuff...
           */
           {
-            char  alsig[4],
-                alkey[4];
+            char  alsig[4], alkey[4];
 
             count=ReadBlob(image,4,alsig);
             if ((count == 0) || (LocaleNCompare(alsig,"8BIM",4) != 0)) {
               if (debug != MagickFalse)
               {
-      if (image->debug != MagickFalse)
+                if (image->debug != MagickFalse)
                   (void) LogMagickEvent(CoderEvent,GetMagickModule(),"  adjustment layer type was %.4s instead of 8BIM", alsig);
               }
               ThrowReaderException(CorruptImageError,"ImproperImageHeader");
@@ -1160,7 +1166,7 @@ static Image *ReadPSDImage(const ImageInfo *image_info,ExceptionInfo *exception)
             length=ReadBlobMSBLong(image);
               if (debug != MagickFalse)
               {
-      if (image->debug != MagickFalse)
+                if (image->debug != MagickFalse)
                   (void) LogMagickEvent(CoderEvent,GetMagickModule(),
                             "      adjustment layer key: %.4s, data length=%.20g",
                             alkey, (double) length);
@@ -1533,7 +1539,6 @@ ModuleExport void UnregisterPSDImage(void)
 %
 %    o image:  The image.
 %
-%
 */
 
 static inline ssize_t SetPSDOffset(const PSDInfo *psd_info,Image *image,

diff --git a/coders/pwp.c b/coders/pwp.c
index 3a5f19f0e5773754173ee38866a1933f23123681..02f71419b4db10f9bf240a6fbdcd41e6a250d2eb 100644 (file)
--- a/coders/pwp.c
+++ b/coders/pwp.c
@@ -146,6 +146,7 @@ static Image *ReadPWPImage(const ImageInfo *image_info,ExceptionInfo *exception)
     i;
 
   size_t
+    filesize,
     length;
 
   ssize_t
@@ -154,9 +155,6 @@ static Image *ReadPWPImage(const ImageInfo *image_info,ExceptionInfo *exception)
   unsigned char
     magick[MaxTextExtent];
 
-  size_t
-    filesize;
-
   /*
     Open image file.
   */