diff --git a/coders/aai.c b/coders/aai.c
index 76b9ccf..214b175 100644
--- a/coders/aai.c
+++ b/coders/aai.c
@@ -183,7 +183,7 @@
         SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
         if (GetPixelAlpha(image,q) != OpaqueAlpha)
           image->matte=MagickTrue;
-        q+=GetPixelComponents(image);
+        q+=GetPixelChannels(image);
       }
       if (SyncAuthenticPixels(image,exception) == MagickFalse)
         break;
@@ -387,7 +387,7 @@
           GetPixelAlpha(image,p) : OpaqueAlpha));
         if (*q == 255)
           *q=254;
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
         q++;
       }
       count=WriteBlob(image,(size_t) (q-pixels),pixels);
diff --git a/coders/avs.c b/coders/avs.c
index 12d881b..5f8441b 100644
--- a/coders/avs.c
+++ b/coders/avs.c
@@ -180,7 +180,7 @@
         SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
         if (GetPixelAlpha(image,q) != OpaqueAlpha)
           image->matte=MagickTrue;
-        q+=GetPixelComponents(image);
+        q+=GetPixelChannels(image);
       }
       if (SyncAuthenticPixels(image,exception) == MagickFalse)
         break;
@@ -382,7 +382,7 @@
         *q++=ScaleQuantumToChar(GetPixelRed(image,p));
         *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
         *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
       count=WriteBlob(image,(size_t) (q-pixels),pixels);
       if (count != (ssize_t) (q-pixels))
diff --git a/coders/bgr.c b/coders/bgr.c
index 556863b..c882751 100644
--- a/coders/bgr.c
+++ b/coders/bgr.c
@@ -253,8 +253,8 @@
                 SetPixelAlpha(image,OpaqueAlpha,q);
                 if (image->matte != MagickFalse)
                   SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -359,8 +359,8 @@
                     default:
                       break;
                   }
-                  p+=GetPixelComponents(canvas_image);
-                  q+=GetPixelComponents(image);
+                  p+=GetPixelChannels(canvas_image);
+                  q+=GetPixelChannels(image);
                 }
                 if (SyncAuthenticPixels(image,exception) == MagickFalse)
                   break;
@@ -425,8 +425,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -477,8 +477,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -529,8 +529,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -590,8 +590,8 @@
                   for (x=0; x < (ssize_t) image->columns; x++)
                   {
                     SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
-                    p+=GetPixelComponents(canvas_image);
-                    q+=GetPixelComponents(image);
+                    p+=GetPixelChannels(canvas_image);
+                    q+=GetPixelChannels(image);
                   }
                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
                     break;
@@ -677,8 +677,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -748,8 +748,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -819,8 +819,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -892,8 +892,8 @@
                   for (x=0; x < (ssize_t) image->columns; x++)
                   {
                     SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
-                    p+=GetPixelComponents(canvas_image);
-                    q+=GetPixelComponents(image);
+                    p+=GetPixelChannels(canvas_image);
+                    q+=GetPixelChannels(image);
                   }
                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
                     break;
diff --git a/coders/bmp.c b/coders/bmp.c
index a42f401..b0bc283 100644
--- a/coders/bmp.c
+++ b/coders/bmp.c
@@ -1009,7 +1009,7 @@
             {
               index=(Quantum) (((*p) & (0x80 >> bit)) != 0 ? 0x01 : 0x00);
               SetPixelIndex(image,index,q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             p++;
           }
@@ -1019,7 +1019,7 @@
               {
                 index=(Quantum) (((*p) & (0x80 >> bit)) != 0 ? 0x01 : 0x00);
                 SetPixelIndex(image,index,q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
               p++;
             }
@@ -1051,17 +1051,17 @@
           {
             index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             index=ConstrainColormapIndex(image,*p & 0x0f);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             p++;
           }
           if ((image->columns % 2) != 0)
             {
               index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
               SetPixelIndex(image,index,q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
               p++;
             }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -1095,7 +1095,7 @@
           {
             index=ConstrainColormapIndex(image,*p++);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -1165,7 +1165,7 @@
             if (image->matte != MagickFalse)
               SetPixelAlpha(image,
                 ScaleShortToQuantum((unsigned short) opacity),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -1198,7 +1198,7 @@
             SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
             SetPixelRed(image,ScaleCharToQuantum(*p++),q);
             SetPixelAlpha(image,OpaqueAlpha,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -1260,7 +1260,7 @@
             if (image->matte != MagickFalse)
               SetPixelAlpha(image,
                 ScaleShortToQuantum((unsigned short) opacity),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -1658,7 +1658,7 @@
                 bit=0;
                 byte=0;
               }
-             p+=GetPixelComponents(image);
+             p+=GetPixelChannels(image);
            }
            if (bit != 0)
              {
@@ -1707,7 +1707,7 @@
                 nibble=0;
                 byte=0;
               }
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           if (nibble != 0)
             {
@@ -1741,7 +1741,7 @@
           for (x=0; x < (ssize_t) image->columns; x++)
           {
             *q++=(unsigned char) GetPixelIndex(image,p);
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           for ( ; x < (ssize_t) bytes_per_line; x++)
             *q++=0x00;
@@ -1771,7 +1771,7 @@
             *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
             *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
             *q++=ScaleQuantumToChar(GetPixelRed(image,p));
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           for (x=3L*(ssize_t) image->columns; x < (ssize_t) bytes_per_line; x++)
             *q++=0x00;
@@ -1802,7 +1802,7 @@
             *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
             *q++=ScaleQuantumToChar(GetPixelRed(image,p));
             *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           if (image->previous == (Image *) NULL)
             {
diff --git a/coders/clipboard.c b/coders/clipboard.c
index 086758f..cd737db 100644
--- a/coders/clipboard.c
+++ b/coders/clipboard.c
@@ -218,7 +218,7 @@
           SetPixelBlue(image,ScaleCharToQuantum(pBits->rgbBlue),q);
           SetPixelAlpha(image,OpaqueAlpha,q);
           pBits++;
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
diff --git a/coders/cmyk.c b/coders/cmyk.c
index 0f37675..d736168 100644
--- a/coders/cmyk.c
+++ b/coders/cmyk.c
@@ -253,8 +253,8 @@
                 SetPixelAlpha(image,OpaqueAlpha,q);
                 if (image->matte != MagickFalse)
                   SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -360,8 +360,8 @@
                     default:
                       break;
                   }
-                  p+=GetPixelComponents(canvas_image);
-                  q+=GetPixelComponents(image);
+                  p+=GetPixelChannels(canvas_image);
+                  q+=GetPixelChannels(image);
                 }
                 if (SyncAuthenticPixels(image,exception) == MagickFalse)
                   break;
@@ -426,8 +426,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -478,8 +478,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -530,8 +530,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -582,8 +582,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelBlack(image,GetPixelBlack(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -637,8 +637,8 @@
                   for (x=0; x < (ssize_t) image->columns; x++)
                   {
                     SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
-                    p+=GetPixelComponents(canvas_image);
-                    q+=GetPixelComponents(image);
+                    p+=GetPixelChannels(canvas_image);
+                    q+=GetPixelChannels(image);
                   }
                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
                     break;
@@ -724,8 +724,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -795,8 +795,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -866,8 +866,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -937,8 +937,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelBlack(image,GetPixelBlack(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -1010,8 +1010,8 @@
                   for (x=0; x < (ssize_t) image->columns; x++)
                   {
                     SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
-                    p+=GetPixelComponents(canvas_image);
-                    q+=GetPixelComponents(image);
+                    p+=GetPixelChannels(canvas_image);
+                    q+=GetPixelChannels(image);
                   }
                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
                     break;
diff --git a/coders/cut.c b/coders/cut.c
index f84ef1d..091d499 100644
--- a/coders/cut.c
+++ b/coders/cut.c
@@ -118,7 +118,7 @@
           {
             index=(Quantum) ((((*p) & (0x80 >> bit)) != 0) ? 0x01 : 0x00);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           p++;
         }
@@ -128,7 +128,7 @@
               {
                 index=(Quantum) ((((*p) & (0x80 >> bit)) != 0) ? 0x01 : 0x00);
                 SetPixelIndex(image,index,q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
             p++;
           }
@@ -145,35 +145,35 @@
         {
           index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
           SetPixelIndex(image,index,q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
           index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
           SetPixelIndex(image,index,q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
           index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
           SetPixelIndex(image,index,q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
           index=ConstrainColormapIndex(image,(*p) & 0x3);
           SetPixelIndex(image,index,q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
           p++;
         }
         if ((image->columns % 4) != 0)
           {
             index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             if ((image->columns % 4) >= 1)
 
               {
                 index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
                 SetPixelIndex(image,index,q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
                 if ((image->columns % 4) >= 2)
 
                   {
                     index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
                     SetPixelIndex(image,index,q);
-                    q+=GetPixelComponents(image);
+                    q+=GetPixelChannels(image);
                   }
               }
             p++;
@@ -192,17 +192,17 @@
         {
             index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             index=ConstrainColormapIndex(image,(*p) & 0xf);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             p++;
           }
         if ((image->columns % 2) != 0)
           {
             index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             p++;
           }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -218,7 +218,7 @@
           index=ConstrainColormapIndex(image,*p);
           SetPixelIndex(image,index,q);
           p++;
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
@@ -259,7 +259,7 @@
         intensity=GetPixelRed(image,q);
       if (intensity >= scale_intensity)
         return(255);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
   }
   if (intensity < ScaleCharToQuantum(2))
@@ -589,7 +589,7 @@
                           SetPixelGreen(image,QuantumRange,q);
                           SetPixelBlue(image,QuantumRange,q);
                         }
-                      q+=GetPixelComponents(image);
+                      q+=GetPixelChannels(image);
                     }
                   if (SyncAuthenticPixels(image,exception) == MagickFalse) goto Finish;
                 }
diff --git a/coders/dcm.c b/coders/dcm.c
index b3c4c7c..b207379 100644
--- a/coders/dcm.c
+++ b/coders/dcm.c
@@ -3752,7 +3752,7 @@
                 default:
                   break;
               }
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
               break;
@@ -3907,7 +3907,7 @@
             SetPixelRed(image,pixel.red,q);
             SetPixelGreen(image,pixel.green,q);
             SetPixelBlue(image,pixel.blue,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -4040,7 +4040,7 @@
                 (((size_t) pixel.green) << 8)),q);
               SetPixelBlue(image,(((size_t) GetPixelBlue(image,q)) |
                 (((size_t) pixel.blue) << 8)),q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
               break;
diff --git a/coders/dds.c b/coders/dds.c
index 0422561..dc7a796 100644
--- a/coders/dds.c
+++ b/coders/dds.c
@@ -554,7 +554,7 @@
               SetPixelAlpha(image,ScaleCharToQuantum(colors.a[code]),q);
               if (colors.a[code] && (image->matte == MagickFalse))
                 image->matte=MagickTrue;  /* Correct matte */
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
         }
       }
@@ -643,7 +643,7 @@
               else
                 alpha = 17U * (unsigned char) ((a1 >> (4*(4*(j-2)+i))) & 0xf);
               SetPixelAlpha(image,ScaleCharToQuantum((unsigned char) alpha),q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
         }
       }
@@ -747,7 +747,7 @@
               else
                 alpha = (((6-alpha_code) * a0 + (alpha_code-1) * a1) / 5);
               SetPixelAlpha(image,ScaleCharToQuantum((unsigned char) alpha),q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
         }
       }
@@ -791,7 +791,7 @@
         ReadBlobByte(image)),q);
       if (dds_info->pixelformat.rgb_bitcount == 32)
         (void) ReadBlobByte(image);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -832,7 +832,7 @@
         ReadBlobByte(image)),q);
       SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
         ReadBlobByte(image)),q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
diff --git a/coders/debug.c b/coders/debug.c
index 69743f7..1fb6753 100644
--- a/coders/debug.c
+++ b/coders/debug.c
@@ -247,7 +247,7 @@
           }
         (void) WriteBlobString(image,tuple);
         (void) WriteBlobString(image,"\n");
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
       status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
         image->rows);
diff --git a/coders/dib.c b/coders/dib.c
index 0f2a519..658a7ac 100644
--- a/coders/dib.c
+++ b/coders/dib.c
@@ -656,7 +656,7 @@
           {
             index=(Quantum) ((*p) & (0x80 >> bit) ? 0x01 : 0x00);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           p++;
         }
@@ -666,7 +666,7 @@
             {
               index=(Quantum) ((*p) & (0x80 >> bit) ? 0x01 : 0x00);
               SetPixelIndex(image,index,q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             p++;
           }
@@ -698,17 +698,17 @@
         {
           index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
           SetPixelIndex(image,index,q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
           index=ConstrainColormapIndex(image,*p & 0xf);
           SetPixelIndex(image,index,q);
           p++;
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         if ((image->columns % 2) != 0)
           {
             index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             p++;
           }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -743,7 +743,7 @@
           index=ConstrainColormapIndex(image,*p);
           SetPixelIndex(image,index,q);
           p++;
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
@@ -797,7 +797,7 @@
               SetPixelBlue(image,ScaleCharToQuantum(ScaleColor5to8(
                 (unsigned char) (word & 0x1f))),q);
             }
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
@@ -830,7 +830,7 @@
           SetPixelRed(image,ScaleCharToQuantum(*p++),q);
           if (image->matte != MagickFalse)
             SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
@@ -1092,7 +1092,7 @@
               bit=0;
               byte=0;
             }
-           p+=GetPixelComponents(image);
+           p+=GetPixelChannels(image);
          }
          if (bit != 0)
            {
@@ -1122,7 +1122,7 @@
         for (x=0; x < (ssize_t) image->columns; x++)
         {
           *q++=(unsigned char) GetPixelIndex(image,p);
-          p+=GetPixelComponents(image);
+          p+=GetPixelChannels(image);
         }
         for ( ; x < (ssize_t) bytes_per_line; x++)
           *q++=0x00;
@@ -1155,7 +1155,7 @@
             GetPixelBlue(image,p)) << 0)));
           *q++=(unsigned char)(word & 0xff);
           *q++=(unsigned char)(word >> 8);
