(no commit message)

diff --git a/coders/ps2.c b/coders/ps2.c
index bc9dcda060778d181396355a1b932827d59f1d9d..466225d6c7b538b0f42c9a64b1aba74e70329c29 100644 (file)
--- a/coders/ps2.c
+++ b/coders/ps2.c
@@ -769,6 +769,9 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
           case RLECompression:
           default:
           {
+            MemoryInfo
+              *pixel_info;
+
             register unsigned char
               *q;
 
@@ -776,12 +779,12 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
               Allocate pixel array.
             */
             length=(size_t) number_pixels;
-            pixels=(unsigned char *) AcquireQuantumMemory(length,
-              sizeof(*pixels));
-            if (pixels == (unsigned char *) NULL)
+            pixel_info=AcquireVirtualMemory(length,sizeof(*pixels));
+            if (pixel_info == (MemoryInfo *) NULL)
               ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
+            pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
             /*
-              Dump Runlength encoded pixels.
+              Dump runlength encoded pixels.
             */
             q=pixels;
             for (y=0; y < (ssize_t) image->rows; y++)
@@ -804,7 +807,7 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
               status=LZWEncodeImage(image,length,pixels,exception);
             else
               status=PackbitsEncodeImage(image,length,pixels,exception);
-            pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+            pixel_info=RelinquishVirtualMemory(pixel_info);
             if (status == MagickFalse)
               {
                 (void) CloseBlob(image);
@@ -865,6 +868,9 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
             case RLECompression:
             default:
             {
+              MemoryInfo
+                *pixel_info;
+
               register unsigned char
                 *q;
 
@@ -872,13 +878,13 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
                 Allocate pixel array.
               */
               length=(size_t) number_pixels;
-              pixels=(unsigned char *) AcquireQuantumMemory(length,
-                4*sizeof(*pixels));
-              if (pixels == (unsigned char *) NULL)
+              pixel_info=AcquireVirtualMemory(length,4*sizeof(*pixels));
+              if (pixel_info == (MemoryInfo *) NULL)
                 ThrowWriterException(ResourceLimitError,
                   "MemoryAllocationFailed");
+              pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
               /*
-                Dump Packbit encoded pixels.
+                Dump runlength encoded pixels.
               */
               q=pixels;
               for (y=0; y < (ssize_t) image->rows; y++)
@@ -926,7 +932,7 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
                   (void) CloseBlob(image);
                   return(MagickFalse);
                 }
-              pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+              pixel_info=RelinquishVirtualMemory(pixel_info);
               break;
             }
             case NoCompression:
@@ -1013,6 +1019,9 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
             case RLECompression:
             default:
             {
+              MemoryInfo
+                *pixel_info;
+
               register unsigned char
                 *q;
 
@@ -1020,13 +1029,13 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
                 Allocate pixel array.
               */
               length=(size_t) number_pixels;
-              pixels=(unsigned char *) AcquireQuantumMemory(length,
-                sizeof(*pixels));
-              if (pixels == (unsigned char *) NULL)
+              pixel_info=AcquireVirtualMemory(length,sizeof(*pixels));
+              if (pixel_info == (MemoryInfo *) NULL)
                 ThrowWriterException(ResourceLimitError,
                   "MemoryAllocationFailed");
+              pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
               /*
-                Dump Runlength encoded pixels.
+                Dump runlength encoded pixels.
               */
               q=pixels;
               for (y=0; y < (ssize_t) image->rows; y++)
@@ -1049,7 +1058,7 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
                 status=LZWEncodeImage(image,length,pixels,exception);
               else
                 status=PackbitsEncodeImage(image,length,pixels,exception);
-              pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+              pixel_info=RelinquishVirtualMemory(pixel_info);
               if (status == MagickFalse)
                 {
                   (void) CloseBlob(image);

diff --git a/coders/ps3.c b/coders/ps3.c
index ef7a7918f2e43cd71f38659f7d1c868e0d53ca17..2a68d92c101e4cf12add5fcc6ada85df4ccf7b32 100644 (file)
--- a/coders/ps3.c
+++ b/coders/ps3.c
@@ -238,7 +238,7 @@ static MagickBooleanType Huffman2DEncodeImage(const ImageInfo *image_info,
 }
 
 static MagickBooleanType SerializeImage(const ImageInfo *image_info,
-  Image *image,unsigned char **pixels,size_t *length,ExceptionInfo *exception)
+  Image *image,MemoryInfo **pixel_info,size_t *length,ExceptionInfo *exception)
 {
   MagickBooleanType
     status;
@@ -262,10 +262,10 @@ static MagickBooleanType SerializeImage(const ImageInfo *image_info,
   status=MagickTrue;
   *length=(image->colorspace == CMYKColorspace ? 4 : 3)*(size_t)
     image->columns*image->rows;
-  *pixels=(unsigned char *) AcquireQuantumMemory(*length,sizeof(**pixels));
-  if (*pixels == (unsigned char *) NULL)
+  *pixel_info=AcquireVirtualMemory(*length,sizeof(*q));
+  if (*pixel_info == (MemoryInfo *) NULL)
     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
-  q=(*pixels);
+  q=(unsigned char *) GetVirtualMemoryBlob(*pixel_info);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
@@ -297,12 +297,12 @@ static MagickBooleanType SerializeImage(const ImageInfo *image_info,
       }
   }
   if (status == MagickFalse)
-    *pixels=(unsigned char *) RelinquishMagickMemory(*pixels);
+    *pixel_info=RelinquishVirtualMemory(*pixel_info);
   return(status);
 }
 
 static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,
-  Image *image,unsigned char **pixels,size_t *length,ExceptionInfo *exception)
+  Image *image,MemoryInfo **pixel_info,size_t *length,ExceptionInfo *exception)
 {
   MagickBooleanType
     status;
@@ -335,10 +335,10 @@ static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,
   pack=IsImageMonochrome(image,exception) == MagickFalse ? 1UL : 8UL;
   padded_columns=((image->columns+pack-1)/pack)*pack;
   *length=(size_t) padded_columns*image->rows/pack;
-  *pixels=(unsigned char *) AcquireQuantumMemory(*length,sizeof(**pixels));
-  if (*pixels == (unsigned char *) NULL)
+  *pixel_info=AcquireVirtualMemory(*length,sizeof(*q));
+  if (*pixel_info == (MemoryInfo *) NULL)
     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
-  q=(*pixels);
+  q=(unsigned char *) GetVirtualMemoryBlob(*pixel_info);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
@@ -374,12 +374,12 @@ static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,
       break;
   }
   if (status == MagickFalse)
