(no commit message)

diff --git a/magick/morphology.c b/magick/morphology.c
index 1f6297a3cf0f9ca995e0e3ed4c769270be6c7273..9caa097215361a624f6414638f2134ae258ea878 100644 (file)
--- a/magick/morphology.c
+++ b/magick/morphology.c
@@ -2645,7 +2645,8 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
         */
         *q = p[r];
         if (image->colorspace == CMYKColorspace)
-          q_indexes[y] = p_indexes[r];
+          SetIndexPixelComponent(q_indexes+y,GetIndexPixelComponent(
+            p_indexes+r));
 
         /* Set the bias of the weighted average output */
         result.red     =
@@ -2671,10 +2672,10 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
             */
             for (v=0; v < (ssize_t) kernel->height; v++) {
               if ( IsNan(*k) ) continue;
-              result.red     += (*k)*k_pixels->red;
-              result.green   += (*k)*k_pixels->green;
-              result.blue    += (*k)*k_pixels->blue;
-              result.opacity += (*k)*k_pixels->opacity;
+              result.red     += (*k)*GetRedPixelComponent(k_pixels);
+              result.green   += (*k)*GetGreenPixelComponent(k_pixels);
+              result.blue    += (*k)*GetBluePixelComponent(k_pixels);
+              result.opacity += (*k)*GetOpacityPixelComponent(k_pixels);
               if ( image->colorspace == CMYKColorspace)
                 result.index += (*k)*(*k_indexes);
               k--;
@@ -2682,17 +2683,17 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
               k_indexes++;
             }
             if ((channel & RedChannel) != 0)
-              q->red = ClampToQuantum(result.red);
+              SetRedPixelComponent(q,ClampToQuantum(result.red));
             if ((channel & GreenChannel) != 0)
-              q->green = ClampToQuantum(result.green);
+              SetGreenPixelComponent(q,ClampToQuantum(result.green));
             if ((channel & BlueChannel) != 0)
-              q->blue = ClampToQuantum(result.blue);
+              SetBluePixelComponent(q,ClampToQuantum(result.blue));
             if ((channel & OpacityChannel) != 0
                 && image->matte == MagickTrue )
-              q->opacity = ClampToQuantum(result.opacity);
+              SetOpacityPixelComponent(q,ClampToQuantum(result.opacity));
             if ((channel & IndexChannel) != 0
                 && image->colorspace == CMYKColorspace)
-              q_indexes[x] = ClampToQuantum(result.index);
+              SetIndexPixelComponent(q_indexes+x,ClampToQuantum(result.index));
           }
         else
           { /* Channel 'Sync' Flag, and Alpha Channel enabled.
@@ -2706,12 +2707,12 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
             gamma=0.0;
             for (v=0; v < (ssize_t) kernel->height; v++) {
               if ( IsNan(*k) ) continue;
-              alpha=(*k)*(QuantumScale*(QuantumRange-k_pixels->opacity));
+              alpha=(*k)*(QuantumScale*(QuantumRange-GetOpacityPixelComponent(k_pixels)));
               gamma += alpha;
-              result.red     += alpha*k_pixels->red;
-              result.green   += alpha*k_pixels->green;
-              result.blue    += alpha*k_pixels->blue;
-              result.opacity += (*k)*k_pixels->opacity;
+              result.red     += alpha*GetRedPixelComponent(k_pixels);
+              result.green   += alpha*GetGreenPixelComponent(k_pixels);
+              result.blue    += alpha*GetBluePixelComponent(k_pixels);
+              result.opacity += (*k)*GetOpacityPixelComponent(k_pixels);
               if ( image->colorspace == CMYKColorspace)
                 result.index += alpha*(*k_indexes);
               k--;
@@ -2720,21 +2721,22 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
             }
             /* Sync'ed channels, all channels are modified */
             gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
-            q->red = ClampToQuantum(gamma*result.red);
-            q->green = ClampToQuantum(gamma*result.green);
-            q->blue = ClampToQuantum(gamma*result.blue);
-            q->opacity = ClampToQuantum(result.opacity);
+            SetRedPixelComponent(q,ClampToQuantum(gamma*result.red));
+            SetGreenPixelComponent(q,ClampToQuantum(gamma*result.green));
+            SetBluePixelComponent(q,ClampToQuantum(gamma*result.blue));
+            SetOpacityPixelComponent(q,ClampToQuantum(result.opacity));
             if (image->colorspace == CMYKColorspace)
-              q_indexes[x] = ClampToQuantum(gamma*result.index);
+              SetIndexPixelComponent(q_indexes+x,ClampToQuantum(gamma*
+                result.index));
           }
 
         /* Count up changed pixels */
-        if (   ( p[r].red != q->red )
-            || ( p[r].green != q->green )
-            || ( p[r].blue != q->blue )
-            || ( p[r].opacity != q->opacity )
+        if (   ( p[r].red != GetRedPixelComponent(q))
+            || ( p[r].green != GetGreenPixelComponent(q))
+            || ( p[r].blue != GetBluePixelComponent(q))
+            || ( p[r].opacity != GetOpacityPixelComponent(q))
             || ( image->colorspace == CMYKColorspace &&
-                    p_indexes[r] != q_indexes[x] ) )
+                GetIndexPixelComponent(p_indexes+r) != GetIndexPixelComponent(q_indexes+x) ) )
           changed++;  /* The pixel was changed in some way! */
         p++;
         q++;
