(no commit message)

diff --git a/MagickCore/annotate.c b/MagickCore/annotate.c
index 3b4db8fff8c2a86477e867ce8c9a60a7b9154c39..3ae835ea53d1f3281a390f8658db786066ce93ae 100644 (file)
--- a/MagickCore/annotate.c
+++ b/MagickCore/annotate.c
@@ -1438,7 +1438,8 @@ static MagickBooleanType RenderFreetype(Image *image,const DrawInfo *draw_info,
                 q+=GetPixelChannels(image);
                 continue;
               }
-            (void) GetFillColor(draw_info,x_offset,y_offset,&fill_color);
+            (void) GetFillColor(draw_info,x_offset,y_offset,&fill_color,
+              exception);
             fill_opacity=fill_opacity*fill_color.alpha;
             CompositePixelOver(image,&fill_color,fill_opacity,q,
               GetPixelAlpha(image,q),q);
@@ -1818,7 +1819,7 @@ static MagickBooleanType RenderPostscript(Image *image,
           break;
         for (x=0; x < (ssize_t) annotate_image->columns; x++)
         {
-          (void) GetFillColor(draw_info,x,y,&fill_color);
+          (void) GetFillColor(draw_info,x,y,&fill_color,exception);
           SetPixelAlpha(annotate_image,ClampToQuantum((((MagickRealType)
             GetPixelIntensity(annotate_image,q)*fill_color.alpha)/
             QuantumRange)),q);

diff --git a/MagickCore/cache-private.h b/MagickCore/cache-private.h
index efdd39a28ef8b94dd2d36c9104bd0262143980a9..4a9a277eb3771f46fb310edb6fe70f341ca655b3 100644 (file)
--- a/MagickCore/cache-private.h
+++ b/MagickCore/cache-private.h
@@ -41,9 +41,9 @@ typedef void
 
 typedef MagickBooleanType
   (*GetOneAuthenticPixelFromHandler)(Image *,const ssize_t,const ssize_t,
-    PixelPacket *,ExceptionInfo *),
+    Quantum *,ExceptionInfo *),
   (*GetOneVirtualPixelFromHandler)(const Image *,const VirtualPixelMethod,
-    const ssize_t,const ssize_t,PixelPacket *,ExceptionInfo *),
+    const ssize_t,const ssize_t,Quantum *,ExceptionInfo *),
   (*SyncAuthenticPixelsHandler)(Image *,ExceptionInfo *);
 
 typedef const Quantum