-    *pixels=(unsigned char *) RelinquishMagickMemory(*pixels);
+    *pixel_info=RelinquishVirtualMemory(*pixel_info);
   return(status);
 }
 
 static MagickBooleanType SerializeImageIndexes(const ImageInfo *image_info,
-  Image *image,unsigned char **pixels,size_t *length,ExceptionInfo *exception)
+  Image *image,MemoryInfo **pixel_info,size_t *length,ExceptionInfo *exception)
 {
   MagickBooleanType
     status;
@@ -402,10 +402,10 @@ static MagickBooleanType SerializeImageIndexes(const ImageInfo *image_info,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   status=MagickTrue;
   *length=(size_t) image->columns*image->rows;
-  *pixels=(unsigned char *) AcquireQuantumMemory(*length,sizeof(**pixels));
-  if (*pixels == (unsigned char *) NULL)
+  *pixel_info=AcquireVirtualMemory(*length,sizeof(*q));
+  if (*pixel_info == (MemoryInfo *) NULL)
     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
-  q=(*pixels);
+  q=(unsigned char *) GetVirtualMemoryBlob(*pixel_info);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
@@ -425,7 +425,7 @@ static MagickBooleanType SerializeImageIndexes(const ImageInfo *image_info,
       }
   }
   if (status == MagickFalse)
-    *pixels=(unsigned char *) RelinquishMagickMemory(*pixels);
+    *pixel_info=RelinquishVirtualMemory(*pixel_info);
   return(status);
 }
 