@@ -2830,7 +2832,7 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
        */
       *q = p[r];
       if (image->colorspace == CMYKColorspace)
-        q_indexes[x] = p_indexes[r];
+        SetIndexPixelComponent(q_indexes+x,GetIndexPixelComponent(p_indexes+r));
 
       /* Defaults */
       min.red     =
@@ -2850,7 +2852,7 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
       result.opacity = QuantumRange - (MagickRealType) p[r].opacity;
       result.index   = 0.0;
       if ( image->colorspace == CMYKColorspace)
-         result.index   = (MagickRealType) p_indexes[r];
+         result.index   = (MagickRealType) GetIndexPixelComponent(p_indexes+r);
 
       switch (method) {
         case ConvolveMorphology:
@@ -2906,23 +2908,24 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
                     result.blue    += (*k)*k_pixels[u].blue;
                     result.opacity += (*k)*k_pixels[u].opacity;
                     if ( image->colorspace == CMYKColorspace)
-                      result.index   += (*k)*k_indexes[u];
+                      result.index += (*k)*GetIndexPixelComponent(k_indexes+u);
                   }
                   k_pixels += virt_width;
                   k_indexes += virt_width;
                 }
                 if ((channel & RedChannel) != 0)
-                  q->red = ClampToQuantum(result.red);
+                  SetRedPixelComponent(q,ClampToQuantum(result.red));
                 if ((channel & GreenChannel) != 0)
-                  q->green = ClampToQuantum(result.green);
+                  SetGreenPixelComponent(q,ClampToQuantum(result.green));
                 if ((channel & BlueChannel) != 0)
-                  q->blue = ClampToQuantum(result.blue);
+                  SetBluePixelComponent(q,ClampToQuantum(result.blue));
                 if ((channel & OpacityChannel) != 0
                     && image->matte == MagickTrue )
-                  q->opacity = ClampToQuantum(result.opacity);
+                  SetOpacityPixelComponent(q,ClampToQuantum(result.opacity));
                 if ((channel & IndexChannel) != 0
                     && image->colorspace == CMYKColorspace)
-                  q_indexes[x] = ClampToQuantum(result.index);
+                  SetIndexPixelComponent(q_indexes+x,ClampToQuantum(
+                    result.index));
               }
             else
               { /* Channel 'Sync' Flag, and Alpha Channel enabled.
@@ -2945,19 +2948,20 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
                     result.blue    += alpha*k_pixels[u].blue;
                     result.opacity += (*k)*k_pixels[u].opacity;
                     if ( image->colorspace == CMYKColorspace)
-                      result.index   += alpha*k_indexes[u];
+                      result.index+=alpha*GetIndexPixelComponent(k_indexes+u);
                   }
                   k_pixels += virt_width;
                   k_indexes += virt_width;
                 }
                 /* Sync'ed channels, all channels are modified */
                 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
-                q->red = ClampToQuantum(gamma*result.red);
-                q->green = ClampToQuantum(gamma*result.green);
-                q->blue = ClampToQuantum(gamma*result.blue);
-                q->opacity = ClampToQuantum(result.opacity);
+                SetRedPixelComponent(q,ClampToQuantum(gamma*result.red));
+                SetGreenPixelComponent(q,ClampToQuantum(gamma*result.green));
+                SetBluePixelComponent(q,ClampToQuantum(gamma*result.blue));
+                SetOpacityPixelComponent(q,ClampToQuantum(result.opacity));
                 if (image->colorspace == CMYKColorspace)
-                  q_indexes[x] = ClampToQuantum(gamma*result.index);
+                  SetIndexPixelComponent(q_indexes+x,ClampToQuantum(gamma*
+                   result.index));
               }
             break;
 
@@ -2982,7 +2986,8 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
                 Minimize(min.opacity,
                             QuantumRange-(double) k_pixels[u].opacity);
                 if ( image->colorspace == CMYKColorspace)
-                  Minimize(min.index,   (double) k_indexes[u]);
+                  Minimize(min.index,(double) GetIndexPixelComponent(
+                    k_indexes+u));
               }
               k_pixels += virt_width;
               k_indexes += virt_width;
@@ -3013,7 +3018,8 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
                 Maximize(max.opacity,
                             QuantumRange-(double) k_pixels[u].opacity);
                 if ( image->colorspace == CMYKColorspace)
-                  Maximize(max.index,   (double) k_indexes[u]);
+                  Maximize(max.index,   (double) GetIndexPixelComponent(
+                    k_indexes+u));
               }
               k_pixels += virt_width;
               k_indexes += virt_width;
@@ -3048,7 +3054,8 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
                   Minimize(min.opacity,
                               QuantumRange-(double) k_pixels[u].opacity);
                   if ( image->colorspace == CMYKColorspace)
-                    Minimize(min.index,   (double) k_indexes[u]);
+                    Minimize(min.index,(double) GetIndexPixelComponent(
+                      k_indexes+u));
                 }
                 else if ( (*k) < 0.3 )
                 { /* maximum of background pixels */
@@ -3058,7 +3065,8 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
                   Maximize(max.opacity,
                               QuantumRange-(double) k_pixels[u].opacity);
                   if ( image->colorspace == CMYKColorspace)
-                    Maximize(max.index,   (double) k_indexes[u]);
+                    Maximize(max.index,   (double) GetIndexPixelComponent(
+                      k_indexes+u));
                 }
               }
               k_pixels += virt_width;