-          p+=GetPixelComponents(image);
+          p+=GetPixelChannels(image);
         }
         for (x=(ssize_t) (2*image->columns); x < (ssize_t) bytes_per_line; x++)
           *q++=0x00;
@@ -1185,7 +1185,7 @@
           *q++=ScaleQuantumToChar(GetPixelRed(image,p));
           if (image->matte != MagickFalse)
             *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
-          p+=GetPixelComponents(image);
+          p+=GetPixelChannels(image);
         }
         if (dib_info.bits_per_pixel == 24)
           for (x=(ssize_t) (3*image->columns); x < (ssize_t) bytes_per_line; x++)
diff --git a/coders/djvu.c b/coders/djvu.c
index 0bdc893..5d6ae78 100644
--- a/coders/djvu.c
+++ b/coders/djvu.c
@@ -410,7 +410,7 @@
                                                 if (bit == 8)
                                                         bit=0;
                                                 byte>>=1;
-                                          o+=GetPixelComponents(image);
+                                          o+=GetPixelChannels(image);
                                         }
                                 if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
                                         break;
@@ -444,7 +444,7 @@
                     SetPixelRed(image,ScaleCharToQuantum(*s++),r);
                     SetPixelGreen(image,ScaleCharToQuantum(*s++),r);
                     SetPixelBlue(image,ScaleCharToQuantum(*s++),r);
-                    r+=GetPixelComponents(image);
+                    r+=GetPixelChannels(image);
                   }
 
                               SyncAuthenticPixels(image,&image->exception);
diff --git a/coders/dps.c b/coders/dps.c
index 2b2cf4d..22dfcff 100644
--- a/coders/dps.c
+++ b/coders/dps.c
@@ -385,7 +385,7 @@
             SetPixelGreen(image,ScaleShortToQuantum(colors[index].green),q);
             index=(pixel >> blue_shift) & blue_mask;
             SetPixelBlue(image,ScaleShortToQuantum(colors[index].blue),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -410,7 +410,7 @@
             color=(pixel >> blue_shift) & blue_mask;
             color=(color*65535L)/blue_mask;
             SetPixelBlue(image,ScaleShortToQuantum((unsigned short) color),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -452,7 +452,7 @@
         for (x=0; x < (ssize_t) image->columns; x++)
         {
           SetPixelIndex(image,(unsigned short) XGetPixel(dps_image,x,y),q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
@@ -501,7 +501,7 @@
                   SetPixelAlpha(image,OpaqueAlpha,q);
                   if (XGetPixel(matte_image,x,y) == 0)
                     SetPixelAlpha(image,TransparentAlpha,q);
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
                 if (SyncAuthenticPixels(image,exception) == MagickFalse)
                   break;
diff --git a/coders/emf.c b/coders/emf.c
index c9ae41e..7df34b6 100644
--- a/coders/emf.c
+++ b/coders/emf.c
@@ -618,7 +618,7 @@
       SetPixelBlue(image,ScaleCharToQuantum(pBits->rgbBlue),q);
       SetPixelAlpha(image,OpaqueAlpha,q);
       pBits++;
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
diff --git a/coders/exr.c b/coders/exr.c
index c8c5969..7cd528c 100644
--- a/coders/exr.c
+++ b/coders/exr.c
@@ -233,7 +233,7 @@
         ImfHalfToFloat(scanline[x].b)),q);
       SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
         ImfHalfToFloat(scanline[x].a)),q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -443,7 +443,7 @@
       else
         ImfFloatToHalf(QuantumScale*GetPixelAlpha(image,p),&half_quantum);
       scanline[x].a=half_quantum;
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     ImfOutputSetFrameBuffer(file,scanline-(y*image->columns),1,image->columns);
     ImfOutputWritePixels(file,1);
diff --git a/coders/fits.c b/coders/fits.c
index 694c16a..9058fc6 100644
--- a/coders/fits.c
+++ b/coders/fits.c
@@ -448,7 +448,7 @@
           (pixel-fits_info.min_data)+fits_info.zero)),q);
         SetPixelGreen(image,GetPixelRed(image,q),q);
         SetPixelBlue(image,GetPixelRed(image,q),q);
-        q+=GetPixelComponents(image);
+        q+=GetPixelChannels(image);
       }
       if (SyncAuthenticPixels(image,exception) == MagickFalse)
         break;
diff --git a/coders/fpx.c b/coders/fpx.c
index cefeb77..4c7d4a6 100644
--- a/coders/fpx.c
+++ b/coders/fpx.c
@@ -470,7 +470,7 @@
       SetPixelAlpha(image,OpaqueAlpha,q);
       if (image->matte != MagickFalse)
         SetPixelAlpha(image,ScaleCharToQuantum(*a),q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
       r+=red_component->columnStride;
       g+=green_component->columnStride;
       b+=blue_component->columnStride;
diff --git a/coders/gif.c b/coders/gif.c
index b3c8bb9..def3599 100644
--- a/coders/gif.c
+++ b/coders/gif.c
@@ -450,7 +450,7 @@
       SetPixelAlpha(image,(ssize_t) index == opacity ? TransparentAlpha :
         OpaqueAlpha,q);
       x++;
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (x < (ssize_t) image->columns)
       break;
@@ -666,7 +666,7 @@
     if (y == 0)
       {
         waiting_code=(short) GetPixelIndex(image,p);
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
     for (x=(ssize_t) (y == 0 ? 1 : 0); x < (ssize_t) image->columns; x++)
     {
@@ -674,7 +674,7 @@
         Probe hash table.
       */
       index=(Quantum) ((size_t) GetPixelIndex(image,p) & 0xff);
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
       k=(ssize_t) (((size_t) index << (MaxGIFBits-8))+waiting_code);
       if (k >= MaxHashTable)
         k-=MaxHashTable;
diff --git a/coders/gray.c b/coders/gray.c
index 699a485..c9d6e5e 100644
--- a/coders/gray.c
+++ b/coders/gray.c
@@ -228,8 +228,8 @@
             SetPixelRed(image,GetPixelRed(canvas_image,p),q);
             SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
             SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
-            p+=GetPixelComponents(canvas_image);
-            q+=GetPixelComponents(image);
+            p+=GetPixelChannels(canvas_image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
diff --git a/coders/hald.c b/coders/hald.c
index 1e6cd25..95d075b 100644
--- a/coders/hald.c
+++ b/coders/hald.c
@@ -152,7 +152,7 @@
           (cube_size-1.0)),q);
         SetPixelBlue(image,ClampToQuantum(QuantumRange*blue/(cube_size-1.0)),q);
         SetPixelAlpha(image,OpaqueAlpha,q);
-        q+=GetPixelComponents(image);
+        q+=GetPixelChannels(image);
       }
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
diff --git a/coders/hdr.c b/coders/hdr.c
index 86d5a2d..d5978aa 100644
--- a/coders/hdr.c
+++ b/coders/hdr.c
@@ -474,7 +474,7 @@
           SetPixelGreen(image,ClampToQuantum(QuantumRange*gamma*pixel[1]),q);
           SetPixelBlue(image,ClampToQuantum(QuantumRange*gamma*pixel[2]),q);
         }
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -784,7 +784,7 @@
           pixels[i++]=pixel[2];
           pixels[i++]=pixel[3];
         }
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     if ((image->columns >= 8) && (image->columns <= 0x7ffff))
       {
diff --git a/coders/histogram.c b/coders/histogram.c
index 3ff651c..6ce7d7b 100644
--- a/coders/histogram.c
+++ b/coders/histogram.c
@@ -267,25 +267,25 @@
       break;
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
+      if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
         histogram[ScaleQuantumToChar(GetPixelRed(image,p))].red++;
-      if ((GetPixelGreenTraits(image) & ActivePixelTrait) != 0)
+      if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
         histogram[ScaleQuantumToChar(GetPixelGreen(image,p))].green++;
-      if ((GetPixelBlueTraits(image) & ActivePixelTrait) != 0)
+      if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
         histogram[ScaleQuantumToChar(GetPixelBlue(image,p))].blue++;
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
   }
   maximum=histogram[0].red;
   for (x=0; x < (ssize_t) histogram_image->columns; x++)
   {
-    if (((GetPixelRedTraits(image) & ActivePixelTrait) != 0) &&
+    if (((GetPixelRedTraits(image) & UpdatePixelTrait) != 0) &&
         (maximum < histogram[x].red))
       maximum=histogram[x].red;
-    if (((GetPixelGreenTraits(image) & ActivePixelTrait) != 0) &&
+    if (((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0) &&
         (maximum < histogram[x].green))
       maximum=histogram[x].green;
-    if (((GetPixelBlueTraits(image) & ActivePixelTrait) != 0) &&
+    if (((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0) &&
         (maximum < histogram[x].blue))
       maximum=histogram[x].blue;
   }
@@ -302,7 +302,7 @@
     q=GetAuthenticPixels(histogram_image,x,0,1,histogram_image->rows,exception);
     if (q == (const Quantum *) NULL)
       break;
-    if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
+    if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
       {
         y=(ssize_t) ceil(histogram_image->rows-scale*histogram[x].red-0.5);
         r=q+y;
@@ -312,7 +312,7 @@
           r++;
         }
       }
-    if ((GetPixelGreenTraits(image) & ActivePixelTrait) != 0)
+    if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
       {
         y=(ssize_t) ceil(histogram_image->rows-scale*histogram[x].green-0.5);
         r=q+y;
@@ -322,7 +322,7 @@
           r++;
         }
       }
-    if ((GetPixelBlueTraits(image) & ActivePixelTrait) != 0)
+    if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
       {
         y=(ssize_t) ceil(histogram_image->rows-scale*histogram[x].blue-0.5);
         r=q+y;
diff --git a/coders/hrz.c b/coders/hrz.c
index b337f40..92dc674 100644
--- a/coders/hrz.c
+++ b/coders/hrz.c
@@ -162,7 +162,7 @@
       SetPixelGreen(image,4*ScaleCharToQuantum(*p++),q);
       SetPixelBlue(image,4*ScaleCharToQuantum(*p++),q);
       SetPixelAlpha(image,OpaqueAlpha,q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -328,7 +328,7 @@
       *q++=ScaleQuantumToChar(GetPixelRed(hrz_image,p))/4;
       *q++=ScaleQuantumToChar(GetPixelGreen(hrz_image,p))/4;
       *q++=ScaleQuantumToChar(GetPixelBlue(hrz_image,p))/4;
-      p+=GetPixelComponents(hrz_image);
+      p+=GetPixelChannels(hrz_image);
     }
     count=WriteBlob(image,(size_t) (q-pixels),pixels);
     if (count != (ssize_t) (q-pixels))
diff --git a/coders/icon.c b/coders/icon.c
index c13e235..3a7e7aa 100644
--- a/coders/icon.c
+++ b/coders/icon.c
@@ -409,7 +409,7 @@
                 {
                   SetPixelIndex(image,((byte & (0x80 >> bit)) != 0 ? 0x01 :
                     0x00),q);
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
               }
               if ((image->columns % 8) != 0)
@@ -419,7 +419,7 @@
                   {
                     SetPixelIndex(image,((byte & (0x80 >> bit)) != 0 ? 0x01 :
                       0x00),q);
-                    q+=GetPixelComponents(image);
+                    q+=GetPixelChannels(image);
                   }
                 }
               for (x=0; x < (ssize_t) scanline_pad; x++)
@@ -450,15 +450,15 @@
               {
                 byte=(size_t) ReadBlobByte(image);
                 SetPixelIndex(image,((byte >> 4) & 0xf),q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
                 SetPixelIndex(image,((byte) & 0xf),q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
               if ((image->columns % 2) != 0)
                 {
                   byte=(size_t) ReadBlobByte(image);
                   SetPixelIndex(image,((byte >> 4) & 0xf),q);
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
               for (x=0; x < (ssize_t) scanline_pad; x++)
                 (void) ReadBlobByte(image);
@@ -488,7 +488,7 @@
               {
                 byte=(size_t) ReadBlobByte(image);
                 SetPixelIndex(image,byte,q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
               for (x=0; x < (ssize_t) scanline_pad; x++)
                 (void) ReadBlobByte(image);
@@ -519,7 +519,7 @@
                 byte=(size_t) ReadBlobByte(image);
                 byte|=(size_t) (ReadBlobByte(image) << 8);
                 SetPixelIndex(image,byte,q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
               for (x=0; x < (ssize_t) scanline_pad; x++)
                 (void) ReadBlobByte(image);
@@ -557,7 +557,7 @@
                 if (icon_info.bits_per_pixel == 32)
                   SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
                     ReadBlobByte(image)),q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
               if (icon_info.bits_per_pixel == 24)
                 for (x=0; x < (ssize_t) scanline_pad; x++)
@@ -597,7 +597,7 @@
                 {
                   SetPixelAlpha(image,(((byte & (0x80 >> bit)) != 0) ?
                     TransparentAlpha : OpaqueAlpha),q);
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
               }
               if ((image->columns % 8) != 0)
@@ -607,7 +607,7 @@
                   {
                     SetPixelAlpha(image,(((byte & (0x80 >> bit)) != 0) ?
                       TransparentAlpha : OpaqueAlpha),q);
-                    q+=GetPixelComponents(image);
+                    q+=GetPixelChannels(image);
                   }
                 }
               if ((image->columns % 32) != 0)
@@ -1015,7 +1015,7 @@
                     bit=0;
                     byte=0;
                   }
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (bit != 0)
                 *q++=(unsigned char) (byte << (8-bit));
@@ -1056,7 +1056,7 @@
                     nibble=0;
                     byte=0;
                   }
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (nibble != 0)
                 *q++=(unsigned char) (byte << 4);
@@ -1083,7 +1083,7 @@
               for (x=0; x < (ssize_t) next->columns; x++)
               {
                 *q++=(unsigned char) GetPixelIndex(next,p);
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (next->previous == (Image *) NULL)
                 {
@@ -1115,7 +1115,7 @@
                   *q++=ScaleQuantumToChar(QuantumRange);
                 else
                   *q++=ScaleQuantumToChar(GetPixelAlpha(next,p));
-                p+=GetPixelComponents(next);
+                p+=GetPixelChannels(next);
               }
               if (icon_info.bits_per_pixel == 24)
                 for (x=3L*(ssize_t) next->columns; x < (ssize_t) bytes_per_line; x++)
@@ -1211,7 +1211,7 @@
                 bit=0;
                 byte=0;
               }
-            p+=GetPixelComponents(next);
+            p+=GetPixelChannels(next);
           }
           if (bit != 0)
             (void) WriteBlobByte(image,(unsigned char) (byte << (8-bit)));
diff --git a/coders/jbig.c b/coders/jbig.c
index d59cd3a..bdd4422 100644
--- a/coders/jbig.c
+++ b/coders/jbig.c
@@ -235,7 +235,7 @@
         bit=0;
       SetPixelIndex(image,index,q);
       SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -472,7 +472,7 @@
             bit=0;
             byte=0;
           }
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
       if (bit != 0)
         *q++=byte << (8-bit);
diff --git a/coders/jp2.c b/coders/jp2.c
index 4274d8e..c8667dc 100644
--- a/coders/jp2.c
+++ b/coders/jp2.c
@@ -541,7 +541,7 @@
           SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
           SetPixelGreen(image,GetPixelRed(image,q),q);
           SetPixelBlue(image,GetPixelRed(image,q),q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         break;
       }
@@ -558,7 +558,7 @@
           SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) pixel,range[1]),q);
           pixel=(QuantumAny) jas_matrix_getv(pixels[2],x/x_step[2]);
           SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) pixel,range[2]),q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         break;
       }
