X-Git-Url: https://granicus.if.org/sourcecode?a=blobdiff_plain;f=coders%2Fpcx.c;h=fa2942f445f6cda469f33e3dc719bacff3e1c694;hb=2ea2cbfa1006eeda0d230955f9933062065b6aa1;hp=e8d9851153b826a67ddd4f7e3c3fb9071c5e7a2c;hpb=ce70c17bb6433add2eb069515a4f3105989e0662;p=imagemagick

diff --git a/coders/pcx.c b/coders/pcx.c
index e8d985115..fa2942f44 100644
--- a/coders/pcx.c
+++ b/coders/pcx.c
@@ -45,6 +45,7 @@
 #include "magick/cache.h"
 #include "magick/color.h"
 #include "magick/color-private.h"
+#include "magick/colormap.h"
 #include "magick/colorspace.h"
 #include "magick/exception.h"
 #include "magick/exception-private.h"
@@ -196,7 +197,7 @@ static MagickBooleanType IsPCX(const unsigned char *magick,const size_t length)
 %
 */
 
-static inline long MagickAbsoluteValue(const long x)
+static inline ssize_t MagickAbsoluteValue(const ssize_t x)
 {
   if (x < 0)
     return(-x);
@@ -227,7 +228,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
     id,
     mask;
 
-  long
+  ssize_t
     y;
 
   MagickBooleanType
@@ -243,13 +244,13 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
   register IndexPacket
     *indexes;
 
-  register long
+  register ssize_t
     x;
 
   register PixelPacket
     *q;
 
-  register long
+  register ssize_t
     i;
 
   register unsigned char
@@ -265,7 +266,8 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
     *pcx_pixels,
     *scanline;
 
-  unsigned long
+  size_t
+    one,
     pcx_packets;
 
   /*
@@ -291,7 +293,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
   page_table=(MagickOffsetType *) NULL;
   if (LocaleCompare(image_info->magick,"DCX") == 0)
     {
-      unsigned long
+      size_t
         magic;
 
       /*
@@ -338,9 +340,9 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
     /*
       Read PCX raster colormap.
     */
-    image->columns=(unsigned long) MagickAbsoluteValue((long) pcx_info.right-
+    image->columns=(size_t) MagickAbsoluteValue((ssize_t) pcx_info.right-
       pcx_info.left)+1UL;
-    image->rows=(unsigned long) MagickAbsoluteValue((long) pcx_info.bottom-
+    image->rows=(size_t) MagickAbsoluteValue((ssize_t) pcx_info.bottom-
       pcx_info.top)+1UL;
     if ((image->columns == 0) || (image->rows == 0) ||
         (pcx_info.bits_per_pixel == 0))
@@ -357,17 +359,18 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
     count=ReadBlob(image,3*image->colors,pcx_colormap);
     pcx_info.reserved=(unsigned char) ReadBlobByte(image);
     pcx_info.planes=(unsigned char) ReadBlobByte(image);
+    one=1;
     if ((pcx_info.bits_per_pixel != 8) || (pcx_info.planes == 1))
       if ((pcx_info.version == 3) || (pcx_info.version == 5) ||
           ((pcx_info.bits_per_pixel*pcx_info.planes) == 1))
-        image->colors=(unsigned long) MagickMin(1UL << (1UL*
+        image->colors=(size_t) MagickMin(one << (1UL*
           (pcx_info.bits_per_pixel*pcx_info.planes)),256UL);
     if (AcquireImageColormap(image,image->colors) == MagickFalse)
       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
     if ((pcx_info.bits_per_pixel >= 8) && (pcx_info.planes != 1))
       image->storage_class=DirectClass;
     p=pcx_colormap;
-    for (i=0; i < (long) image->colors; i++)
+    for (i=0; i < (ssize_t) image->colors; i++)
     {
       image->colormap[i].red=ScaleCharToQuantum(*p++);
       image->colormap[i].green=ScaleCharToQuantum(*p++);
@@ -383,7 +386,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
     /*
       Read image data.
     */
-    pcx_packets=(unsigned long) image->rows*pcx_info.bytes_per_line*
+    pcx_packets=(size_t) image->rows*pcx_info.bytes_per_line*
       pcx_info.planes;
     pcx_pixels=(unsigned char *) AcquireQuantumMemory(pcx_packets,
       sizeof(*pcx_pixels));
@@ -461,7 +464,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
                 pcx_info.colormap_signature=(unsigned char) ReadBlobByte(image);
                 count=ReadBlob(image,3*image->colors,pcx_colormap);
                 p=pcx_colormap;
-                for (i=0; i < (long) image->colors; i++)
+                for (i=0; i < (ssize_t) image->colors; i++)
                 {
                   image->colormap[i].red=ScaleCharToQuantum(*p++);
                   image->colormap[i].green=ScaleCharToQuantum(*p++);
@@ -473,7 +476,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
     /*
       Convert PCX raster image to pixel packets.
     */
-    for (y=0; y < (long) image->rows; y++)
+    for (y=0; y < (ssize_t) image->rows; y++)
     {
       p=pcx_pixels+(y*pcx_info.bytes_per_line*pcx_info.planes);
       q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
@@ -485,7 +488,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
         for (i=0; i < pcx_info.planes; i++)
         {
           r=scanline+i;
-          for (x=0; x < (long) pcx_info.bytes_per_line; x++)
+          for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
           {
             switch (i)
             {
@@ -517,12 +520,12 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
       else
         if (pcx_info.planes > 1)
           {
-            for (x=0; x < (long) image->columns; x++)
+            for (x=0; x < (ssize_t) image->columns; x++)
               *r++=0;
             for (i=0; i < pcx_info.planes; i++)
             {
               r=scanline;
-              for (x=0; x < (long) pcx_info.bytes_per_line; x++)
+              for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
               {
                  bits=(*p++);
                  for (mask=0x80; mask != 0; mask>>=1)
@@ -539,10 +542,10 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
           {
             case 1:
             {
-              register long
+              register ssize_t
                 bit;
 
-              for (x=0; x < ((long) image->columns-7); x+=8)
+              for (x=0; x < ((ssize_t) image->columns-7); x+=8)
               {
                 for (bit=7; bit >= 0; bit--)
                   *r++=(unsigned char) ((*p) & (0x01 << bit) ? 0x01 : 0x00);
@@ -550,7 +553,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
               }
               if ((image->columns % 8) != 0)
                 {
-                  for (bit=7; bit >= (long) (8-(image->columns % 8)); bit--)
+                  for (bit=7; bit >= (ssize_t) (8-(image->columns % 8)); bit--)
                     *r++=(unsigned char) ((*p) & (0x01 << bit) ? 0x01 : 0x00);
                   p++;
                 }
@@ -558,7 +561,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
             }
             case 2:
             {
-              for (x=0; x < ((long) image->columns-3); x+=4)
+              for (x=0; x < ((ssize_t) image->columns-3); x+=4)
               {
                 *r++=(*p >> 6) & 0x3;
                 *r++=(*p >> 4) & 0x3;
@@ -568,7 +571,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
               }
               if ((image->columns % 4) != 0)
                 {
-                  for (i=3; i >= (long) (4-(image->columns % 4)); i--)
+                  for (i=3; i >= (ssize_t) (4-(image->columns % 4)); i--)
                     *r++=(unsigned char) ((*p >> (i*2)) & 0x03);
                   p++;
                 }
@@ -576,7 +579,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
             }
             case 4:
             {
-              for (x=0; x < ((long) image->columns-1); x+=2)
+              for (x=0; x < ((ssize_t) image->columns-1); x+=2)
               {
                 *r++=(*p >> 4) & 0xf;
                 *r++=(*p) & 0xf;
@@ -598,7 +601,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
         Transfer image scanline.
       */
       r=scanline;
-      for (x=0; x < (long) image->columns; x++)
+      for (x=0; x < (ssize_t) image->columns; x++)
       {
         if (image->storage_class == PseudoClass)
           indexes[x]=(IndexPacket) (*r++);
@@ -616,7 +619,8 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
         break;
       if (image->previous == (Image *) NULL)
         {
-          status=SetImageProgress(image,LoadImageTag,y,image->rows);
+          status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+                image->rows);
           if (status == MagickFalse)
             break;
         }
@@ -691,10 +695,10 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
 %
 %  The format of the RegisterPCXImage method is:
 %
-%      unsigned long RegisterPCXImage(void)
+%      size_t RegisterPCXImage(void)
 %
 */
-ModuleExport unsigned long RegisterPCXImage(void)
+ModuleExport size_t RegisterPCXImage(void)
 {
   MagickInfo
     *entry;
@@ -776,7 +780,7 @@ static MagickBooleanType PCXWritePixels(PCXInfo *pcx_info,
   register const unsigned char
     *q;
 
-  register long
+  register ssize_t
     i,
     x;
 
@@ -788,11 +792,11 @@ static MagickBooleanType PCXWritePixels(PCXInfo *pcx_info,
     previous;
 
   q=pixels;
-  for (i=0; i < (long) pcx_info->planes; i++)
+  for (i=0; i < (ssize_t) pcx_info->planes; i++)
   {
     previous=(*q++);
     count=1;
-    for (x=0; x < (long) (pcx_info->bytes_per_line-1); x++)
+    for (x=0; x < (ssize_t) (pcx_info->bytes_per_line-1); x++)
     {
       packet=(*q++);
       if ((packet == previous) && (count < 63))
@@ -821,7 +825,7 @@ static MagickBooleanType PCXWritePixels(PCXInfo *pcx_info,
 
 static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
 {
-  long
+  ssize_t
     y;
 
   MagickBooleanType
@@ -841,7 +845,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
   register const PixelPacket
     *p;
 
-  register long
+  register ssize_t
     i,
     x;
 
@@ -931,7 +935,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
         if (image->matte != MagickFalse)
           pcx_info.planes++;
       }
-    pcx_info.bytes_per_line=(unsigned short) (((unsigned long) image->columns*
+    pcx_info.bytes_per_line=(unsigned short) (((size_t) image->columns*
       pcx_info.bits_per_pixel+7)/8);
     pcx_info.palette_info=1;
     pcx_info.colormap_signature=0x0c;
@@ -958,7 +962,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
     (void) memset(pcx_colormap,0,3*256*sizeof(*pcx_colormap));
     q=pcx_colormap;
     if ((image->storage_class == PseudoClass) && (image->colors <= 256))
-      for (i=0; i < (long) image->colors; i++)
+      for (i=0; i < (ssize_t) image->colors; i++)
       {
         *q++=ScaleQuantumToChar(image->colormap[i].red);
         *q++=ScaleQuantumToChar(image->colormap[i].green);
@@ -985,7 +989,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
         /*
           Convert DirectClass image to PCX raster pixels.
         */
-        for (y=0; y < (long) image->rows; y++)
+        for (y=0; y < (ssize_t) image->rows; y++)
         {
           pixels=GetVirtualPixels(image,0,y,image->columns,1,
             &image->exception);
@@ -999,7 +1003,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
             {
               case 0:
               {
-                for (x=0; x < (long) pcx_info.bytes_per_line; x++)
+                for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
                 {
                   *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
                   p++;
@@ -1008,7 +1012,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
               }
               case 1:
               {
-                for (x=0; x < (long) pcx_info.bytes_per_line; x++)
+                for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
                 {
                   *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
                   p++;
@@ -1017,7 +1021,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
               }
               case 2:
               {
-                for (x=0; x < (long) pcx_info.bytes_per_line; x++)
+                for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
                 {
                   *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
                   p++;
@@ -1027,9 +1031,9 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
               case 3:
               default:
               {
-                for (x=(long) pcx_info.bytes_per_line; x != 0; x--)
+                for (x=(ssize_t) pcx_info.bytes_per_line; x != 0; x--)
                 {
-                  *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacityPixelComponent(p)));
+                  *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
                   p++;
                 }
                 break;
@@ -1040,7 +1044,8 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
             break;
           if (image->previous == (Image *) NULL)
             {
-              status=SetImageProgress(image,SaveImageTag,y,image->rows);
+              status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+                image->rows);
               if (status == MagickFalse)
                 break;
             }
@@ -1049,20 +1054,21 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
     else
       {
         if (pcx_info.bits_per_pixel > 1)
-          for (y=0; y < (long) image->rows; y++)
+          for (y=0; y < (ssize_t) image->rows; y++)
           {
             p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
             if (p == (const PixelPacket *) NULL)
               break;
             indexes=GetVirtualIndexQueue(image);
             q=pcx_pixels;
-            for (x=0; x < (long) image->columns; x++)
+            for (x=0; x < (ssize_t) image->columns; x++)
               *q++=(unsigned char) indexes[x];
             if (PCXWritePixels(&pcx_info,pcx_pixels,image) == MagickFalse)
               break;
             if (image->previous == (Image *) NULL)
               {
-                status=SetImageProgress(image,SaveImageTag,y,image->rows);
+                status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+                image->rows);
                 if (status == MagickFalse)
                   break;
               }
@@ -1085,7 +1091,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
               polarity=(IndexPacket) (
                 PixelIntensityToQuantum(&image->colormap[0]) <
                 PixelIntensityToQuantum(&image->colormap[1]) ? 1 : 0);
-            for (y=0; y < (long) image->rows; y++)
+            for (y=0; y < (ssize_t) image->rows; y++)
             {
               p=GetVirtualPixels(image,0,y,image->columns,1,
                 &image->exception);
@@ -1095,7 +1101,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
               bit=0;
               byte=0;
               q=pcx_pixels;
-              for (x=0; x < (long) image->columns; x++)
+              for (x=0; x < (ssize_t) image->columns; x++)
               {
                 byte<<=1;
                 if (indexes[x] == polarity)
@@ -1115,7 +1121,8 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
                 break;
               if (image->previous == (Image *) NULL)
                 {
-                  status=SetImageProgress(image,SaveImageTag,y,image->rows);
+                  status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+                image->rows);
                   if (status == MagickFalse)
                     break;
                 }
@@ -1126,6 +1133,10 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
       }
     pcx_pixels=(unsigned char *) RelinquishMagickMemory(pcx_pixels);
     pcx_colormap=(unsigned char *) RelinquishMagickMemory(pcx_colormap);
+    if (page_table == (MagickOffsetType *) NULL)
+      break;
+    if (scene >= 1023)
+      break;
     if (GetNextImageInList(image) == (Image *) NULL)
       break;
     image=SyncNextImageInList(image);
@@ -1133,8 +1144,6 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
       GetImageListLength(image));
     if (status == MagickFalse)
       break;
-    if (scene >= 1023)
-      break;
   } while (image_info->adjoin != MagickFalse);
   if (page_table != (MagickOffsetType *) NULL)
     {
@@ -1146,8 +1155,8 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
       if (offset < 0)
         ThrowWriterException(CorruptImageError,"ImproperImageHeader");
       (void) WriteBlobLSBLong(image,0x3ADE68B1L);
-      for (i=0; i <= (long) scene; i++)
-        (void) WriteBlobLSBLong(image,(unsigned long) page_table[i]);
+      for (i=0; i <= (ssize_t) scene; i++)
+        (void) WriteBlobLSBLong(image,(unsigned int) page_table[i]);
       page_table=(MagickOffsetType *) RelinquishMagickMemory(page_table);
     }
   if (status == MagickFalse)