@@ -3159,7 +3167,8 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
                 Minimize(result.blue,    (*k)+k_pixels[u].blue);
                 Minimize(result.opacity, (*k)+QuantumRange-k_pixels[u].opacity);
                 if ( image->colorspace == CMYKColorspace)
-                  Minimize(result.index,   (*k)+k_indexes[u]);
+                  Minimize(result.index,(*k)+GetIndexPixelComponent(
+                    k_indexes+u));
               }
               k_pixels += virt_width;
               k_indexes += virt_width;
@@ -3214,26 +3223,26 @@ static ssize_t MorphologyPrimitive(const Image *image, Image *result_image,
           break;  /* full pixel was directly assigned - not a channel method */
         default:
           if ((channel & RedChannel) != 0)
-            q->red = ClampToQuantum(result.red);
+            SetRedPixelComponent(q,ClampToQuantum(result.red));
           if ((channel & GreenChannel) != 0)
-            q->green = ClampToQuantum(result.green);
+            SetGreenPixelComponent(q,ClampToQuantum(result.green));
           if ((channel & BlueChannel) != 0)
-            q->blue = ClampToQuantum(result.blue);
+            SetBluePixelComponent(q,ClampToQuantum(result.blue));
           if ((channel & OpacityChannel) != 0
               && image->matte == MagickTrue )
-            q->opacity = ClampToQuantum(QuantumRange-result.opacity);
+            SetOpacityPixelComponent(q,ClampToQuantum(QuantumRange-result.opacity));
           if ((channel & IndexChannel) != 0
               && image->colorspace == CMYKColorspace)
-            q_indexes[x] = ClampToQuantum(result.index);
+            SetIndexPixelComponent(q_indexes+x,ClampToQuantum(result.index));
           break;
       }
       /* Count up changed pixels */
-      if (   ( p[r].red != q->red )
-          || ( p[r].green != q->green )
-          || ( p[r].blue != q->blue )
-          || ( p[r].opacity != q->opacity )
+      if (   ( p[r].red != GetRedPixelComponent(q) )
+          || ( p[r].green != GetGreenPixelComponent(q) )
+          || ( p[r].blue != GetBluePixelComponent(q) )
+          || ( p[r].opacity != GetOpacityPixelComponent(q) )
           || ( image->colorspace == CMYKColorspace &&
-                  p_indexes[r] != q_indexes[x] ) )
+               GetIndexPixelComponent(p_indexes+r) != GetIndexPixelComponent(q_indexes+x) ) )
         changed++;  /* The pixel was changed in some way! */
       p++;
       q++;
@@ -3411,7 +3420,7 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
                 Minimize(result.blue,    (*k)+k_pixels[u].blue);
                 Minimize(result.opacity, (*k)+QuantumRange-k_pixels[u].opacity);
                 if ( image->colorspace == CMYKColorspace)
-                  Minimize(result.index,   (*k)+k_indexes[u]);
+                  Minimize(result.index,   (*k)+GetIndexPixelComponent(k_indexes+u));
               }
               k_pixels += virt_width;
               k_indexes += virt_width;
@@ -3428,7 +3437,7 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
                 Minimize(result.blue,    (*k)+k_pixels[u].blue);
                 Minimize(result.opacity, (*k)+QuantumRange-k_pixels[u].opacity);
                 if ( image->colorspace == CMYKColorspace)
-                  Minimize(result.index,   (*k)+k_indexes[u]);
+                  Minimize(result.index,   (*k)+GetIndexPixelComponent(k_indexes+u));
               }
             break;
         case VoronoiMorphology:
@@ -3446,7 +3455,7 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
                 if( result.opacity > (*k)+k_pixels[u].opacity )
                   {
                     SetMagickPixelPacket(image,&k_pixels[u],&k_indexes[u],
-                         &result);
+                      &result);
                     result.opacity += *k;
                   }
               }
@@ -3463,7 +3472,7 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
                 if( result.opacity > (*k)+k_pixels[u].opacity )
                   {
                     SetMagickPixelPacket(image,&k_pixels[u],&k_indexes[u],
-                         &result);
+                      &result);
                     result.opacity += *k;
                   }
               }
@@ -3479,25 +3488,25 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
           break;
         default:
           if ((channel & RedChannel) != 0)
-            q->red = ClampToQuantum(result.red);
+            SetRedPixelComponent(q,ClampToQuantum(result.red));
           if ((channel & GreenChannel) != 0)
-            q->green = ClampToQuantum(result.green);
+            SetGreenPixelComponent(q,ClampToQuantum(result.green));
           if ((channel & BlueChannel) != 0)
-            q->blue = ClampToQuantum(result.blue);
+            SetBluePixelComponent(q,ClampToQuantum(result.blue));
           if ((channel & OpacityChannel) != 0 && image->matte == MagickTrue )
-            q->opacity = ClampToQuantum(QuantumRange-result.opacity);
+            SetOpacityPixelComponent(q,ClampToQuantum(QuantumRange-result.opacity));
           if ((channel & IndexChannel) != 0
               && image->colorspace == CMYKColorspace)
