(no commit message)

diff --git a/coders/svg.c b/coders/svg.c
index f574fdee3c34d840b8c288ac15bcba352de540b2..c7af834c747ce5a2c391e9bd6886173e33341f05 100644 (file)
--- a/coders/svg.c
+++ b/coders/svg.c
@@ -2875,6 +2875,9 @@ static Image *ReadSVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
         cairo_t
           *cairo_image;
 
+        MemoryInfo
+          *pixel_info;
+
         register unsigned char
           *p;
 
@@ -2886,7 +2889,7 @@ static Image *ReadSVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
 
 #else
         GdkPixbuf
-          *pixel_info;
+          *pixel_buffer;
 
         register const guchar
           *p;
@@ -2932,12 +2935,12 @@ static Image *ReadSVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
         rsvg_handle_get_dimensions(svg_handle,&dimension_info);
         image->columns=image->resolution.x*dimension_info.width/72.0;
         image->rows=image->resolution.y*dimension_info.height/72.0;
-        pixels=(unsigned char *) NULL;
+        pixel_info=(MemoryInfo *) NULL;
 #else
-        pixel_info=rsvg_handle_get_pixbuf(svg_handle);
+        pixel_buffer=rsvg_handle_get_pixbuf(svg_handle);
         rsvg_handle_free(svg_handle);
-        image->columns=gdk_pixbuf_get_width(pixel_info);
-        image->rows=gdk_pixbuf_get_height(pixel_info);
+        image->columns=gdk_pixbuf_get_width(pixel_buffer);
+        image->rows=gdk_pixbuf_get_height(pixel_buffer);
 #endif
         image->alpha_trait=BlendPixelTrait;
         SetImageProperty(image,"svg:base-uri",
@@ -2945,7 +2948,7 @@ static Image *ReadSVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
         if ((image->columns == 0) || (image->rows == 0))
           {
 #if !defined(MAGICKCORE_CAIRO_DELEGATE)
-            g_object_unref(G_OBJECT(pixel_info));
+            g_object_unref(G_OBJECT(pixel_buffer));
 #endif
             g_object_unref(svg_handle);
             ThrowReaderException(MissingDelegateError,
@@ -2962,14 +2965,14 @@ static Image *ReadSVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
             stride=(size_t) cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32,
               image->columns);
 #endif
-            pixels=(unsigned char *) AcquireQuantumMemory(stride,image->rows*
-              sizeof(*pixels));
-            if (pixels == (unsigned char *) NULL)
+            pixel_info=AcquireVirtualMemory(stride,image->rows*sizeof(*pixels));
+            if (pixel_info == (MemoryInfo *) NULL)
               {
                 g_object_unref(svg_handle);
                 ThrowReaderException(ResourceLimitError,
                   "MemoryAllocationFailed");
               }
+            pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
 #endif
             (void) SetImageBackgroundColor(image,exception);
 #if defined(MAGICKCORE_CAIRO_DELEGATE)
@@ -2977,7 +2980,7 @@ static Image *ReadSVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
               CAIRO_FORMAT_ARGB32,image->columns,image->rows,stride);
             if (cairo_surface == (cairo_surface_t *) NULL)
               {
-                pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+                pixel_info=RelinquishVirtualMemory(pixel_info);
                 g_object_unref(svg_handle);
                 ThrowReaderException(ResourceLimitError,
                   "MemoryAllocationFailed");
@@ -2994,7 +2997,7 @@ static Image *ReadSVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
             g_object_unref(svg_handle);
             p=pixels;
 #else
-            p=gdk_pixbuf_get_pixels(pixel_info);
+            p=gdk_pixbuf_get_pixels(pixel_buffer);
 #endif
             GetPixelInfo(image,&fill_color);
             for (y=0; y < (ssize_t) image->rows; y++)
@@ -3042,10 +3045,10 @@ static Image *ReadSVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
             }
           }
 #if defined(MAGICKCORE_CAIRO_DELEGATE)
-        if (pixels != (unsigned char *) NULL)
-          pixels=(unsigned char *) RelinquishMagickMemory(pixels);
+        if (pixel_info != (MemoryInfo *) NULL)
+          pixel_info=RelinquishVirtualMemory(pixel_info);
 #else
-        g_object_unref(G_OBJECT(pixel_info));
+        g_object_unref(G_OBJECT(pixel_buffer));
 #endif
         (void) CloseBlob(image);
         return(GetFirstImageInList(image));

