granicus.if.org Git - imagemagick/blob - magick/pixel.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                      PPPP   IIIII  X   X  EEEEE  L                          %
   7 %                      P   P    I     X X   E      L                          %
   8 %                      PPPP     I      X    EEE    L                          %
   9 %                      P        I     X X   E      L                          %
  10 %                      P      IIIII  X   X  EEEEE  LLLLL                      %
  11 %                                                                             %
  12 %                  MagickCore Methods to Import/Export Pixels                 %
  13 %                                                                             %
  14 %                             Software Design                                 %
  15 %                               John Cristy                                   %
  16 %                               October 1998                                  %
  17 %                                                                             %
  18 %                                                                             %
  19 %  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
  20 %  dedicated to making software imaging solutions freely available.           %
  21 %                                                                             %
  22 %  You may not use this file except in compliance with the License.  You may  %
  23 %  obtain a copy of the License at                                            %
  24 %                                                                             %
  25 %    http://www.imagemagick.org/script/license.php                            %
  26 %                                                                             %
  27 %  Unless required by applicable law or agreed to in writing, software        %
  28 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  29 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  30 %  See the License for the specific language governing permissions and        %
  31 %  limitations under the License.                                             %
  32 %                                                                             %
  33 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  34 %
  35 %
  36 */
  37 \f
  38 /*
  39   Include declarations.
  40 */
  41 #include "magick/studio.h"
  42 #include "magick/property.h"
  43 #include "magick/blob.h"
  44 #include "magick/blob-private.h"
  45 #include "magick/color-private.h"
  46 #include "magick/exception.h"
  47 #include "magick/exception-private.h"
  48 #include "magick/cache.h"
  49 #include "magick/constitute.h"
  50 #include "magick/delegate.h"
  51 #include "magick/geometry.h"
  52 #include "magick/list.h"
  53 #include "magick/magick.h"
  54 #include "magick/memory_.h"
  55 #include "magick/monitor.h"
  56 #include "magick/option.h"
  57 #include "magick/pixel.h"
  58 #include "magick/pixel-private.h"
  59 #include "magick/quantum.h"
  60 #include "magick/resource_.h"
  61 #include "magick/semaphore.h"
  62 #include "magick/statistic.h"
  63 #include "magick/stream.h"
  64 #include "magick/string_.h"
  65 #include "magick/utility.h"
  66 \f
  67 /*
  68 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  69 %                                                                             %
  70 %                                                                             %
  71 %                                                                             %
  72 %   E x p o r t I m a g e P i x e l s                                         %
  73 %                                                                             %
  74 %                                                                             %
  75 %                                                                             %
  76 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  77 %
  78 %  ExportImagePixels() extracts pixel data from an image and returns it to you.
  79 %  The method returns MagickTrue on success otherwise MagickFalse if an error is
  80 %  encountered.  The data is returned as char, short int, int, ssize_t, float,
  81 %  or double in the order specified by map.
  82 %
  83 %  Suppose you want to extract the first scanline of a 640x480 image as
  84 %  character data in red-green-blue order:
  85 %
  86 %      ExportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels,exception);
  87 %
  88 %  The format of the ExportImagePixels method is:
  89 %
  90 %      MagickBooleanType ExportImagePixels(const Image *image,
  91 %        const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
  92 %        const size_t rows,const char *map,const StorageType type,
  93 %        void *pixels,ExceptionInfo *exception)
  94 %
  95 %  A description of each parameter follows:
  96 %
  97 %    o image: the image.
  98 %
  99 %    o x_offset,y_offset,columns,rows:  These values define the perimeter
 100 %      of a region of pixels you want to extract.
 101 %
 102 %    o map:  This string reflects the expected ordering of the pixel array.
 103 %      It can be any combination or order of R = red, G = green, B = blue,
 104 %      A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
 105 %      Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
 106 %      P = pad.
 107 %
 108 %    o type: Define the data type of the pixels.  Float and double types are
 109 %      normalized to [0..1] otherwise [0..QuantumRange].  Choose from these
 110 %      types: CharPixel, DoublePixel, FloatPixel, IntegerPixel, LongPixel,
 111 %      QuantumPixel, or ShortPixel.
 112 %
 113 %    o pixels: This array of values contain the pixel components as defined by
 114 %      map and type.  You must preallocate this array where the expected
 115 %      length varies depending on the values of width, height, map, and type.
 116 %
 117 %    o exception: return any errors or warnings in this structure.
 118 %
 119 */
 120 MagickExport MagickBooleanType ExportImagePixels(const Image *image,
 121   const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
 122   const size_t rows,const char *map,const StorageType type,void *pixels,
 123   ExceptionInfo *exception)
 124 {
 125   QuantumType
 126     *quantum_map;
 127
 128   register ssize_t
 129     i,
 130     x;
 131
 132   register const IndexPacket
 133     *indexes;
 134
 135   register const PixelPacket
 136     *p;
 137
 138   size_t
 139     length;
 140
 141   ssize_t
 142     y;
 143
 144   assert(image != (Image *) NULL);
 145   assert(image->signature == MagickSignature);
 146   if (image->debug != MagickFalse)
 147     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 148   length=strlen(map);
 149   quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
 150   if (quantum_map == (QuantumType *) NULL)
 151     {
 152       (void) ThrowMagickException(exception,GetMagickModule(),
 153         ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
 154       return(MagickFalse);
 155     }
 156   for (i=0; i < (ssize_t) length; i++)
 157   {
 158     switch (map[i])
 159     {
 160       case 'A':
 161       case 'a':
 162       {
 163         quantum_map[i]=AlphaQuantum;
 164         break;
 165       }
 166       case 'B':
 167       case 'b':
 168       {
 169         quantum_map[i]=BlueQuantum;
 170         break;
 171       }
 172       case 'C':
 173       case 'c':
 174       {
 175         quantum_map[i]=CyanQuantum;
 176         if (image->colorspace == CMYKColorspace)
 177           break;
 178         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 179         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 180           "ColorSeparatedImageRequired","`%s'",map);
 181         return(MagickFalse);
 182       }
 183       case 'g':
 184       case 'G':
 185       {
 186         quantum_map[i]=GreenQuantum;
 187         break;
 188       }
 189       case 'I':
 190       case 'i':
 191       {
 192         quantum_map[i]=IndexQuantum;
 193         break;
 194       }
 195       case 'K':
 196       case 'k':
 197       {
 198         quantum_map[i]=BlackQuantum;
 199         if (image->colorspace == CMYKColorspace)
 200           break;
 201         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 202         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 203           "ColorSeparatedImageRequired","`%s'",map);
 204         return(MagickFalse);
 205       }
 206       case 'M':
 207       case 'm':
 208       {
 209         quantum_map[i]=MagentaQuantum;
 210         if (image->colorspace == CMYKColorspace)
 211           break;
 212         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 213         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 214           "ColorSeparatedImageRequired","`%s'",map);
 215         return(MagickFalse);
 216       }
 217       case 'o':
 218       case 'O':
 219       {
 220         quantum_map[i]=OpacityQuantum;
 221         break;
 222       }
 223       case 'P':
 224       case 'p':
 225       {
 226         quantum_map[i]=UndefinedQuantum;
 227         break;
 228       }
 229       case 'R':
 230       case 'r':
 231       {
 232         quantum_map[i]=RedQuantum;
 233         break;
 234       }
 235       case 'Y':
 236       case 'y':
 237       {
 238         quantum_map[i]=YellowQuantum;
 239         if (image->colorspace == CMYKColorspace)
 240           break;
 241         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 242         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 243           "ColorSeparatedImageRequired","`%s'",map);
 244         return(MagickFalse);
 245       }
 246       default:
 247       {
 248         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 249         (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
 250           "UnrecognizedPixelMap","`%s'",map);
 251         return(MagickFalse);
 252       }
 253     }
 254   }
 255   switch (type)
 256   {
 257     case CharPixel:
 258     {
 259       register unsigned char
 260         *q;
 261
 262       q=(unsigned char *) pixels;
 263       if (LocaleCompare(map,"BGR") == 0)
 264         {
 265           for (y=0; y < (ssize_t) rows; y++)
 266           {
 267             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 268             if (p == (const PixelPacket *) NULL)
 269               break;
 270             for (x=0; x < (ssize_t) columns; x++)
 271             {
 272               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 273               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 274               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 275               p++;
 276             }
 277           }
 278           break;
 279         }
 280       if (LocaleCompare(map,"BGRA") == 0)
 281         {
 282           for (y=0; y < (ssize_t) rows; y++)
 283           {
 284             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 285             if (p == (const PixelPacket *) NULL)
 286               break;
 287             for (x=0; x < (ssize_t) columns; x++)
 288             {
 289               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 290               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 291               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 292               *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
 293               p++;
 294             }
 295           }
 296           break;
 297         }
 298       if (LocaleCompare(map,"BGRP") == 0)
 299         {
 300           for (y=0; y < (ssize_t) rows; y++)
 301           {
 302             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 303             if (p == (const PixelPacket *) NULL)
 304               break;
 305             for (x=0; x < (ssize_t) columns; x++)
 306             {
 307               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 308               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 309               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 310               *q++=ScaleQuantumToChar((Quantum) 0);
 311               p++;
 312             }
 313           }
 314           break;
 315         }
 316       if (LocaleCompare(map,"I") == 0)
 317         {
 318           for (y=0; y < (ssize_t) rows; y++)
 319           {
 320             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 321             if (p == (const PixelPacket *) NULL)
 322               break;
 323             for (x=0; x < (ssize_t) columns; x++)
 324             {
 325               *q++=ScaleQuantumToChar(PixelIntensityToQuantum(p));
 326               p++;
 327             }
 328           }
 329           break;
 330         }
 331       if (LocaleCompare(map,"RGB") == 0)
 332         {
 333           for (y=0; y < (ssize_t) rows; y++)
 334           {
 335             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 336             if (p == (const PixelPacket *) NULL)
 337               break;
 338             for (x=0; x < (ssize_t) columns; x++)
 339             {
 340               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 341               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 342               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 343               p++;
 344             }
 345           }
 346           break;
 347         }
 348       if (LocaleCompare(map,"RGBA") == 0)
 349         {
 350           for (y=0; y < (ssize_t) rows; y++)
 351           {
 352             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 353             if (p == (const PixelPacket *) NULL)
 354               break;
 355             for (x=0; x < (ssize_t) columns; x++)
 356             {
 357               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 358               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 359               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 360               *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
 361               p++;
 362             }
 363           }
 364           break;
 365         }
 366       if (LocaleCompare(map,"RGBP") == 0)
 367         {
 368           for (y=0; y < (ssize_t) rows; y++)
 369           {
 370             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 371             if (p == (const PixelPacket *) NULL)
 372               break;
 373             for (x=0; x < (ssize_t) columns; x++)
 374             {
 375               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 376               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 377               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 378               *q++=ScaleQuantumToChar((Quantum) 0);
 379               p++;
 380             }
 381           }
 382           break;
 383         }
 384       for (y=0; y < (ssize_t) rows; y++)
 385       {
 386         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 387         if (p == (const PixelPacket *) NULL)
 388           break;
 389         indexes=GetVirtualIndexQueue(image);
 390         for (x=0; x < (ssize_t) columns; x++)
 391         {
 392           for (i=0; i < (ssize_t) length; i++)
 393           {
 394             *q=0;
 395             switch (quantum_map[i])
 396             {
 397               case RedQuantum:
 398               case CyanQuantum:
 399               {
 400                 *q=ScaleQuantumToChar(GetRedPixelComponent(p));
 401                 break;
 402               }
 403               case GreenQuantum:
 404               case MagentaQuantum:
 405               {
 406                 *q=ScaleQuantumToChar(GetGreenPixelComponent(p));
 407                 break;
 408               }
 409               case BlueQuantum:
 410               case YellowQuantum:
 411               {
 412                 *q=ScaleQuantumToChar(GetBluePixelComponent(p));
 413                 break;
 414               }
 415               case AlphaQuantum:
 416               {
 417                 *q=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
 418                 break;
 419               }
 420               case OpacityQuantum:
 421               {
 422                 *q=ScaleQuantumToChar(GetOpacityPixelComponent(p));
 423                 break;
 424               }
 425               case BlackQuantum:
 426               {
 427                 if (image->colorspace == CMYKColorspace)
 428                   *q=ScaleQuantumToChar(indexes[x]);
 429                 break;
 430               }
 431               case IndexQuantum:
 432               {
 433                 *q=ScaleQuantumToChar(PixelIntensityToQuantum(p));
 434                 break;
 435               }
 436               default:
 437                 break;
 438             }
 439             q++;
 440           }
 441           p++;
 442         }
 443       }
 444       break;
 445     }
 446     case DoublePixel:
 447     {
 448       register double
 449         *q;
 450
 451       q=(double *) pixels;
 452       if (LocaleCompare(map,"BGR") == 0)
 453         {
 454           for (y=0; y < (ssize_t) rows; y++)
 455           {
 456             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 457             if (p == (const PixelPacket *) NULL)
 458               break;
 459             for (x=0; x < (ssize_t) columns; x++)
 460             {
 461               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 462               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 463               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 464               p++;
 465             }
 466           }
 467           break;
 468         }
 469       if (LocaleCompare(map,"BGRA") == 0)
 470         {
 471           for (y=0; y < (ssize_t) rows; y++)
 472           {
 473             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 474             if (p == (const PixelPacket *) NULL)
 475               break;
 476             for (x=0; x < (ssize_t) columns; x++)
 477             {
 478               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 479               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 480               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 481               *q++=(double) (QuantumScale*((Quantum) (QuantumRange-
 482                 GetOpacityPixelComponent(p))));
 483               p++;
 484             }
 485           }
 486           break;
 487         }
 488       if (LocaleCompare(map,"BGRP") == 0)
 489         {
 490           for (y=0; y < (ssize_t) rows; y++)
 491           {
 492             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 493             if (p == (const PixelPacket *) NULL)
 494               break;
 495             for (x=0; x < (ssize_t) columns; x++)
 496             {
 497               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 498               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 499               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 500               *q++=0.0;
 501               p++;
 502             }
 503           }
 504           break;
 505         }
 506       if (LocaleCompare(map,"I") == 0)
 507         {
 508           for (y=0; y < (ssize_t) rows; y++)
 509           {
 510             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 511             if (p == (const PixelPacket *) NULL)
 512               break;
 513             for (x=0; x < (ssize_t) columns; x++)
 514             {
 515               *q++=(double) (QuantumScale*PixelIntensityToQuantum(p));
 516               p++;
 517             }
 518           }
 519           break;
 520         }
 521       if (LocaleCompare(map,"RGB") == 0)
 522         {
 523           for (y=0; y < (ssize_t) rows; y++)
 524           {
 525             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 526             if (p == (const PixelPacket *) NULL)
 527               break;
 528             for (x=0; x < (ssize_t) columns; x++)
 529             {
 530               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 531               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 532               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 533               p++;
 534             }
 535           }
 536           break;
 537         }
 538       if (LocaleCompare(map,"RGBA") == 0)
 539         {
 540           for (y=0; y < (ssize_t) rows; y++)
 541           {
 542             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 543             if (p == (const PixelPacket *) NULL)
 544               break;
 545             for (x=0; x < (ssize_t) columns; x++)
 546             {
 547               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 548               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 549               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 550               *q++=(double) (QuantumScale*((Quantum) (QuantumRange-
 551                 GetOpacityPixelComponent(p))));
 552               p++;
 553             }
 554           }
 555           break;
 556         }
 557       if (LocaleCompare(map,"RGBP") == 0)
 558         {
 559           for (y=0; y < (ssize_t) rows; y++)
 560           {
 561             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 562             if (p == (const PixelPacket *) NULL)
 563               break;
 564             for (x=0; x < (ssize_t) columns; x++)
 565             {
 566               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 567               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 568               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 569               *q++=0.0;
 570               p++;
 571             }
 572           }
 573           break;
 574         }
 575       for (y=0; y < (ssize_t) rows; y++)
 576       {
 577         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 578         if (p == (const PixelPacket *) NULL)
 579           break;
 580         indexes=GetVirtualIndexQueue(image);
 581         for (x=0; x < (ssize_t) columns; x++)
 582         {
 583           for (i=0; i < (ssize_t) length; i++)
 584           {
 585             *q=0;
 586             switch (quantum_map[i])
 587             {
 588               case RedQuantum:
 589               case CyanQuantum:
 590               {
 591                 *q=(double) (QuantumScale*GetRedPixelComponent(p));
 592                 break;
 593               }
 594               case GreenQuantum:
 595               case MagentaQuantum:
 596               {
 597                 *q=(double) (QuantumScale*GetGreenPixelComponent(p));
 598                 break;
 599               }
 600               case BlueQuantum:
 601               case YellowQuantum:
 602               {
 603                 *q=(double) (QuantumScale*GetBluePixelComponent(p));
 604                 break;
 605               }
 606               case AlphaQuantum:
 607               {
 608                 *q=(double) (QuantumScale*((Quantum) (QuantumRange-
 609                   GetOpacityPixelComponent(p))));
 610                 break;
 611               }
 612               case OpacityQuantum:
 613               {
 614                 *q=(double) (QuantumScale*GetOpacityPixelComponent(p));
 615                 break;
 616               }
 617               case BlackQuantum:
 618               {
 619                 if (image->colorspace == CMYKColorspace)
 620                   *q=(double) (QuantumScale*indexes[x]);
 621                 break;
 622               }
 623               case IndexQuantum:
 624               {
 625                 *q=(double) (QuantumScale*PixelIntensityToQuantum(p));
 626                 break;
 627               }
 628               default:
 629                 *q=0;
 630             }
 631             q++;
 632           }
 633           p++;
 634         }
 635       }
 636       break;
 637     }
 638     case FloatPixel:
 639     {
 640       register float
 641         *q;
 642
 643       q=(float *) pixels;
 644       if (LocaleCompare(map,"BGR") == 0)
 645         {
 646           for (y=0; y < (ssize_t) rows; y++)
 647           {
 648             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 649             if (p == (const PixelPacket *) NULL)
 650               break;
 651             for (x=0; x < (ssize_t) columns; x++)
 652             {
 653               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 654               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 655               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 656               p++;
 657             }
 658           }
 659           break;
 660         }
 661       if (LocaleCompare(map,"BGRA") == 0)
 662         {
 663           for (y=0; y < (ssize_t) rows; y++)
 664           {
 665             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 666             if (p == (const PixelPacket *) NULL)
 667               break;
 668             for (x=0; x < (ssize_t) columns; x++)
 669             {
 670               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 671               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 672               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 673               *q++=(float) (QuantumScale*(Quantum) (GetAlphaPixelComponent(p)));
 674               p++;
 675             }
 676           }
 677           break;
 678         }
 679       if (LocaleCompare(map,"BGRP") == 0)
 680         {
 681           for (y=0; y < (ssize_t) rows; y++)
 682           {
 683             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 684             if (p == (const PixelPacket *) NULL)
 685               break;
 686             for (x=0; x < (ssize_t) columns; x++)
 687             {
 688               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 689               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 690               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 691               *q++=0.0;
 692               p++;
 693             }
 694           }
 695           break;
 696         }
 697       if (LocaleCompare(map,"I") == 0)
 698         {
 699           for (y=0; y < (ssize_t) rows; y++)
 700           {
 701             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 702             if (p == (const PixelPacket *) NULL)
 703               break;
 704             for (x=0; x < (ssize_t) columns; x++)
 705             {
 706               *q++=(float) (QuantumScale*PixelIntensityToQuantum(p));
 707               p++;
 708             }
 709           }
 710           break;
 711         }
 712       if (LocaleCompare(map,"RGB") == 0)
 713         {
 714           for (y=0; y < (ssize_t) rows; y++)
 715           {
 716             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 717             if (p == (const PixelPacket *) NULL)
 718               break;
 719             for (x=0; x < (ssize_t) columns; x++)
 720             {
 721               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 722               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 723               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 724               p++;
 725             }
 726           }
 727           break;
 728         }
 729       if (LocaleCompare(map,"RGBA") == 0)
 730         {
 731           for (y=0; y < (ssize_t) rows; y++)
 732           {
 733             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 734             if (p == (const PixelPacket *) NULL)
 735               break;
 736             for (x=0; x < (ssize_t) columns; x++)
 737             {
 738               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 739               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 740               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 741               *q++=(float) (QuantumScale*((Quantum) (GetAlphaPixelComponent(p))));
 742               p++;
 743             }
 744           }
 745           break;
 746         }
 747       if (LocaleCompare(map,"RGBP") == 0)
 748         {
 749           for (y=0; y < (ssize_t) rows; y++)
 750           {
 751             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 752             if (p == (const PixelPacket *) NULL)
 753               break;
 754             for (x=0; x < (ssize_t) columns; x++)
 755             {
 756               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 757               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 758               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 759               *q++=0.0;
 760               p++;
 761             }
 762           }
 763           break;
 764         }
 765       for (y=0; y < (ssize_t) rows; y++)
 766       {
 767         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 768         if (p == (const PixelPacket *) NULL)
 769           break;
 770         indexes=GetVirtualIndexQueue(image);
 771         for (x=0; x < (ssize_t) columns; x++)
 772         {
 773           for (i=0; i < (ssize_t) length; i++)
 774           {
 775             *q=0;
 776             switch (quantum_map[i])
 777             {
 778               case RedQuantum:
 779               case CyanQuantum:
 780               {
 781                 *q=(float) (QuantumScale*GetRedPixelComponent(p));
 782                 break;
 783               }
 784               case GreenQuantum:
 785               case MagentaQuantum:
 786               {
 787                 *q=(float) (QuantumScale*GetGreenPixelComponent(p));
 788                 break;
 789               }
 790               case BlueQuantum:
 791               case YellowQuantum:
 792               {
 793                 *q=(float) (QuantumScale*GetBluePixelComponent(p));
 794                 break;
 795               }
 796               case AlphaQuantum:
 797               {
 798                 *q=(float) (QuantumScale*((Quantum) (GetAlphaPixelComponent(p))));
 799                 break;
 800               }
 801               case OpacityQuantum:
 802               {
 803                 *q=(float) (QuantumScale*GetOpacityPixelComponent(p));
 804                 break;
 805               }
 806               case BlackQuantum:
 807               {
 808                 if (image->colorspace == CMYKColorspace)
 809                   *q=(float) (QuantumScale*indexes[x]);
 810                 break;
 811               }
 812               case IndexQuantum:
 813               {
 814                 *q=(float) (QuantumScale*PixelIntensityToQuantum(p));
 815                 break;
 816               }
 817               default:
 818                 *q=0;
 819             }
 820             q++;
 821           }
 822           p++;
 823         }
 824       }
 825       break;
 826     }
 827     case IntegerPixel:
 828     {
 829       register unsigned int
 830         *q;
 831
 832       q=(unsigned int *) pixels;
 833       if (LocaleCompare(map,"BGR") == 0)
 834         {
 835           for (y=0; y < (ssize_t) rows; y++)
 836           {
 837             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 838             if (p == (const PixelPacket *) NULL)
 839               break;
 840             for (x=0; x < (ssize_t) columns; x++)
 841             {
 842               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 843               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 844               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 845               p++;
 846             }
 847           }
 848           break;
 849         }
 850       if (LocaleCompare(map,"BGRA") == 0)
 851         {
 852           for (y=0; y < (ssize_t) rows; y++)
 853           {
 854             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 855             if (p == (const PixelPacket *) NULL)
 856               break;
 857             for (x=0; x < (ssize_t) columns; x++)
 858             {
 859               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 860               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 861               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 862               *q++=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
 863                 GetOpacityPixelComponent(p)));
 864               p++;
 865             }
 866           }
 867           break;
 868         }
 869       if (LocaleCompare(map,"BGRP") == 0)
 870         {
 871           for (y=0; y < (ssize_t) rows; y++)
 872           {
 873             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 874             if (p == (const PixelPacket *) NULL)
 875               break;
 876             for (x=0; x < (ssize_t) columns; x++)
 877             {
 878               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 879               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 880               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 881               *q++=0U;
 882               p++;
 883             }
 884           }
 885           break;
 886         }
 887       if (LocaleCompare(map,"I") == 0)
 888         {
 889           for (y=0; y < (ssize_t) rows; y++)
 890           {
 891             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 892             if (p == (const PixelPacket *) NULL)
 893               break;
 894             for (x=0; x < (ssize_t) columns; x++)
 895             {
 896               *q++=(unsigned int)
 897                 ScaleQuantumToLong(PixelIntensityToQuantum(p));
 898               p++;
 899             }
 900           }
 901           break;
 902         }
 903       if (LocaleCompare(map,"RGB") == 0)
 904         {
 905           for (y=0; y < (ssize_t) rows; y++)
 906           {
 907             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 908             if (p == (const PixelPacket *) NULL)
 909               break;
 910             for (x=0; x < (ssize_t) columns; x++)
 911             {
 912               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 913               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 914               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 915               p++;
 916             }
 917           }
 918           break;
 919         }
 920       if (LocaleCompare(map,"RGBA") == 0)
 921         {
 922           for (y=0; y < (ssize_t) rows; y++)
 923           {
 924             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 925             if (p == (const PixelPacket *) NULL)
 926               break;
 927             for (x=0; x < (ssize_t) columns; x++)
 928             {
 929               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 930               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 931               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 932               *q++=(unsigned int) ScaleQuantumToLong((Quantum)
 933                 (GetAlphaPixelComponent(p)));
 934               p++;
 935             }
 936           }
 937           break;
 938         }
 939       if (LocaleCompare(map,"RGBP") == 0)
 940         {
 941           for (y=0; y < (ssize_t) rows; y++)
 942           {
 943             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 944             if (p == (const PixelPacket *) NULL)
 945               break;
 946             for (x=0; x < (ssize_t) columns; x++)
 947             {
 948               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 949               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 950               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 951               *q++=0U;
 952               p++;
 953             }
 954           }
 955           break;
 956         }
 957       for (y=0; y < (ssize_t) rows; y++)
 958       {
 959         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 960         if (p == (const PixelPacket *) NULL)
 961           break;
 962         indexes=GetVirtualIndexQueue(image);
 963         for (x=0; x < (ssize_t) columns; x++)
 964         {
 965           for (i=0; i < (ssize_t) length; i++)
 966           {
 967             *q=0;
 968             switch (quantum_map[i])
 969             {
 970               case RedQuantum:
 971               case CyanQuantum:
 972               {
 973                 *q=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 974                 break;
 975               }
 976               case GreenQuantum:
 977               case MagentaQuantum:
 978               {
 979                 *q=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 980                 break;
 981               }
 982               case BlueQuantum:
 983               case YellowQuantum:
 984               {
 985                 *q=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 986                 break;
 987               }
 988               case AlphaQuantum:
 989               {
 990                 *q=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
 991                   GetOpacityPixelComponent(p)));
 992                 break;
 993               }
 994               case OpacityQuantum:
 995               {
 996                 *q=(unsigned int) ScaleQuantumToLong(GetOpacityPixelComponent(p));
 997                 break;
 998               }
 999               case BlackQuantum:
1000               {
1001                 if (image->colorspace == CMYKColorspace)
1002                   *q=(unsigned int) ScaleQuantumToLong(indexes[x]);
1003                 break;
1004               }
1005               case IndexQuantum:
1006               {
1007                 *q=(unsigned int)
1008                   ScaleQuantumToLong(PixelIntensityToQuantum(p));
1009                 break;
1010               }
1011               default:
1012                 *q=0;
1013             }
1014             q++;
1015           }
1016           p++;
1017         }
1018       }
1019       break;
1020     }
1021     case LongPixel:
1022     {
1023       register size_t
1024         *q;
1025
1026       q=(size_t *) pixels;
1027       if (LocaleCompare(map,"BGR") == 0)
1028         {
1029           for (y=0; y < (ssize_t) rows; y++)
1030           {
1031             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1032             if (p == (const PixelPacket *) NULL)
1033               break;
1034             for (x=0; x < (ssize_t) columns; x++)
1035             {
1036               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1037               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1038               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1039               p++;
1040             }
1041           }
1042           break;
1043         }
1044       if (LocaleCompare(map,"BGRA") == 0)
1045         {
1046           for (y=0; y < (ssize_t) rows; y++)
1047           {
1048             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1049             if (p == (const PixelPacket *) NULL)
1050               break;
1051             for (x=0; x < (ssize_t) columns; x++)
1052             {
1053               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1054               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1055               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1056               *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1057               p++;
1058             }
1059           }
1060           break;
1061         }
1062       if (LocaleCompare(map,"BGRP") == 0)
1063         {
1064           for (y=0; y < (ssize_t) rows; y++)
1065           {
1066             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1067             if (p == (const PixelPacket *) NULL)
1068               break;
1069             for (x=0; x < (ssize_t) columns; x++)
1070             {
1071               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1072               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1073               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1074               *q++=0;
1075               p++;
1076             }
1077           }
1078           break;
1079         }
1080       if (LocaleCompare(map,"I") == 0)
1081         {
1082           for (y=0; y < (ssize_t) rows; y++)
1083           {
1084             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1085             if (p == (const PixelPacket *) NULL)
1086               break;
1087             for (x=0; x < (ssize_t) columns; x++)
1088             {
1089               *q++=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1090               p++;
1091             }
1092           }
1093           break;
1094         }
1095       if (LocaleCompare(map,"RGB") == 0)
1096         {
1097           for (y=0; y < (ssize_t) rows; y++)
1098           {
1099             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1100             if (p == (const PixelPacket *) NULL)
1101               break;
1102             for (x=0; x < (ssize_t) columns; x++)
1103             {
1104               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1105               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1106               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1107               p++;
1108             }
1109           }
1110           break;
1111         }
1112       if (LocaleCompare(map,"RGBA") == 0)
1113         {
1114           for (y=0; y < (ssize_t) rows; y++)
1115           {
1116             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1117             if (p == (const PixelPacket *) NULL)
1118               break;
1119             for (x=0; x < (ssize_t) columns; x++)
1120             {
1121               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1122               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1123               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1124               *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1125               p++;
1126             }
1127           }
1128           break;
1129         }
1130       if (LocaleCompare(map,"RGBP") == 0)
1131         {
1132           for (y=0; y < (ssize_t) rows; y++)
1133           {
1134             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1135             if (p == (const PixelPacket *) NULL)
1136               break;
1137             for (x=0; x < (ssize_t) columns; x++)
1138             {
1139               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1140               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1141               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1142               *q++=0;
1143               p++;
1144             }
1145           }
1146           break;
1147         }
1148       for (y=0; y < (ssize_t) rows; y++)
1149       {
1150         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1151         if (p == (const PixelPacket *) NULL)
1152           break;
1153         indexes=GetVirtualIndexQueue(image);
1154         for (x=0; x < (ssize_t) columns; x++)
1155         {
1156           for (i=0; i < (ssize_t) length; i++)
1157           {
1158             *q=0;
1159             switch (quantum_map[i])
1160             {
1161               case RedQuantum:
1162               case CyanQuantum:
1163               {
1164                 *q=ScaleQuantumToLong(GetRedPixelComponent(p));
1165                 break;
1166               }
1167               case GreenQuantum:
1168               case MagentaQuantum:
1169               {
1170                 *q=ScaleQuantumToLong(GetGreenPixelComponent(p));
1171                 break;
1172               }
1173               case BlueQuantum:
1174               case YellowQuantum:
1175               {
1176                 *q=ScaleQuantumToLong(GetBluePixelComponent(p));
1177                 break;
1178               }
1179               case AlphaQuantum:
1180               {
1181                 *q=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1182                 break;
1183               }
1184               case OpacityQuantum:
1185               {
1186                 *q=ScaleQuantumToLong(GetOpacityPixelComponent(p));
1187                 break;
1188               }
1189               case BlackQuantum:
1190               {
1191                 if (image->colorspace == CMYKColorspace)
1192                   *q=ScaleQuantumToLong(indexes[x]);
1193                 break;
1194               }
1195               case IndexQuantum:
1196               {
1197                 *q=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1198                 break;
1199               }
1200               default:
1201                 break;
1202             }
1203             q++;
1204           }
1205           p++;
1206         }
1207       }
1208       break;
1209     }
1210     case QuantumPixel:
1211     {
1212       register Quantum
1213         *q;
1214
1215       q=(Quantum *) pixels;
1216       if (LocaleCompare(map,"BGR") == 0)
1217         {
1218           for (y=0; y < (ssize_t) rows; y++)
1219           {
1220             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1221             if (p == (const PixelPacket *) NULL)
1222               break;
1223             for (x=0; x < (ssize_t) columns; x++)
1224             {
1225               *q++=GetBluePixelComponent(p);
1226               *q++=GetGreenPixelComponent(p);
1227               *q++=GetRedPixelComponent(p);
1228               p++;
1229             }
1230           }
1231           break;
1232         }
1233       if (LocaleCompare(map,"BGRA") == 0)
1234         {
1235           for (y=0; y < (ssize_t) rows; y++)
1236           {
1237             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1238             if (p == (const PixelPacket *) NULL)
1239               break;
1240             for (x=0; x < (ssize_t) columns; x++)
1241             {
1242               *q++=GetBluePixelComponent(p);
1243               *q++=GetGreenPixelComponent(p);
1244               *q++=GetRedPixelComponent(p);
1245               *q++=(Quantum) (GetAlphaPixelComponent(p));
1246               p++;
1247             }
1248           }
1249           break;
1250         }
1251       if (LocaleCompare(map,"BGRP") == 0)
1252         {
1253           for (y=0; y < (ssize_t) rows; y++)
1254           {
1255             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1256             if (p == (const PixelPacket *) NULL)
1257               break;
1258             for (x=0; x < (ssize_t) columns; x++)
1259             {
1260               *q++=GetBluePixelComponent(p);
1261               *q++=GetGreenPixelComponent(p);
1262               *q++=GetRedPixelComponent(p);
1263               *q++=(Quantum) 0;
1264               p++;
1265             }
1266           }
1267           break;
1268         }
1269       if (LocaleCompare(map,"I") == 0)
1270         {
1271           for (y=0; y < (ssize_t) rows; y++)
1272           {
1273             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1274             if (p == (const PixelPacket *) NULL)
1275               break;
1276             for (x=0; x < (ssize_t) columns; x++)
1277             {
1278               *q++=PixelIntensityToQuantum(p);
1279               p++;
1280             }
1281           }
1282           break;
1283         }
1284       if (LocaleCompare(map,"RGB") == 0)
1285         {
1286           for (y=0; y < (ssize_t) rows; y++)
1287           {
1288             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1289             if (p == (const PixelPacket *) NULL)
1290               break;
1291             for (x=0; x < (ssize_t) columns; x++)
1292             {
1293               *q++=GetRedPixelComponent(p);
1294               *q++=GetGreenPixelComponent(p);
1295               *q++=GetBluePixelComponent(p);
1296               p++;
1297             }
1298           }
1299           break;
1300         }
1301       if (LocaleCompare(map,"RGBA") == 0)
1302         {
1303           for (y=0; y < (ssize_t) rows; y++)
1304           {
1305             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1306             if (p == (const PixelPacket *) NULL)
1307               break;
1308             for (x=0; x < (ssize_t) columns; x++)
1309             {
1310               *q++=GetRedPixelComponent(p);
1311               *q++=GetGreenPixelComponent(p);
1312               *q++=GetBluePixelComponent(p);
1313               *q++=(Quantum) (GetAlphaPixelComponent(p));
1314               p++;
1315             }
1316           }
1317           break;
1318         }
1319       if (LocaleCompare(map,"RGBP") == 0)
1320         {
1321           for (y=0; y < (ssize_t) rows; y++)
1322           {
1323             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1324             if (p == (const PixelPacket *) NULL)
1325               break;
1326             for (x=0; x < (ssize_t) columns; x++)
1327             {
1328               *q++=GetRedPixelComponent(p);
1329               *q++=GetGreenPixelComponent(p);
1330               *q++=GetBluePixelComponent(p);
1331               *q++=(Quantum) 0;
1332               p++;
1333             }
1334           }
1335           break;
1336         }
1337       for (y=0; y < (ssize_t) rows; y++)
1338       {
1339         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1340         if (p == (const PixelPacket *) NULL)
1341           break;
1342         indexes=GetVirtualIndexQueue(image);
1343         for (x=0; x < (ssize_t) columns; x++)
1344         {
1345           for (i=0; i < (ssize_t) length; i++)
1346           {
1347             *q=(Quantum) 0;
1348             switch (quantum_map[i])
1349             {
1350               case RedQuantum:
1351               case CyanQuantum:
1352               {
1353                 *q=GetRedPixelComponent(p);
1354                 break;
1355               }
1356               case GreenQuantum:
1357               case MagentaQuantum:
1358               {
1359                 *q=GetGreenPixelComponent(p);
1360                 break;
1361               }
1362               case BlueQuantum:
1363               case YellowQuantum:
1364               {
1365                 *q=GetBluePixelComponent(p);
1366                 break;
1367               }
1368               case AlphaQuantum:
1369               {
1370                 *q=(Quantum) (GetAlphaPixelComponent(p));
1371                 break;
1372               }
1373               case OpacityQuantum:
1374               {
1375                 *q=GetOpacityPixelComponent(p);
1376                 break;
1377               }
1378               case BlackQuantum:
1379               {
1380                 if (image->colorspace == CMYKColorspace)
1381                   *q=indexes[x];
1382                 break;
1383               }
1384               case IndexQuantum:
1385               {
1386                 *q=(PixelIntensityToQuantum(p));
1387                 break;
1388               }
1389               default:
1390                 *q=(Quantum) 0;
1391             }
1392             q++;
1393           }
1394           p++;
1395         }
1396       }
1397       break;
1398     }
1399     case ShortPixel:
1400     {
1401       register unsigned short
1402         *q;
1403
1404       q=(unsigned short *) pixels;
1405       if (LocaleCompare(map,"BGR") == 0)
1406         {
1407           for (y=0; y < (ssize_t) rows; y++)
1408           {
1409             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1410             if (p == (const PixelPacket *) NULL)
1411               break;
1412             for (x=0; x < (ssize_t) columns; x++)
1413             {
1414               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1415               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1416               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1417               p++;
1418             }
1419           }
1420           break;
1421         }
1422       if (LocaleCompare(map,"BGRA") == 0)
1423         {
1424           for (y=0; y < (ssize_t) rows; y++)
1425           {
1426             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1427             if (p == (const PixelPacket *) NULL)
1428               break;
1429             for (x=0; x < (ssize_t) columns; x++)
1430             {
1431               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1432               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1433               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1434               *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1435               p++;
1436             }
1437           }
1438           break;
1439         }
1440       if (LocaleCompare(map,"BGRP") == 0)
1441         {
1442           for (y=0; y < (ssize_t) rows; y++)
1443           {
1444             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1445             if (p == (const PixelPacket *) NULL)
1446               break;
1447             for (x=0; x < (ssize_t) columns; x++)
1448             {
1449               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1450               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1451               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1452               *q++=0;
1453               p++;
1454             }
1455           }
1456           break;
1457         }
1458       if (LocaleCompare(map,"I") == 0)
1459         {
1460           for (y=0; y < (ssize_t) rows; y++)
1461           {
1462             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1463             if (p == (const PixelPacket *) NULL)
1464               break;
1465             for (x=0; x < (ssize_t) columns; x++)
1466             {
1467               *q++=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1468               p++;
1469             }
1470           }
1471           break;
1472         }
1473       if (LocaleCompare(map,"RGB") == 0)
1474         {
1475           for (y=0; y < (ssize_t) rows; y++)
1476           {
1477             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1478             if (p == (const PixelPacket *) NULL)
1479               break;
1480             for (x=0; x < (ssize_t) columns; x++)
1481             {
1482               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1483               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1484               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1485               p++;
1486             }
1487           }
1488           break;
1489         }
1490       if (LocaleCompare(map,"RGBA") == 0)
1491         {
1492           for (y=0; y < (ssize_t) rows; y++)
1493           {
1494             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1495             if (p == (const PixelPacket *) NULL)
1496               break;
1497             for (x=0; x < (ssize_t) columns; x++)
1498             {
1499               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1500               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1501               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1502               *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1503               p++;
1504             }
1505           }
1506           break;
1507         }
1508       if (LocaleCompare(map,"RGBP") == 0)
1509         {
1510           for (y=0; y < (ssize_t) rows; y++)
1511           {
1512             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1513             if (p == (const PixelPacket *) NULL)
1514               break;
1515             for (x=0; x < (ssize_t) columns; x++)
1516             {
1517               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1518               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1519               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1520               *q++=0;
1521               p++;
1522             }
1523           }
1524           break;
1525         }
1526       for (y=0; y < (ssize_t) rows; y++)
1527       {
1528         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1529         if (p == (const PixelPacket *) NULL)
1530           break;
1531         indexes=GetVirtualIndexQueue(image);
1532         for (x=0; x < (ssize_t) columns; x++)
1533         {
1534           for (i=0; i < (ssize_t) length; i++)
1535           {
1536             *q=0;
1537             switch (quantum_map[i])
1538             {
1539               case RedQuantum:
1540               case CyanQuantum:
1541               {
1542                 *q=ScaleQuantumToShort(GetRedPixelComponent(p));
1543                 break;
1544               }
1545               case GreenQuantum:
1546               case MagentaQuantum:
1547               {
1548                 *q=ScaleQuantumToShort(GetGreenPixelComponent(p));
1549                 break;
1550               }
1551               case BlueQuantum:
1552               case YellowQuantum:
1553               {
1554                 *q=ScaleQuantumToShort(GetBluePixelComponent(p));
1555                 break;
1556               }
1557               case AlphaQuantum:
1558               {
1559                 *q=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1560                 break;
1561               }
1562               case OpacityQuantum:
1563               {
1564                 *q=ScaleQuantumToShort(GetOpacityPixelComponent(p));
1565                 break;
1566               }
1567               case BlackQuantum:
1568               {
1569                 if (image->colorspace == CMYKColorspace)
1570                   *q=ScaleQuantumToShort(indexes[x]);
1571                 break;
1572               }
1573               case IndexQuantum:
1574               {
1575                 *q=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1576                 break;
1577               }
1578               default:
1579                 break;
1580             }
1581             q++;
1582           }
1583           p++;
1584         }
1585       }
1586       break;
1587     }
1588     default:
1589     {
1590       quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1591       (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1592         "UnrecognizedPixelMap","`%s'",map);
1593       break;
1594     }
1595   }
1596   quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1597   return(MagickTrue);
1598 }
1599 \f
1600 /*
1601 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1602 %                                                                             %
1603 %                                                                             %
1604 %                                                                             %
1605 %   G e t M a g i c k P i x e l P a c k e t                                   %
1606 %                                                                             %
1607 %                                                                             %
1608 %                                                                             %
1609 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1610 %
1611 %  GetMagickPixelPacket() initializes the MagickPixelPacket structure.
1612 %
1613 %  The format of the GetMagickPixelPacket method is:
1614 %
1615 %      GetMagickPixelPacket(const Image *image,MagickPixelPacket *pixel)
1616 %
1617 %  A description of each parameter follows:
1618 %
1619 %    o image: the image.
1620 %
1621 %    o pixel: Specifies a pointer to a PixelPacket structure.
1622 %
1623 */
1624 MagickExport void GetMagickPixelPacket(const Image *image,
1625   MagickPixelPacket *pixel)
1626 {
1627   pixel->storage_class=DirectClass;
1628   pixel->colorspace=RGBColorspace;
1629   pixel->matte=MagickFalse;
1630   pixel->fuzz=0.0;
1631   pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
1632   pixel->red=0.0;
1633   pixel->green=0.0;
1634   pixel->blue=0.0;
1635   pixel->opacity=(MagickRealType) OpaqueOpacity;
1636   pixel->index=0.0;
1637   if (image == (const Image *) NULL)
1638     return;
1639   pixel->storage_class=image->storage_class;
1640   pixel->colorspace=image->colorspace;
1641   pixel->matte=image->matte;
1642   pixel->depth=image->depth;
1643   pixel->fuzz=image->fuzz;
1644 }
1645 \f
1646 /*
1647 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1648 %                                                                             %
1649 %                                                                             %
1650 %                                                                             %
1651 %   I m p o r t I m a g e P i x e l s                                         %
1652 %                                                                             %
1653 %                                                                             %
1654 %                                                                             %
1655 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1656 %
1657 %  ImportImagePixels() accepts pixel data and stores in the image at the
1658 %  location you specify.  The method returns MagickTrue on success otherwise
1659 %  MagickFalse if an error is encountered.  The pixel data can be either char,
1660 %  short int, int, ssize_t, float, or double in the order specified by map.
1661 %
1662 %  Suppose your want to upload the first scanline of a 640x480 image from
1663 %  character data in red-green-blue order:
1664 %
1665 %      ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
1666 %
1667 %  The format of the ImportImagePixels method is:
1668 %
1669 %      MagickBooleanType ImportImagePixels(Image *image,const ssize_t x_offset,
1670 %        const ssize_t y_offset,const size_t columns,
1671 %        const size_t rows,const char *map,const StorageType type,
1672 %        const void *pixels)
1673 %
1674 %  A description of each parameter follows:
1675 %
1676 %    o image: the image.
1677 %
1678 %    o x_offset,y_offset,columns,rows:  These values define the perimeter
1679 %      of a region of pixels you want to define.
1680 %
1681 %    o map:  This string reflects the expected ordering of the pixel array.
1682 %      It can be any combination or order of R = red, G = green, B = blue,
1683 %      A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
1684 %      Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
1685 %      P = pad.
1686 %
1687 %    o type: Define the data type of the pixels.  Float and double types are
1688 %      normalized to [0..1] otherwise [0..QuantumRange].  Choose from these
1689 %      types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or
1690 %      DoublePixel.
1691 %
1692 %    o pixels: This array of values contain the pixel components as defined by
1693 %      map and type.  You must preallocate this array where the expected
1694 %      length varies depending on the values of width, height, map, and type.
1695 %
1696 */
1697 MagickExport MagickBooleanType ImportImagePixels(Image *image,
1698   const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
1699   const size_t rows,const char *map,const StorageType type,
1700   const void *pixels)
1701 {
1702   ExceptionInfo
1703     *exception;
1704
1705   PixelPacket
1706     *q;
1707
1708   QuantumType
1709     *quantum_map;
1710
1711   register IndexPacket
1712     *indexes;
1713
1714   register ssize_t
1715     i,
1716     x;
1717
1718   size_t
1719     length;
1720
1721   ssize_t
1722     y;
1723
1724   /*
1725     Allocate image structure.
1726   */
1727   assert(image != (Image *) NULL);
1728   assert(image->signature == MagickSignature);
1729   if (image->debug != MagickFalse)
1730     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1731   length=strlen(map);
1732   quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
1733   if (quantum_map == (QuantumType *) NULL)
1734     ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1735       image->filename);
1736   for (i=0; i < (ssize_t) length; i++)
1737   {
1738     switch (map[i])
1739     {
1740       case 'a':
1741       case 'A':
1742       {
1743         quantum_map[i]=AlphaQuantum;
1744         image->matte=MagickTrue;
1745         break;
1746       }
1747       case 'B':
1748       case 'b':
1749       {
1750         quantum_map[i]=BlueQuantum;
1751         break;
1752       }
1753       case 'C':
1754       case 'c':
1755       {
1756         quantum_map[i]=CyanQuantum;
1757         (void) SetImageColorspace(image,CMYKColorspace);
1758         break;
1759       }
1760       case 'g':
1761       case 'G':
1762       {
1763         quantum_map[i]=GreenQuantum;
1764         break;
1765       }
1766       case 'K':
1767       case 'k':
1768       {
1769         quantum_map[i]=BlackQuantum;
1770         (void) SetImageColorspace(image,CMYKColorspace);
1771         break;
1772       }
1773       case 'I':
1774       case 'i':
1775       {
1776         quantum_map[i]=IndexQuantum;
1777         break;
1778       }
1779       case 'm':
1780       case 'M':
1781       {
1782         quantum_map[i]=MagentaQuantum;
1783         (void) SetImageColorspace(image,CMYKColorspace);
1784         break;
1785       }
1786       case 'O':
1787       case 'o':
1788       {
1789         quantum_map[i]=OpacityQuantum;
1790         image->matte=MagickTrue;
1791         break;
1792       }
1793       case 'P':
1794       case 'p':
1795       {
1796         quantum_map[i]=UndefinedQuantum;
1797         break;
1798       }
1799       case 'R':
1800       case 'r':
1801       {
1802         quantum_map[i]=RedQuantum;
1803         break;
1804       }
1805       case 'Y':
1806       case 'y':
1807       {
1808         quantum_map[i]=YellowQuantum;
1809         (void) SetImageColorspace(image,CMYKColorspace);
1810         break;
1811       }
1812       default:
1813       {
1814         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1815         (void) ThrowMagickException(&image->exception,GetMagickModule(),
1816           OptionError,"UnrecognizedPixelMap","`%s'",map);
1817         return(MagickFalse);
1818       }
1819     }
1820   }
1821   if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1822     return(MagickFalse);
1823   /*
1824     Transfer the pixels from the pixel datarray to the image.
1825   */
1826   exception=(&image->exception);
1827   switch (type)
1828   {
1829     case CharPixel:
1830     {
1831       register const unsigned char
1832         *p;
1833
1834       p=(const unsigned char *) pixels;
1835       if (LocaleCompare(map,"BGR") == 0)
1836         {
1837           for (y=0; y < (ssize_t) rows; y++)
1838           {
1839             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1840             if (q == (PixelPacket *) NULL)
1841               break;
1842             for (x=0; x < (ssize_t) columns; x++)
1843             {
1844               q->blue=ScaleCharToQuantum(*p++);
1845               q->green=ScaleCharToQuantum(*p++);
1846               q->red=ScaleCharToQuantum(*p++);
1847               q++;
1848             }
1849             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1850               break;
1851           }
1852           break;
1853         }
1854       if (LocaleCompare(map,"BGRA") == 0)
1855         {
1856           for (y=0; y < (ssize_t) rows; y++)
1857           {
1858             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1859             if (q == (PixelPacket *) NULL)
1860               break;
1861             for (x=0; x < (ssize_t) columns; x++)
1862             {
1863               q->blue=ScaleCharToQuantum(*p++);
1864               q->green=ScaleCharToQuantum(*p++);
1865               q->red=ScaleCharToQuantum(*p++);
1866               q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
1867               q++;
1868             }
1869             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1870               break;
1871           }
1872           break;
1873         }
1874       if (LocaleCompare(map,"BGRO") == 0)
1875         {
1876           for (y=0; y < (ssize_t) rows; y++)
1877           {
1878             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1879             if (q == (PixelPacket *) NULL)
1880               break;
1881             for (x=0; x < (ssize_t) columns; x++)
1882             {
1883               q->blue=ScaleCharToQuantum(*p++);
1884               q->green=ScaleCharToQuantum(*p++);
1885               q->red=ScaleCharToQuantum(*p++);
1886               q->opacity=ScaleCharToQuantum(*p++);
1887               q++;
1888             }
1889             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1890               break;
1891           }
1892           break;
1893         }
1894       if (LocaleCompare(map,"BGRP") == 0)
1895         {
1896           for (y=0; y < (ssize_t) rows; y++)
1897           {
1898             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1899             if (q == (PixelPacket *) NULL)
1900               break;
1901             for (x=0; x < (ssize_t) columns; x++)
1902             {
1903               q->blue=ScaleCharToQuantum(*p++);
1904               q->green=ScaleCharToQuantum(*p++);
1905               q->red=ScaleCharToQuantum(*p++);
1906               p++;
1907               q++;
1908             }
1909             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1910               break;
1911           }
1912           break;
1913         }
1914       if (LocaleCompare(map,"I") == 0)
1915         {
1916           for (y=0; y < (ssize_t) rows; y++)
1917           {
1918             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1919             if (q == (PixelPacket *) NULL)
1920               break;
1921             for (x=0; x < (ssize_t) columns; x++)
1922             {
1923               q->red=ScaleCharToQuantum(*p++);
1924               q->green=q->red;
1925               q->blue=q->red;
1926               q++;
1927             }
1928             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1929               break;
1930           }
1931           break;
1932         }
1933       if (LocaleCompare(map,"RGB") == 0)
1934         {
1935           for (y=0; y < (ssize_t) rows; y++)
1936           {
1937             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1938             if (q == (PixelPacket *) NULL)
1939               break;
1940             for (x=0; x < (ssize_t) columns; x++)
1941             {
1942               q->red=ScaleCharToQuantum(*p++);
1943               q->green=ScaleCharToQuantum(*p++);
1944               q->blue=ScaleCharToQuantum(*p++);
1945               q++;
1946             }
1947             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1948               break;
1949           }
1950           break;
1951         }
1952       if (LocaleCompare(map,"RGBA") == 0)
1953         {
1954           for (y=0; y < (ssize_t) rows; y++)
1955           {
1956             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1957             if (q == (PixelPacket *) NULL)
1958               break;
1959             for (x=0; x < (ssize_t) columns; x++)
1960             {
1961               q->red=ScaleCharToQuantum(*p++);
1962               q->green=ScaleCharToQuantum(*p++);
1963               q->blue=ScaleCharToQuantum(*p++);
1964               q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
1965               q++;
1966             }
1967             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1968               break;
1969           }
1970           break;
1971         }
1972       if (LocaleCompare(map,"RGBO") == 0)
1973         {
1974           for (y=0; y < (ssize_t) rows; y++)
1975           {
1976             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1977             if (q == (PixelPacket *) NULL)
1978               break;
1979             for (x=0; x < (ssize_t) columns; x++)
1980             {
1981               q->red=ScaleCharToQuantum(*p++);
1982               q->green=ScaleCharToQuantum(*p++);
1983               q->blue=ScaleCharToQuantum(*p++);
1984               q->opacity=ScaleCharToQuantum(*p++);
1985               q++;
1986             }
1987             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1988               break;
1989           }
1990           break;
1991         }
1992       if (LocaleCompare(map,"RGBP") == 0)
1993         {
1994           for (y=0; y < (ssize_t) rows; y++)
1995           {
1996             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1997             if (q == (PixelPacket *) NULL)
1998               break;
1999             for (x=0; x < (ssize_t) columns; x++)
2000             {
2001               q->red=ScaleCharToQuantum(*p++);
2002               q->green=ScaleCharToQuantum(*p++);
2003               q->blue=ScaleCharToQuantum(*p++);
2004               p++;
2005               q++;
2006             }
2007             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2008               break;
2009           }
2010           break;
2011         }
2012       for (y=0; y < (ssize_t) rows; y++)
2013       {
2014         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2015         if (q == (PixelPacket *) NULL)
2016           break;
2017         indexes=GetAuthenticIndexQueue(image);
2018         for (x=0; x < (ssize_t) columns; x++)
2019         {
2020           for (i=0; i < (ssize_t) length; i++)
2021           {
2022             switch (quantum_map[i])
2023             {
2024               case RedQuantum:
2025               case CyanQuantum:
2026               {
2027                 q->red=ScaleCharToQuantum(*p);
2028                 break;
2029               }
2030               case GreenQuantum:
2031               case MagentaQuantum:
2032               {
2033                 q->green=ScaleCharToQuantum(*p);
2034                 break;
2035               }
2036               case BlueQuantum:
2037               case YellowQuantum:
2038               {
2039                 q->blue=ScaleCharToQuantum(*p);
2040                 break;
2041               }
2042               case AlphaQuantum:
2043               {
2044                 q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p);
2045                 break;
2046               }
2047               case OpacityQuantum:
2048               {
2049                 q->opacity=ScaleCharToQuantum(*p);
2050                 break;
2051               }
2052               case BlackQuantum:
2053               {
2054                 indexes[x]=ScaleCharToQuantum(*p);
2055                 break;
2056               }
2057               case IndexQuantum:
2058               {
2059                 q->red=ScaleCharToQuantum(*p);
2060                 q->green=q->red;
2061                 q->blue=q->red;
2062                 break;
2063               }
2064               default:
2065                 break;
2066             }
2067             p++;
2068           }
2069           q++;
2070         }
2071         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2072           break;
2073       }
2074       break;
2075     }
2076     case DoublePixel:
2077     {
2078       register const double
2079         *p;
2080
2081       p=(const double *) pixels;
2082       if (LocaleCompare(map,"BGR") == 0)
2083         {
2084           for (y=0; y < (ssize_t) rows; y++)
2085           {
2086             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2087             if (q == (PixelPacket *) NULL)
2088               break;
2089             for (x=0; x < (ssize_t) columns; x++)
2090             {
2091               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2092               p++;
2093               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2094               p++;
2095               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2096               p++;
2097               q++;
2098             }
2099             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2100               break;
2101           }
2102           break;
2103         }
2104       if (LocaleCompare(map,"BGRA") == 0)
2105         {
2106           for (y=0; y < (ssize_t) rows; y++)
2107           {
2108             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2109             if (q == (PixelPacket *) NULL)
2110               break;
2111             for (x=0; x < (ssize_t) columns; x++)
2112             {
2113               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2114               p++;
2115               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2116               p++;
2117               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2118               p++;
2119               q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2120                 QuantumRange*(*p));
2121               p++;
2122               q++;
2123             }
2124             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2125               break;
2126           }
2127           break;
2128         }
2129       if (LocaleCompare(map,"BGRP") == 0)
2130         {
2131           for (y=0; y < (ssize_t) rows; y++)
2132           {
2133             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2134             if (q == (PixelPacket *) NULL)
2135               break;
2136             for (x=0; x < (ssize_t) columns; x++)
2137             {
2138               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2139               p++;
2140               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2141               p++;
2142               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2143               p++;
2144               p++;
2145               q++;
2146             }
2147             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2148               break;
2149           }
2150           break;
2151         }
2152       if (LocaleCompare(map,"I") == 0)
2153         {
2154           for (y=0; y < (ssize_t) rows; y++)
2155           {
2156             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2157             if (q == (PixelPacket *) NULL)
2158               break;
2159             for (x=0; x < (ssize_t) columns; x++)
2160             {
2161               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2162               q->green=q->red;
2163               q->blue=q->red;
2164               p++;
2165               q++;
2166             }
2167             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2168               break;
2169           }
2170           break;
2171         }
2172       if (LocaleCompare(map,"RGB") == 0)
2173         {
2174           for (y=0; y < (ssize_t) rows; y++)
2175           {
2176             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2177             if (q == (PixelPacket *) NULL)
2178               break;
2179             for (x=0; x < (ssize_t) columns; x++)
2180             {
2181               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2182               p++;
2183               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2184               p++;
2185               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2186               p++;
2187               q++;
2188             }
2189             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2190               break;
2191           }
2192           break;
2193         }
2194       if (LocaleCompare(map,"RGBA") == 0)
2195         {
2196           for (y=0; y < (ssize_t) rows; y++)
2197           {
2198             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2199             if (q == (PixelPacket *) NULL)
2200               break;
2201             for (x=0; x < (ssize_t) columns; x++)
2202             {
2203               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2204               p++;
2205               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2206               p++;
2207               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2208               p++;
2209               q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2210                 QuantumRange*(*p));
2211               p++;
2212               q++;
2213             }
2214             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2215               break;
2216           }
2217           break;
2218         }
2219       if (LocaleCompare(map,"RGBP") == 0)
2220         {
2221           for (y=0; y < (ssize_t) rows; y++)
2222           {
2223             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2224             if (q == (PixelPacket *) NULL)
2225               break;
2226             for (x=0; x < (ssize_t) columns; x++)
2227             {
2228               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2229               p++;
2230               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2231               p++;
2232               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2233               p++;
2234               q++;
2235             }
2236             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2237               break;
2238           }
2239           break;
2240         }
2241       for (y=0; y < (ssize_t) rows; y++)
2242       {
2243         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2244         if (q == (PixelPacket *) NULL)
2245           break;
2246         indexes=GetAuthenticIndexQueue(image);
2247         for (x=0; x < (ssize_t) columns; x++)
2248         {
2249           for (i=0; i < (ssize_t) length; i++)
2250           {
2251             switch (quantum_map[i])
2252             {
2253               case RedQuantum:
2254               case CyanQuantum:
2255               {
2256                 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2257                 break;
2258               }
2259               case GreenQuantum:
2260               case MagentaQuantum:
2261               {
2262                 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2263                 break;
2264               }
2265               case BlueQuantum:
2266               case YellowQuantum:
2267               {
2268                 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2269                 break;
2270               }
2271               case AlphaQuantum:
2272               {
2273                 q->opacity=(Quantum) QuantumRange-ClampToQuantum(
2274                   (MagickRealType) QuantumRange*(*p));
2275                 break;
2276               }
2277               case OpacityQuantum:
2278               {
2279                 q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2280                 break;
2281               }
2282               case BlackQuantum:
2283               {
2284                 indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2285                 break;
2286               }
2287               case IndexQuantum:
2288               {
2289                 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2290                 q->green=q->red;
2291                 q->blue=q->red;
2292                 break;
2293               }
2294               default:
2295                 break;
2296             }
2297             p++;
2298           }
2299           q++;
2300         }
2301         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2302           break;
2303       }
2304       break;
2305     }
2306     case FloatPixel:
2307     {
2308       register const float
2309         *p;
2310
2311       p=(const float *) pixels;
2312       if (LocaleCompare(map,"BGR") == 0)
2313         {
2314           for (y=0; y < (ssize_t) rows; y++)
2315           {
2316             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2317             if (q == (PixelPacket *) NULL)
2318               break;
2319             for (x=0; x < (ssize_t) columns; x++)
2320             {
2321               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2322               p++;
2323               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2324               p++;
2325               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2326               p++;
2327               q++;
2328             }
2329             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2330               break;
2331           }
2332           break;
2333         }
2334       if (LocaleCompare(map,"BGRA") == 0)
2335         {
2336           for (y=0; y < (ssize_t) rows; y++)
2337           {
2338             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2339             if (q == (PixelPacket *) NULL)
2340               break;
2341             for (x=0; x < (ssize_t) columns; x++)
2342             {
2343               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2344               p++;
2345               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2346               p++;
2347               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2348               p++;
2349               q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2350                 QuantumRange*(*p));
2351               p++;
2352               q++;
2353             }
2354             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2355               break;
2356           }
2357           break;
2358         }
2359       if (LocaleCompare(map,"BGRP") == 0)
2360         {
2361           for (y=0; y < (ssize_t) rows; y++)
2362           {
2363             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2364             if (q == (PixelPacket *) NULL)
2365               break;
2366             for (x=0; x < (ssize_t) columns; x++)
2367             {
2368               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2369               p++;
2370               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2371               p++;
2372               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2373               p++;
2374               p++;
2375               q++;
2376             }
2377             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2378               break;
2379           }
2380           break;
2381         }
2382       if (LocaleCompare(map,"I") == 0)
2383         {
2384           for (y=0; y < (ssize_t) rows; y++)
2385           {
2386             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2387             if (q == (PixelPacket *) NULL)
2388               break;
2389             for (x=0; x < (ssize_t) columns; x++)
2390             {
2391               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2392               q->green=q->red;
2393               q->blue=q->red;
2394               p++;
2395               q++;
2396             }
2397             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2398               break;
2399           }
2400           break;
2401         }
2402       if (LocaleCompare(map,"RGB") == 0)
2403         {
2404           for (y=0; y < (ssize_t) rows; y++)
2405           {
2406             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2407             if (q == (PixelPacket *) NULL)
2408               break;
2409             for (x=0; x < (ssize_t) columns; x++)
2410             {
2411               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2412               p++;
2413               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2414               p++;
2415               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2416               p++;
2417               q++;
2418             }
2419             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2420               break;
2421           }
2422           break;
2423         }
2424       if (LocaleCompare(map,"RGBA") == 0)
2425         {
2426           for (y=0; y < (ssize_t) rows; y++)
2427           {
2428             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2429             if (q == (PixelPacket *) NULL)
2430               break;
2431             for (x=0; x < (ssize_t) columns; x++)
2432             {
2433               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2434               p++;
2435               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2436               p++;
2437               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2438               p++;
2439               q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2440                 QuantumRange*(*p));
2441               p++;
2442               q++;
2443             }
2444             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2445               break;
2446           }
2447           break;
2448         }
2449       if (LocaleCompare(map,"RGBP") == 0)
2450         {
2451           for (y=0; y < (ssize_t) rows; y++)
2452           {
2453             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2454             if (q == (PixelPacket *) NULL)
2455               break;
2456             for (x=0; x < (ssize_t) columns; x++)
2457             {
2458               q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2459               p++;
2460               q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2461               p++;
2462               q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2463               p++;
2464               q++;
2465             }
2466             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2467               break;
2468           }
2469           break;
2470         }
2471       for (y=0; y < (ssize_t) rows; y++)
2472       {
2473         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2474         if (q == (PixelPacket *) NULL)
2475           break;
2476         indexes=GetAuthenticIndexQueue(image);
2477         for (x=0; x < (ssize_t) columns; x++)
2478         {
2479           for (i=0; i < (ssize_t) length; i++)
2480           {
2481             switch (quantum_map[i])
2482             {
2483               case RedQuantum:
2484               case CyanQuantum:
2485               {
2486                 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2487                 break;
2488               }
2489               case GreenQuantum:
2490               case MagentaQuantum:
2491               {
2492                 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2493                 break;
2494               }
2495               case BlueQuantum:
2496               case YellowQuantum:
2497               {
2498                 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2499                 break;
2500               }
2501               case AlphaQuantum:
2502               {
2503                 q->opacity=(Quantum) QuantumRange-ClampToQuantum(
2504                   (MagickRealType) QuantumRange*(*p));
2505                 break;
2506               }
2507               case OpacityQuantum:
2508               {
2509                 q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2510                 break;
2511               }
2512               case BlackQuantum:
2513               {
2514                 indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2515                 break;
2516               }
2517               case IndexQuantum:
2518               {
2519                 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2520                 q->green=q->red;
2521                 q->blue=q->red;
2522                 break;
2523               }
2524               default:
2525                 break;
2526             }
2527             p++;
2528           }
2529           q++;
2530         }
2531         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2532           break;
2533       }
2534       break;
2535     }
2536     case IntegerPixel:
2537     {
2538       register const unsigned int
2539         *p;
2540
2541       p=(const unsigned int *) pixels;
2542       if (LocaleCompare(map,"BGR") == 0)
2543         {
2544           for (y=0; y < (ssize_t) rows; y++)
2545           {
2546             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2547             if (q == (PixelPacket *) NULL)
2548               break;
2549             for (x=0; x < (ssize_t) columns; x++)
2550             {
2551               q->blue=ScaleLongToQuantum(*p++);
2552               q->green=ScaleLongToQuantum(*p++);
2553               q->red=ScaleLongToQuantum(*p++);
2554               q++;
2555             }
2556             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2557               break;
2558           }
2559           break;
2560         }
2561       if (LocaleCompare(map,"BGRA") == 0)
2562         {
2563           for (y=0; y < (ssize_t) rows; y++)
2564           {
2565             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2566             if (q == (PixelPacket *) NULL)
2567               break;
2568             for (x=0; x < (ssize_t) columns; x++)
2569             {
2570               q->blue=ScaleLongToQuantum(*p++);
2571               q->green=ScaleLongToQuantum(*p++);
2572               q->red=ScaleLongToQuantum(*p++);
2573               q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2574               q++;
2575             }
2576             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2577               break;
2578           }
2579           break;
2580         }
2581       if (LocaleCompare(map,"BGRP") == 0)
2582         {
2583           for (y=0; y < (ssize_t) rows; y++)
2584           {
2585             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2586             if (q == (PixelPacket *) NULL)
2587               break;
2588             for (x=0; x < (ssize_t) columns; x++)
2589             {
2590               q->blue=ScaleLongToQuantum(*p++);
2591               q->green=ScaleLongToQuantum(*p++);
2592               q->red=ScaleLongToQuantum(*p++);
2593               p++;
2594               q++;
2595             }
2596             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2597               break;
2598           }
2599           break;
2600         }
2601       if (LocaleCompare(map,"I") == 0)
2602         {
2603           for (y=0; y < (ssize_t) rows; y++)
2604           {
2605             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2606             if (q == (PixelPacket *) NULL)
2607               break;
2608             for (x=0; x < (ssize_t) columns; x++)
2609             {
2610               q->red=ScaleLongToQuantum(*p++);
2611               q->green=q->red;
2612               q->blue=q->red;
2613               q++;
2614             }
2615             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2616               break;
2617           }
2618           break;
2619         }
2620       if (LocaleCompare(map,"RGB") == 0)
2621         {
2622           for (y=0; y < (ssize_t) rows; y++)
2623           {
2624             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2625             if (q == (PixelPacket *) NULL)
2626               break;
2627             for (x=0; x < (ssize_t) columns; x++)
2628             {
2629               q->red=ScaleLongToQuantum(*p++);
2630               q->green=ScaleLongToQuantum(*p++);
2631               q->blue=ScaleLongToQuantum(*p++);
2632               q++;
2633             }
2634             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2635               break;
2636           }
2637           break;
2638         }
2639       if (LocaleCompare(map,"RGBA") == 0)
2640         {
2641           for (y=0; y < (ssize_t) rows; y++)
2642           {
2643             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2644             if (q == (PixelPacket *) NULL)
2645               break;
2646             for (x=0; x < (ssize_t) columns; x++)
2647             {
2648               q->red=ScaleLongToQuantum(*p++);
2649               q->green=ScaleLongToQuantum(*p++);
2650               q->blue=ScaleLongToQuantum(*p++);
2651               q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2652               q++;
2653             }
2654             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2655               break;
2656           }
2657           break;
2658         }
2659       if (LocaleCompare(map,"RGBP") == 0)
2660         {
2661           for (y=0; y < (ssize_t) rows; y++)
2662           {
2663             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2664             if (q == (PixelPacket *) NULL)
2665               break;
2666             for (x=0; x < (ssize_t) columns; x++)
2667             {
2668               q->red=ScaleLongToQuantum(*p++);
2669               q->green=ScaleLongToQuantum(*p++);
2670               q->blue=ScaleLongToQuantum(*p++);
2671               p++;
2672               q++;
2673             }
2674             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2675               break;
2676           }
2677           break;
2678         }
2679       for (y=0; y < (ssize_t) rows; y++)
2680       {
2681         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2682         if (q == (PixelPacket *) NULL)
2683           break;
2684         indexes=GetAuthenticIndexQueue(image);
2685         for (x=0; x < (ssize_t) columns; x++)
2686         {
2687           for (i=0; i < (ssize_t) length; i++)
2688           {
2689             switch (quantum_map[i])
2690             {
2691               case RedQuantum:
2692               case CyanQuantum:
2693               {
2694                 q->red=ScaleLongToQuantum(*p);
2695                 break;
2696               }
2697               case GreenQuantum:
2698               case MagentaQuantum:
2699               {
2700                 q->green=ScaleLongToQuantum(*p);
2701                 break;
2702               }
2703               case BlueQuantum:
2704               case YellowQuantum:
2705               {
2706                 q->blue=ScaleLongToQuantum(*p);
2707                 break;
2708               }
2709               case AlphaQuantum:
2710               {
2711                 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
2712                 break;
2713               }
2714               case OpacityQuantum:
2715               {
2716                 q->opacity=ScaleLongToQuantum(*p);
2717                 break;
2718               }
2719               case BlackQuantum:
2720               {
2721                 indexes[x]=ScaleLongToQuantum(*p);
2722                 break;
2723               }
2724               case IndexQuantum:
2725               {
2726                 q->red=ScaleLongToQuantum(*p);
2727                 q->green=q->red;
2728                 q->blue=q->red;
2729                 break;
2730               }
2731               default:
2732                 break;
2733             }
2734             p++;
2735           }
2736           q++;
2737         }
2738         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2739           break;
2740       }
2741       break;
2742     }
2743     case LongPixel:
2744     {
2745       register const unsigned int
2746         *p;
2747
2748       p=(const unsigned int *) pixels;
2749       if (LocaleCompare(map,"BGR") == 0)
2750         {
2751           for (y=0; y < (ssize_t) rows; y++)
2752           {
2753             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2754             if (q == (PixelPacket *) NULL)
2755               break;
2756             for (x=0; x < (ssize_t) columns; x++)
2757             {
2758               q->blue=ScaleLongToQuantum(*p++);
2759               q->green=ScaleLongToQuantum(*p++);
2760               q->red=ScaleLongToQuantum(*p++);
2761               q++;
2762             }
2763             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2764               break;
2765           }
2766           break;
2767         }
2768       if (LocaleCompare(map,"BGRA") == 0)
2769         {
2770           for (y=0; y < (ssize_t) rows; y++)
2771           {
2772             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2773             if (q == (PixelPacket *) NULL)
2774               break;
2775             for (x=0; x < (ssize_t) columns; x++)
2776             {
2777               q->blue=ScaleLongToQuantum(*p++);
2778               q->green=ScaleLongToQuantum(*p++);
2779               q->red=ScaleLongToQuantum(*p++);
2780               q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2781               q++;
2782             }
2783             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2784               break;
2785           }
2786           break;
2787         }
2788       if (LocaleCompare(map,"BGRP") == 0)
2789         {
2790           for (y=0; y < (ssize_t) rows; y++)
2791           {
2792             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2793             if (q == (PixelPacket *) NULL)
2794               break;
2795             for (x=0; x < (ssize_t) columns; x++)
2796             {
2797               q->blue=ScaleLongToQuantum(*p++);
2798               q->green=ScaleLongToQuantum(*p++);
2799               q->red=ScaleLongToQuantum(*p++);
2800               p++;
2801               q++;
2802             }
2803             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2804               break;
2805           }
2806           break;
2807         }
2808       if (LocaleCompare(map,"I") == 0)
2809         {
2810           for (y=0; y < (ssize_t) rows; y++)
2811           {
2812             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2813             if (q == (PixelPacket *) NULL)
2814               break;
2815             for (x=0; x < (ssize_t) columns; x++)
2816             {
2817               q->red=ScaleLongToQuantum(*p++);
2818               q->green=q->red;
2819               q->blue=q->red;
2820               q++;
2821             }
2822             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2823               break;
2824           }
2825           break;
2826         }
2827       if (LocaleCompare(map,"RGB") == 0)
2828         {
2829           for (y=0; y < (ssize_t) rows; y++)
2830           {
2831             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2832             if (q == (PixelPacket *) NULL)
2833               break;
2834             for (x=0; x < (ssize_t) columns; x++)
2835             {
2836               q->red=ScaleLongToQuantum(*p++);
2837               q->green=ScaleLongToQuantum(*p++);
2838               q->blue=ScaleLongToQuantum(*p++);
2839               q++;
2840             }
2841             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2842               break;
2843           }
2844           break;
2845         }
2846       if (LocaleCompare(map,"RGBA") == 0)
2847         {
2848           for (y=0; y < (ssize_t) rows; y++)
2849           {
2850             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2851             if (q == (PixelPacket *) NULL)
2852               break;
2853             for (x=0; x < (ssize_t) columns; x++)
2854             {
2855               q->red=ScaleLongToQuantum(*p++);
2856               q->green=ScaleLongToQuantum(*p++);
2857               q->blue=ScaleLongToQuantum(*p++);
2858               q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2859               q++;
2860             }
2861             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2862               break;
2863           }
2864           break;
2865         }
2866       if (LocaleCompare(map,"RGBP") == 0)
2867         {
2868           for (y=0; y < (ssize_t) rows; y++)
2869           {
2870             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2871             if (q == (PixelPacket *) NULL)
2872               break;
2873             for (x=0; x < (ssize_t) columns; x++)
2874             {
2875               q->red=ScaleLongToQuantum(*p++);
2876               q->green=ScaleLongToQuantum(*p++);
2877               q->blue=ScaleLongToQuantum(*p++);
2878               p++;
2879               q++;
2880             }
2881             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2882               break;
2883           }
2884           break;
2885         }
2886       for (y=0; y < (ssize_t) rows; y++)
2887       {
2888         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2889         if (q == (PixelPacket *) NULL)
2890           break;
2891         indexes=GetAuthenticIndexQueue(image);
2892         for (x=0; x < (ssize_t) columns; x++)
2893         {
2894           for (i=0; i < (ssize_t) length; i++)
2895           {
2896             switch (quantum_map[i])
2897             {
2898               case RedQuantum:
2899               case CyanQuantum:
2900               {
2901                 q->red=ScaleLongToQuantum(*p);
2902                 break;
2903               }
2904               case GreenQuantum:
2905               case MagentaQuantum:
2906               {
2907                 q->green=ScaleLongToQuantum(*p);
2908                 break;
2909               }
2910               case BlueQuantum:
2911               case YellowQuantum:
2912               {
2913                 q->blue=ScaleLongToQuantum(*p);
2914                 break;
2915               }
2916               case AlphaQuantum:
2917               {
2918                 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
2919                 break;
2920               }
2921               case OpacityQuantum:
2922               {
2923                 q->opacity=ScaleLongToQuantum(*p);
2924                 break;
2925               }
2926               case BlackQuantum:
2927               {
2928                 indexes[x]=ScaleLongToQuantum(*p);
2929                 break;
2930               }
2931               case IndexQuantum:
2932               {
2933                 q->red=ScaleLongToQuantum(*p);
2934                 q->green=q->red;
2935                 q->blue=q->red;
2936                 break;
2937               }
2938               default:
2939                 break;
2940             }
2941             p++;
2942           }
2943           q++;
2944         }
2945         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2946           break;
2947       }
2948       break;
2949     }
2950     case QuantumPixel:
2951     {
2952       register const Quantum
2953         *p;
2954
2955       p=(const Quantum *) pixels;
2956       if (LocaleCompare(map,"BGR") == 0)
2957         {
2958           for (y=0; y < (ssize_t) rows; y++)
2959           {
2960             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2961             if (q == (PixelPacket *) NULL)
2962               break;
2963             for (x=0; x < (ssize_t) columns; x++)
2964             {
2965               q->blue=(*p++);
2966               q->green=(*p++);
2967               q->red=(*p++);
2968               q++;
2969             }
2970             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2971               break;
2972           }
2973           break;
2974         }
2975       if (LocaleCompare(map,"BGRA") == 0)
2976         {
2977           for (y=0; y < (ssize_t) rows; y++)
2978           {
2979             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2980             if (q == (PixelPacket *) NULL)
2981               break;
2982             for (x=0; x < (ssize_t) columns; x++)
2983             {
2984               q->blue=(*p++);
2985               q->green=(*p++);
2986               q->red=(*p++);
2987               q->opacity=(Quantum) QuantumRange-(*p++);
2988               q++;
2989             }
2990             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2991               break;
2992           }
2993           break;
2994         }
2995       if (LocaleCompare(map,"BGRP") == 0)
2996         {
2997           for (y=0; y < (ssize_t) rows; y++)
2998           {
2999             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3000             if (q == (PixelPacket *) NULL)
3001               break;
3002             for (x=0; x < (ssize_t) columns; x++)
3003             {
3004               q->blue=(*p++);
3005               q->green=(*p++);
3006               q->red=(*p++);
3007               p++;
3008               q++;
3009             }
3010             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3011               break;
3012           }
3013           break;
3014         }
3015       if (LocaleCompare(map,"I") == 0)
3016         {
3017           for (y=0; y < (ssize_t) rows; y++)
3018           {
3019             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3020             if (q == (PixelPacket *) NULL)
3021               break;
3022             for (x=0; x < (ssize_t) columns; x++)
3023             {
3024               q->red=(*p++);
3025               q->green=q->red;
3026               q->blue=q->red;
3027               q++;
3028             }
3029             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3030               break;
3031           }
3032           break;
3033         }
3034       if (LocaleCompare(map,"RGB") == 0)
3035         {
3036           for (y=0; y < (ssize_t) rows; y++)
3037           {
3038             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3039             if (q == (PixelPacket *) NULL)
3040               break;
3041             for (x=0; x < (ssize_t) columns; x++)
3042             {
3043               q->red=(*p++);
3044               q->green=(*p++);
3045               q->blue=(*p++);
3046               q++;
3047             }
3048             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3049               break;
3050           }
3051           break;
3052         }
3053       if (LocaleCompare(map,"RGBA") == 0)
3054         {
3055           for (y=0; y < (ssize_t) rows; y++)
3056           {
3057             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3058             if (q == (PixelPacket *) NULL)
3059               break;
3060             for (x=0; x < (ssize_t) columns; x++)
3061             {
3062               q->red=(*p++);
3063               q->green=(*p++);
3064               q->blue=(*p++);
3065               q->opacity=(Quantum) QuantumRange-(*p++);
3066               q++;
3067             }
3068             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3069               break;
3070           }
3071           break;
3072         }
3073       if (LocaleCompare(map,"RGBP") == 0)
3074         {
3075           for (y=0; y < (ssize_t) rows; y++)
3076           {
3077             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3078             if (q == (PixelPacket *) NULL)
3079               break;
3080             for (x=0; x < (ssize_t) columns; x++)
3081             {
3082               q->red=(*p++);
3083               q->green=(*p++);
3084               q->blue=(*p++);
3085               p++;
3086               q++;
3087             }
3088             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3089               break;
3090           }
3091           break;
3092         }
3093       for (y=0; y < (ssize_t) rows; y++)
3094       {
3095         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3096         if (q == (PixelPacket *) NULL)
3097           break;
3098         indexes=GetAuthenticIndexQueue(image);
3099         for (x=0; x < (ssize_t) columns; x++)
3100         {
3101           for (i=0; i < (ssize_t) length; i++)
3102           {
3103             switch (quantum_map[i])
3104             {
3105               case RedQuantum:
3106               case CyanQuantum:
3107               {
3108                 q->red=(*p);
3109                 break;
3110               }
3111               case GreenQuantum:
3112               case MagentaQuantum:
3113               {
3114                 q->green=(*p);
3115                 break;
3116               }
3117               case BlueQuantum:
3118               case YellowQuantum:
3119               {
3120                 q->blue=(*p);
3121                 break;
3122               }
3123               case AlphaQuantum:
3124               {
3125                 q->opacity=(Quantum) QuantumRange-(*p);
3126                 break;
3127               }
3128               case OpacityQuantum:
3129               {
3130                 q->opacity=(*p);
3131                 break;
3132               }
3133               case BlackQuantum:
3134               {
3135                 indexes[x]=(*p);
3136                 break;
3137               }
3138               case IndexQuantum:
3139               {
3140                 q->red=(*p);
3141                 q->green=q->red;
3142                 q->blue=q->red;
3143                 break;
3144               }
3145               default:
3146                 break;
3147             }
3148             p++;
3149           }
3150           q++;
3151         }
3152         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3153           break;
3154       }
3155       break;
3156     }
3157     case ShortPixel:
3158     {
3159       register const unsigned short
3160         *p;
3161
3162       p=(const unsigned short *) pixels;
3163       if (LocaleCompare(map,"BGR") == 0)
3164         {
3165           for (y=0; y < (ssize_t) rows; y++)
3166           {
3167             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3168             if (q == (PixelPacket *) NULL)
3169               break;
3170             for (x=0; x < (ssize_t) columns; x++)
3171             {
3172               q->blue=ScaleShortToQuantum(*p++);
3173               q->green=ScaleShortToQuantum(*p++);
3174               q->red=ScaleShortToQuantum(*p++);
3175               q++;
3176             }
3177             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3178               break;
3179           }
3180           break;
3181         }
3182       if (LocaleCompare(map,"BGRA") == 0)
3183         {
3184           for (y=0; y < (ssize_t) rows; y++)
3185           {
3186             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3187             if (q == (PixelPacket *) NULL)
3188               break;
3189             for (x=0; x < (ssize_t) columns; x++)
3190             {
3191               q->blue=ScaleShortToQuantum(*p++);
3192               q->green=ScaleShortToQuantum(*p++);
3193               q->red=ScaleShortToQuantum(*p++);
3194               q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
3195               q++;
3196             }
3197             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3198               break;
3199           }
3200           break;
3201         }
3202       if (LocaleCompare(map,"BGRP") == 0)
3203         {
3204           for (y=0; y < (ssize_t) rows; y++)
3205           {
3206             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3207             if (q == (PixelPacket *) NULL)
3208               break;
3209             for (x=0; x < (ssize_t) columns; x++)
3210             {
3211               q->blue=ScaleShortToQuantum(*p++);
3212               q->green=ScaleShortToQuantum(*p++);
3213               q->red=ScaleShortToQuantum(*p++);
3214               p++;
3215               q++;
3216             }
3217             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3218               break;
3219           }
3220           break;
3221         }
3222       if (LocaleCompare(map,"I") == 0)
3223         {
3224           for (y=0; y < (ssize_t) rows; y++)
3225           {
3226             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3227             if (q == (PixelPacket *) NULL)
3228               break;
3229             for (x=0; x < (ssize_t) columns; x++)
3230             {
3231               q->red=ScaleShortToQuantum(*p++);
3232               q->green=q->red;
3233               q->blue=q->red;
3234               q++;
3235             }
3236             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3237               break;
3238           }
3239           break;
3240         }
3241       if (LocaleCompare(map,"RGB") == 0)
3242         {
3243           for (y=0; y < (ssize_t) rows; y++)
3244           {
3245             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3246             if (q == (PixelPacket *) NULL)
3247               break;
3248             for (x=0; x < (ssize_t) columns; x++)
3249             {
3250               q->red=ScaleShortToQuantum(*p++);
3251               q->green=ScaleShortToQuantum(*p++);
3252               q->blue=ScaleShortToQuantum(*p++);
3253               q++;
3254             }
3255             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3256               break;
3257           }
3258           break;
3259         }
3260       if (LocaleCompare(map,"RGBA") == 0)
3261         {
3262           for (y=0; y < (ssize_t) rows; y++)
3263           {
3264             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3265             if (q == (PixelPacket *) NULL)
3266               break;
3267             for (x=0; x < (ssize_t) columns; x++)
3268             {
3269               q->red=ScaleShortToQuantum(*p++);
3270               q->green=ScaleShortToQuantum(*p++);
3271               q->blue=ScaleShortToQuantum(*p++);
3272               q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
3273               q++;
3274             }
3275             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3276               break;
3277           }
3278           break;
3279         }
3280       if (LocaleCompare(map,"RGBP") == 0)
3281         {
3282           for (y=0; y < (ssize_t) rows; y++)
3283           {
3284             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3285             if (q == (PixelPacket *) NULL)
3286               break;
3287             for (x=0; x < (ssize_t) columns; x++)
3288             {
3289               q->red=ScaleShortToQuantum(*p++);
3290               q->green=ScaleShortToQuantum(*p++);
3291               q->blue=ScaleShortToQuantum(*p++);
3292               p++;
3293               q++;
3294             }
3295             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3296               break;
3297           }
3298           break;
3299         }
3300       for (y=0; y < (ssize_t) rows; y++)
3301       {
3302         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3303         if (q == (PixelPacket *) NULL)
3304           break;
3305         indexes=GetAuthenticIndexQueue(image);
3306         for (x=0; x < (ssize_t) columns; x++)
3307         {
3308           for (i=0; i < (ssize_t) length; i++)
3309           {
3310             switch (quantum_map[i])
3311             {
3312               case RedQuantum:
3313               case CyanQuantum:
3314               {
3315                 q->red=ScaleShortToQuantum(*p);
3316                 break;
3317               }
3318               case GreenQuantum:
3319               case MagentaQuantum:
3320               {
3321                 q->green=ScaleShortToQuantum(*p);
3322                 break;
3323               }
3324               case BlueQuantum:
3325               case YellowQuantum:
3326               {
3327                 q->blue=ScaleShortToQuantum(*p);
3328                 break;
3329               }
3330               case AlphaQuantum:
3331               {
3332                 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p);
3333                 break;
3334               }
3335               case OpacityQuantum:
3336               {
3337                 q->opacity=ScaleShortToQuantum(*p);
3338                 break;
3339               }
3340               case BlackQuantum:
3341               {
3342                 indexes[x]=ScaleShortToQuantum(*p);
3343                 break;
3344               }
3345               case IndexQuantum:
3346               {
3347                 q->red=ScaleShortToQuantum(*p);
3348                 q->green=q->red;
3349                 q->blue=q->red;
3350                 break;
3351               }
3352               default:
3353                 break;
3354             }
3355             p++;
3356           }
3357           q++;
3358         }
3359         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3360           break;
3361       }
3362       break;
3363     }
3364     default:
3365     {
3366       quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3367       (void) ThrowMagickException(&image->exception,GetMagickModule(),
3368         OptionError,"UnrecognizedPixelMap","`%s'",map);
3369       break;
3370     }
3371   }
3372   quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3373   return(MagickTrue);
3374 }