-            q_indexes[x] = ClampToQuantum(result.index);
+            SetIndexPixelComponent(q_indexes+x,ClampToQuantum(result.index));
           break;
       }
       /* Count up changed pixels */
-      if (   ( p[r].red != q->red )
-          || ( p[r].green != q->green )
-          || ( p[r].blue != q->blue )
-          || ( p[r].opacity != q->opacity )
+      if (   ( p[r].red != GetRedPixelComponent(q) )
+          || ( p[r].green != GetGreenPixelComponent(q) )
+          || ( p[r].blue != GetBluePixelComponent(q) )
+          || ( p[r].opacity != GetOpacityPixelComponent(q) )
           || ( image->colorspace == CMYKColorspace &&
-                  p_indexes[r] != q_indexes[x] ) )
+               GetIndexPixelComponent(p_indexes+r) != GetIndexPixelComponent(q_indexes+x) ) )
         changed++;  /* The pixel was changed in some way! */
 
       p++; /* increment pixel buffers */
@@ -3601,7 +3610,7 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
                 Minimize(result.blue,    (*k)+k_pixels[u].blue);
                 Minimize(result.opacity, (*k)+QuantumRange-k_pixels[u].opacity);
                 if ( image->colorspace == CMYKColorspace)
-                  Minimize(result.index,   (*k)+k_indexes[u]);
+                  Minimize(result.index,(*k)+GetIndexPixelComponent(k_indexes+u));
               }
               k_pixels += virt_width;
               k_indexes += virt_width;
@@ -3618,7 +3627,7 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
                 Minimize(result.blue,    (*k)+k_pixels[u].blue);
                 Minimize(result.opacity, (*k)+QuantumRange-k_pixels[u].opacity);
                 if ( image->colorspace == CMYKColorspace)
-                  Minimize(result.index,   (*k)+k_indexes[u]);
+                  Minimize(result.index,   (*k)+GetIndexPixelComponent(k_indexes+u));
               }
             break;
         case VoronoiMorphology:
@@ -3636,7 +3645,7 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
                 if( result.opacity > (*k)+k_pixels[u].opacity )
                   {
                     SetMagickPixelPacket(image,&k_pixels[u],&k_indexes[u],
-                         &result);
+                      &result);
                     result.opacity += *k;
                   }
               }
@@ -3653,7 +3662,7 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
                 if( result.opacity > (*k)+k_pixels[u].opacity )
                   {
                     SetMagickPixelPacket(image,&k_pixels[u],&k_indexes[u],
-                         &result);
+                      &result);
                     result.opacity += *k;
                   }
               }
@@ -3669,25 +3678,25 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
           break;
         default:
           if ((channel & RedChannel) != 0)
-            q->red = ClampToQuantum(result.red);
+            SetRedPixelComponent(q,ClampToQuantum(result.red));
           if ((channel & GreenChannel) != 0)
-            q->green = ClampToQuantum(result.green);
+            SetGreenPixelComponent(q,ClampToQuantum(result.green));
           if ((channel & BlueChannel) != 0)
-            q->blue = ClampToQuantum(result.blue);
+            SetBluePixelComponent(q,ClampToQuantum(result.blue));
           if ((channel & OpacityChannel) != 0 && image->matte == MagickTrue )
-            q->opacity = ClampToQuantum(QuantumRange-result.opacity);
+            SetOpacityPixelComponent(q,ClampToQuantum(QuantumRange-result.opacity));
           if ((channel & IndexChannel) != 0
               && image->colorspace == CMYKColorspace)
-            q_indexes[x] = ClampToQuantum(result.index);
+            SetIndexPixelComponent(q_indexes+x,ClampToQuantum(result.index));
           break;
       }
       /* Count up changed pixels */
-      if (   ( p[r].red != q->red )
-          || ( p[r].green != q->green )
-          || ( p[r].blue != q->blue )
-          || ( p[r].opacity != q->opacity )
+      if (   ( p[r].red != GetRedPixelComponent(q) )
+          || ( p[r].green != GetGreenPixelComponent(q) )
+          || ( p[r].blue != GetBluePixelComponent(q) )
+          || ( p[r].opacity != GetOpacityPixelComponent(q) )
           || ( image->colorspace == CMYKColorspace &&
-                  p_indexes[r] != q_indexes[x] ) )
+               GetIndexPixelComponent(p_indexes+r) != GetIndexPixelComponent(q_indexes+x) ) )
         changed++;  /* The pixel was changed in some way! */
 
       p--; /* go backward through pixel buffers */

diff --git a/magick/paint.c b/magick/paint.c
index 0dd9702953400b004de95de7ef0845e1606d7337..a9d020eb6a2a65e7d3500eeaf9837615c161918e 100644 (file)
--- a/magick/paint.c
+++ b/magick/paint.c
@@ -348,16 +348,16 @@ MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
           if (image->colorspace == CMYKColorspace)
             ConvertRGBToCMYK(&fill);
           if ((channel & RedChannel) != 0)
-            q->red=ClampToQuantum(fill.red);
+            SetRedPixelComponent(q,ClampToQuantum(fill.red));
           if ((channel & GreenChannel) != 0)
-            q->green=ClampToQuantum(fill.green);
+            SetGreenPixelComponent(q,ClampToQuantum(fill.green));
           if ((channel & BlueChannel) != 0)