@@ -577,7 +577,7 @@
           SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) pixel,range[2]),q);
           pixel=(QuantumAny) jas_matrix_getv(pixels[3],x/x_step[3]);
           SetPixelAlpha(image,ScaleAnyToQuantum((QuantumAny) pixel,range[3]),q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         break;
       }
@@ -939,7 +939,7 @@
             jas_matrix_setv(pixels[3],x,(jas_seqent_t) ScaleQuantumToAny(
               GetPixelAlpha(image,p),range));
         }
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     for (i=0; i < (ssize_t) number_components; i++)
       (void) jas_image_writecmpt(jp2_image,(short) i,0,(unsigned int) y,
diff --git a/coders/jpeg.c b/coders/jpeg.c
index 221ef00..7808d02 100644
--- a/coders/jpeg.c
+++ b/coders/jpeg.c
@@ -1247,7 +1247,7 @@
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
             p++;
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
         else
           if (image->colorspace != CMYKColorspace)
@@ -1260,7 +1260,7 @@
               SetPixelBlue(image,ScaleShortToQuantum((unsigned char)
                 (GETJSAMPLE(*p++) << 4)),q);
               SetPixelAlpha(image,OpaqueAlpha,q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
           else
             for (x=0; x < (ssize_t) image->columns; x++)
@@ -1274,7 +1274,7 @@
               SetPixelBlack(image,QuantumRange-ScaleShortToQuantum(
                 (unsigned char) (GETJSAMPLE(*p++) << 4)),q);
               SetPixelAlpha(image,OpaqueAlpha,q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
       }
     else
@@ -1285,7 +1285,7 @@
           SetPixelIndex(image,index,q);
           SetPixelPacket(image,image->colormap+(ssize_t) index,q);
           p++;
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
       else
         if (image->colorspace != CMYKColorspace)
@@ -1298,7 +1298,7 @@
             SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
               GETJSAMPLE(*p++)),q);
             SetPixelAlpha(image,OpaqueAlpha,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
         else
           for (x=0; x < (ssize_t) image->columns; x++)
@@ -1312,7 +1312,7 @@
             SetPixelBlack(image,QuantumRange-ScaleCharToQuantum(
               (unsigned char) GETJSAMPLE(*p++)),q);
             SetPixelAlpha(image,OpaqueAlpha,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -2227,7 +2227,7 @@
             *q++=(JSAMPLE) ScaleQuantumToChar(GetPixelRed(image,p));
             *q++=(JSAMPLE) ScaleQuantumToChar(GetPixelGreen(image,p));
             *q++=(JSAMPLE) ScaleQuantumToChar(GetPixelBlue(image,p));
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           (void) jpeg_write_scanlines(&jpeg_info,scanline,1);
           status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
@@ -2252,7 +2252,7 @@
             for (x=0; x < (ssize_t) image->columns; x++)
             {
               *q++=(JSAMPLE) ScaleQuantumToChar(GetPixelIntensity(image,p));
-              p+=GetPixelComponents(image);
+              p+=GetPixelChannels(image);
             }
             (void) jpeg_write_scanlines(&jpeg_info,scanline,1);
             status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
@@ -2286,7 +2286,7 @@
                 GetPixelBlue(image,p))));
               *q++=(JSAMPLE) (ScaleQuantumToChar((Quantum) (QuantumRange-
                 GetPixelBlack(image,p))));
-              p+=GetPixelComponents(image);
+              p+=GetPixelChannels(image);
             }
             (void) jpeg_write_scanlines(&jpeg_info,scanline,1);
             status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
@@ -2313,7 +2313,7 @@
         {
           *q++=(JSAMPLE) (ScaleQuantumToShort(GetPixelIntensity(image,p)) >>
             4);
-          p+=GetPixelComponents(image);
+          p+=GetPixelChannels(image);
         }
         (void) jpeg_write_scanlines(&jpeg_info,scanline,1);
         status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
@@ -2341,7 +2341,7 @@
             *q++=(JSAMPLE) (ScaleQuantumToShort(GetPixelRed(image,p)) >> 4);
             *q++=(JSAMPLE) (ScaleQuantumToShort(GetPixelGreen(image,p)) >> 4);
             *q++=(JSAMPLE) (ScaleQuantumToShort(GetPixelBlue(image,p)) >> 4);
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           (void) jpeg_write_scanlines(&jpeg_info,scanline,1);
           status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
@@ -2375,7 +2375,7 @@
               GetPixelBlue(image,p)) >> 4));
             *q++=(JSAMPLE) (4095-(ScaleQuantumToShort(
               GetPixelBlack(image,p)) >> 4));
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           (void) jpeg_write_scanlines(&jpeg_info,scanline,1);
           status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
diff --git a/coders/mac.c b/coders/mac.c
index 10b1935..9d92162 100644
--- a/coders/mac.c
+++ b/coders/mac.c
@@ -193,7 +193,7 @@
                 byte<<=1;
                 if (bit == 8)
                   bit=0;
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -228,7 +228,7 @@
             byte<<=1;
             if (bit == 8)
               bit=0;
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
diff --git a/coders/map.c b/coders/map.c
index 58b3ca5..0a08aee 100644
--- a/coders/map.c
+++ b/coders/map.c
@@ -227,7 +227,7 @@
         }
       SetPixelIndex(image,index,q);
       SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -423,7 +423,7 @@
       if (image->colors > 256)
         *q++=(unsigned char) ((size_t) GetPixelIndex(image,p) >> 8);
       *q++=(unsigned char) GetPixelIndex(image,p);
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     (void) WriteBlob(image,(size_t) (q-pixels),pixels);
   }
diff --git a/coders/mat.c b/coders/mat.c
index b969244..c35d967 100644
--- a/coders/mat.c
+++ b/coders/mat.c
@@ -235,7 +235,7 @@
         }
     }
     p++;
-    q+=GetPixelComponents(image);
+    q+=GetPixelChannels(image);
   }
   if (!SyncAuthenticPixels(image,exception))
     return;
diff --git a/coders/matte.c b/coders/matte.c
index b037aab..43da963 100644
--- a/coders/matte.c
+++ b/coders/matte.c
@@ -199,8 +199,8 @@
       SetPixelGreen(matte_image,GetPixelAlpha(image,p),q);
       SetPixelBlue(matte_image,GetPixelAlpha(image,p),q);
       SetPixelAlpha(matte_image,OpaqueAlpha,q);
-      p+=GetPixelComponents(image);
-      q+=GetPixelComponents(matte_image);
+      p+=GetPixelChannels(image);
+      q+=GetPixelChannels(matte_image);
     }
     if (SyncAuthenticPixels(matte_image,exception) == MagickFalse)
       break;
diff --git a/coders/miff.c b/coders/miff.c
index f73431e..25d28cc 100644
--- a/coders/miff.c
+++ b/coders/miff.c
@@ -1412,7 +1412,7 @@
               }
             if (image->matte != MagickFalse)
               SetPixelAlpha(image,pixel.alpha,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           break;
         }
@@ -2392,7 +2392,7 @@
         {
           length=0;
           SetPixelInfo(image,p,&pixel);
-          p+=GetPixelComponents(image);
+          p+=GetPixelChannels(image);
           for (x=1; x < (ssize_t) image->columns; x++)
           {
             SetPixelInfo(image,p,&target);
@@ -2405,7 +2405,7 @@
                 length=0;
               }
             SetPixelInfo(image,p,&pixel);
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           q=PopRunlengthPacket(image,q,length,&pixel);
           (void) WriteBlob(image,(size_t) (q-pixels),pixels);
diff --git a/coders/mono.c b/coders/mono.c
index 32e071b..138b257 100644
--- a/coders/mono.c
+++ b/coders/mono.c
@@ -172,7 +172,7 @@
       if (bit == 8)
         bit=0;
       byte>>=1;
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -340,7 +340,7 @@
           bit=0;
           byte=0;
         }
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     if (bit != 0)
       (void) WriteBlobByte(image,(unsigned char) (byte >> (8-bit)));
diff --git a/coders/msl.c b/coders/msl.c
index 0e8ea07..3657506 100644
--- a/coders/msl.c
+++ b/coders/msl.c
@@ -736,10 +736,10 @@
                 }
               }
             }
-          PushPixelComponentMap(msl_info->image[n],channel);
+          PushPixelChannelMap(msl_info->image[n],channel);
           noise_image=AddNoiseImage(msl_info->image[n],noise,
             &msl_info->image[n]->exception);
-          PopPixelComponentMap(msl_info->image[n]);
+          PopPixelChannelMap(msl_info->image[n]);
           if (noise_image == (Image *) NULL)
             break;
           msl_info->image[n]=DestroyImage(msl_info->image[n]);
@@ -1231,10 +1231,10 @@
                 }
               }
             }
-          PushPixelComponentMap(msl_info->image[n],channel);
+          PushPixelChannelMap(msl_info->image[n],channel);
           blur_image=BlurImage(msl_info->image[n],geometry_info.rho,
             geometry_info.sigma,&msl_info->image[n]->exception);
-          PopPixelComponentMap(msl_info->image[n]);
+          PopPixelChannelMap(msl_info->image[n]);
           if (blur_image == (Image *) NULL)
             break;
           msl_info->image[n]=DestroyImage(msl_info->image[n]);
@@ -1945,7 +1945,7 @@
                           if (GetPixelAlpha(composite_image,q) == OpaqueAlpha)
                             SetPixelAlpha(composite_image,
                               ClampToQuantum(opacity),q);
-                          q+=GetPixelComponents(composite_image);
+                          q+=GetPixelChannels(composite_image);
                         }
                         if (SyncCacheViewAuthenticPixels(composite_view,&exception) == MagickFalse)
                           break;
@@ -2055,7 +2055,7 @@
             geometry.y);
           flags=ParseGravityGeometry(image,composite_geometry,&geometry,
             &exception);
-          PushPixelComponentMap(image,channel);
+          PushPixelChannelMap(image,channel);
           if (rotate_image == (Image *) NULL)
             CompositeImage(image,compose,composite_image,geometry.x,geometry.y);
           else