@@ -446,6 +446,9 @@ static MagickBooleanType WritePS3MaskImage(const ImageInfo *image_info,
     start,
     stop;
 
+  MemoryInfo
+    *pixel_info;
+
   register ssize_t
     i;
 
@@ -530,15 +533,16 @@ static MagickBooleanType WritePS3MaskImage(const ImageInfo *image_info,
     case NoCompression:
     default:
     {
-      status=SerializeImageChannel(image_info,mask_image,&pixels,&length,
+      status=SerializeImageChannel(image_info,mask_image,&pixel_info,&length,
         exception);
       if (status == MagickFalse)
         break;
       Ascii85Initialize(image);
+      pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
       for (i=0; i < (ssize_t) length; i++)
         Ascii85Encode(image,pixels[i]);
       Ascii85Flush(image);
-      pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+      pixel_info=RelinquishVirtualMemory(pixel_info);
       break;
     }
     case FaxCompression:
@@ -553,32 +557,35 @@ static MagickBooleanType WritePS3MaskImage(const ImageInfo *image_info,
     }
     case LZWCompression:
     {
-      status=SerializeImageChannel(image_info,mask_image,&pixels,&length,
+      status=SerializeImageChannel(image_info,mask_image,&pixel_info,&length,
         exception);
       if (status == MagickFalse)
         break;
+      pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
       status=LZWEncodeImage(image,length,pixels,exception);
-      pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+      pixel_info=RelinquishVirtualMemory(pixel_info);
       break;
     }
     case RLECompression:
     {
-      status=SerializeImageChannel(image_info,mask_image,&pixels,&length,
+      status=SerializeImageChannel(image_info,mask_image,&pixel_info,&length,
         exception);
       if (status == MagickFalse)
         break;
+      pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
       status=PackbitsEncodeImage(image,length,pixels,exception);
-      pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+      pixel_info=RelinquishVirtualMemory(pixel_info);
       break;
     }
     case ZipCompression:
     {
-      status=SerializeImageChannel(image_info,mask_image,&pixels,&length,
+      status=SerializeImageChannel(image_info,mask_image,&pixel_info,&length,
         exception);
       if (status == MagickFalse)
         break;
+      pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
       status=ZLIBEncodeImage(image,length,pixels,exception);
-      pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+      pixel_info=RelinquishVirtualMemory(pixel_info);
       break;
     }
   }
@@ -828,6 +835,9 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
   MagickStatusType
     flags;
 
+  MemoryInfo
+    *pixel_info;
+
   PointInfo
     delta,
     resolution,
@@ -1312,13 +1322,14 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
             }
           else
             {
-              status=SerializeImageChannel(image_info,image,&pixels,&length,
+              status=SerializeImageChannel(image_info,image,&pixel_info,&length,
                 exception);
               if (status == MagickFalse)
                 {
                   (void) CloseBlob(image);
                   return(MagickFalse);
                 }
+              pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
               switch (compression)
               {
                 case NoCompression:
@@ -1347,7 +1358,7 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
                   break;
                 }
               }
-              pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+              pixel_info=RelinquishVirtualMemory(pixel_info);
             }
       }
     else
@@ -1397,12 +1408,14 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
               /*
                 Stream based compressions.
               */
-              status=SerializeImage(image_info,image,&pixels,&length,exception);
+              status=SerializeImage(image_info,image,&pixel_info,&length,
+                exception);
               if (status == MagickFalse)
                 {
                   (void) CloseBlob(image);
                   return(MagickFalse);
                 }
+              pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
               switch (compression)
               {
                 case NoCompression:
@@ -1431,7 +1444,7 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
                   break;
                 }
               }
-              pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+              pixel_info=RelinquishVirtualMemory(pixel_info);
             }
           }
         else