-            q->blue=ClampToQuantum(fill.blue);
+            SetBluePixelComponent(q,ClampToQuantum(fill.blue));
           if ((channel & OpacityChannel) != 0)
-            q->opacity=ClampToQuantum(fill.opacity);
+            SetOpacityPixelComponent(q,ClampToQuantum(fill.opacity));
           if (((channel & IndexChannel) != 0) &&
               (image->colorspace == CMYKColorspace))
-            indexes[x]=ClampToQuantum(fill.index);
+            SetIndexPixelComponent(indexes+x,ClampToQuantum(fill.index));
         }
       p++;
       q++;
@@ -687,7 +687,8 @@ MagickExport Image *OilPaintImage(const Image *image,const double radius,
       }
       *q=(*(p+j));
       if (image->colorspace == CMYKColorspace)
-        paint_indexes[x]=indexes[x+j];
+        SetIndexPixelComponent(paint_indexes+x,GetIndexPixelComponent(
+          indexes+x+j));
       p++;
       q++;
     }
@@ -837,16 +838,16 @@ MagickExport MagickBooleanType OpaquePaintImageChannel(Image *image,
       if (IsMagickColorSimilar(&pixel,target) != invert)
         {
           if ((channel & RedChannel) != 0)
-            q->red=ClampToQuantum(fill->red);
+            SetRedPixelComponent(q,ClampToQuantum(fill->red));
           if ((channel & GreenChannel) != 0)
-            q->green=ClampToQuantum(fill->green);
+            SetGreenPixelComponent(q,ClampToQuantum(fill->green));
           if ((channel & BlueChannel) != 0)
-            q->blue=ClampToQuantum(fill->blue);
+            SetBluePixelComponent(q,ClampToQuantum(fill->blue));
           if ((channel & OpacityChannel) != 0)
-            q->opacity=ClampToQuantum(fill->opacity);
+            SetOpacityPixelComponent(q,ClampToQuantum(fill->opacity));
           if (((channel & IndexChannel) != 0) &&
               (image->colorspace == CMYKColorspace))
-            indexes[x]=ClampToQuantum(fill->index);
+            SetIndexPixelComponent(indexes+x,ClampToQuantum(fill->index));
         }
       q++;
     }

diff --git a/magick/pixel.c b/magick/pixel.c
index b546364774fbb44a86cab104d56f296148684d0d..748e0baf18d8e78f6d5e01e4ba9caf810da8af1c 100644 (file)
--- a/magick/pixel.c
+++ b/magick/pixel.c
@@ -427,7 +427,7 @@ MagickExport MagickBooleanType ExportImagePixels(const Image *image,
               case BlackQuantum:
               {
                 if (image->colorspace == CMYKColorspace)
-                  *q=ScaleQuantumToChar(indexes[x]);
+                  *q=ScaleQuantumToChar(GetIndexPixelComponent(indexes+x));
                 break;
               }
               case IndexQuantum:
@@ -619,7 +619,7 @@ MagickExport MagickBooleanType ExportImagePixels(const Image *image,
               case BlackQuantum:
               {
                 if (image->colorspace == CMYKColorspace)
-                  *q=(double) (QuantumScale*indexes[x]);
+                  *q=(double) (QuantumScale*GetIndexPixelComponent(indexes+x));
                 break;
               }
               case IndexQuantum:
@@ -808,7 +808,7 @@ MagickExport MagickBooleanType ExportImagePixels(const Image *image,
               case BlackQuantum:
               {
                 if (image->colorspace == CMYKColorspace)
-                  *q=(float) (QuantumScale*indexes[x]);
+                  *q=(float) (QuantumScale*GetIndexPixelComponent(indexes+x));
                 break;
               }
               case IndexQuantum:
@@ -1001,7 +1001,7 @@ MagickExport MagickBooleanType ExportImagePixels(const Image *image,
               case BlackQuantum:
               {
                 if (image->colorspace == CMYKColorspace)
-                  *q=(unsigned int) ScaleQuantumToLong(indexes[x]);
+                  *q=(unsigned int) ScaleQuantumToLong(GetIndexPixelComponent(indexes+x));
                 break;
               }
               case IndexQuantum:
@@ -1191,7 +1191,7 @@ MagickExport MagickBooleanType ExportImagePixels(const Image *image,
               case BlackQuantum:
               {
                 if (image->colorspace == CMYKColorspace)
-                  *q=ScaleQuantumToLong(indexes[x]);
+                  *q=ScaleQuantumToLong(GetIndexPixelComponent(indexes+x));
                 break;
               }
               case IndexQuantum:
@@ -1380,7 +1380,7 @@ MagickExport MagickBooleanType ExportImagePixels(const Image *image,
               case BlackQuantum:
               {
                 if (image->colorspace == CMYKColorspace)
-                  *q=indexes[x];
+                  *q=GetIndexPixelComponent(indexes+x);
                 break;
               }
               case IndexQuantum:
@@ -1569,7 +1569,7 @@ MagickExport MagickBooleanType ExportImagePixels(const Image *image,
               case BlackQuantum:
               {
                 if (image->colorspace == CMYKColorspace)
-                  *q=ScaleQuantumToShort(indexes[x]);
+                  *q=ScaleQuantumToShort(GetIndexPixelComponent(indexes+x));
                 break;
               }
               case IndexQuantum:
@@ -1865,7 +1865,7 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
-              q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
+              SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -1963,7 +1963,7 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
               SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
-              q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
+              SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -2043,7 +2043,7 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               }
               case AlphaQuantum:
               {
-                q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p);
+                SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(*p));
                 break;
               }
               case OpacityQuantum:
@@ -2222,8 +2222,8 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
                 QuantumRange*(*p)));
               p++;
-              q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
-                QuantumRange*(*p));
+              SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
+                (MagickRealType) QuantumRange*(*p)));
               p++;
               q++;
             }