diff --git a/MagickCore/cache-view.c b/MagickCore/cache-view.c
index 4e951b968c3f538b95a2ce4aa383ceb1512a1aee..43da94a2ed8e42f5f45ee6730f72441ad5a643af 100644 (file)
--- a/MagickCore/cache-view.c
+++ b/MagickCore/cache-view.c
@@ -642,7 +642,7 @@ MagickExport const Quantum *GetCacheViewVirtualPixels(
 %
 %      MagickBooleaNType GetOneCacheViewAuthenticPixel(
 %        const CacheView *cache_view,const ssize_t x,const ssize_t y,
-%        PixelPacket *pixel,ExceptionInfo *exception)
+%        Quantum *pixel,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -656,8 +656,8 @@ MagickExport const Quantum *GetCacheViewVirtualPixels(
 %
 */
 MagickExport MagickBooleanType GetOneCacheViewAuthenticPixel(
-  const CacheView *cache_view,const ssize_t x,const ssize_t y,
-  PixelPacket *pixel,ExceptionInfo *exception)
+  const CacheView *cache_view,const ssize_t x,const ssize_t y,Quantum *pixel,
+  ExceptionInfo *exception)
 {
   const int
     id = GetOpenMPThreadId();
@@ -665,17 +665,31 @@ MagickExport MagickBooleanType GetOneCacheViewAuthenticPixel(
   Quantum
     *p;
 
+  register ssize_t
+    i;
+
   assert(cache_view != (CacheView *) NULL);
   assert(cache_view->signature == MagickSignature);
-  *pixel=cache_view->image->background_color;
   assert(id < (int) cache_view->number_threads);
+  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
   p=GetAuthenticPixelCacheNexus(cache_view->image,x,y,1,1,
     cache_view->nexus_info[id],exception);
   if (p == (const Quantum *) NULL)
-    return(MagickFalse);
-  GetPixelPacketPixel(cache_view->image,p,pixel);
-  if (GetPixelCacheColorspace(cache_view->image->cache) == CMYKColorspace)
-    pixel->black=GetPixelBlack(cache_view->image,p);
+    {
+      pixel[RedPixelChannel]=cache_view->image->background_color.red;
+      pixel[GreenPixelChannel]=cache_view->image->background_color.green;
+      pixel[BluePixelChannel]=cache_view->image->background_color.blue;
+      pixel[AlphaPixelChannel]=cache_view->image->background_color.alpha;
+      return(MagickFalse);
+    }
+  for (i=0; i < (ssize_t) GetPixelChannels(cache_view->image); i++)
+  {
+    PixelChannel
+      channel;
+
+    channel=GetPixelChannelMapChannel(cache_view->image,(PixelChannel) i);
+    pixel[channel]=p[i];
+  }
   return(MagickTrue);
 }
 \f
@@ -698,7 +712,7 @@ MagickExport MagickBooleanType GetOneCacheViewAuthenticPixel(
 %
 %      MagickBooleanType GetOneCacheViewVirtualPixel(
 %        const CacheView *cache_view,const ssize_t x,const ssize_t y,
-%        PixelPacket *pixel,ExceptionInfo *exception)
+%        Quantum *pixel,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -712,8 +726,8 @@ MagickExport MagickBooleanType GetOneCacheViewAuthenticPixel(
 %
 */
 MagickExport MagickBooleanType GetOneCacheViewVirtualPixel(
-  const CacheView *cache_view,const ssize_t x,const ssize_t y,
-  PixelPacket *pixel,ExceptionInfo *exception)
+  const CacheView *cache_view,const ssize_t x,const ssize_t y,Quantum *pixel,
+  ExceptionInfo *exception)
 {
   const int
     id = GetOpenMPThreadId();
@@ -721,18 +735,32 @@ MagickExport MagickBooleanType GetOneCacheViewVirtualPixel(
   const Quantum
     *p;
 
+  register ssize_t
+    i;
+
   assert(cache_view != (CacheView *) NULL);
   assert(cache_view->signature == MagickSignature);
-  *pixel=cache_view->image->background_color;
   assert(id < (int) cache_view->number_threads);
+  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
   p=GetVirtualPixelsFromNexus(cache_view->image,
     cache_view->virtual_pixel_method,x,y,1,1,cache_view->nexus_info[id],
     exception);
   if (p == (const Quantum *) NULL)
-    return(MagickFalse);
-  GetPixelPacketPixel(cache_view->image,p,pixel);
-  if (GetPixelCacheColorspace(cache_view->image->cache) == CMYKColorspace)
-    pixel->black=GetPixelBlack(cache_view->image,p);
+    {
+      pixel[RedPixelChannel]=cache_view->image->background_color.red;
+      pixel[GreenPixelChannel]=cache_view->image->background_color.green;
+      pixel[BluePixelChannel]=cache_view->image->background_color.blue;
+      pixel[AlphaPixelChannel]=cache_view->image->background_color.alpha;
+      return(MagickFalse);
+    }
+  for (i=0; i < (ssize_t) GetPixelChannels(cache_view->image); i++)
+  {
+    PixelChannel
+      channel;
+
+    channel=GetPixelChannelMapChannel(cache_view->image,(PixelChannel) i);
+    pixel[channel]=p[i];
+  }
   return(MagickTrue);
 }
 \f
@@ -757,7 +785,7 @@ MagickExport MagickBooleanType GetOneCacheViewVirtualPixel(
 %      MagickBooleanType GetOneCacheViewVirtualMethodPixel(
 %        const CacheView *cache_view,
 %        const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
-%        const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+%        const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -774,7 +802,7 @@ MagickExport MagickBooleanType GetOneCacheViewVirtualPixel(
 */
 MagickExport MagickBooleanType GetOneCacheViewVirtualMethodPixel(
   const CacheView *cache_view,const VirtualPixelMethod virtual_pixel_method,
-  const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+  const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
 {
   const int
     id = GetOpenMPThreadId();
@@ -782,17 +810,31 @@ MagickExport MagickBooleanType GetOneCacheViewVirtualMethodPixel(
   const Quantum
     *p;
 
+  register ssize_t
+    i;
+
   assert(cache_view != (CacheView *) NULL);
   assert(cache_view->signature == MagickSignature);
-  *pixel=cache_view->image->background_color;
   assert(id < (int) cache_view->number_threads);
+  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
   p=GetVirtualPixelsFromNexus(cache_view->image,virtual_pixel_method,x,y,1,1,
     cache_view->nexus_info[id],exception);
   if (p == (const Quantum *) NULL)
-    return(MagickFalse);
-  GetPixelPacketPixel(cache_view->image,p,pixel);
-  if (GetPixelCacheColorspace(cache_view->image->cache) == CMYKColorspace)
-    pixel->black=GetPixelBlack(cache_view->image,p);
+    {
+      pixel[RedPixelChannel]=cache_view->image->background_color.red;
+      pixel[GreenPixelChannel]=cache_view->image->background_color.green;
+      pixel[BluePixelChannel]=cache_view->image->background_color.blue;
+      pixel[AlphaPixelChannel]=cache_view->image->background_color.alpha;
+      return(MagickFalse);
+    }
+  for (i=0; i < (ssize_t) GetPixelChannels(cache_view->image); i++)
+  {
+    PixelChannel
+      channel;
+
+    channel=GetPixelChannelMapChannel(cache_view->image,(PixelChannel) i);
+    pixel[channel]=p[i];
+  }
   return(MagickTrue);
 }
 \f

diff --git a/MagickCore/cache-view.h b/MagickCore/cache-view.h
index 7be39f185a265ad887605378176bc8e24061cd49..abb99b4cc84095d4eace8818b95e236bd33f61d2 100644 (file)
--- a/MagickCore/cache-view.h
+++ b/MagickCore/cache-view.h
@@ -72,12 +72,11 @@ extern MagickExport ExceptionInfo
 
 extern MagickExport MagickBooleanType
   GetOneCacheViewVirtualPixel(const CacheView *,const ssize_t,const ssize_t,
-    PixelPacket *,ExceptionInfo *),
-  GetOneCacheViewVirtualMethodPixel(const CacheView *,
-    const VirtualPixelMethod,const ssize_t,const ssize_t,PixelPacket *,
-    ExceptionInfo *),
+    Quantum *,ExceptionInfo *),
+  GetOneCacheViewVirtualMethodPixel(const CacheView *,const VirtualPixelMethod,
+    const ssize_t,const ssize_t,Quantum *,ExceptionInfo *),
   GetOneCacheViewAuthenticPixel(const CacheView *,const ssize_t,const ssize_t,
-    PixelPacket *,ExceptionInfo *),
+    Quantum *,ExceptionInfo *),
   SetCacheViewStorageClass(CacheView *,const ClassType),
   SetCacheViewVirtualPixelMethod(CacheView *,const VirtualPixelMethod),
   SyncCacheViewAuthenticPixels(CacheView *,ExceptionInfo *);

diff --git a/MagickCore/cache.c b/MagickCore/cache.c
index b84ffe51ac3d93387cdf167b9f5cc4fe48bce9d9..4c0e9b77d0ac63f08bac391fb9a72d7517425c95 100644 (file)
--- a/MagickCore/cache.c
+++ b/MagickCore/cache.c
@@ -125,9 +125,9 @@ static const void
 
 static MagickBooleanType
   GetOneAuthenticPixelFromCache(Image *,const ssize_t,const ssize_t,
-    PixelPacket *,ExceptionInfo *),
+    Quantum *,ExceptionInfo *),
   GetOneVirtualPixelFromCache(const Image *,const VirtualPixelMethod,
-    const ssize_t,const ssize_t,PixelPacket *,ExceptionInfo *),
+    const ssize_t,const ssize_t,Quantum *,ExceptionInfo *),
   OpenPixelCache(Image *,const MapMode,ExceptionInfo *),
   ReadPixelCacheMetacontent(CacheInfo *,NexusInfo *,ExceptionInfo *),
   ReadPixelCachePixels(CacheInfo *,NexusInfo *,ExceptionInfo *),
@@ -2106,7 +2106,7 @@ static Cache GetImagePixelCache(Image *image,const MagickBooleanType clone,
 %  The format of the GetOneAuthenticPixel() method is:
 %
 %      MagickBooleanType GetOneAuthenticPixel(const Image image,const ssize_t x,
-%        const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+%        const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -2120,7 +2120,7 @@ static Cache GetImagePixelCache(Image *image,const MagickBooleanType clone,
 %
 */
 MagickExport MagickBooleanType GetOneAuthenticPixel(Image *image,
-  const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+  const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
 {
   CacheInfo
     *cache_info;
@@ -2128,20 +2128,36 @@ MagickExport MagickBooleanType GetOneAuthenticPixel(Image *image,
   register Quantum
     *q;
 
+  register ssize_t
+    i;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   assert(image->cache != (Cache) NULL);
   cache_info=(CacheInfo *) image->cache;
   assert(cache_info->signature == MagickSignature);
-  *pixel=image->background_color;
+  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
   if (cache_info->methods.get_one_authentic_pixel_from_handler !=
        (GetOneAuthenticPixelFromHandler) NULL)
     return(cache_info->methods.get_one_authentic_pixel_from_handler(image,x,y,
       pixel,exception));
   q=GetAuthenticPixelsCache(image,x,y,1UL,1UL,exception);
   if (q == (Quantum *) NULL)
-    return(MagickFalse);
-  GetPixelPacketPixel(image,q,pixel);
+    {
+      pixel[RedPixelChannel]=image->background_color.red;
+      pixel[GreenPixelChannel]=image->background_color.green;
+      pixel[BluePixelChannel]=image->background_color.blue;
+      pixel[AlphaPixelChannel]=image->background_color.alpha;
+      return(MagickFalse);
+    }
+  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+  {
+    PixelChannel
+      channel;
+
+    channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+    pixel[channel]=q[i];
+  }
   return(MagickTrue);
 }
 \f
@@ -2162,7 +2178,7 @@ MagickExport MagickBooleanType GetOneAuthenticPixel(Image *image,
 %  The format of the GetOneAuthenticPixelFromCache() method is:
 %
 %      MagickBooleanType GetOneAuthenticPixelFromCache(const Image image,
-%        const ssize_t x,const ssize_t y,PixelPacket *pixel,
+%        const ssize_t x,const ssize_t y,Quantum *pixel,
 %        ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
@@ -2177,7 +2193,7 @@ MagickExport MagickBooleanType GetOneAuthenticPixel(Image *image,
 %
 */
 static MagickBooleanType GetOneAuthenticPixelFromCache(Image *image,
-  const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+  const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
 {
   CacheInfo
     *cache_info;
@@ -2188,18 +2204,34 @@ static MagickBooleanType GetOneAuthenticPixelFromCache(Image *image,
   register Quantum
     *q;
 
+  register ssize_t
+    i;
+
   assert(image != (const Image *) NULL);
   assert(image->signature == MagickSignature);
   assert(image->cache != (Cache) NULL);
   cache_info=(CacheInfo *) image->cache;
   assert(cache_info->signature == MagickSignature);
   assert(id < (int) cache_info->number_threads);
-  *pixel=image->background_color;
+  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
   q=GetAuthenticPixelCacheNexus(image,x,y,1UL,1UL,cache_info->nexus_info[id],
     exception);
   if (q == (Quantum *) NULL)
-    return(MagickFalse);
-  GetPixelPacketPixel(image,q,pixel);
+    {
+      pixel[RedPixelChannel]=image->background_color.red;
+      pixel[GreenPixelChannel]=image->background_color.green;
+      pixel[BluePixelChannel]=image->background_color.blue;
+      pixel[AlphaPixelChannel]=image->background_color.alpha;
+      return(MagickFalse);
+    }
+  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+  {
+    PixelChannel
+      channel;
+
+    channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+    pixel[channel]=q[i];
+  }
   return(MagickTrue);
 }
 \f
@@ -2283,7 +2315,7 @@ MagickExport MagickBooleanType GetOneVirtualMagickPixel(const Image *image,
 %
 %      MagickBooleanType GetOneVirtualMethodPixel(const Image image,
 %        const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
-%        const ssize_t y,PixelPacket *pixel,ExceptionInfo exception)
+%        const ssize_t y,Quantum *pixel,ExceptionInfo exception)
 %
 %  A description of each parameter follows:
 %
@@ -2300,7 +2332,7 @@ MagickExport MagickBooleanType GetOneVirtualMagickPixel(const Image *image,
 */
 MagickExport MagickBooleanType GetOneVirtualMethodPixel(const Image *image,
   const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
-  PixelPacket *pixel,ExceptionInfo *exception)
+  Quantum *pixel,ExceptionInfo *exception)
 {
   CacheInfo
     *cache_info;
@@ -2311,12 +2343,15 @@ MagickExport MagickBooleanType GetOneVirtualMethodPixel(const Image *image,
   const Quantum
     *p;
 
+  register ssize_t
+    i;
+
   assert(image != (const Image *) NULL);
   assert(image->signature == MagickSignature);
   assert(image->cache != (Cache) NULL);
   cache_info=(CacheInfo *) image->cache;
   assert(cache_info->signature == MagickSignature);
-  *pixel=image->background_color;
+  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
   if (cache_info->methods.get_one_virtual_pixel_from_handler !=
        (GetOneVirtualPixelFromHandler) NULL)
     return(cache_info->methods.get_one_virtual_pixel_from_handler(image,
@@ -2325,10 +2360,21 @@ MagickExport MagickBooleanType GetOneVirtualMethodPixel(const Image *image,
   p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,x,y,1UL,1UL,
     cache_info->nexus_info[id],exception);
   if (p == (const Quantum *) NULL)
-    return(MagickFalse);
-  GetPixelPacketPixel(image,p,pixel);
-  if (image->colorspace == CMYKColorspace)
-    pixel->black=GetPixelBlack(image,p);
+    {
+      pixel[RedPixelChannel]=image->background_color.red;
+      pixel[GreenPixelChannel]=image->background_color.green;
+      pixel[BluePixelChannel]=image->background_color.blue;
+      pixel[AlphaPixelChannel]=image->background_color.alpha;
+      return(MagickFalse);
+    }
+  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+  {
+    PixelChannel
+      channel;
+
+    channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+    pixel[channel]=p[i];
+  }
   return(MagickTrue);
 }
 \f
@@ -2350,7 +2396,7 @@ MagickExport MagickBooleanType GetOneVirtualMethodPixel(const Image *image,
 %  The format of the GetOneVirtualPixel() method is:
 %
 %      MagickBooleanType GetOneVirtualPixel(const Image image,const ssize_t x,
-%        const ssize_t y,PixelPacket *pixel,ExceptionInfo exception)
+%        const ssize_t y,Quantum *pixel,ExceptionInfo exception)
 %
 %  A description of each parameter follows:
 %
@@ -2364,7 +2410,7 @@ MagickExport MagickBooleanType GetOneVirtualMethodPixel(const Image *image,
 %
 */
 MagickExport MagickBooleanType GetOneVirtualPixel(const Image *image,
-  const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+  const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
 {
   CacheInfo
     *cache_info;
@@ -2375,12 +2421,15 @@ MagickExport MagickBooleanType GetOneVirtualPixel(const Image *image,
   const Quantum
     *p;
 
+  register ssize_t
+    i;
+
   assert(image != (const Image *) NULL);
   assert(image->signature == MagickSignature);
   assert(image->cache != (Cache) NULL);
   cache_info=(CacheInfo *) image->cache;
   assert(cache_info->signature == MagickSignature);
-  *pixel=image->background_color;
+  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
   if (cache_info->methods.get_one_virtual_pixel_from_handler !=
        (GetOneVirtualPixelFromHandler) NULL)
     return(cache_info->methods.get_one_virtual_pixel_from_handler(image,
@@ -2389,10 +2438,21 @@ MagickExport MagickBooleanType GetOneVirtualPixel(const Image *image,
   p=GetVirtualPixelsFromNexus(image,GetPixelCacheVirtualMethod(image),x,y,
     1UL,1UL,cache_info->nexus_info[id],exception);
   if (p == (const Quantum *) NULL)
-    return(MagickFalse);
-  GetPixelPacketPixel(image,p,pixel);
-  if (image->colorspace == CMYKColorspace)
-    pixel->black=GetPixelBlack(image,p);
+    {
+      pixel[RedPixelChannel]=image->background_color.red;
+      pixel[GreenPixelChannel]=image->background_color.green;
+      pixel[BluePixelChannel]=image->background_color.blue;
+      pixel[AlphaPixelChannel]=image->background_color.alpha;
+      return(MagickFalse);
+    }
+  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+  {
+    PixelChannel
+      channel;
+
+    channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+    pixel[channel]=p[i];
+  }
   return(MagickTrue);
 }
 \f
@@ -2415,7 +2475,7 @@ MagickExport MagickBooleanType GetOneVirtualPixel(const Image *image,
 %
 %      MagickBooleanType GetOneVirtualPixelFromCache(const Image image,
 %        const VirtualPixelMethod method,const ssize_t x,const ssize_t y,
-%        PixelPacket *pixel,ExceptionInfo *exception)
+%        Quantum *pixel,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -2432,7 +2492,7 @@ MagickExport MagickBooleanType GetOneVirtualPixel(const Image *image,
 */
 static MagickBooleanType GetOneVirtualPixelFromCache(const Image *image,
   const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
-  PixelPacket *pixel,ExceptionInfo *exception)
+  Quantum *pixel,ExceptionInfo *exception)
 {
   CacheInfo
     *cache_info;
@@ -2443,20 +2503,34 @@ static MagickBooleanType GetOneVirtualPixelFromCache(const Image *image,
   const Quantum
     *p;
 
+  register ssize_t
+    i;
+
   assert(image != (const Image *) NULL);
   assert(image->signature == MagickSignature);
   assert(image->cache != (Cache) NULL);
   cache_info=(CacheInfo *) image->cache;
   assert(cache_info->signature == MagickSignature);
   assert(id < (int) cache_info->number_threads);
-  *pixel=image->background_color;
+  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
   p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,x,y,1UL,1UL,
     cache_info->nexus_info[id],exception);
   if (p == (const Quantum *) NULL)
-    return(MagickFalse);
-  GetPixelPacketPixel(image,p,pixel);
-  if (image->colorspace == CMYKColorspace)
-    pixel->black=GetPixelBlack(image,p);
+    {
+      pixel[RedPixelChannel]=image->background_color.red;
+      pixel[GreenPixelChannel]=image->background_color.green;
+      pixel[BluePixelChannel]=image->background_color.blue;
+      pixel[AlphaPixelChannel]=image->background_color.alpha;
+      return(MagickFalse);
+    }
+  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+  {
+    PixelChannel
+      channel;
+
+    channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+    pixel[channel]=p[i];
+  }
   return(MagickTrue);
 }
 \f

diff --git a/MagickCore/cache.h b/MagickCore/cache.h
index a511519c6e09cfe1908287145f22aed4474f758a..95fd84d22cc4166b8e05e91d5da05f1e3cea95f4 100644 (file)
--- a/MagickCore/cache.h
+++ b/MagickCore/cache.h
@@ -35,11 +35,11 @@ extern MagickExport const void
 extern MagickExport MagickBooleanType
   GetOneVirtualMagickPixel(const Image *,const ssize_t,const ssize_t,
     PixelInfo *,ExceptionInfo *),
-  GetOneVirtualPixel(const Image *,const ssize_t,const ssize_t,PixelPacket *,
+  GetOneVirtualPixel(const Image *,const ssize_t,const ssize_t,Quantum *,
     ExceptionInfo *),
   GetOneVirtualMethodPixel(const Image *,const VirtualPixelMethod,const ssize_t,
-    const ssize_t,PixelPacket *,ExceptionInfo *),
-  GetOneAuthenticPixel(Image *,const ssize_t,const ssize_t,PixelPacket *,
+    const ssize_t,Quantum *,ExceptionInfo *),
+  GetOneAuthenticPixel(Image *,const ssize_t,const ssize_t,Quantum *,
     ExceptionInfo *),
   PersistPixelCache(Image *,const char *,const MagickBooleanType,
     MagickOffsetType *,ExceptionInfo *),

diff --git a/MagickCore/display.c b/MagickCore/display.c
index a1cb7052542711b0a511ca1e1ee691a962405d28..8b24ee6843add611f09464f0187b872a56bc42ed 100644 (file)
--- a/MagickCore/display.c
+++ b/MagickCore/display.c
@@ -3755,11 +3755,18 @@ static MagickBooleanType XColorEditImage(Display *display,
               pixel,
               target;
 
+            Quantum
+              virtual_pixel[MaxPixelChannels];
+
             /*
               Update color information using replace algorithm.
             */
             (void) GetOneCacheViewVirtualPixel(image_view,(ssize_t) x_offset,
-              (ssize_t) y_offset,&target,exception);
+              (ssize_t) y_offset,virtual_pixel,exception);
+            target.red=virtual_pixel[RedPixelChannel];
+            target.green=virtual_pixel[GreenPixelChannel];
+            target.blue=virtual_pixel[BluePixelChannel];
+            target.alpha=virtual_pixel[AlphaPixelChannel];
             if ((*image)->storage_class == DirectClass)
               {
                 for (y=0; y < (int) (*image)->rows; y++)
@@ -10100,11 +10107,18 @@ static MagickBooleanType XMatteEditImage(Display *display,
               pixel,
               target;
 
+            Quantum
+              virtual_pixel[MaxPixelChannels];
+
             /*
               Update matte information using replace algorithm.
             */
             (void) GetOneCacheViewVirtualPixel(image_view,(ssize_t) x_offset,
-              (ssize_t) y_offset,&target,exception);
+              (ssize_t) y_offset,virtual_pixel,exception);
+            target.red=virtual_pixel[RedPixelChannel];
+            target.green=virtual_pixel[GreenPixelChannel];
+            target.blue=virtual_pixel[BluePixelChannel];
+            target.alpha=virtual_pixel[AlphaPixelChannel];
             for (y=0; y < (int) (*image)->rows; y++)
             {
               q=GetCacheViewAuthenticPixels(image_view,0,(ssize_t) y,
@@ -13204,6 +13218,9 @@ static Image *XTileImage(Display *display,XResourceInfo *resource_info,
       PixelPacket
         pixel;
 
+      Quantum
+        virtual_pixel[MaxPixelChannels];
+
       register int
         j;
 
@@ -13235,7 +13252,12 @@ static Image *XTileImage(Display *display,XResourceInfo *resource_info,
         x_offset=(int) (width*(tile % (((int) image->columns-x)/width))+x);
         y_offset=(int) (height*(tile/(((int) image->columns-x)/width))+y);
         image_view=AcquireCacheView(image);
-        (void) GetOneCacheViewVirtualPixel(image_view,0,0,&pixel,exception);
+        (void) GetOneCacheViewVirtualPixel(image_view,0,0,virtual_pixel,
+          exception);
+        pixel.red=virtual_pixel[RedPixelChannel];
+        pixel.green=virtual_pixel[GreenPixelChannel];
+        pixel.blue=virtual_pixel[BluePixelChannel];
+        pixel.alpha=virtual_pixel[AlphaPixelChannel];
         for (i=0; i < (int) height; i++)
         {
           s=GetCacheViewAuthenticPixels(image_view,(ssize_t) x_offset,(ssize_t)

diff --git a/MagickCore/draw-private.h b/MagickCore/draw-private.h
index 1489e25c8401c5232130c4eb22854696b10d3a5a..6e49ca858dd34d7af3bb5234b819618d6dee11d1 100644 (file)
--- a/MagickCore/draw-private.h
+++ b/MagickCore/draw-private.h
@@ -27,55 +27,67 @@ extern "C" {
 #include "MagickCore/memory_.h"
 
 static inline MagickBooleanType GetFillColor(const DrawInfo *draw_info,
-  const ssize_t x,const ssize_t y,PixelPacket *pixel)
+  const ssize_t x,const ssize_t y,PixelPacket *fill,ExceptionInfo *exception)
 {
-  Image
-    *pattern;
-
-  MagickBooleanType
-    status;
-
-  pattern=draw_info->fill_pattern;
-  if (pattern == (Image *) NULL)
+  if (draw_info->fill_pattern == (Image *) NULL)
     {
-      *pixel=draw_info->fill;
+      *fill=draw_info->fill;
       return(MagickTrue);
     }
+  {
+    Image
+      *pattern;
+
+    MagickBooleanType
+      status;
+
+    Quantum
+      pixel[MaxPixelChannels];
+
+    pattern=draw_info->fill_pattern;
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && (_OPENMP >= 200203)
-  #pragma omp critical
+    #pragma omp critical
 #endif
-  status=GetOneVirtualMethodPixel(pattern,TileVirtualPixelMethod,
-    x+pattern->tile_offset.x,y+pattern->tile_offset.y,pixel,
-    &pattern->exception);
-  if (pattern->matte == MagickFalse)
-    pixel->alpha=OpaqueAlpha;
-  return(status);
+    status=GetOneVirtualMethodPixel(pattern,TileVirtualPixelMethod,x+
+      pattern->tile_offset.x,y+pattern->tile_offset.y,pixel,exception);
+    fill->red=pixel[RedPixelChannel];
+    fill->green=pixel[GreenPixelChannel];
+    fill->blue=pixel[BluePixelChannel];
+    fill->alpha=pixel[AlphaPixelChannel];
+    return(status);
+  }
 }
 
 static inline MagickBooleanType GetStrokeColor(const DrawInfo *draw_info,
-  const ssize_t x,const ssize_t y,PixelPacket *pixel)
+  const ssize_t x,const ssize_t y,PixelPacket *stroke,ExceptionInfo *exception)
 {
-  Image
-    *pattern;
-
-  MagickBooleanType
-    status;
-
-  pattern=draw_info->stroke_pattern;
-  if (pattern == (Image *) NULL)
+  if (draw_info->stroke_pattern == (Image *) NULL)
     {
-      *pixel=draw_info->stroke;
+      *stroke=draw_info->stroke;
       return(MagickTrue);
     }
+  {
+    Image
+      *pattern;
+
+    MagickBooleanType
+      status;
+
+    Quantum
+      pixel[MaxPixelChannels];
+
+    pattern=draw_info->stroke_pattern;
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && (_OPENMP >= 200203)
   #pragma omp critical
 #endif
-  status=GetOneVirtualMethodPixel(pattern,TileVirtualPixelMethod,
-    x+pattern->tile_offset.x,y+pattern->tile_offset.y,pixel,
-    &pattern->exception);
-  if (pattern->matte == MagickFalse)
-    pixel->alpha=OpaqueAlpha;
-  return(status);
+    status=GetOneVirtualMethodPixel(pattern,TileVirtualPixelMethod,x+
+      pattern->tile_offset.x,y+pattern->tile_offset.y,pixel,exception);
+    stroke->red=pixel[RedPixelChannel];
+    stroke->green=pixel[GreenPixelChannel];
+    stroke->blue=pixel[BluePixelChannel];
+    stroke->alpha=pixel[AlphaPixelChannel];
+    return(status);
+  }
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)

diff --git a/MagickCore/draw.c b/MagickCore/draw.c
index d45ed33c319c529284f02b921113dacb95e43033..448024f1103a68248836b6786a485e1f88544b3a 100644 (file)
--- a/MagickCore/draw.c
+++ b/MagickCore/draw.c
@@ -3916,7 +3916,7 @@ static MagickBooleanType DrawPolygonPrimitive(Image *image,
           if ((x == (ssize_t) ceil(primitive_info->point.x-0.5)) &&
               (y == (ssize_t) ceil(primitive_info->point.y-0.5)))
             {
-              (void) GetStrokeColor(draw_info,x,y,&pixel);
+              (void) GetStrokeColor(draw_info,x,y,&pixel,exception);
               SetPixelPacket(image,&pixel,q);
             }
           q+=GetPixelChannels(image);
@@ -3980,11 +3980,11 @@ static MagickBooleanType DrawPolygonPrimitive(Image *image,
           fill_opacity=fill_opacity > 0.25 ? 1.0 : 0.0;
           stroke_opacity=stroke_opacity > 0.25 ? 1.0 : 0.0;
         }
-      (void) GetFillColor(draw_info,x,y,&fill_color);
+      (void) GetFillColor(draw_info,x,y,&fill_color,exception);
       fill_opacity=fill_opacity*fill_color.alpha;
       CompositePixelOver(image,&fill_color,fill_opacity,q,(MagickRealType)
         GetPixelAlpha(image,q),q);
-      (void) GetStrokeColor(draw_info,x,y,&stroke_color);
+      (void) GetStrokeColor(draw_info,x,y,&stroke_color,exception);
       stroke_opacity=stroke_opacity*stroke_color.alpha;
       CompositePixelOver(image,&stroke_color,stroke_opacity,q,(MagickRealType)
         GetPixelAlpha(image,q),q);
@@ -4180,7 +4180,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
       q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
       if (q == (Quantum *) NULL)
         break;
-      (void) GetFillColor(draw_info,x,y,&fill_color);
+      (void) GetFillColor(draw_info,x,y,&fill_color,exception);
       CompositePixelOver(image,&fill_color,(MagickRealType) fill_color.alpha,q,
         (MagickRealType) GetPixelAlpha(image,q),q);
       (void) SyncCacheViewAuthenticPixels(image_view,exception);
@@ -4202,7 +4202,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
           q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
           if (q == (Quantum *) NULL)
             break;
-          (void) GetFillColor(draw_info,x,y,&pixel);
+          (void) GetFillColor(draw_info,x,y,&pixel,exception);
           SetPixelPacket(image,&pixel,q);
           (void) SyncCacheViewAuthenticPixels(image_view,exception);
           break;
@@ -4216,7 +4216,15 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
             pixel,
             target;
 
-          (void) GetOneCacheViewVirtualPixel(image_view,x,y,&target,exception);
+          Quantum
+            virtual_pixel[MaxPixelChannels];
+
+          (void) GetOneCacheViewVirtualPixel(image_view,x,y,virtual_pixel,
+            exception);
+          target.red=virtual_pixel[RedPixelChannel];
+          target.green=virtual_pixel[GreenPixelChannel];
+          target.blue=virtual_pixel[BluePixelChannel];
+          target.alpha=virtual_pixel[AlphaPixelChannel];
           for (y=0; y < (ssize_t) image->rows; y++)
           {
             register Quantum
@@ -4234,7 +4242,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
                   q+=GetPixelChannels(image);
                   continue;
                 }
-              (void) GetFillColor(draw_info,x,y,&pixel);
+              (void) GetFillColor(draw_info,x,y,&pixel,exception);
               SetPixelPacket(image,&pixel,q);
               q+=GetPixelChannels(image);
             }
@@ -4284,7 +4292,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
               break;
             for (x=0; x < (ssize_t) image->columns; x++)
             {
-              (void) GetFillColor(draw_info,x,y,&pixel);
+              (void) GetFillColor(draw_info,x,y,&pixel,exception);
               SetPixelPacket(image,&pixel,q);
               q+=GetPixelChannels(image);
             }
@@ -4315,7 +4323,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
           q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
           if (q == (Quantum *) NULL)
             break;
-          (void) GetFillColor(draw_info,x,y,&pixel);
+          (void) GetFillColor(draw_info,x,y,&pixel,exception);
           SetPixelAlpha(image,pixel.alpha,q);
           (void) SyncCacheViewAuthenticPixels(image_view,exception);
           break;
@@ -4329,7 +4337,15 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
             pixel,
             target;
 
-          (void) GetOneCacheViewVirtualPixel(image_view,x,y,&target,exception);
+          Quantum
+            virtual_pixel[MaxPixelChannels];
+
+          (void) GetOneCacheViewVirtualPixel(image_view,x,y,virtual_pixel,
+            exception);
+          target.red=virtual_pixel[RedPixelChannel];
+          target.green=virtual_pixel[GreenPixelChannel];
+          target.blue=virtual_pixel[BluePixelChannel];
+          target.alpha=virtual_pixel[AlphaPixelChannel];
           for (y=0; y < (ssize_t) image->rows; y++)
           {
             register Quantum
@@ -4350,7 +4366,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
                   q+=GetPixelChannels(image);
                   continue;
                 }
-              (void) GetFillColor(draw_info,x,y,&pixel);
+              (void) GetFillColor(draw_info,x,y,&pixel,exception);
               SetPixelAlpha(image,pixel.alpha,q);
               q+=GetPixelChannels(image);
             }
@@ -4405,7 +4421,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
               break;
             for (x=0; x < (ssize_t) image->columns; x++)
             {
-              (void) GetFillColor(draw_info,x,y,&pixel);
+              (void) GetFillColor(draw_info,x,y,&pixel,exception);
               SetPixelAlpha(image,pixel.alpha,q);
               q+=GetPixelChannels(image);
             }

diff --git a/MagickCore/paint.c b/MagickCore/paint.c
index 65072d05720f73682bc43c41c3dfa633aa4e8a27..c94f8919aef0d399445d8254ff2e168c6daa5ecc 100644 (file)
--- a/MagickCore/paint.c
+++ b/MagickCore/paint.c
@@ -194,6 +194,8 @@ MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
     Push initial segment on stack.
   */
   status=MagickTrue;
+  fill_color.black=0.0;
+  fill_color.index=0.0;
   x=x_offset;
   y=y_offset;
   start=0;
@@ -332,7 +334,7 @@ MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
     {
       if (GetPixelAlpha(floodplane_image,p) != OpaqueAlpha)
         {
-          (void) GetFillColor(draw_info,x,y,&fill_color);
+          (void) GetFillColor(draw_info,x,y,&fill_color,exception);
           SetPixelInfoPacket(image,&fill_color,&fill);
           if (image->colorspace == CMYKColorspace)
             ConvertRGBToCMYK(&fill);

diff --git a/MagickCore/stream.c b/MagickCore/stream.c
index 0d90a0881b6b5b5707695b1298c67c65b04c4063..aa302d4c4c1d25a2f8a5007d3b95926131eef20c 100644 (file)
--- a/MagickCore/stream.c
+++ b/MagickCore/stream.c
@@ -425,7 +425,7 @@ static Quantum *GetAuthenticPixelsFromStream(const Image *image)
 %  The format of the GetOneAuthenticPixelFromStream() method is:
 %
 %      MagickBooleanType GetOneAuthenticPixelFromStream(const Image image,
-%        const ssize_t x,const ssize_t y,PixelPacket *pixel,
+%        const ssize_t x,const ssize_t y,Quantum *pixel,
 %        ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
@@ -440,18 +440,34 @@ static Quantum *GetAuthenticPixelsFromStream(const Image *image)
 %
 */
 static MagickBooleanType GetOneAuthenticPixelFromStream(Image *image,
-  const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+  const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
 {
   register Quantum
     *q;
 
+  register ssize_t
+    i;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
-  *pixel=image->background_color;
+  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
   q=GetAuthenticPixelsStream(image,x,y,1,1,exception);
   if (q != (Quantum *) NULL)
-    return(MagickFalse);
-  GetPixelPacketPixel(image,q,pixel);
+    {
+      pixel[RedPixelChannel]=image->background_color.red;
+      pixel[GreenPixelChannel]=image->background_color.green;
+      pixel[BluePixelChannel]=image->background_color.blue;
+      pixel[AlphaPixelChannel]=image->background_color.alpha;
+      return(MagickFalse);
+    }
+  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+  {
+    PixelChannel
+      channel;
+
+    channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+    pixel[channel]=q[i];
+  }
   return(MagickTrue);
 }
 \f
@@ -473,7 +489,7 @@ static MagickBooleanType GetOneAuthenticPixelFromStream(Image *image,
 %
 %      MagickBooleanType GetOneVirtualPixelFromStream(const Image image,
 %        const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
-%        const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+%        const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -490,20 +506,34 @@ static MagickBooleanType GetOneAuthenticPixelFromStream(Image *image,
 */
 static MagickBooleanType GetOneVirtualPixelFromStream(const Image *image,
   const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
-  PixelPacket *pixel,ExceptionInfo *exception)
+  Quantum *pixel,ExceptionInfo *exception)
 {
   const Quantum
     *p;
 
+  register ssize_t
+    i;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
-  *pixel=image->background_color;
+  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
   p=GetVirtualPixelStream(image,virtual_pixel_method,x,y,1,1,exception);
   if (p == (const Quantum *) NULL)
-    return(MagickFalse);
-  GetPixelPacketPixel(image,p,pixel);
-  if (image->colorspace == CMYKColorspace)
-    pixel->black=GetPixelBlack(image,p);
+    {
+      pixel[RedPixelChannel]=image->background_color.red;
+      pixel[GreenPixelChannel]=image->background_color.green;
+      pixel[BluePixelChannel]=image->background_color.blue;
+      pixel[AlphaPixelChannel]=image->background_color.alpha;
+      return(MagickFalse);
+    }
+  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+  {
+    PixelChannel
+      channel;
+
+    channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+    pixel[channel]=p[i];
+  }
   return(MagickTrue);
 }
 \f

diff --git a/MagickCore/version.h b/MagickCore/version.h
index 915ea3c5cbfb2058d43a8139a1386c3f7a9b2282..fbaf355229935bd535a5dd9fb23ded5f98885c93 100644 (file)
--- a/MagickCore/version.h
+++ b/MagickCore/version.h
@@ -34,7 +34,7 @@ extern "C" {
 #define MagickLibAddendum  "-0"
 #define MagickLibInterface  7
 #define MagickLibMinInterface  7
-#define MagickReleaseDate  "2011-10-01"
+#define MagickReleaseDate  "2011-10-02"
 #define MagickChangeDate   "20110801"
 #define MagickAuthoritativeURL  "http://www.imagemagick.org"
 #if defined(MAGICKCORE_OPENMP_SUPPORT)

diff --git a/MagickCore/xwindow.c b/MagickCore/xwindow.c
index b9c75b117d07c744cc4684d891c341f7336963e3..395dabbcf7a9d9f0e9f89785360df90c7ceae111 100644 (file)
--- a/MagickCore/xwindow.c
+++ b/MagickCore/xwindow.c
@@ -481,6 +481,9 @@ MagickPrivate MagickBooleanType XAnnotateImage(Display *display,
   Pixmap
     annotate_pixmap;
 
+  Quantum
+    virtual_pixel[MaxPixelChannels];
+
   unsigned int
     depth,
     height,
@@ -553,8 +556,12 @@ MagickPrivate MagickBooleanType XAnnotateImage(Display *display,
   x=0;
   y=0;
   (void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
-  (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,
-    &annotate_image->background_color,&image->exception);
+  (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,virtual_pixel,
+    &image->exception);
+  annotate_image->background_color.red=virtual_pixel[RedPixelChannel];
+  annotate_image->background_color.green=virtual_pixel[GreenPixelChannel];
+  annotate_image->background_color.blue=virtual_pixel[BluePixelChannel];
+  annotate_image->background_color.alpha=virtual_pixel[AlphaPixelChannel];
   if (annotate_info->stencil == ForegroundStencil)
     annotate_image->matte=MagickTrue;
   exception=(&image->exception);
@@ -2308,6 +2315,9 @@ MagickPrivate MagickBooleanType XDrawImage(Display *display,
   MagickBooleanType
     matte;
 
+  Quantum
+    virtual_pixel[MaxPixelChannels];
+
   Pixmap
     draw_pixmap;
 
@@ -2466,8 +2476,12 @@ MagickPrivate MagickBooleanType XDrawImage(Display *display,
   x=0;
   y=0;
   (void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
-  (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,
-    &draw_image->background_color,&image->exception);
+  (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,virtual_pixel,
+    &image->exception);
+  draw_image->background_color.red=virtual_pixel[RedPixelChannel];
+  draw_image->background_color.green=virtual_pixel[GreenPixelChannel];
+  draw_image->background_color.blue=virtual_pixel[BluePixelChannel];
+  draw_image->background_color.alpha=virtual_pixel[AlphaPixelChannel];
   if (SetImageStorageClass(draw_image,DirectClass,&image->exception) == MagickFalse)
     return(MagickFalse);
   draw_image->matte=MagickTrue;

diff --git a/coders/msl.c b/coders/msl.c
index 71b95580b91935ab9a3bcc9eccaea2755f52cc6a..f7f9a1466875787067d725384fd0fbda7a40e58d 100644 (file)
--- a/coders/msl.c
+++ b/coders/msl.c
@@ -1760,9 +1760,6 @@ static void MSLStartElement(void *context,const xmlChar *tag,
             *composite_image,
             *rotate_image;
 
-          PixelPacket
-            target;
-
           /*
             Composite image.
           */
@@ -1789,8 +1786,8 @@ static void MSLStartElement(void *context,const xmlChar *tag,
                 {
                   if (LocaleCompare(keyword,"compose") == 0)
                     {
-                      option=ParseCommandOption(MagickComposeOptions,MagickFalse,
-                        value);
+                      option=ParseCommandOption(MagickComposeOptions,
+                        MagickFalse,value);
                       if (option < 0)
                         ThrowMSLException(OptionError,"UnrecognizedComposeType",
                           value);
@@ -1883,14 +1880,12 @@ static void MSLStartElement(void *context,const xmlChar *tag,
                         &geometry,&exception);
                       if ((flags & HeightValue) == 0)
                         geometry.height=geometry.width;
-                      (void) GetOneVirtualPixel(msl_info->image[n],geometry.x,
-                        geometry.y,&target,&exception);
                       break;
                     }
                   if (LocaleCompare(keyword,"gravity") == 0)
                     {
-                      option=ParseCommandOption(MagickGravityOptions,MagickFalse,
-                        value);
+                      option=ParseCommandOption(MagickGravityOptions,
+                        MagickFalse,value);
                       if (option < 0)
                         ThrowMSLException(OptionError,"UnrecognizedGravityType",
                           value);
@@ -2046,8 +2041,6 @@ static void MSLStartElement(void *context,const xmlChar *tag,
                   if (LocaleCompare(keyword,"x") == 0)
                     {
                       geometry.x=StringToLong(value);
-                      (void) GetOneVirtualPixel(msl_info->image[n],geometry.x,
-                        geometry.y,&target,&exception);
                       break;
                     }
                   ThrowMSLException(OptionError,"UnrecognizedAttribute",
@@ -2060,8 +2053,6 @@ static void MSLStartElement(void *context,const xmlChar *tag,
                   if (LocaleCompare(keyword,"y") == 0)
                     {
                       geometry.y=StringToLong(value);
-                      (void) GetOneVirtualPixel(msl_info->image[n],geometry.x,
-                        geometry.y,&target,&exception);
                       break;
                     }
                   ThrowMSLException(OptionError,"UnrecognizedAttribute",
@@ -2093,7 +2084,8 @@ static void MSLStartElement(void *context,const xmlChar *tag,
               */
               geometry.x-=(ssize_t) (rotate_image->columns-
                 composite_image->columns)/2;
-              geometry.y-=(ssize_t) (rotate_image->rows-composite_image->rows)/2;
+              geometry.y-=(ssize_t) (rotate_image->rows-
+                composite_image->rows)/2;
               CompositeImage(image,compose,rotate_image,geometry.x,geometry.y);
               rotate_image=DestroyImage(rotate_image);
             }

diff --git a/coders/stegano.c b/coders/stegano.c
index a4c4591e9ab54ee8c905ea69a3fd30fed7ad2552..995191290ff396a8bfa3d066abf775d16725b2e8 100644 (file)
--- a/coders/stegano.c
+++ b/coders/stegano.c
@@ -181,10 +181,17 @@ static Image *ReadSTEGANOImage(const ImageInfo *image_info,
       x=0;
       for ( ; (x < (ssize_t) image->columns) && (j < (ssize_t) depth); x++)
       {
+        Quantum
+          virtual_pixel[MaxPixelChannels];
+
         if ((k/(ssize_t) watermark->columns) >= (ssize_t) watermark->rows)
           break;
         (void) GetOneVirtualPixel(watermark,k % (ssize_t) watermark->columns,
-          k/(ssize_t) watermark->columns,&pixel,exception);
+          k/(ssize_t) watermark->columns,virtual_pixel,exception);
+        pixel.red=virtual_pixel[RedPixelChannel];
+        pixel.green=virtual_pixel[GreenPixelChannel];
+        pixel.blue=virtual_pixel[BluePixelChannel];
+        pixel.alpha=virtual_pixel[AlphaPixelChannel];
         q=GetAuthenticPixels(image,x,y,1,1,exception);
         if (q == (Quantum *) NULL)
           break;