@@ -2069,7 +2069,7 @@
               CompositeImage(image,compose,rotate_image,geometry.x,geometry.y);
               rotate_image=DestroyImage(rotate_image);
             }
-          PopPixelComponentMap(image);
+          PopPixelChannelMap(image);
           composite_image=DestroyImage(composite_image);
           break;
         }
@@ -3736,11 +3736,11 @@
           draw_info=CloneDrawInfo(msl_info->image_info[n],
             msl_info->draw_info[n]);
           draw_info->fill.alpha=ClampToQuantum(opacity);
-          PushPixelComponentMap(msl_info->image[n],AlphaChannel);
+          PushPixelChannelMap(msl_info->image[n],AlphaChannel);
           (void) FloodfillPaintImage(msl_info->image[n],draw_info,&target,
             geometry.x,geometry.y,paint_method == FloodfillMethod ?
             MagickFalse : MagickTrue);
-          PopPixelComponentMap(msl_info->image[n]);
+          PopPixelChannelMap(msl_info->image[n]);
           draw_info=DestroyDrawInfo(draw_info);
           break;
         }
@@ -4036,9 +4036,9 @@
                 }
               }
             }
-          PushPixelComponentMap(msl_info->image[n],channel);
+          PushPixelChannelMap(msl_info->image[n],channel);
           (void) NegateImage(msl_info->image[n],gray);
-          PopPixelComponentMap(msl_info->image[n]);
+          PopPixelChannelMap(msl_info->image[n]);
           break;
         }
       if (LocaleCompare((const char *) tag,"normalize") == 0)
@@ -4227,10 +4227,10 @@
                 }
               }
             }
-          PushPixelComponentMap(msl_info->image[n],channel);
+          PushPixelChannelMap(msl_info->image[n],channel);
           (void) OpaquePaintImage(msl_info->image[n],&target,&fill_color,
             MagickFalse);
-          PopPixelComponentMap(msl_info->image[n]);
+          PopPixelChannelMap(msl_info->image[n]);
           break;
         }
       ThrowMSLException(OptionError,"UnrecognizedElement",(const char *) tag);
diff --git a/coders/mtv.c b/coders/mtv.c
index 374b277..e3a2b9a 100644
--- a/coders/mtv.c
+++ b/coders/mtv.c
@@ -180,7 +180,7 @@
         SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
         SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
         SetPixelAlpha(image,OpaqueAlpha,q);
-        q+=GetPixelComponents(image);
+        q+=GetPixelChannels(image);
       }
       if (SyncAuthenticPixels(image,exception) == MagickFalse)
         break;
@@ -383,7 +383,7 @@
         *q++=ScaleQuantumToChar(GetPixelRed(image,p));
         *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
         *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
       (void) WriteBlob(image,(size_t) (q-pixels),pixels);
       if (image->previous == (Image *) NULL)
diff --git a/coders/null.c b/coders/null.c
index 3492c69..00f87e2 100644
--- a/coders/null.c
+++ b/coders/null.c
@@ -139,7 +139,7 @@
     for (x=0; x < (ssize_t) image->columns; x++)
     {
       SetPixelPixelInfo(image,&background,q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
diff --git a/coders/otb.c b/coders/otb.c
index 53e925b..621650f 100644
--- a/coders/otb.c
+++ b/coders/otb.c
@@ -186,7 +186,7 @@
       bit++;
       if (bit == 8)
         bit=0;
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -367,7 +367,7 @@
           bit=0;
           byte=0;
         }
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     if (bit != 0)
       (void) WriteBlobByte(image,byte);
diff --git a/coders/palm.c b/coders/palm.c
index 66fa9b6..cc85499 100644
--- a/coders/palm.c
+++ b/coders/palm.c
@@ -477,7 +477,7 @@
             SetPixelGreen(image,(QuantumRange*((color16 >> 5) & 0x3f))/0x3f,q);
             SetPixelBlue(image,(QuantumRange*((color16 >> 0) & 0x1f))/0x1f,q);
             SetPixelAlpha(image,OpaqueAlpha,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
         }
       else
@@ -497,7 +497,7 @@
                 ptr++;
                 bit=8-bits_per_pixel;
               }
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -826,7 +826,7 @@
             {
               SetPixelIndex(image,FindColor(image,&image->colormap[(ssize_t)
                 GetPixelIndex(image,q)]),q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
           }
           affinity_image=DestroyImage(affinity_image);
@@ -868,7 +868,7 @@
               }
             *ptr++=(unsigned char) ((color16 >> 8) & 0xff);
             *ptr++=(unsigned char) (color16 & 0xff);
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
         }
       else
@@ -891,7 +891,7 @@
                 byte=0x00;
                 bit=(unsigned char) (8-bits_per_pixel);
               }
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           if ((image->columns % (8/bits_per_pixel)) != 0)
             *ptr++=byte;
diff --git a/coders/pcd.c b/coders/pcd.c
index 19f7e35..62fb2a7 100644
--- a/coders/pcd.c
+++ b/coders/pcd.c
@@ -676,7 +676,7 @@
             SetPixelRed(image,ScaleCharToQuantum(*yy++),q);
             SetPixelGreen(image,ScaleCharToQuantum(*c1++),q);
             SetPixelBlue(image,ScaleCharToQuantum(*c2++),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -784,7 +784,7 @@
       SetPixelRed(image,ScaleCharToQuantum(*yy++),q);
       SetPixelGreen(image,ScaleCharToQuantum(*c1++),q);
       SetPixelBlue(image,ScaleCharToQuantum(*c2++),q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -1027,7 +1027,7 @@
     for (x=0; x < (ssize_t) (tile_image->columns << 1); x++)
     {
       (void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelRed(tile_image,p)));
-      p+=GetPixelComponents(tile_image);
+      p+=GetPixelChannels(tile_image);
     }
     q=GetVirtualPixels(downsample_image,0,y >> 1,downsample_image->columns,
       1,&downsample_image->exception);
diff --git a/coders/pcl.c b/coders/pcl.c
index e8d524c..ae35056 100644
--- a/coders/pcl.c
+++ b/coders/pcl.c
@@ -871,7 +871,7 @@
                 bit=0;
                 byte=0;
               }
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           if (bit != 0)
             *q++=byte << (8-bit);
@@ -885,7 +885,7 @@
           for (x=0; x < (ssize_t) image->columns; x++)
           {
             *q++=(unsigned char) GetPixelIndex(image,p);
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           break;
         }
@@ -900,7 +900,7 @@
             *q++=ScaleQuantumToChar(GetPixelRed(image,p));
             *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
             *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           break;
         }
diff --git a/coders/pcx.c b/coders/pcx.c
index 11e8202..91e0ab0 100644
--- a/coders/pcx.c
+++ b/coders/pcx.c
@@ -610,7 +610,7 @@
             if (image->matte != MagickFalse)
               SetPixelAlpha(image,ScaleCharToQuantum(*r++),q);
           }
-        q+=GetPixelComponents(image);
+        q+=GetPixelChannels(image);
       }
       if (SyncAuthenticPixels(image,exception) == MagickFalse)
         break;
@@ -1008,7 +1008,7 @@
                 for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
                 {
                   *q++=ScaleQuantumToChar(GetPixelRed(image,p));
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 break;
               }
@@ -1017,7 +1017,7 @@
                 for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
                 {
                   *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 break;
               }
@@ -1026,7 +1026,7 @@
                 for (x=0; x < (ssize_t) pcx_info.bytes_per_line; x++)
                 {
                   *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 break;
               }
@@ -1036,7 +1036,7 @@
                 for (x=(ssize_t) pcx_info.bytes_per_line; x != 0; x--)
                 {
                   *q++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(image,p)));
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 break;
               }
@@ -1065,7 +1065,7 @@
             for (x=0; x < (ssize_t) image->columns; x++)
             {
               *q++=(unsigned char) GetPixelIndex(image,p);
-              p+=GetPixelComponents(image);
+              p+=GetPixelChannels(image);
             }
             if (PCXWritePixels(&pcx_info,pcx_pixels,image) == MagickFalse)
               break;
@@ -1115,7 +1115,7 @@
                     bit=0;
                     byte=0;
                   }
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (bit != 0)
                 *q++=byte << (8-bit);