@@ -2292,8 +2292,8 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               }
               case AlphaQuantum:
               {
-                q->opacity=(Quantum) QuantumRange-ClampToQuantum(
-                  (MagickRealType) QuantumRange*(*p));
+                SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
+                  (MagickRealType) QuantumRange*(*p)));
                 break;
               }
               case OpacityQuantum:
@@ -2304,7 +2304,8 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               }
               case BlackQuantum:
               {
-                indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(
+                  (MagickRealType) QuantumRange*(*p)));
                 break;
               }
               case IndexQuantum:
@@ -2376,8 +2377,8 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
                 QuantumRange*(*p)));
               p++;
-              q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
-                QuantumRange*(*p));
+              SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
+                (MagickRealType) QuantumRange*(*p)));
               p++;
               q++;
             }
@@ -2476,8 +2477,8 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
                 QuantumRange*(*p)));
               p++;
-              q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
-                QuantumRange*(*p));
+              SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
+                (MagickRealType) QuantumRange*(*p)));
               p++;
               q++;
             }
@@ -2546,8 +2547,8 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               }
               case AlphaQuantum:
               {
-                q->opacity=(Quantum) QuantumRange-ClampToQuantum(
-                  (MagickRealType) QuantumRange*(*p));
+                SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
+                  (MagickRealType) QuantumRange*(*p)));
                 break;
               }
               case OpacityQuantum:
@@ -2558,7 +2559,8 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               }
               case BlackQuantum:
               {
-                indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(
+                  (MagickRealType) QuantumRange*(*p)));
                 break;
               }
               case IndexQuantum:
@@ -2596,9 +2598,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->red=ScaleLongToQuantum(*p++);
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -2615,10 +2617,10 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->red=ScaleLongToQuantum(*p++);
-              q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -2635,9 +2637,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->red=ScaleLongToQuantum(*p++);
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
               p++;
               q++;
             }
@@ -2655,7 +2657,7 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleLongToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
               SetGreenPixelComponent(q,GetRedPixelComponent(q));
               SetBluePixelComponent(q,GetRedPixelComponent(q));
               q++;
@@ -2674,9 +2676,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->blue=ScaleLongToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -2693,10 +2695,10 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->blue=ScaleLongToQuantum(*p++);
-              q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+              SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -2713,9 +2715,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->blue=ScaleLongToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
               p++;
               q++;
             }
@@ -2739,39 +2741,39 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               case RedQuantum:
               case CyanQuantum:
               {
-                q->red=ScaleLongToQuantum(*p);
+                SetRedPixelComponent(q,ScaleLongToQuantum(*p));
                 break;
               }
               case GreenQuantum:
               case MagentaQuantum:
               {
-                q->green=ScaleLongToQuantum(*p);
+                SetGreenPixelComponent(q,ScaleLongToQuantum(*p));
                 break;
               }
               case BlueQuantum:
               case YellowQuantum:
               {
-                q->blue=ScaleLongToQuantum(*p);
+                SetBluePixelComponent(q,ScaleLongToQuantum(*p));
                 break;
               }
               case AlphaQuantum:
               {
-                q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
+                SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(*p));
                 break;
               }
               case OpacityQuantum:
               {
-                q->opacity=ScaleLongToQuantum(*p);
+                SetOpacityPixelComponent(q,ScaleLongToQuantum(*p));
                 break;
               }
               case BlackQuantum:
               {
-                indexes[x]=ScaleLongToQuantum(*p);
+                SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(*p));
                 break;
               }
               case IndexQuantum:
               {
-                q->red=ScaleLongToQuantum(*p);
+                SetRedPixelComponent(q,ScaleLongToQuantum(*p));
                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
                 SetBluePixelComponent(q,GetRedPixelComponent(q));
                 break;
@@ -2803,9 +2805,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->red=ScaleLongToQuantum(*p++);
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -2822,10 +2824,10 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->red=ScaleLongToQuantum(*p++);
-              q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -2842,9 +2844,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->red=ScaleLongToQuantum(*p++);
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
               p++;
               q++;
             }
@@ -2862,7 +2864,7 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleLongToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
               SetGreenPixelComponent(q,GetRedPixelComponent(q));
               SetBluePixelComponent(q,GetRedPixelComponent(q));
               q++;
@@ -2881,9 +2883,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->blue=ScaleLongToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -2900,10 +2902,10 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->blue=ScaleLongToQuantum(*p++);
-              q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+              SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -2920,9 +2922,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleLongToQuantum(*p++);
-              q->green=ScaleLongToQuantum(*p++);
-              q->blue=ScaleLongToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+              SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
               p++;
               q++;
             }