diff --git a/coders/tiff.c b/coders/tiff.c
index 249f1a1447d8304593816395d6b4bd840dd15583..6e7e84c124eb4b254305aadb388d083a75f3ee1a 100644 (file)
--- a/coders/tiff.c
+++ b/coders/tiff.c
@@ -1666,6 +1666,9 @@ static Image *ReadTIFFImage(const ImageInfo *image_info,
       case ReadGenericMethod:
       default:
       {
+        MemoryInfo
+          *pixel_info;
+
         register uint32
           *p;
 
@@ -1682,13 +1685,14 @@ static Image *ReadTIFFImage(const ImageInfo *image_info,
             TIFFClose(tiff);
             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
           }
-        pixels=(uint32 *) AcquireQuantumMemory(image->columns,image->rows*
+        pixel_info=AcquireVirtualMemory(image->columns,image->rows*
           sizeof(uint32));
-        if (pixels == (uint32 *) NULL)
+        if (pixel_info == (MemoryInfo *) NULL)
           {
             TIFFClose(tiff);
             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
           }
+        pixels=(uint32 *) GetVirtualMemoryBlob(pixel_info);
         (void) TIFFReadRGBAImage(tiff,(uint32) image->columns,
           (uint32) image->rows,(uint32 *) pixels,0);
         /*
@@ -1709,12 +1713,12 @@ static Image *ReadTIFFImage(const ImageInfo *image_info,
           q+=GetPixelChannels(image)*(image->columns-1);
           for (x=0; x < (ssize_t) image->columns; x++)
           {
-            SetPixelRed(image,ScaleCharToQuantum((unsigned char)
-              TIFFGetR(*p)),q);
+            SetPixelRed(image,ScaleCharToQuantum((unsigned char) TIFFGetR(*p)),
+              q);
             SetPixelGreen(image,ScaleCharToQuantum((unsigned char)
               TIFFGetG(*p)),q);
-            SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
-              TIFFGetB(*p)),q);
+            SetPixelBlue(image,ScaleCharToQuantum((unsigned char) TIFFGetB(*p)),
+              q);
             if (image->alpha_trait == BlendPixelTrait)
               SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
                 TIFFGetA(*p)),q);
@@ -1731,7 +1735,7 @@ static Image *ReadTIFFImage(const ImageInfo *image_info,
                 break;
             }
         }
-        pixels=(uint32 *) RelinquishMagickMemory(pixels);
+        pixel_info=RelinquishVirtualMemory(pixel_info);
         break;
       }
     }

diff --git a/coders/viff.c b/coders/viff.c
index 070d687dc760d41a031d43be4da72e69d8c22bb7..83334b2c3061262298cdd02d500a23a13e3baf4c 100644 (file)
--- a/coders/viff.c
+++ b/coders/viff.c
@@ -246,7 +246,7 @@ static Image *ReadVIFFImage(const ImageInfo *image_info,
 
   unsigned char
     buffer[7],
-    *viff_pixels;
+    *pixels;
 
   ViffInfo
     viff_info;
@@ -509,11 +509,11 @@ static Image *ReadVIFFImage(const ImageInfo *image_info,
       max_packets=((image->columns+7UL) >> 3UL)*image->rows;
     else
       max_packets=(size_t) (number_pixels*viff_info.number_data_bands);
-    viff_pixels=(unsigned char *) AcquireQuantumMemory(max_packets,
-      bytes_per_pixel*sizeof(*viff_pixels));
-    if (viff_pixels == (unsigned char *) NULL)
+    pixels=(unsigned char *) AcquireQuantumMemory(max_packets,
+      bytes_per_pixel*sizeof(*pixels));
+    if (pixels == (unsigned char *) NULL)
       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
-    count=ReadBlob(image,bytes_per_pixel*max_packets,viff_pixels);
+    count=ReadBlob(image,bytes_per_pixel*max_packets,pixels);
     lsb_first=1;
     if (*(char *) &lsb_first &&
         ((viff_info.machine_dependency != VFF_DEP_DECORDER) &&
@@ -522,13 +522,13 @@ static Image *ReadVIFFImage(const ImageInfo *image_info,
       {
         case VFF_TYP_2_BYTE:
         {
-          MSBOrderShort(viff_pixels,bytes_per_pixel*max_packets);
+          MSBOrderShort(pixels,bytes_per_pixel*max_packets);
           break;
         }
         case VFF_TYP_4_BYTE:
         case VFF_TYP_FLOAT:
         {
-          MSBOrderLong(viff_pixels,bytes_per_pixel*max_packets);
+          MSBOrderLong(pixels,bytes_per_pixel*max_packets);
           break;
         }
         default: break;
@@ -546,11 +546,11 @@ static Image *ReadVIFFImage(const ImageInfo *image_info,
         */
         switch ((int) viff_info.data_storage_type)
         {
-          case VFF_TYP_2_BYTE: value=1.0*((short *) viff_pixels)[0]; break;
-          case VFF_TYP_4_BYTE: value=1.0*((int *) viff_pixels)[0]; break;
-          case VFF_TYP_FLOAT: value=((float *) viff_pixels)[0]; break;
-          case VFF_TYP_DOUBLE: value=((double *) viff_pixels)[0]; break;
-          default: value=1.0*viff_pixels[0]; break;
+          case VFF_TYP_2_BYTE: value=1.0*((short *) pixels)[0]; break;
+          case VFF_TYP_4_BYTE: value=1.0*((int *) pixels)[0]; break;
+          case VFF_TYP_FLOAT: value=((float *) pixels)[0]; break;
+          case VFF_TYP_DOUBLE: value=((double *) pixels)[0]; break;
+          default: value=1.0*pixels[0]; break;
         }
         max_value=value;
         min_value=value;
@@ -558,11 +558,11 @@ static Image *ReadVIFFImage(const ImageInfo *image_info,
         {
           switch ((int) viff_info.data_storage_type)
           {
-            case VFF_TYP_2_BYTE: value=1.0*((short *) viff_pixels)[i]; break;
-            case VFF_TYP_4_BYTE: value=1.0*((int *) viff_pixels)[i]; break;
-            case VFF_TYP_FLOAT: value=((float *) viff_pixels)[i]; break;
-            case VFF_TYP_DOUBLE: value=((double *) viff_pixels)[i]; break;
-            default: value=1.0*viff_pixels[i]; break;
+            case VFF_TYP_2_BYTE: value=1.0*((short *) pixels)[i]; break;
+            case VFF_TYP_4_BYTE: value=1.0*((int *) pixels)[i]; break;
+            case VFF_TYP_FLOAT: value=((float *) pixels)[i]; break;
+            case VFF_TYP_DOUBLE: value=((double *) pixels)[i]; break;
+            default: value=1.0*pixels[i]; break;
           }
           if (value > max_value)
             max_value=value;
@@ -584,16 +584,16 @@ static Image *ReadVIFFImage(const ImageInfo *image_info,
     /*
       Convert pixels to Quantum size.
     */
-    p=(unsigned char *) viff_pixels;
+    p=(unsigned char *) pixels;
     for (i=0; i < (ssize_t) max_packets; i++)
     {
       switch ((int) viff_info.data_storage_type)
       {
-        case VFF_TYP_2_BYTE: value=1.0*((short *) viff_pixels)[i]; break;
-        case VFF_TYP_4_BYTE: value=1.0*((int *) viff_pixels)[i]; break;
-        case VFF_TYP_FLOAT: value=((float *) viff_pixels)[i]; break;
-        case VFF_TYP_DOUBLE: value=((double *) viff_pixels)[i]; break;
-        default: value=1.0*viff_pixels[i]; break;
+        case VFF_TYP_2_BYTE: value=1.0*((short *) pixels)[i]; break;
+        case VFF_TYP_4_BYTE: value=1.0*((int *) pixels)[i]; break;
+        case VFF_TYP_FLOAT: value=((float *) pixels)[i]; break;
+        case VFF_TYP_DOUBLE: value=((double *) pixels)[i]; break;
+        default: value=1.0*pixels[i]; break;
       }
       if (viff_info.map_scheme == VFF_MS_NONE)
         {
@@ -610,7 +610,7 @@ static Image *ReadVIFFImage(const ImageInfo *image_info,
     /*
       Convert VIFF raster image to pixel packets.
     */
-    p=(unsigned char *) viff_pixels;
+    p=(unsigned char *) pixels;
     if (viff_info.data_storage_type == VFF_TYP_BIT)
       {
         /*
@@ -723,7 +723,7 @@ static Image *ReadVIFFImage(const ImageInfo *image_info,
               }
           }
         }
-    viff_pixels=(unsigned char *) RelinquishMagickMemory(viff_pixels);
+    pixels=(unsigned char *) RelinquishMagickMemory(pixels);
     if (image->storage_class == PseudoClass)
       (void) SyncImage(image,exception);
     if (EOFBlob(image) != MagickFalse)
@@ -932,6 +932,9 @@ static MagickBooleanType WriteVIFFImage(const ImageInfo *image_info,
     number_pixels,
     packets;
 
+  MemoryInfo
+    *pixel_info;
+
   register const Quantum
     *p;
 
@@ -949,7 +952,7 @@ static MagickBooleanType WriteVIFFImage(const ImageInfo *image_info,
 
   unsigned char
     buffer[8],
-    *viff_pixels;
+    *pixels;
 
   ViffInfo
     viff_info;
@@ -1083,11 +1086,11 @@ static MagickBooleanType WriteVIFFImage(const ImageInfo *image_info,
     /*
       Convert MIFF to VIFF raster pixels.
     */
-    viff_pixels=(unsigned char *) AcquireQuantumMemory((size_t) packets,
-      sizeof(*viff_pixels));
-    if (viff_pixels == (unsigned char *) NULL)
+    pixel_info=AcquireVirtualMemory((size_t) packets,sizeof(*pixels));
+    if (pixel_info == (MemoryInfo *) NULL)
       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
-    q=viff_pixels;
+    pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
+    q=pixels;
     if (image->storage_class == DirectClass)
       {
         /*
@@ -1144,7 +1147,7 @@ static MagickBooleanType WriteVIFFImage(const ImageInfo *image_info,
           /*
             Convert PseudoClass packet to VIFF colormapped pixels.
           */
-          q=viff_pixels;
+          q=pixels;
           for (y=0; y < (ssize_t) image->rows; y++)
           {
             p=GetVirtualPixels(image,0,y,image->columns,1,exception);
@@ -1235,8 +1238,8 @@ static MagickBooleanType WriteVIFFImage(const ImageInfo *image_info,
                 }
             }
           }
-    (void) WriteBlob(image,(size_t) packets,viff_pixels);
-    viff_pixels=(unsigned char *) RelinquishMagickMemory(viff_pixels);
+    (void) WriteBlob(image,(size_t) packets,pixels);
+    pixel_info=RelinquishVirtualMemory(pixel_info);
     if (GetNextImageInList(image) == (Image *) NULL)
       break;
     image=SyncNextImageInList(image);

diff --git a/coders/webp.c b/coders/webp.c
index 34864f60aaace29742838d567392b51a070306ef..57f0110b8f01538848cf1d6a8c90c76d40218e12 100644 (file)
--- a/coders/webp.c
+++ b/coders/webp.c
@@ -191,7 +191,7 @@ static MagickBooleanType IsWEBPImageLossless(const unsigned char *stream,
     if (chunk_size > MAX_CHUNK_PAYLOAD)
       break;
     chunk_size_pad=(CHUNK_HEADER_SIZE+chunk_size+1) & ~1;
-    if (memcmp( stream+offset,VP8_CHUNK_HEADER,VP8_CHUNK_HEADER_SIZE) == 0)
+    if (memcmp(stream+offset,VP8_CHUNK_HEADER,VP8_CHUNK_HEADER_SIZE) == 0)
       return(*(stream+offset+VP8_CHUNK_HEADER_SIZE) == LOSSLESS_FLAG ?
         MagickTrue : MagickFalse);
     offset+=chunk_size_pad;
@@ -430,6 +430,9 @@ static MagickBooleanType WriteWEBPImage(const ImageInfo *image_info,
   MagickBooleanType
     status;
 
+  MemoryInfo
+    *pixel_info;
+
   register uint32_t
     *restrict q;
 
@@ -544,10 +547,11 @@ static MagickBooleanType WriteWEBPImage(const ImageInfo *image_info,
   /*
     Allocate memory for pixels.
   */
-  picture.argb=(uint32_t *) AcquireQuantumMemory(image->columns,image->rows*
+  pixel_info=AcquireVirtualMemory(image->columns,image->rows*
     sizeof(*picture.argb));
-  if (picture.argb == (uint32_t *) NULL)
+  if (pixel_info == (MemoryInfo *) NULL)
     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
+  picture.argb=(uint32_t *) GetVirtualMemoryBlob(pixel_info);
   /*
     Convert image to WebP raster pixels.
   */
@@ -579,7 +583,7 @@ static MagickBooleanType WriteWEBPImage(const ImageInfo *image_info,
   }
   webp_status=WebPEncode(&configure,&picture);
   WebPPictureFree(&picture);
-  picture.argb=(uint32_t *) RelinquishMagickMemory(picture.argb);
+  pixel_info=RelinquishVirtualMemory(pixel_info);
   (void) CloseBlob(image);
   return(webp_status == 0 ? MagickFalse : MagickTrue);
 }