diff --git a/coders/pdb.c b/coders/pdb.c
index 7bcebc4..dc4b374 100644
--- a/coders/pdb.c
+++ b/coders/pdb.c
@@ -442,7 +442,7 @@
           {
             index=(Quantum) (*p & (0x80 >> bit) ? 0x00 : 0x01);
             SetPixelIndex(image,index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           p++;
         }
@@ -470,17 +470,17 @@
         {
           index=ConstrainColormapIndex(image,3UL-((*p >> 6) & 0x03));
           SetPixelIndex(image,index,q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
           index=ConstrainColormapIndex(image,3UL-((*p >> 4) & 0x03));
           SetPixelIndex(image,index,q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
           index=ConstrainColormapIndex(image,3UL-((*p >> 2) & 0x03));
           SetPixelIndex(image,index,q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
           index=ConstrainColormapIndex(image,3UL-((*p) & 0x03));
           SetPixelIndex(image,index,q);
           p++;
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
@@ -506,11 +506,11 @@
         {
           index=ConstrainColormapIndex(image,15UL-((*p >> 4) & 0x0f));
           SetPixelIndex(image,index,q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
           index=ConstrainColormapIndex(image,15UL-((*p) & 0x0f));
           SetPixelIndex(image,index,q);
           p++;
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
diff --git a/coders/pdf.c b/coders/pdf.c
index 06cf2f9..06483d9 100644
--- a/coders/pdf.c
+++ b/coders/pdf.c
@@ -1605,7 +1605,7 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (image->previous == (Image *) NULL)
                 {
@@ -1647,7 +1647,7 @@
               {
                 Ascii85Encode(image,ScaleQuantumToChar(
                   GetPixelIntensity(image,p)));
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (image->previous == (Image *) NULL)
                 {
@@ -1712,7 +1712,7 @@
                 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
                 if (image->colorspace == CMYKColorspace)
                   *q++=ScaleQuantumToChar(GetPixelBlack(image,p));
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (image->previous == (Image *) NULL)
                 {
@@ -1758,7 +1758,7 @@
                 if (image->colorspace == CMYKColorspace)
                   Ascii85Encode(image,ScaleQuantumToChar(
                     GetPixelBlack(image,p)));
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (image->previous == (Image *) NULL)
                 {
@@ -1804,7 +1804,7 @@
                 for (x=0; x < (ssize_t) image->columns; x++)
                 {
                   *q++=(unsigned char) GetPixelIndex(image,p);
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 if (image->previous == (Image *) NULL)
                   {
@@ -1846,7 +1846,7 @@
                 for (x=0; x < (ssize_t) image->columns; x++)
                 {
                   Ascii85Encode(image,(unsigned char) GetPixelIndex(image,p));
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 if (image->previous == (Image *) NULL)
                   {
@@ -2054,7 +2054,7 @@
               for (x=0; x < (ssize_t) tile_image->columns; x++)
               {
                 *q++=ScaleQuantumToChar(GetPixelIntensity(tile_image,p));
-                p+=GetPixelComponents(tile_image);
+                p+=GetPixelChannels(tile_image);
               }
             }
 #if defined(MAGICKCORE_ZLIB_DELEGATE)
@@ -2090,7 +2090,7 @@
               {
                 Ascii85Encode(image,
                   ScaleQuantumToChar(GetPixelIntensity(tile_image,p)));
-                p+=GetPixelComponents(tile_image);
+                p+=GetPixelChannels(tile_image);
               }
             }
             Ascii85Flush(image);
@@ -2153,7 +2153,7 @@
                 *q++=ScaleQuantumToChar(GetPixelBlue(tile_image,p));
                 if (image->colorspace == CMYKColorspace)
                   *q++=ScaleQuantumToChar(GetPixelBlack(tile_image,p));
-                p+=GetPixelComponents(tile_image);
+                p+=GetPixelChannels(tile_image);
               }
             }
 #if defined(MAGICKCORE_ZLIB_DELEGATE)
@@ -2196,7 +2196,7 @@
                 if (image->colorspace == CMYKColorspace)
                   Ascii85Encode(image,ScaleQuantumToChar(
                     GetPixelBlack(tile_image,p)));
-                p+=GetPixelComponents(tile_image);
+                p+=GetPixelChannels(tile_image);
               }
             }
             Ascii85Flush(image);
@@ -2238,7 +2238,7 @@
                 for (x=0; x < (ssize_t) tile_image->columns; x++)
                 {
                   *q++=(unsigned char) GetPixelIndex(tile_image,p);
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
               }
 #if defined(MAGICKCORE_ZLIB_DELEGATE)
@@ -2274,7 +2274,7 @@
                 {
                   Ascii85Encode(image,(unsigned char)
                     GetPixelIndex(tile_image,p));
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
               }
               Ascii85Flush(image);
@@ -2441,7 +2441,7 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
             }
 #if defined(MAGICKCORE_ZLIB_DELEGATE)
@@ -2475,7 +2475,7 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 Ascii85Encode(image,ScaleQuantumToChar(GetPixelAlpha(image,p)));
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
             }
             Ascii85Flush(image);
diff --git a/coders/pict.c b/coders/pict.c
index 5ad5d97..c2e3776 100644
--- a/coders/pict.c
+++ b/coders/pict.c
@@ -494,7 +494,7 @@
       */
       for (y=0; y < (ssize_t) image->rows; y++)
       {
-        q=pixels+y*width*GetPixelComponents(image);;
+        q=pixels+y*width*GetPixelChannels(image);;
         number_pixels=bytes_per_line;
         count=ReadBlob(blob,(size_t) number_pixels,scanline);
         (void) count;
@@ -1219,7 +1219,7 @@
                         }
                   }
                 p++;
-                q+=GetPixelComponents(tile_image);
+                q+=GetPixelChannels(tile_image);
               }
               if (SyncAuthenticPixels(tile_image,exception) == MagickFalse)
                 break;
@@ -1878,7 +1878,7 @@
       for (x=0; x < (ssize_t) image->columns; x++)
       {
         scanline[x]=(unsigned char) GetPixelIndex(image,p);
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
       count+=EncodeImage(image,scanline,(size_t) (row_bytes & 0x7FFF),
         packed_scanline);
@@ -1932,7 +1932,7 @@
             *blue++=ScaleQuantumToChar(GetPixelBlue(image,p));
             if (image->matte != MagickFalse)
               *opacity++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(image,p)));
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           count+=EncodeImage(image,scanline,bytes_per_line & 0x7FFF,
             packed_scanline);
diff --git a/coders/pix.c b/coders/pix.c
index bff50cf..bc0dbd1 100644
--- a/coders/pix.c
+++ b/coders/pix.c
@@ -189,7 +189,7 @@
         SetPixelGreen(image,green,q);
         SetPixelRed(image,red,q);
         length--;
-        q+=GetPixelComponents(image);
+        q+=GetPixelChannels(image);
       }
       if (SyncAuthenticPixels(image,exception) == MagickFalse)
         break;
diff --git a/coders/plasma.c b/coders/plasma.c
index c351b19..411398c 100644
--- a/coders/plasma.c
+++ b/coders/plasma.c
@@ -175,7 +175,7 @@
     for (x=0; x < (ssize_t) image->columns; x++)
     {
       SetPixelAlpha(image,QuantumRange/2,q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
diff --git a/coders/png.c b/coders/png.c
index ca9edcd..92dfe2f 100644
--- a/coders/png.c
+++ b/coders/png.c
@@ -1028,7 +1028,7 @@
                 if (ok_to_reduce == MagickFalse)
                   break;
 
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (x >= 0)
                 break;
@@ -1158,7 +1158,7 @@
     {
        if (IsPixelGray(image,p) == MagickFalse)
           return(MagickFalse);
-       p+=GetPixelComponents(image);
+       p+=GetPixelChannels(image);
     }
   }
   return(MagickTrue);
@@ -2945,7 +2945,7 @@
                     found_transparent_pixel = MagickTrue;
                     break;
                   }
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
             }
 
@@ -3078,7 +3078,7 @@
                 SetPixelAlpha(image,ScaleCharToQuantum((unsigned char) *p++),q);
                 if (GetPixelAlpha(image,q) != OpaqueAlpha)
                   found_transparent_pixel = MagickTrue;
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
 
             else
@@ -3117,7 +3117,7 @@
                   SetPixelAlpha(image,ScaleShortToQuantum(quantum),q);
                   if (GetPixelAlpha(image,q) != OpaqueAlpha)
                     found_transparent_pixel = MagickTrue;
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
 
 #else /* MAGICKCORE_QUANTUM_DEPTH == 8 */
@@ -3130,7 +3130,7 @@
                   if (GetPixelAlpha(image,q) != OpaqueAlpha)
                     found_transparent_pixel = MagickTrue;
                   p++;
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
 #endif
             }
@@ -3154,7 +3154,7 @@
         for (x=0; x < (ssize_t) image->columns; x++)
         {
           SetPixelIndex(image,*r++,q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
 
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3304,7 +3304,7 @@
                 }
 #endif
 
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
 
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -4323,8 +4323,8 @@
       SetPixelRed(image,GetPixelRed(jng_image,s),q);
       SetPixelGreen(image,GetPixelGreen(jng_image,s),q);
       SetPixelBlue(image,GetPixelBlue(jng_image,s),q);
-      q+=GetPixelComponents(image);
-      s+=GetPixelComponents(jng_image);
+      q+=GetPixelChannels(image);
+      s+=GetPixelChannels(jng_image);
     }
 
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -4370,8 +4370,8 @@
                for (x=(ssize_t) image->columns; x != 0; x--)
                {
                   SetPixelAlpha(image,GetPixelRed(jng_image,s),q);
-                  q+=GetPixelComponents(image);
-                  s+=GetPixelComponents(jng_image);
+                  q+=GetPixelChannels(image);
+                  s+=GetPixelChannels(jng_image);
                }
 
              else
@@ -4380,8 +4380,8 @@
                   SetPixelAlpha(image,GetPixelRed(jng_image,s),q);
                   if (GetPixelAlpha(image,q) != OpaqueAlpha)
                     image->matte=MagickTrue;
-                  q+=GetPixelComponents(image);
-                  s+=GetPixelComponents(jng_image);
+                  q+=GetPixelChannels(image);
+                  s+=GetPixelChannels(jng_image);
                }
 
              if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -6211,7 +6211,7 @@
                             GetPixelBlue(image,q)),q);
                           SetPixelAlpha(image,ScaleQuantumToShort(
                             GetPixelAlpha(image,q)),q);
-                          q+=GetPixelComponents(image);
+                          q+=GetPixelChannels(image);
                        }
 
                        if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -6415,9 +6415,9 @@
                                  +GetPixelAlpha(image,pixels)),q);
                             }
                         }
-                      n+=GetPixelComponents(image);
-                      q+=GetPixelComponents(large_image);
-                      pixels+=GetPixelComponents(image);
+                      n+=GetPixelChannels(image);
+                      q+=GetPixelChannels(large_image);
+                      pixels+=GetPixelChannels(image);
                     } /* x */
 
                     if (SyncAuthenticPixels(large_image,exception) == 0)
@@ -6452,13 +6452,13 @@
                     *pixels;
 
                   q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
-                  pixels=q+(image->columns-length)*GetPixelComponents(image);
-                  n=pixels+GetPixelComponents(image);
+                  pixels=q+(image->columns-length)*GetPixelChannels(image);
+                  n=pixels+GetPixelChannels(image);
 
                   for (x=(ssize_t) (image->columns-length);
                     x < (ssize_t) image->columns; x++)
                   {
-                    /* To do: Rewrite using Get/Set***PixelComponent() */
+                    /* To do: Rewrite using Get/Set***PixelChannel() */
 
                     if (x == (ssize_t) (image->columns-length))
                       m=(ssize_t) mng_info->magn_ml;
@@ -6496,7 +6496,7 @@
                             SetPixelAlpha(image,GetPixelAlpha(image,pixels),q);
                           }
 
-                          /* To do: Rewrite using Get/Set***PixelComponent() */
+                          /* To do: Rewrite using Get/Set***PixelChannel() */
                           else
                             {
                               /* Interpolate */
@@ -6570,10 +6570,10 @@
                                  +GetPixelAlpha(image,pixels)),q);
                             }
                         }
-                      q+=GetPixelComponents(image);
+                      q+=GetPixelChannels(image);
                     }
-                    n+=GetPixelComponents(image);
-                    p+=GetPixelComponents(image);
+                    n+=GetPixelChannels(image);
+                    p+=GetPixelChannels(image);
                   }
 
                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -6599,7 +6599,7 @@
                           GetPixelBlue(image,q)),q);
                         SetPixelAlpha(image,ScaleShortToQuantum(
                           GetPixelAlpha(image,q)),q);
-                        q+=GetPixelComponents(image);
+                        q+=GetPixelChannels(image);
                      }
 
                      if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -8055,7 +8055,7 @@
                      }
                  }
              }
-           q+=GetPixelComponents(image);
+           q+=GetPixelChannels(image);
         }
      }
 
@@ -8148,7 +8148,7 @@
                           ping_have_non_bw=MagickTrue;
                           break;
                        }
-                     s+=GetPixelComponents(image);
+                     s+=GetPixelChannels(image);
                    }
                  }
 
@@ -8162,7 +8162,7 @@
                        {
                          ping_have_non_bw=MagickTrue;
                        }
-                     s+=GetPixelComponents(image);
+                     s+=GetPixelChannels(image);
                    }
                  }
              }
@@ -8283,7 +8283,7 @@
                     break;
                   }
                 }
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
 
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -8395,7 +8395,7 @@
                 }
               else
                   SetPixelAlpha(image,OpaqueAlpha,r);
-              r+=GetPixelComponents(image);
+              r+=GetPixelChannels(image);
           }
 
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -8605,7 +8605,7 @@
               {
                 SetPixelRed(image,ScaleCharToQuantum(0x24),r);
               }
-            r+=GetPixelComponents(image);
+            r+=GetPixelChannels(image);
           }
 
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -8698,7 +8698,7 @@
                      break;
                    }
 
-                 q+=GetPixelComponents(image);
+                 q+=GetPixelChannels(image);
              }
 
              if (ping_have_cheap_transparency == MagickFalse)
@@ -11563,9 +11563,9 @@
         ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 
       (void) CopyMagickString(jpeg_image->magick,"JPEG",MaxTextExtent);
-      PushPixelComponentMap(jpeg_image,AlphaChannel);
+      PushPixelChannelMap(jpeg_image,AlphaChannel);
       status=SeparateImage(jpeg_image);
-      PopPixelComponentMap(jpeg_image);
+      PopPixelChannelMap(jpeg_image);
       jpeg_image->matte=MagickFalse;
 
       if (jng_quality >= 1000)
diff --git a/coders/pnm.c b/coders/pnm.c
index 3b9d5be..f82ba75 100644
--- a/coders/pnm.c
+++ b/coders/pnm.c
@@ -439,7 +439,7 @@
             SetPixelRed(image,PNMInteger(image,2) == 0 ? QuantumRange : 0,q);
             SetPixelGreen(image,GetPixelRed(image,q),q);
             SetPixelBlue(image,GetPixelRed(image,q),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -495,7 +495,7 @@
                 max_value)],q);
             SetPixelGreen(image,GetPixelRed(image,q),q);
             SetPixelBlue(image,GetPixelRed(image,q),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -561,7 +561,7 @@
             SetPixelRed(image,pixel.red,q);
             SetPixelGreen(image,pixel.green,q);
             SetPixelBlue(image,pixel.blue,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -725,7 +725,7 @@
                   SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
                   SetPixelGreen(image,GetPixelRed(image,q),q);
                   SetPixelBlue(image,GetPixelRed(image,q),q);
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
               }
             else
@@ -739,7 +739,7 @@
                   SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
                   SetPixelGreen(image,GetPixelRed(image,q),q);
                   SetPixelBlue(image,GetPixelRed(image,q),q);
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
               }
           sync=SyncAuthenticPixels(image,exception);
@@ -825,7 +825,7 @@
               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
               SetPixelAlpha(image,OpaqueAlpha,q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
           else
             if (image->depth == 16)
@@ -842,7 +842,7 @@
                   p=PushShortPixel(MSBEndian,p,&pixel);
                   SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
                   SetPixelAlpha(image,OpaqueAlpha,q);
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
               }
             else
@@ -860,7 +860,7 @@
                     p=PushCharPixel(p,&pixel);
                     SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
                     SetPixelAlpha(image,OpaqueAlpha,q);
-                    q+=GetPixelComponents(image);
+                    q+=GetPixelChannels(image);
                   }
                 }
               else
@@ -877,7 +877,7 @@
                     p=PushShortPixel(MSBEndian,p,&pixel);
                     SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
                     SetPixelAlpha(image,OpaqueAlpha,q);
-                    q+=GetPixelComponents(image);
+                    q+=GetPixelChannels(image);
                   }
                 }
           if ((type == BilevelType) || (type == GrayscaleType))
@@ -894,7 +894,7 @@
                   type=UndefinedType;
                 if ((type != BilevelType) && (type != GrayscaleType))
                   break;
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
             }
           sync=SyncAuthenticPixels(image,exception);
@@ -1020,7 +1020,7 @@
                           p=PushCharPixel(p,&pixel);
                           SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
                         }
-                      q+=GetPixelComponents(image);
+                      q+=GetPixelChannels(image);
                     }
                   }
                 else
@@ -1040,7 +1040,7 @@
                           p=PushShortPixel(MSBEndian,p,&pixel);
                           SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
                         }
-                      q+=GetPixelComponents(image);
+                      q+=GetPixelChannels(image);
                     }
                   }
                 break;
@@ -1069,7 +1069,7 @@
                           p=PushCharPixel(p,&pixel);
                           SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
                         }
-                      q+=GetPixelComponents(image);
+                      q+=GetPixelChannels(image);
                     }
                   }
                 else
@@ -1093,7 +1093,7 @@
                           p=PushShortPixel(MSBEndian,p,&pixel);
                           SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
                         }
-                      q+=GetPixelComponents(image);
+                      q+=GetPixelChannels(image);
                     }
                   }
                 break;
@@ -1119,7 +1119,7 @@
                           p=PushCharPixel(p,&pixel);
                           SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
                         }
-                      q+=GetPixelComponents(image);
+                      q+=GetPixelChannels(image);
                     }
                   }
                 else