@@ -1505,13 +1518,14 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
                 }
                 Ascii85Flush(image);
               }
-            status=SerializeImageIndexes(image_info,image,&pixels,&length,
+            status=SerializeImageIndexes(image_info,image,&pixel_info,&length,
               exception);
             if (status == MagickFalse)
               {
                 (void) CloseBlob(image);
                 return(MagickFalse);
               }
+            pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
             switch (compression)
             {
               case NoCompression:
@@ -1545,7 +1559,7 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
                 break;
               }
             }
-            pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+            pixel_info=RelinquishVirtualMemory(pixel_info);
           }
     (void) WriteBlobByte(image,'\n');
     if (status == MagickFalse)

diff --git a/coders/rle.c b/coders/rle.c
index dc5df15560b81824d889c5c00603d32897ae2624..8f17e0082ed272ce079b39c7a67e4e05200abe21 100644 (file)
--- a/coders/rle.c
+++ b/coders/rle.c
@@ -149,6 +149,9 @@ static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
   MagickSizeType
     number_pixels;
 
+  MemoryInfo
+    *pixel_info;
+
   register ssize_t
     x;
 
@@ -177,7 +180,7 @@ static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
     *colormap,
     pixel,
     plane,
-    *rle_pixels;
+    *pixels;
 
   /*
     Open image file.
@@ -292,10 +295,11 @@ static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
     number_pixels=(MagickSizeType) image->columns*image->rows;
     if ((number_pixels*number_planes) != (size_t) (number_pixels*number_planes))
       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
-    rle_pixels=(unsigned char *) AcquireQuantumMemory(image->columns,
-      image->rows*number_planes*sizeof(*rle_pixels));
-    if (rle_pixels == (unsigned char *) NULL)
+    pixel_info=AcquireVirtualMemory(image->columns,image->rows*number_planes*
+      sizeof(*pixels));
+    if (pixel_info == (MemoryInfo *) NULL)
       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+    pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
     if ((flags & 0x01) && !(flags & 0x02))
       {
         ssize_t
@@ -304,7 +308,7 @@ static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
         /*
           Set background color.
         */