@@ -2946,39 +2948,39 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               case RedQuantum:
               case CyanQuantum:
               {
-                q->red=ScaleLongToQuantum(*p);
+                SetRedPixelComponent(q,ScaleLongToQuantum(*p));
                 break;
               }
               case GreenQuantum:
               case MagentaQuantum:
               {
-                q->green=ScaleLongToQuantum(*p);
+                SetGreenPixelComponent(q,ScaleLongToQuantum(*p));
                 break;
               }
               case BlueQuantum:
               case YellowQuantum:
               {
-                q->blue=ScaleLongToQuantum(*p);
+                SetBluePixelComponent(q,ScaleLongToQuantum(*p));
                 break;
               }
               case AlphaQuantum:
               {
-                q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
+                SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(*p));
                 break;
               }
               case OpacityQuantum:
               {
-                q->opacity=ScaleLongToQuantum(*p);
+                SetOpacityPixelComponent(q,ScaleLongToQuantum(*p));
                 break;
               }
               case BlackQuantum:
               {
-                indexes[x]=ScaleLongToQuantum(*p);
+                SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(*p));
                 break;
               }
               case IndexQuantum:
               {
-                q->red=ScaleLongToQuantum(*p);
+                SetRedPixelComponent(q,ScaleLongToQuantum(*p));
                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
                 SetBluePixelComponent(q,GetRedPixelComponent(q));
                 break;
@@ -3010,9 +3012,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=(*p++);
-              q->green=(*p++);
-              q->red=(*p++);
+              SetBluePixelComponent(q,*p++);
+              SetGreenPixelComponent(q,*p++);
+              SetRedPixelComponent(q,*p++);
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3029,10 +3031,10 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=(*p++);
-              q->green=(*p++);
-              q->red=(*p++);
-              q->opacity=(Quantum) QuantumRange-(*p++);
+              SetBluePixelComponent(q,*p++);
+              SetGreenPixelComponent(q,*p++);
+              SetRedPixelComponent(q,*p++);
+              SetOpacityPixelComponent(q,QuantumRange-(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3049,9 +3051,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=(*p++);
-              q->green=(*p++);
-              q->red=(*p++);
+              SetBluePixelComponent(q,*p++);
+              SetGreenPixelComponent(q,*p++);
+              SetRedPixelComponent(q,*p++);
               p++;
               q++;
             }
@@ -3069,7 +3071,7 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=(*p++);
+              SetRedPixelComponent(q,*p++);
               SetGreenPixelComponent(q,GetRedPixelComponent(q));
               SetBluePixelComponent(q,GetRedPixelComponent(q));
               q++;
@@ -3088,9 +3090,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=(*p++);
-              q->green=(*p++);
-              q->blue=(*p++);
+              SetRedPixelComponent(q,*p++);
+              SetGreenPixelComponent(q,*p++);
+              SetBluePixelComponent(q,*p++);
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3107,10 +3109,10 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=(*p++);
-              q->green=(*p++);
-              q->blue=(*p++);
-              q->opacity=(Quantum) QuantumRange-(*p++);
+              SetRedPixelComponent(q,*p++);
+              SetGreenPixelComponent(q,*p++);
+              SetBluePixelComponent(q,*p++);
+              SetOpacityPixelComponent(q,QuantumRange-(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3127,9 +3129,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=(*p++);
-              q->green=(*p++);
-              q->blue=(*p++);
+              SetRedPixelComponent(q,*p++);
+              SetGreenPixelComponent(q,*p++);
+              SetBluePixelComponent(q,*p++);
               p++;
               q++;
             }
@@ -3153,39 +3155,39 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               case RedQuantum:
               case CyanQuantum:
               {
-                q->red=(*p);
+                SetRedPixelComponent(q,*p);
                 break;
               }
               case GreenQuantum:
               case MagentaQuantum:
               {
-                q->green=(*p);
+                SetGreenPixelComponent(q,*p);
                 break;
               }
               case BlueQuantum:
               case YellowQuantum:
               {
-                q->blue=(*p);
+                SetBluePixelComponent(q,*p);
                 break;
               }
               case AlphaQuantum:
               {
-                q->opacity=(Quantum) QuantumRange-(*p);
+                SetOpacityPixelComponent(q,QuantumRange-(*p));
                 break;
               }
               case OpacityQuantum:
               {
-                q->opacity=(*p);
+                SetOpacityPixelComponent(q,*p);
                 break;
               }
               case BlackQuantum:
               {
-                indexes[x]=(*p);
+                SetIndexPixelComponent(indexes+x,*p);
                 break;
               }
               case IndexQuantum:
               {
-                q->red=(*p);
+                SetRedPixelComponent(q,*p);
                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
                 SetBluePixelComponent(q,GetRedPixelComponent(q));
                 break;
@@ -3217,9 +3219,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=ScaleShortToQuantum(*p++);
-              q->green=ScaleShortToQuantum(*p++);
-              q->red=ScaleShortToQuantum(*p++);
+              SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+              SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3236,10 +3238,10 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=ScaleShortToQuantum(*p++);
-              q->green=ScaleShortToQuantum(*p++);
-              q->red=ScaleShortToQuantum(*p++);
-              q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
+              SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+              SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+              SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3256,9 +3258,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->blue=ScaleShortToQuantum(*p++);
-              q->green=ScaleShortToQuantum(*p++);
-              q->red=ScaleShortToQuantum(*p++);
+              SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+              SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
               p++;
               q++;
             }
@@ -3276,7 +3278,7 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleShortToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
               SetGreenPixelComponent(q,GetRedPixelComponent(q));
               SetBluePixelComponent(q,GetRedPixelComponent(q));
               q++;
@@ -3295,9 +3297,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleShortToQuantum(*p++);
-              q->green=ScaleShortToQuantum(*p++);
-              q->blue=ScaleShortToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+              SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3314,10 +3316,10 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleShortToQuantum(*p++);
-              q->green=ScaleShortToQuantum(*p++);
-              q->blue=ScaleShortToQuantum(*p++);
-              q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+              SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+              SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(*p++));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3334,9 +3336,9 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               break;
             for (x=0; x < (ssize_t) columns; x++)
             {
-              q->red=ScaleShortToQuantum(*p++);
-              q->green=ScaleShortToQuantum(*p++);
-              q->blue=ScaleShortToQuantum(*p++);
+              SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+              SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+              SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
               p++;
               q++;
             }
@@ -3360,39 +3362,39 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
               case RedQuantum:
               case CyanQuantum:
               {
-                q->red=ScaleShortToQuantum(*p);
+                SetRedPixelComponent(q,ScaleShortToQuantum(*p));
                 break;
               }
               case GreenQuantum:
               case MagentaQuantum:
               {
-                q->green=ScaleShortToQuantum(*p);
+                SetGreenPixelComponent(q,ScaleShortToQuantum(*p));
                 break;
               }
               case BlueQuantum:
               case YellowQuantum:
               {
-                q->blue=ScaleShortToQuantum(*p);
+                SetBluePixelComponent(q,ScaleShortToQuantum(*p));
                 break;
               }
               case AlphaQuantum:
               {
-                q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p);
+                SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(*p));
                 break;
               }
               case OpacityQuantum:
               {
-                q->opacity=ScaleShortToQuantum(*p);
+                SetOpacityPixelComponent(q,ScaleShortToQuantum(*p));
                 break;
               }
               case BlackQuantum:
               {
-                indexes[x]=ScaleShortToQuantum(*p);
+                SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(*p));
                 break;
               }
               case IndexQuantum:
               {
-                q->red=ScaleShortToQuantum(*p);
+                SetRedPixelComponent(q,ScaleShortToQuantum(*p));
                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
                 SetBluePixelComponent(q,GetRedPixelComponent(q));
                 break;

diff --git a/magick/prepress.c b/magick/prepress.c
index 8a593f629304a11add4f38523eab377e5b855342..21c0585d20785fbd0a693d3a9d36d8901998ec82 100644 (file)
--- a/magick/prepress.c
+++ b/magick/prepress.c
@@ -134,7 +134,8 @@ MagickExport double GetImageTotalInkDensity(Image *image)
     indexes=GetCacheViewVirtualIndexQueue(image_view);
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      density=(double) GetRedPixelComponent(p)+GetGreenPixelComponent(p)+GetBluePixelComponent(p)+indexes[x];
+      density=(double) GetRedPixelComponent(p)+GetGreenPixelComponent(p)+
+        GetBluePixelComponent(p)+GetIndexPixelComponent(indexes+x);
       if (density > total_ink_density)
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_GetImageTotalInkDensity)