@@ -1141,7 +1141,7 @@
                           p=PushShortPixel(MSBEndian,p,&pixel);
                           SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
                         }
-                      q+=GetPixelComponents(image);
+                      q+=GetPixelChannels(image);
                     }
                   }
                 break;
@@ -1645,7 +1645,7 @@
                 (void) WriteBlob(image,q-pixels,pixels);
                 q=pixels;
               }
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           if (image->previous == (Image *) NULL)
             {
@@ -1704,7 +1704,7 @@
                 (void) WriteBlob(image,q-pixels,pixels);
                 q=pixels;
               }
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           if (image->previous == (Image *) NULL)
             {
@@ -1766,7 +1766,7 @@
                 (void) WriteBlob(image,q-pixels,pixels);
                 q=pixels;
               }
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           if (image->previous == (Image *) NULL)
             {
@@ -1868,7 +1868,7 @@
                         pixel=ScaleQuantumToAny(GetPixelRed(image,p),range);
                     }
                   q=PopCharPixel((unsigned char) pixel,q);
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
               else
                 for (x=0; x < (ssize_t) image->columns; x++)
@@ -1883,7 +1883,7 @@
                         pixel=ScaleQuantumToAny(GetPixelRed(image,p),range);
                     }
                   q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
               extent=(size_t) (q-pixels);
             }
@@ -1946,7 +1946,7 @@
                   q=PopCharPixel((unsigned char) pixel,q);
                   pixel=ScaleQuantumToAny(GetPixelBlue(image,p),range);
                   q=PopCharPixel((unsigned char) pixel,q);
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
               else
                 for (x=0; x < (ssize_t) image->columns; x++)
@@ -1957,7 +1957,7 @@
                   q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
                   pixel=ScaleQuantumToAny(GetPixelBlue(image,p),range);
                   q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
               extent=(size_t) (q-pixels);
             }
@@ -2021,7 +2021,7 @@
                             GetPixelAlpha(image,p),range);
                           q=PopCharPixel((unsigned char) pixel,q);
                         }
-                      p+=GetPixelComponents(image);
+                      p+=GetPixelChannels(image);
                     }
                   else
                     for (x=0; x < (ssize_t) image->columns; x++)
@@ -2034,7 +2034,7 @@
                             GetPixelAlpha(image,p),range);
                           q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
                         }
-                      p+=GetPixelComponents(image);
+                      p+=GetPixelChannels(image);
                     }
                   break;
                 }
@@ -2057,7 +2057,7 @@
                           pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),range);
                           q=PopCharPixel((unsigned char) pixel,q);
                         }
-                      p+=GetPixelComponents(image);
+                      p+=GetPixelChannels(image);
                     }
                   else
                     for (x=0; x < (ssize_t) image->columns; x++)
@@ -2075,7 +2075,7 @@
                           pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),range);
                           q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
                         }
-                      p+=GetPixelComponents(image);
+                      p+=GetPixelChannels(image);
                     }
                   break;
                 }
@@ -2095,7 +2095,7 @@
                           pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),range);
                           q=PopCharPixel((unsigned char) pixel,q);
                         }
-                      p+=GetPixelComponents(image);
+                      p+=GetPixelChannels(image);
                     }
                   else
                     for (x=0; x < (ssize_t) image->columns; x++)
@@ -2111,7 +2111,7 @@
                           pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),range);
                           q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
                         }
-                      p+=GetPixelComponents(image);
+                      p+=GetPixelChannels(image);
                     }
                   break;
                 }
diff --git a/coders/ps.c b/coders/ps.c
index 7ce244e..9ea57be 100644
--- a/coders/ps.c
+++ b/coders/ps.c
@@ -1769,7 +1769,7 @@
                     (void) WriteBlob(image,q-pixels,pixels);
                     q=pixels;
                   }
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (image->previous == (Image *) NULL)
                 {
@@ -1828,7 +1828,7 @@
                     bit=0;
                     byte=0;
                   }
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (bit != 0)
                 {
@@ -1906,7 +1906,7 @@
                       length=0;
                     }
                   GetPixelPacket(image,p,&pixel);
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 WriteRunlengthPacket(image,pixel,length,p);
                 if ((q-pixels+10) >= 80)
@@ -1967,7 +1967,7 @@
                       (void) WriteBlob(image,q-pixels,pixels);
                       q=pixels;
                     }
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 if (image->previous == (Image *) NULL)
                   {
@@ -2054,7 +2054,7 @@
                   pixel.green=GetPixelGreen(image,p);
                   pixel.blue=GetPixelBlue(image,p);
                   pixel.alpha=GetPixelAlpha(image,p);
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 q=PopHexPixel(hex_digits,(size_t) index,q);
                 q=PopHexPixel(hex_digits,(size_t)
@@ -2096,7 +2096,7 @@
                       (void) WriteBlob(image,q-pixels,pixels);
                       q=pixels;
                     }
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 if (image->previous == (Image *) NULL)
                   {
diff --git a/coders/ps2.c b/coders/ps2.c
index 1190dd9..ae734eb 100644
--- a/coders/ps2.c
+++ b/coders/ps2.c
@@ -785,7 +785,7 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
                 image->rows);
@@ -821,7 +821,7 @@
               {
                 Ascii85Encode(image,ScaleQuantumToChar(
                   GetPixelIntensity(image,p)));
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
                 y,image->rows);
@@ -902,7 +902,7 @@
                         *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
                         *q++=ScaleQuantumToChar(GetPixelBlack(image,p));
                       }
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
                   y,image->rows);
@@ -967,7 +967,7 @@
                         Ascii85Encode(image,ScaleQuantumToChar(
                           GetPixelBlack(image,p)));
                       }
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
                   y,image->rows);
@@ -1032,7 +1032,7 @@
                 for (x=0; x < (ssize_t) image->columns; x++)
                 {
                   *q++=(unsigned char) GetPixelIndex(image,p);
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
                   y,image->rows);
@@ -1067,7 +1067,7 @@
                 for (x=0; x < (ssize_t) image->columns; x++)
                 {
                   Ascii85Encode(image,(unsigned char) GetPixelIndex(image,p));
-                  p+=GetPixelComponents(image);
+                  p+=GetPixelChannels(image);
                 }
                 progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
                   y,image->rows);
diff --git a/coders/ps3.c b/coders/ps3.c
index 84c10c8..e009f90 100644
--- a/coders/ps3.c
+++ b/coders/ps3.c
@@ -272,7 +272,7 @@
         *q++=ScaleQuantumToChar(GetPixelRed(image,p));
         *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
         *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
     else
       for (x=0; x < (ssize_t) image->columns; x++)
@@ -281,7 +281,7 @@
         *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
         *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
         *q++=ScaleQuantumToChar(GetPixelBlack(image,p));
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
     if (image->previous == (Image *) NULL)
       {
@@ -343,7 +343,7 @@
       for (x=0; x < (ssize_t) image->columns; x++)
       {
         *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
     else
       {
@@ -360,7 +360,7 @@
               *q++=code;
               code='\0';
             }
-          p+=GetPixelComponents(image);
+          p+=GetPixelChannels(image);
         }
       }
     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
@@ -409,7 +409,7 @@
     for (x=0; x < (ssize_t) image->columns; x++)
     {
       *q++=(unsigned char) GetPixelIndex(image,p);
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     if (image->previous == (Image *) NULL)
       {
@@ -515,9 +515,9 @@
   mask_image=CloneImage(image,0,0,MagickTrue,&image->exception);
   if (mask_image == (Image *) NULL)
     ThrowWriterException(CoderError,image->exception.reason);
-  PushPixelComponentMap(mask_image,AlphaChannel);
+  PushPixelChannelMap(mask_image,AlphaChannel);
   status=SeparateImage(mask_image);
-  PopPixelComponentMap(mask_image);
+  PopPixelChannelMap(mask_image);
   if (status == MagickFalse)
     {
       mask_image=DestroyImage(mask_image);
diff --git a/coders/psd.c b/coders/psd.c
index e5fa83d..6b3e793 100644
--- a/coders/psd.c
+++ b/coders/psd.c
@@ -669,7 +669,7 @@
                       (0x01 << (7-bit))) != 0 ? 0 : 255,q);
                     SetPixelPacket(image,image->colormap+(ssize_t)
                       GetPixelIndex(image,q),q);
-                    q+=GetPixelComponents(image);
+                    q+=GetPixelChannels(image);
                     x++;
                   }
                   q--;
@@ -712,7 +712,7 @@
         default:
           break;
       }
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -1317,7 +1317,7 @@
                     SetPixelAlpha(layer_info[i].image,(Quantum)
                       (QuantumScale*(GetPixelAlpha(layer_info[i].image,q))*
                       layer_info[i].opacity),q);
-                    q+=GetPixelComponents(layer_info[i].image);
+                    q+=GetPixelChannels(layer_info[i].image);
                   }
                   if (SyncAuthenticPixels(layer_info[i].image,exception) == MagickFalse)
                     break;
diff --git a/coders/raw.c b/coders/raw.c
index 30cb258..5fd602b 100644
--- a/coders/raw.c
+++ b/coders/raw.c
@@ -225,8 +225,8 @@
             SetPixelRed(image,GetPixelRed(canvas_image,p),q);
             SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
             SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
-            p+=GetPixelComponents(canvas_image);
-            q+=GetPixelComponents(image);
+            p+=GetPixelChannels(canvas_image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
diff --git a/coders/rgb.c b/coders/rgb.c
index 14bf485..8f9e990 100644
--- a/coders/rgb.c
+++ b/coders/rgb.c
@@ -258,8 +258,8 @@
                 SetPixelAlpha(image,OpaqueAlpha,q);
                 if (image->matte != MagickFalse)
                   SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -366,8 +366,8 @@
                     default:
                       break;
                   }
-                  p+=GetPixelComponents(canvas_image);
-                  q+=GetPixelComponents(image);
+                  p+=GetPixelChannels(canvas_image);
+                  q+=GetPixelChannels(image);
                 }
                 if (SyncAuthenticPixels(image,exception) == MagickFalse)
                   break;