-        p=rle_pixels;
+        p=pixels;
         for (i=0; i < (ssize_t) number_pixels; i++)
         {
           if (image->alpha_trait != BlendPixelTrait)
@@ -360,7 +364,7 @@ static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
           operand=ReadBlobByte(image);
           if (opcode & 0x40)
             operand=(int) ReadBlobLSBShort(image);
-          p=rle_pixels+((image->rows-y-1)*image->columns*number_planes)+
+          p=pixels+((image->rows-y-1)*image->columns*number_planes)+
             x*number_planes+plane;
           operand++;
           for (i=0; i < (ssize_t) operand; i++)
@@ -384,7 +388,7 @@ static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
           pixel=(unsigned char) ReadBlobByte(image);
           (void) ReadBlobByte(image);
           operand++;
-          p=rle_pixels+((image->rows-y-1)*image->columns*number_planes)+
+          p=pixels+((image->rows-y-1)*image->columns*number_planes)+
             x*number_planes+plane;
           for (i=0; i < (ssize_t) operand; i++)
           {
@@ -410,7 +414,7 @@ static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
           Apply colormap affineation to image.
         */
         mask=(MagickStatusType) (map_length-1);
-        p=rle_pixels;
+        p=pixels;
         if (number_colormaps == 1)
           for (i=0; i < (ssize_t) number_pixels; i++)
           {
@@ -434,7 +438,7 @@ static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
         /*
           Convert raster image to DirectClass pixel packets.
         */
-        p=rle_pixels;
+        p=pixels;
         for (y=0; y < (ssize_t) image->rows; y++)
         {
           q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
@@ -489,7 +493,7 @@ static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
               image->colormap[i].blue=ScaleCharToQuantum(*(p+map_length*2));
               p++;
             }
-        p=rle_pixels;
+        p=pixels;
         if (image->alpha_trait != BlendPixelTrait)
           {
             /*
@@ -553,7 +557,7 @@ static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
       }
     if (number_colormaps != 0)
       colormap=(unsigned char *) RelinquishMagickMemory(colormap);
-    rle_pixels=(unsigned char *) RelinquishMagickMemory(rle_pixels);
+    pixel_info=RelinquishVirtualMemory(pixel_info);
     if (EOFBlob(image) != MagickFalse)
       {
         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",

diff --git a/coders/sgi.c b/coders/sgi.c
index c6a4522b734725831279933d3342516480666f62..3323a757b1e42ddfb84503fb22799ed88385160c 100644 (file)
--- a/coders/sgi.c
+++ b/coders/sgi.c
@@ -271,6 +271,9 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
   MagickSizeType
     number_pixels;
 
+  MemoryInfo
+    *pixel_info;
+
   register Quantum
     *q;
 
@@ -294,7 +297,7 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
     z;
 
   unsigned char
-    *iris_pixels;
+    *pixels;
 
   /*
     Open image file.
@@ -376,10 +379,11 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
     if ((4*bytes_per_pixel*number_pixels) != ((MagickSizeType) (size_t)
         (4*bytes_per_pixel*number_pixels)))
       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
-    iris_pixels=(unsigned char *) AcquireQuantumMemory(iris_info.columns,
-      iris_info.rows*4*bytes_per_pixel*sizeof(*iris_pixels));
-    if (iris_pixels == (unsigned char *) NULL)
+    pixel_info=AcquireVirtualMemory(iris_info.columns,iris_info.rows*4*
+      bytes_per_pixel*sizeof(*pixels));
+    if (pixel_info == (MemoryInfo *) NULL)
       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+    pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
     if ((int) iris_info.storage != 0x01)
       {
         unsigned char
@@ -394,7 +398,7 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
         for (z=0; z < (ssize_t) iris_info.depth; z++)
         {
-          p=iris_pixels+bytes_per_pixel*z;
+          p=pixels+bytes_per_pixel*z;
           for (y=0; y < (ssize_t) iris_info.rows; y++)
           {
             count=ReadBlob(image,bytes_per_pixel*iris_info.columns,scanline);
@@ -419,6 +423,9 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
       }
     else
       {
+        MemoryInfo
+          *packet_info;
+
         size_t
           *runlength;
 
@@ -437,14 +444,23 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
         */
         offsets=(ssize_t *) AcquireQuantumMemory((size_t) iris_info.rows,
           iris_info.depth*sizeof(*offsets));
-        packets=(unsigned char *) AcquireQuantumMemory((size_t)
-          iris_info.columns+10UL,4UL*sizeof(*packets));
         runlength=(size_t *) AcquireQuantumMemory(iris_info.rows,
           iris_info.depth*sizeof(*runlength));
+        packet_info=AcquireVirtualMemory((size_t) iris_info.columns+10UL,4UL*
+          sizeof(*packets));
         if ((offsets == (ssize_t *) NULL) ||
-            (packets == (unsigned char *) NULL) ||
-            (runlength == (size_t *) NULL))
-          ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+            (runlength == (size_t *) NULL) ||
+            (packet_info == (MemoryInfo *) NULL))
+          {
+            if (offsets == (ssize_t *) NULL)
+              offsets=(ssize_t *) RelinquishMagickMemory(offsets);
+            if (runlength == (size_t *) NULL)
+              runlength=(size_t *) RelinquishMagickMemory(runlength);
+            if (packet_info == (MemoryInfo *) NULL)
+              packet_info=RelinquishVirtualMemory(packet_info);
+            ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+          }
+        packets=(unsigned char *) GetVirtualMemoryBlob(packet_info);
         for (i=0; i < (ssize_t) (iris_info.rows*iris_info.depth); i++)
           offsets[i]=(int) ReadBlobMSBLong(image);
         for (i=0; i < (ssize_t) (iris_info.rows*iris_info.depth); i++)
@@ -470,7 +486,7 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
           {
             for (z=0; z < (ssize_t) iris_info.depth; z++)
             {
-              p=iris_pixels;
+              p=pixels;
               for (y=0; y < (ssize_t) iris_info.rows; y++)
               {
                 if (offset != offsets[y+z*iris_info.rows])
@@ -498,7 +514,7 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
               position;
            
             position=TellBlob(image);
-            p=iris_pixels;
+            p=pixels;
             for (y=0; y < (ssize_t) iris_info.rows; y++)
             {
               for (z=0; z < (ssize_t) iris_info.depth; z++)
@@ -523,8 +539,8 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
             }
             offset=(ssize_t) SeekBlob(image,position,SEEK_SET);
           }
+        packet_info=RelinquishVirtualMemory(packet_info);
         runlength=(size_t *) RelinquishMagickMemory(runlength);
-        packets=(unsigned char *) RelinquishMagickMemory(packets);
         offsets=(ssize_t *) RelinquishMagickMemory(offsets);
       }
     /*
@@ -546,7 +562,7 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
           {
             for (y=0; y < (ssize_t) image->rows; y++)
             {
-              p=iris_pixels+(image->rows-y-1)*8*image->columns;
+              p=pixels+(image->rows-y-1)*8*image->columns;
               q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
               if (q == (Quantum *) NULL)
                 break;
@@ -579,7 +595,7 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
         else
           for (y=0; y < (ssize_t) image->rows; y++)
           {
-            p=iris_pixels+(image->rows-y-1)*4*image->columns;
+            p=pixels+(image->rows-y-1)*4*image->columns;
             q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
             if (q == (Quantum *) NULL)
               break;
@@ -619,7 +635,7 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
           {
             for (y=0; y < (ssize_t) image->rows; y++)
             {
-              p=iris_pixels+(image->rows-y-1)*8*image->columns;
+              p=pixels+(image->rows-y-1)*8*image->columns;
               q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
               if (q == (Quantum *) NULL)
                 break;
@@ -645,7 +661,7 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
         else
           for (y=0; y < (ssize_t) image->rows; y++)
           {
-            p=iris_pixels+(image->rows-y-1)*4*image->columns;
+            p=pixels+(image->rows-y-1)*4*image->columns;
             q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
             if (q == (Quantum *) NULL)
               break;
@@ -667,7 +683,7 @@ static Image *ReadSGIImage(const ImageInfo *image_info,ExceptionInfo *exception)
           }
         (void) SyncImage(image,exception);
       }
-    iris_pixels=(unsigned char *) RelinquishMagickMemory(iris_pixels);
+    pixel_info=RelinquishVirtualMemory(pixel_info);
     if (EOFBlob(image) != MagickFalse)
       {
         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
@@ -865,6 +881,9 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
   MagickSizeType
     number_pixels;
 
+  MemoryInfo
+    *pixel_info;
+
   SGIInfo
     iris_info;
 
@@ -883,7 +902,7 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
     z;
 
   unsigned char
-    *iris_pixels,
+    *pixels,
     *packets;
 
   /*
@@ -969,10 +988,11 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
     if ((4*iris_info.bytes_per_pixel*number_pixels) !=
         ((MagickSizeType) (size_t) (4*iris_info.bytes_per_pixel*number_pixels)))
       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
-    iris_pixels=(unsigned char *) AcquireQuantumMemory((size_t) number_pixels,
-      4*iris_info.bytes_per_pixel*sizeof(*iris_pixels));
-    if (iris_pixels == (unsigned char *) NULL)
+    pixel_info=AcquireVirtualMemory((size_t) number_pixels,4*
+      iris_info.bytes_per_pixel*sizeof(*pixels));
+    if (pixel_info == (MemoryInfo *) NULL)
       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
+    pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
     /*
       Convert image pixels to uncompressed SGI pixels.
     */
@@ -987,7 +1007,7 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
           register unsigned char
             *q;
 
-          q=(unsigned char *) iris_pixels;
+          q=(unsigned char *) pixels;
           q+=((iris_info.rows-1)-y)*(4*iris_info.columns)+4*x;
           *q++=ScaleQuantumToChar(GetPixelRed(image,p));
           *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
@@ -1001,7 +1021,7 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
           register unsigned short
             *q;
 
-          q=(unsigned short *) iris_pixels;
+          q=(unsigned short *) pixels;
           q+=((iris_info.rows-1)-y)*(4*iris_info.columns)+4*x;
           *q++=ScaleQuantumToShort(GetPixelRed(image,p));
           *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
@@ -1034,7 +1054,7 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
                 register unsigned char
                   *q;
 
-                q=(unsigned char *) iris_pixels;
+                q=(unsigned char *) pixels;
                 q+=y*(4*iris_info.columns)+4*x+z;
                 (void) WriteBlobByte(image,*q);
               }
@@ -1044,7 +1064,7 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
                 register unsigned short
                   *q;
 
-                q=(unsigned short *) iris_pixels;
+                q=(unsigned short *) pixels;
                 q+=y*(4*iris_info.columns)+4*x+z;
                 (void) WriteBlobMSBShort(image,*q);
               }
@@ -1054,6 +1074,9 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
       }
       default:
       {
+        MemoryInfo
+          *packet_info;
+
         size_t
           length,
           number_packets,
@@ -1068,17 +1091,26 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
         */
         offsets=(ssize_t *) AcquireQuantumMemory(iris_info.rows*iris_info.depth,
           sizeof(*offsets));
-        packets=(unsigned char *) AcquireQuantumMemory((2*(size_t)
-          iris_info.columns+10)*image->rows,4*sizeof(*packets));
         runlength=(size_t *) AcquireQuantumMemory(iris_info.rows,
           iris_info.depth*sizeof(*runlength));
+        packet_info=AcquireVirtualMemory((2*(size_t) iris_info.columns+10)*
+          image->rows,4*sizeof(*packets));
         if ((offsets == (ssize_t *) NULL) ||
-            (packets == (unsigned char *) NULL) ||
-            (runlength == (size_t *) NULL))
-          ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
+            (runlength == (size_t *) NULL) ||
+            (packet_info == (MemoryInfo *) NULL))
+          {
+            if (offsets != (ssize_t *) NULL)
+              offsets=(ssize_t *) RelinquishMagickMemory(offsets);
+            if (runlength != (size_t *) NULL)
+              runlength=(size_t *) RelinquishMagickMemory(runlength);
+            if (packet_info != (MemoryInfo *) NULL)
+              packet_info=RelinquishVirtualMemory(packet_info);
+            ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
+          }
+        packets=(unsigned char *) GetVirtualMemoryBlob(packet_info);
         offset=512+4*2*((ssize_t) iris_info.rows*iris_info.depth);
         number_packets=0;
-        q=iris_pixels;
+        q=pixels;
         for (y=0; y < (ssize_t) iris_info.rows; y++)
         {
           for (z=0; z < (ssize_t) iris_info.depth; z++)
@@ -1103,13 +1135,13 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
         /*
           Relinquish resources.
         */
-        runlength=(size_t *) RelinquishMagickMemory(runlength);
-        packets=(unsigned char *) RelinquishMagickMemory(packets);
         offsets=(ssize_t *) RelinquishMagickMemory(offsets);
+        runlength=(size_t *) RelinquishMagickMemory(runlength);
+        packet_info=RelinquishVirtualMemory(packet_info);
         break;
       }
     }
-    iris_pixels=(unsigned char *) RelinquishMagickMemory(iris_pixels);
+    pixel_info=RelinquishVirtualMemory(pixel_info);
     if (GetNextImageInList(image) == (Image *) NULL)
       break;
     image=SyncNextImageInList(image);