diff --git a/magick/profile.c b/magick/profile.c
index 818b8757c72e429f09623f8a211e5f9a1e812cd0..726c0c12c1f7c2362c84062c0220dfbb90a663a4 100644 (file)
--- a/magick/profile.c
+++ b/magick/profile.c
@@ -1251,14 +1251,14 @@ MagickExport MagickBooleanType ProfileImage(Image *image,const char *name,
               p=source_pixels[id];
               for (x=0; x < (ssize_t) image->columns; x++)
               {
-                *p++=ScaleQuantumToShort(q->red);
+                *p++=ScaleQuantumToShort(GetRedPixelComponent(q));
                 if (source_channels > 1)
                   {
-                    *p++=ScaleQuantumToShort(q->green);
-                    *p++=ScaleQuantumToShort(q->blue);
+                    *p++=ScaleQuantumToShort(GetGreenPixelComponent(q));
+                    *p++=ScaleQuantumToShort(GetBluePixelComponent(q));
                   }
                 if (source_channels > 3)
-                  *p++=ScaleQuantumToShort(indexes[x]);
+                  *p++=ScaleQuantumToShort(GetIndexPixelComponent(indexes+x));
                 q++;
               }
               cmsDoTransform(transform[id],source_pixels[id],target_pixels[id],
@@ -1267,20 +1267,20 @@ MagickExport MagickBooleanType ProfileImage(Image *image,const char *name,
               q-=image->columns;
               for (x=0; x < (ssize_t) image->columns; x++)
               {
-                q->red=ScaleShortToQuantum(*p);
+                SetRedPixelCompinent(q,ScaleShortToQuantum(*p));
                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
                 SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p++;
                 if (target_channels > 1)
                   {
-                    q->green=ScaleShortToQuantum(*p);
+                    SetGreenPixelComponent(q,ScaleShortToQuantum(*p));
                     p++;
-                    q->blue=ScaleShortToQuantum(*p);
+                    SetBluePixelComponent(q,ScaleShortToQuantum(*p));
                     p++;
                   }
                 if (target_channels > 3)
                   {
-                    indexes[x]=ScaleShortToQuantum(*p);
+                    SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(*p));
                     p++;
                   }
                 q++;