@@ -432,8 +432,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -485,8 +485,8 @@
               {
                 SetPixelGreen(image,
                   GetPixelGreen(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -538,8 +538,8 @@
               {
                 SetPixelBlue(image,
                   GetPixelBlue(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -600,8 +600,8 @@
                   {
                     SetPixelAlpha(image,
                       GetPixelAlpha(canvas_image,p),q);
-                    p+=GetPixelComponents(canvas_image);
-                    q+=GetPixelComponents(image);
+                    p+=GetPixelChannels(canvas_image);
+                    q+=GetPixelChannels(image);
                   }
                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
                     break;
@@ -687,8 +687,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -759,8 +759,8 @@
               {
                 SetPixelGreen(image,
                   GetPixelGreen(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -831,8 +831,8 @@
               {
                 SetPixelBlue(image,
                   GetPixelBlue(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -905,8 +905,8 @@
                   {
                     SetPixelAlpha(image,
                       GetPixelAlpha(canvas_image,p),q);
-                    p+=GetPixelComponents(canvas_image);
-                    q+=GetPixelComponents(image);
+                    p+=GetPixelChannels(canvas_image);
+                    q+=GetPixelChannels(image);
                   }
                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
                     break;
diff --git a/coders/rle.c b/coders/rle.c
index 0b3b074..c2fecd9 100644
--- a/coders/rle.c
+++ b/coders/rle.c
@@ -447,7 +447,7 @@
             SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
             if (image->matte != MagickFalse)
               SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -503,7 +503,7 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelIndex(image,*p++,q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -533,7 +533,7 @@
                 SetPixelGreen(image,image->colormap[*p++].green,q);
                 SetPixelBlue(image,image->colormap[*p++].blue,q);
                 SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
diff --git a/coders/sct.c b/coders/sct.c
index bc12048..ad2f66e 100644
--- a/coders/sct.c
+++ b/coders/sct.c
@@ -262,7 +262,7 @@
             break;
           }
         }
-        q+=GetPixelComponents(image);
+        q+=GetPixelChannels(image);
       }
       if (SyncAuthenticPixels(image,exception) == MagickFalse)
         break;
diff --git a/coders/sgi.c b/coders/sgi.c
index 327c23c..c72b488 100644
--- a/coders/sgi.c
+++ b/coders/sgi.c
@@ -562,7 +562,7 @@
                   SetPixelAlpha(image,ScaleShortToQuantum((unsigned short)
                     ((*(p+6) << 8) | (*(p+7)))),q);
                 p+=8;
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -591,7 +591,7 @@
               if (image->matte != MagickFalse)
                 SetPixelAlpha(image,ScaleCharToQuantum(*(p+3)),q);
               p+=4;
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
               break;
@@ -628,7 +628,7 @@
                 quantum|=(*(p+1));
                 SetPixelIndex(image,quantum,q);
                 p+=8;
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -652,7 +652,7 @@
             {
               SetPixelIndex(image,*p,q);
               p+=4;
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
               break;
@@ -986,7 +986,7 @@
           *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
           *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
           *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
-          p+=GetPixelComponents(image);
+          p+=GetPixelChannels(image);
         }
       else
         for (x=0; x < (ssize_t) image->columns; x++)
@@ -1000,7 +1000,7 @@
           *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
           *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
           *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
-          p+=GetPixelComponents(image);
+          p+=GetPixelChannels(image);
         }
       if (image->previous == (Image *) NULL)
         {
diff --git a/coders/sun.c b/coders/sun.c
index 8ca8a4f..b020379 100644
--- a/coders/sun.c
+++ b/coders/sun.c
@@ -448,7 +448,7 @@
           for (bit=7; bit >= 0; bit--)
           {
             SetPixelIndex(image,((*p) & (0x01 << bit) ? 0x00 : 0x01),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           p++;
         }
@@ -457,7 +457,7 @@
             for (bit=7; bit >= (ssize_t) (8-(image->columns % 8)); bit--)
             {
               SetPixelIndex(image,(*p) & (0x01 << bit) ? 0x00 : 0x01,q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             p++;
           }
@@ -489,7 +489,7 @@
             for (x=0; x < (ssize_t) image->columns; x++)
             {
               SetPixelIndex(image,*p++,q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             if ((image->columns % 2) != 0)
               p++;
@@ -548,7 +548,7 @@
                   SetPixelBlue(image,image->colormap[(ssize_t)
                     GetPixelBlue(image,q)].blue,q);
                 }
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             if (((bytes_per_pixel*image->columns) % 2) != 0)
               p++;
@@ -858,7 +858,7 @@
             *q++=ScaleQuantumToChar(GetPixelRed(image,p));
             *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
             *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
           }
           if (((bytes_per_pixel*image->columns) & 0x01) != 0)
             *q++='\0';  /* pad scanline */
@@ -903,7 +903,7 @@
                   bit=0;
                   byte=0;
                 }
-              p+=GetPixelComponents(image);
+              p+=GetPixelChannels(image);
             }
             if (bit != 0)
               (void) WriteBlobByte(image,(unsigned char) (byte << (8-bit)));
@@ -945,7 +945,7 @@
             {
               (void) WriteBlobByte(image,(unsigned char)
                 GetPixelIndex(image,p));
-              p+=GetPixelComponents(image);
+              p+=GetPixelChannels(image);
             }
             if (image->columns & 0x01)
               (void) WriteBlobByte(image,0);  /* pad scanline */
diff --git a/coders/svg.c b/coders/svg.c
index 984ebc4..8a60045 100644
--- a/coders/svg.c
+++ b/coders/svg.c
@@ -2938,7 +2938,7 @@
 #endif
               CompositePixelOver(image,&fill_color,fill_color.alpha,q,
                 (MagickRealType) GetPixelAlpha(image,q),q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
               break;
@@ -3351,7 +3351,7 @@
             trace->bitmap[i++]=GetPixelGreen(image,p);
             trace->bitmap[i++]=GetPixelBlue(image,p);
           }
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
     }
     splines=at_splines_new_full(trace,fitting_options,NULL,NULL,NULL,NULL,NULL,
@@ -3400,7 +3400,7 @@
           "  <circle cx=\"%.20g\" cy=\"%.20g\" r=\"1\" fill=\"%s\"/>\n",
           (double) x,(double) y,tuple);
         (void) WriteBlobString(image,message);
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
     }
     (void) WriteBlobString(image,"</svg>\n");
diff --git a/coders/tga.c b/coders/tga.c
index a6e6592..90ce761 100644
--- a/coders/tga.c
+++ b/coders/tga.c
@@ -446,7 +446,7 @@
       SetPixelBlue(image,pixel.blue,q);
       if (image->matte != MagickFalse)
         SetPixelAlpha(image,pixel.alpha,q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (((unsigned char) (tga_info.attributes & 0xc0) >> 6) == 4)
       offset+=4;
@@ -791,7 +791,7 @@
             if (image->matte != MagickFalse)
               *q++=(unsigned char) ScaleQuantumToChar(GetPixelAlpha(image,p));
           }
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     (void) WriteBlob(image,(size_t) (q-targa_pixels),targa_pixels);
     if (image->previous == (Image *) NULL)
diff --git a/coders/tiff.c b/coders/tiff.c
index d48b0c2..ea73e3b 100644
--- a/coders/tiff.c
+++ b/coders/tiff.c
@@ -1414,7 +1414,7 @@
               SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
                 (TIFFGetA(*p))),q);
             p++;
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -1506,7 +1506,7 @@
                   SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
                     TIFFGetA(*p)),q);
                   p++;
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
               else
                 for (column=columns_remaining; column > 0; column--)
@@ -1518,10 +1518,10 @@
                   SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
                     TIFFGetB(*p)),q);
                   p++;
-                  q+=GetPixelComponents(image);
+                  q+=GetPixelChannels(image);
                 }
               p+=columns-columns_remaining;
-              q-=GetPixelComponents(image)*(image->columns+columns_remaining);
+              q-=GetPixelChannels(image)*(image->columns+columns_remaining);
             }
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -1580,7 +1580,7 @@
           q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
           if (q == (const Quantum *) NULL)
             break;
-          q+=GetPixelComponents(image)*(image->columns-1);
+          q+=GetPixelChannels(image)*(image->columns-1);
           for (x=0; x < (ssize_t) image->columns; x++)
           {
             SetPixelRed(image,ScaleCharToQuantum((unsigned char)
@@ -1593,7 +1593,7 @@
               SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
                 TIFFGetA(*p)),q);
             p--;
-            q-=GetPixelComponents(image);;
+            q-=GetPixelChannels(image);;
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
diff --git a/coders/tim.c b/coders/tim.c
index 3c02c02..d68a947 100644
--- a/coders/tim.c
+++ b/coders/tim.c
@@ -262,16 +262,16 @@
           for (x=0; x < ((ssize_t) image->columns-1); x+=2)
           {
             SetPixelIndex(image,(*p) & 0x0f,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             SetPixelIndex(image,(*p >> 4) & 0x0f,q);
             p++;
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if ((image->columns % 2) != 0)
             {
               SetPixelIndex(image,(*p >> 4) & 0x0f,q);
               p++;
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -299,7 +299,7 @@
           for (x=0; x < (ssize_t) image->columns; x++)
           {
             SetPixelIndex(image,*p++,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -334,7 +334,7 @@
               (1UL*word >> 5) & 0x1f)),q);
             SetPixelRed(image,ScaleCharToQuantum(ScaleColor5to8(
               (1UL*word >> 0) & 0x1f)),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -364,7 +364,7 @@
             SetPixelRed(image,ScaleCharToQuantum(*p++),q);
             SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
             SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
diff --git a/coders/ttf.c b/coders/ttf.c
index c2d705e..c054e2d 100644
--- a/coders/ttf.c
+++ b/coders/ttf.c
@@ -238,7 +238,7 @@
     for (x=0; x < (ssize_t) image->columns; x++)
     {
       SetPixelPacket(image,&background_color,q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
diff --git a/coders/txt.c b/coders/txt.c
index 5f91914..3a7d090 100644
--- a/coders/txt.c
+++ b/coders/txt.c
@@ -651,7 +651,7 @@
     (void) FormatLocaleString(buffer,MaxTextExtent,
       "# ImageMagick pixel enumeration: %.20g,%.20g,%.20g,%s\n",(double)
       image->columns,(double) image->rows,(double)
-      ((MagickOffsetType) GetQuantumRange(image->depth)),colorspace);
+      GetQuantumRange(image->depth),colorspace);
     (void) WriteBlobString(image,buffer);
     GetPixelInfo(image,&pixel);
     for (y=0; y < (ssize_t) image->rows; y++)
@@ -666,24 +666,24 @@
         (void) WriteBlobString(image,buffer);
         SetPixelInfo(image,p,&pixel);
         (void) CopyMagickString(tuple,"(",MaxTextExtent);
-        ConcatenateColorComponent(&pixel,RedPixelComponent,X11Compliance,
+        ConcatenateColorComponent(&pixel,RedPixelChannel,X11Compliance,
           tuple);
         (void) ConcatenateMagickString(tuple,",",MaxTextExtent);
-        ConcatenateColorComponent(&pixel,GreenPixelComponent,X11Compliance,
+        ConcatenateColorComponent(&pixel,GreenPixelChannel,X11Compliance,
           tuple);
         (void) ConcatenateMagickString(tuple,",",MaxTextExtent);
-        ConcatenateColorComponent(&pixel,BluePixelComponent,X11Compliance,
+        ConcatenateColorComponent(&pixel,BluePixelChannel,X11Compliance,
           tuple);
         if (pixel.colorspace == CMYKColorspace)
           {
             (void) ConcatenateMagickString(tuple,",",MaxTextExtent);
-            ConcatenateColorComponent(&pixel,BlackPixelComponent,X11Compliance,
+            ConcatenateColorComponent(&pixel,BlackPixelChannel,X11Compliance,
               tuple);
           }
         if (pixel.matte != MagickFalse)
           {
             (void) ConcatenateMagickString(tuple,",",MaxTextExtent);
-            ConcatenateColorComponent(&pixel,AlphaPixelComponent,X11Compliance,
+            ConcatenateColorComponent(&pixel,AlphaPixelChannel,X11Compliance,
               tuple);
           }
         (void) ConcatenateMagickString(tuple,")",MaxTextExtent);
@@ -697,7 +697,7 @@
           &image->exception);
         (void) WriteBlobString(image,tuple);
         (void) WriteBlobString(image,"\n");
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
       status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
         image->rows);
diff --git a/coders/uil.c b/coders/uil.c
index 4e48f6e..da10b53 100644
--- a/coders/uil.c
+++ b/coders/uil.c
@@ -251,7 +251,7 @@
               if (matte_image[i] != 0)
                 transparent=MagickTrue;
               i++;
-              p+=GetPixelComponents(image);
+              p+=GetPixelChannels(image);
             }
           }
         }
@@ -273,7 +273,7 @@
               if (matte_image[i] != 0)
                 SetPixelIndex(image,image->colors,q);
               p++;
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
           }
         }
@@ -360,7 +360,7 @@
       symbol[j]='\0';
       (void) CopyMagickString(buffer,symbol,MaxTextExtent);
       (void) WriteBlobString(image,buffer);
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     (void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
       (y == (ssize_t) (image->rows-1) ? ");" : ","));
diff --git a/coders/uyvy.c b/coders/uyvy.c
index d0b799c..e74297b 100644
--- a/coders/uyvy.c
+++ b/coders/uyvy.c
@@ -162,11 +162,11 @@
       SetPixelRed(image,ScaleCharToQuantum(y1),q);
       SetPixelGreen(image,ScaleCharToQuantum(u),q);
       SetPixelBlue(image,ScaleCharToQuantum(v),q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
       SetPixelRed(image,ScaleCharToQuantum(y2),q);
       SetPixelGreen(image,ScaleCharToQuantum(u),q);
       SetPixelBlue(image,ScaleCharToQuantum(v),q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -351,7 +351,7 @@
       pixel.green=(double) GetPixelGreen(uyvy_image,p);
       pixel.blue=(double) GetPixelBlue(uyvy_image,p);
       full=full == MagickFalse ? MagickTrue : MagickFalse;
-      p+=GetPixelComponents(uyvy_image);
+      p+=GetPixelChannels(uyvy_image);
     }
     status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
       image->rows);
diff --git a/coders/viff.c b/coders/viff.c
index 7463941..a4fae9d 100644
--- a/coders/viff.c
+++ b/coders/viff.c
@@ -632,7 +632,7 @@
                   quantum|=0x01;
                   SetPixelIndex(image,quantum,q);
                 }
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             p++;
           }
@@ -644,7 +644,7 @@
                     quantum=(size_t) GetPixelIndex(image,q);
                     quantum|=0x01;
                     SetPixelIndex(image,quantum,q);
-                    q+=GetPixelComponents(image);
+                    q+=GetPixelChannels(image);
                   }
               p++;
             }
@@ -669,7 +669,7 @@
           for (x=0; x < (ssize_t) image->columns; x++)
           {
             SetPixelIndex(image,*p++,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -709,7 +709,7 @@
               SetPixelAlpha(image,image->matte != MagickFalse ?
                 ScaleCharToQuantum(*(p+number_pixels*3)) : OpaqueAlpha,q);
               p++;
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
               break;
@@ -1104,7 +1104,7 @@
             if (image->matte != MagickFalse)
               *(q+number_pixels*3)=ScaleQuantumToChar((Quantum)
                 (GetPixelAlpha(image,p)));
-            p+=GetPixelComponents(image);
+            p+=GetPixelChannels(image);
             q++;
           }
           if (image->previous == (Image *) NULL)
@@ -1150,7 +1150,7 @@
             for (x=0; x < (ssize_t) image->columns; x++)
             {
               *q++=(unsigned char) GetPixelIndex(image,p);
-              p+=GetPixelComponents(image);
+              p+=GetPixelChannels(image);
             }
             if (image->previous == (Image *) NULL)
               {
@@ -1196,7 +1196,7 @@
                     bit=0;
                     byte=0;
                   }
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (bit != 0)
                 *q++=byte >> (8-bit);
@@ -1223,7 +1223,7 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 *q++=(unsigned char) GetPixelIntensity(image,p);
-                p+=GetPixelComponents(image);
+                p+=GetPixelChannels(image);
               }
               if (image->previous == (Image *) NULL)
                 {
diff --git a/coders/wbmp.c b/coders/wbmp.c
index 4464c19..5330f5f 100644
--- a/coders/wbmp.c
+++ b/coders/wbmp.c
@@ -203,7 +203,7 @@
       bit++;
       if (bit == 8)
         bit=0;
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -401,7 +401,7 @@
           bit=0;
           byte=0;
         }
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     if (bit != 0)
       (void) WriteBlobByte(image,byte);
diff --git a/coders/webp.c b/coders/webp.c
index dc4d595..57b07a2 100644
--- a/coders/webp.c
+++ b/coders/webp.c
@@ -177,7 +177,7 @@
       SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
       if (GetPixelAlpha(image,q) != OpaqueAlpha)
         image->matte=MagickTrue;
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -378,7 +378,7 @@
       if (image->matte != MagickFalse)
         *q++=ScaleQuantumToChar((Quantum) (image->matte != MagickFalse ?
           GetPixelAlpha(image,p) : OpaqueAlpha));
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
       image->rows);
diff --git a/coders/wpg.c b/coders/wpg.c
index 02c83da..48587e0 100644
--- a/coders/wpg.c
+++ b/coders/wpg.c
@@ -295,7 +295,7 @@
             index=((*p) & (0x80 >> bit) ? 0x01 : 0x00);
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           p++;
         }
@@ -306,7 +306,7 @@
               index=((*p) & (0x80 >> bit) ? 0x01 : 0x00);
               SetPixelIndex(image,index,q);
               SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             p++;
           }
@@ -324,41 +324,41 @@
             index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             index=ConstrainColormapIndex(image,(*p) & 0x3);
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
             p++;
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
         }
        if ((image->columns % 4) != 0)
           {
             index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             if ((image->columns % 4) >= 1)
 
               {
                 index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
                 SetPixelIndex(image,index,q);
                 SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-                q+=GetPixelComponents(image);
+                q+=GetPixelChannels(image);
                 if ((image->columns % 4) >= 2)
 
                   {
                     index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
                     SetPixelIndex(image,index,q);
                     SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-                    q+=GetPixelComponents(image);
+                    q+=GetPixelChannels(image);
                   }
               }
             p++;
@@ -378,12 +378,12 @@
             index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f);
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             index=ConstrainColormapIndex(image,(*p) & 0x0f);
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
             p++;
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
         if ((image->columns % 2) != 0)
           {
@@ -391,7 +391,7 @@
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
             p++;
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
@@ -408,7 +408,7 @@
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
             p++;
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
@@ -424,7 +424,7 @@
           SetPixelRed(image,ScaleCharToQuantum(*p++),q);
           SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
           SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
-          q+=GetPixelComponents(image);
+          q+=GetPixelChannels(image);
         }
       if (!SyncAuthenticPixels(image,exception))
         break;
diff --git a/coders/xbm.c b/coders/xbm.c
index 93a939f..8e0c5fe 100644
--- a/coders/xbm.c
+++ b/coders/xbm.c
@@ -366,7 +366,7 @@
       byte>>=1;
       if (bit == 8)
         bit=0;
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
@@ -562,7 +562,7 @@
           bit=0;
           byte=0;
         }
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
     if (bit != 0)
       {
diff --git a/coders/xc.c b/coders/xc.c
index 15ca73d..82a6483 100644
--- a/coders/xc.c
+++ b/coders/xc.c
@@ -147,7 +147,7 @@
       SetPixelPacket(image,&pixel,q);
       if (image->colorspace == CMYKColorspace)
         SetPixelBlack(image,pixel.black,q);
-      q+=GetPixelComponents(image);
+      q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
diff --git a/coders/xcf.c b/coders/xcf.c
index 562bb07..26bc193 100644
--- a/coders/xcf.c
+++ b/coders/xcf.c
@@ -381,7 +381,7 @@
           SetPixelAlpha(tile_image,ScaleCharToQuantum((unsigned char)
             inLayerInfo->alpha),q);
           graydata++;
-          q+=GetPixelComponents(tile_image);
+          q+=GetPixelChannels(tile_image);
         }
       }
     else
@@ -395,7 +395,7 @@
             SetPixelAlpha(tile_image,xcfdata->alpha == 0U ? OpaqueAlpha :
               ScaleCharToQuantum((unsigned char) inLayerInfo->alpha),q);
             xcfdata++;
-            q+=GetPixelComponents(tile_image);
+            q+=GetPixelChannels(tile_image);
           }
         }
      if (SyncAuthenticPixels(tile_image,exception) == MagickFalse)
@@ -509,7 +509,7 @@
                   break;
                 }
               }
-              q+=GetPixelComponents(tile_image);
+              q+=GetPixelChannels(tile_image);
             }
           }
         else
@@ -569,7 +569,7 @@
                   break;
                 }
               }
-              q+=GetPixelComponents(tile_image);
+              q+=GetPixelChannels(tile_image);
             }
           }
       }
diff --git a/coders/xpm.c b/coders/xpm.c
index a4011b1..d13703c 100644
--- a/coders/xpm.c
+++ b/coders/xpm.c
@@ -407,7 +407,7 @@
             SetPixelIndex(image,j,r);
           SetPixelPacket(image,image->colormap+j,r);
           p+=width;
-          r+=GetPixelComponents(image);
+          r+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
@@ -683,7 +683,7 @@
                 transparent=MagickTrue;
               else
                 SetPixelAlpha(picon,OpaqueAlpha,q);
-              q+=GetPixelComponents(picon);
+              q+=GetPixelChannels(picon);
             }
             if (SyncAuthenticPixels(picon,exception) == MagickFalse)
               break;
@@ -708,7 +708,7 @@
         {
           if (GetPixelAlpha(image,q) == (Quantum) TransparentAlpha)
             SetPixelIndex(picon,picon->colors,q);
-          q+=GetPixelComponents(picon);
+          q+=GetPixelChannels(picon);
         }
         if (SyncAuthenticPixels(picon,exception) == MagickFalse)
           break;
@@ -787,7 +787,7 @@
       symbol[j]='\0';
       (void) CopyMagickString(buffer,symbol,MaxTextExtent);
       (void) WriteBlobString(image,buffer);
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     (void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
       y == (ssize_t) (picon->rows-1) ? "" : ",");
@@ -1015,7 +1015,7 @@
       symbol[j]='\0';
       (void) CopyMagickString(buffer,symbol,MaxTextExtent);
       (void) WriteBlobString(image,buffer);
-      p+=GetPixelComponents(image);
+      p+=GetPixelChannels(image);
     }
     (void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
       (y == (ssize_t) (image->rows-1) ? "" : ","));
diff --git a/coders/xwd.c b/coders/xwd.c
index 48776be..3223e46 100644
--- a/coders/xwd.c
+++ b/coders/xwd.c
@@ -412,7 +412,7 @@
               index=(Quantum) ((pixel >> blue_shift) & blue_mask);
               SetPixelBlue(image,ScaleShortToQuantum(
                 colors[(ssize_t) index].blue),q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
               break;
@@ -442,7 +442,7 @@
               color=(color*65535UL)/blue_mask;
               SetPixelBlue(image,ScaleShortToQuantum((unsigned short)
                 color),q);
-              q+=GetPixelComponents(image);
+              q+=GetPixelChannels(image);
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
               break;
@@ -477,7 +477,7 @@
               (int) y));
             SetPixelIndex(image,index,q);
             SetPixelPacket(image,image->colormap+(ssize_t) index,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -765,7 +765,7 @@
         for (x=0; x < (ssize_t) image->columns; x++)
         {
           *q++=(unsigned char) GetPixelIndex(image,p);
-          p+=GetPixelComponents(image);
+          p+=GetPixelChannels(image);
         }
       }
     else
@@ -774,7 +774,7 @@
         *q++=ScaleQuantumToChar(GetPixelRed(image,p));
         *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
         *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
-        p+=GetPixelComponents(image);
+        p+=GetPixelChannels(image);
       }
     for (x=0; x < (ssize_t) scanline_pad; x++)
       *q++='\0';
diff --git a/coders/ycbcr.c b/coders/ycbcr.c
index f156d37..305291d 100644
--- a/coders/ycbcr.c
+++ b/coders/ycbcr.c
@@ -249,8 +249,8 @@
                 SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
                 if (image->matte != MagickFalse)
                   SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -341,8 +341,8 @@
                     default:
                       break;
                   }
-                  p+=GetPixelComponents(canvas_image);
-                  q+=GetPixelComponents(image);
+                  p+=GetPixelChannels(canvas_image);
+                  q+=GetPixelChannels(image);
                 }
                 if (SyncAuthenticPixels(image,exception) == MagickFalse)
                   break;
@@ -398,8 +398,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -441,8 +441,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -484,8 +484,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -530,8 +530,8 @@
                   for (x=0; x < (ssize_t) image->columns; x++)
                   {
                     SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
-                    p+=GetPixelComponents(canvas_image);
-                    q+=GetPixelComponents(image);
+                    p+=GetPixelChannels(canvas_image);
+                    q+=GetPixelChannels(image);
                   }
                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
                     break;
@@ -608,8 +608,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -670,8 +670,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -732,8 +732,8 @@
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
-                p+=GetPixelComponents(canvas_image);
-                q+=GetPixelComponents(image);
+                p+=GetPixelChannels(canvas_image);
+                q+=GetPixelChannels(image);
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
@@ -797,8 +797,8 @@
                   for (x=0; x < (ssize_t) image->columns; x++)
                   {
                     SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
-                    p+=GetPixelComponents(canvas_image);
-                    q+=GetPixelComponents(image);
+                    p+=GetPixelChannels(canvas_image);
+                    q+=GetPixelChannels(image);
                   }
                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
                     break;
diff --git a/coders/yuv.c b/coders/yuv.c
index c9177dc..5776b94 100644
--- a/coders/yuv.c
+++ b/coders/yuv.c
@@ -257,7 +257,7 @@
               }
             SetPixelGreen(image,0,q);
             SetPixelBlue(image,0,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
             SetPixelGreen(image,0,q);
             SetPixelBlue(image,0,q);
             if (quantum == 1)
@@ -276,7 +276,7 @@
                 p+=2;
               }
             chroma_pixels++;
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
         }
       else
@@ -298,7 +298,7 @@
               }
             SetPixelGreen(image,0,q);
             SetPixelBlue(image,0,q);
-            q+=GetPixelComponents(image);
+            q+=GetPixelChannels(image);
           }
         }
       if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -347,7 +347,7 @@
                 p+=2;
               }
             SetPixelBlue(chroma_image,0,q);
-            q+=GetPixelComponents(chroma_image);
+            q+=GetPixelChannels(chroma_image);
           }
           if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)
             break;
@@ -381,7 +381,7 @@
                 *(p+1)),q);
               p+=2;
             }
-          q+=GetPixelComponents(chroma_image);
+          q+=GetPixelChannels(chroma_image);
         }
         if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)
           break;
@@ -408,7 +408,7 @@
         SetPixelGreen(image,GetPixelGreen(image,chroma_pixels),q);
         SetPixelBlue(image,GetPixelBlue(image,chroma_pixels),q);
         chroma_pixels++;
-        q+=GetPixelComponents(image);
+        q+=GetPixelChannels(image);
       }
       if (SyncAuthenticPixels(image,exception) == MagickFalse)
         break;
@@ -673,7 +673,7 @@
                   GetPixelGreen(yuv_image,s)));
                 (void) WriteBlobByte(image,ScaleQuantumToChar(
                   GetPixelRed(yuv_image,p)));
-                p+=GetPixelComponents(yuv_image);
+                p+=GetPixelChannels(yuv_image);
                 (void) WriteBlobByte(image,ScaleQuantumToChar(
                   GetPixelBlue(yuv_image,s)));
                 (void) WriteBlobByte(image,ScaleQuantumToChar(
@@ -685,13 +685,13 @@
                   GetPixelGreen(yuv_image,s)));
                 (void) WriteBlobShort(image,ScaleQuantumToShort(
                   GetPixelRed(yuv_image,p)));
-                p+=GetPixelComponents(yuv_image);
+                p+=GetPixelChannels(yuv_image);
                 (void) WriteBlobByte(image,ScaleQuantumToChar(
                   GetPixelBlue(yuv_image,s)));
                 (void) WriteBlobShort(image,ScaleQuantumToShort(
                   GetPixelRed(yuv_image,p)));
               }
-            p+=GetPixelComponents(yuv_image);
+            p+=GetPixelChannels(yuv_image);
             s++;
             x++;
           }
@@ -724,7 +724,7 @@
             else
               (void) WriteBlobShort(image,ScaleQuantumToShort(
                 GetPixelRed(yuv_image,p)));
-            p+=GetPixelComponents(yuv_image);
+            p+=GetPixelChannels(yuv_image);
           }
           if (image->previous == (Image *) NULL)
             {
@@ -767,7 +767,7 @@
             else
               (void) WriteBlobShort(image,ScaleQuantumToShort(
                 GetPixelGreen(chroma_image,p)));
-            p+=GetPixelComponents(chroma_image);
+            p+=GetPixelChannels(chroma_image);
           }
         }
         if (image->previous == (Image *) NULL)
@@ -802,7 +802,7 @@
             else
               (void) WriteBlobShort(image,ScaleQuantumToShort(
                 GetPixelBlue(chroma_image,p)));
-            p+=GetPixelComponents(chroma_image);
+            p+=GetPixelChannels(chroma_image);
           }
         }
         if (image->previous == (Image *) NULL)