2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6 % PPPP IIIII X X EEEEE L %
10 % P IIIII X X EEEEE LLLLL %
12 % MagickCore Methods to Import/Export Pixels %
19 % Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
20 % dedicated to making software imaging solutions freely available. %
22 % You may not use this file except in compliance with the License. You may %
23 % obtain a copy of the License at %
25 % http://www.imagemagick.org/script/license.php %
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. %
33 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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"
68 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
72 % E x p o r t I m a g e P i x e l s %
76 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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.
83 % Suppose you want to extract the first scanline of a 640x480 image as
84 % character data in red-green-blue order:
86 % ExportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels,exception);
88 % The format of the ExportImagePixels method is:
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)
95 % A description of each parameter follows:
99 % o x_offset,y_offset,columns,rows: These values define the perimeter
100 % of a region of pixels you want to extract.
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),
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.
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.
117 % o exception: return any errors or warnings in this structure.
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)
132 register const IndexPacket
135 register const PixelPacket
144 assert(image != (Image *) NULL);
145 assert(image->signature == MagickSignature);
146 if (image->debug != MagickFalse)
147 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
149 quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
150 if (quantum_map == (QuantumType *) NULL)
152 (void) ThrowMagickException(exception,GetMagickModule(),
153 ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
156 for (i=0; i < (ssize_t) length; i++)
163 quantum_map[i]=AlphaQuantum;
169 quantum_map[i]=BlueQuantum;
175 quantum_map[i]=CyanQuantum;
176 if (image->colorspace == CMYKColorspace)
178 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
179 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
180 "ColorSeparatedImageRequired","`%s'",map);
186 quantum_map[i]=GreenQuantum;
192 quantum_map[i]=IndexQuantum;
198 quantum_map[i]=BlackQuantum;
199 if (image->colorspace == CMYKColorspace)
201 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
202 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
203 "ColorSeparatedImageRequired","`%s'",map);
209 quantum_map[i]=MagentaQuantum;
210 if (image->colorspace == CMYKColorspace)
212 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
213 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
214 "ColorSeparatedImageRequired","`%s'",map);
220 quantum_map[i]=OpacityQuantum;
226 quantum_map[i]=UndefinedQuantum;
232 quantum_map[i]=RedQuantum;
238 quantum_map[i]=YellowQuantum;
239 if (image->colorspace == CMYKColorspace)
241 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
242 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
243 "ColorSeparatedImageRequired","`%s'",map);
248 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
249 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
250 "UnrecognizedPixelMap","`%s'",map);
259 register unsigned char
262 q=(unsigned char *) pixels;
263 if (LocaleCompare(map,"BGR") == 0)
265 for (y=0; y < (ssize_t) rows; y++)
267 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
268 if (p == (const PixelPacket *) NULL)
270 for (x=0; x < (ssize_t) columns; x++)
272 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
273 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
274 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
280 if (LocaleCompare(map,"BGRA") == 0)
282 for (y=0; y < (ssize_t) rows; y++)
284 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
285 if (p == (const PixelPacket *) NULL)
287 for (x=0; x < (ssize_t) columns; x++)
289 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
290 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
291 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
292 *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
298 if (LocaleCompare(map,"BGRP") == 0)
300 for (y=0; y < (ssize_t) rows; y++)
302 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
303 if (p == (const PixelPacket *) NULL)
305 for (x=0; x < (ssize_t) columns; x++)
307 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
308 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
309 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
310 *q++=ScaleQuantumToChar((Quantum) 0);
316 if (LocaleCompare(map,"I") == 0)
318 for (y=0; y < (ssize_t) rows; y++)
320 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
321 if (p == (const PixelPacket *) NULL)
323 for (x=0; x < (ssize_t) columns; x++)
325 *q++=ScaleQuantumToChar(PixelIntensityToQuantum(p));
331 if (LocaleCompare(map,"RGB") == 0)
333 for (y=0; y < (ssize_t) rows; y++)
335 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
336 if (p == (const PixelPacket *) NULL)
338 for (x=0; x < (ssize_t) columns; x++)
340 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
341 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
342 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
348 if (LocaleCompare(map,"RGBA") == 0)
350 for (y=0; y < (ssize_t) rows; y++)
352 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
353 if (p == (const PixelPacket *) NULL)
355 for (x=0; x < (ssize_t) columns; x++)
357 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
358 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
359 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
360 *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
366 if (LocaleCompare(map,"RGBP") == 0)
368 for (y=0; y < (ssize_t) rows; y++)
370 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
371 if (p == (const PixelPacket *) NULL)
373 for (x=0; x < (ssize_t) columns; x++)
375 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
376 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
377 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
378 *q++=ScaleQuantumToChar((Quantum) 0);
384 for (y=0; y < (ssize_t) rows; y++)
386 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
387 if (p == (const PixelPacket *) NULL)
389 indexes=GetVirtualIndexQueue(image);
390 for (x=0; x < (ssize_t) columns; x++)
392 for (i=0; i < (ssize_t) length; i++)
395 switch (quantum_map[i])
400 *q=ScaleQuantumToChar(GetRedPixelComponent(p));
406 *q=ScaleQuantumToChar(GetGreenPixelComponent(p));
412 *q=ScaleQuantumToChar(GetBluePixelComponent(p));
417 *q=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
422 *q=ScaleQuantumToChar(GetOpacityPixelComponent(p));
427 if (image->colorspace == CMYKColorspace)
428 *q=ScaleQuantumToChar(indexes[x]);
433 *q=ScaleQuantumToChar(PixelIntensityToQuantum(p));
452 if (LocaleCompare(map,"BGR") == 0)
454 for (y=0; y < (ssize_t) rows; y++)
456 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
457 if (p == (const PixelPacket *) NULL)
459 for (x=0; x < (ssize_t) columns; x++)
461 *q++=(double) (QuantumScale*GetBluePixelComponent(p));
462 *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
463 *q++=(double) (QuantumScale*GetRedPixelComponent(p));
469 if (LocaleCompare(map,"BGRA") == 0)
471 for (y=0; y < (ssize_t) rows; y++)
473 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
474 if (p == (const PixelPacket *) NULL)
476 for (x=0; x < (ssize_t) columns; x++)
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))));
488 if (LocaleCompare(map,"BGRP") == 0)
490 for (y=0; y < (ssize_t) rows; y++)
492 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
493 if (p == (const PixelPacket *) NULL)
495 for (x=0; x < (ssize_t) columns; x++)
497 *q++=(double) (QuantumScale*GetBluePixelComponent(p));
498 *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
499 *q++=(double) (QuantumScale*GetRedPixelComponent(p));
506 if (LocaleCompare(map,"I") == 0)
508 for (y=0; y < (ssize_t) rows; y++)
510 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
511 if (p == (const PixelPacket *) NULL)
513 for (x=0; x < (ssize_t) columns; x++)
515 *q++=(double) (QuantumScale*PixelIntensityToQuantum(p));
521 if (LocaleCompare(map,"RGB") == 0)
523 for (y=0; y < (ssize_t) rows; y++)
525 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
526 if (p == (const PixelPacket *) NULL)
528 for (x=0; x < (ssize_t) columns; x++)
530 *q++=(double) (QuantumScale*GetRedPixelComponent(p));
531 *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
532 *q++=(double) (QuantumScale*GetBluePixelComponent(p));
538 if (LocaleCompare(map,"RGBA") == 0)
540 for (y=0; y < (ssize_t) rows; y++)
542 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
543 if (p == (const PixelPacket *) NULL)
545 for (x=0; x < (ssize_t) columns; x++)
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))));
557 if (LocaleCompare(map,"RGBP") == 0)
559 for (y=0; y < (ssize_t) rows; y++)
561 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
562 if (p == (const PixelPacket *) NULL)
564 for (x=0; x < (ssize_t) columns; x++)
566 *q++=(double) (QuantumScale*GetRedPixelComponent(p));
567 *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
568 *q++=(double) (QuantumScale*GetBluePixelComponent(p));
575 for (y=0; y < (ssize_t) rows; y++)
577 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
578 if (p == (const PixelPacket *) NULL)
580 indexes=GetVirtualIndexQueue(image);
581 for (x=0; x < (ssize_t) columns; x++)
583 for (i=0; i < (ssize_t) length; i++)
586 switch (quantum_map[i])
591 *q=(double) (QuantumScale*GetRedPixelComponent(p));
597 *q=(double) (QuantumScale*GetGreenPixelComponent(p));
603 *q=(double) (QuantumScale*GetBluePixelComponent(p));
608 *q=(double) (QuantumScale*((Quantum) (QuantumRange-
609 GetOpacityPixelComponent(p))));
614 *q=(double) (QuantumScale*GetOpacityPixelComponent(p));
619 if (image->colorspace == CMYKColorspace)
620 *q=(double) (QuantumScale*indexes[x]);
625 *q=(double) (QuantumScale*PixelIntensityToQuantum(p));
644 if (LocaleCompare(map,"BGR") == 0)
646 for (y=0; y < (ssize_t) rows; y++)
648 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
649 if (p == (const PixelPacket *) NULL)
651 for (x=0; x < (ssize_t) columns; x++)
653 *q++=(float) (QuantumScale*GetBluePixelComponent(p));
654 *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
655 *q++=(float) (QuantumScale*GetRedPixelComponent(p));
661 if (LocaleCompare(map,"BGRA") == 0)
663 for (y=0; y < (ssize_t) rows; y++)
665 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
666 if (p == (const PixelPacket *) NULL)
668 for (x=0; x < (ssize_t) columns; x++)
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)));
679 if (LocaleCompare(map,"BGRP") == 0)
681 for (y=0; y < (ssize_t) rows; y++)
683 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
684 if (p == (const PixelPacket *) NULL)
686 for (x=0; x < (ssize_t) columns; x++)
688 *q++=(float) (QuantumScale*GetBluePixelComponent(p));
689 *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
690 *q++=(float) (QuantumScale*GetRedPixelComponent(p));
697 if (LocaleCompare(map,"I") == 0)
699 for (y=0; y < (ssize_t) rows; y++)
701 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
702 if (p == (const PixelPacket *) NULL)
704 for (x=0; x < (ssize_t) columns; x++)
706 *q++=(float) (QuantumScale*PixelIntensityToQuantum(p));
712 if (LocaleCompare(map,"RGB") == 0)
714 for (y=0; y < (ssize_t) rows; y++)
716 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
717 if (p == (const PixelPacket *) NULL)
719 for (x=0; x < (ssize_t) columns; x++)
721 *q++=(float) (QuantumScale*GetRedPixelComponent(p));
722 *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
723 *q++=(float) (QuantumScale*GetBluePixelComponent(p));
729 if (LocaleCompare(map,"RGBA") == 0)
731 for (y=0; y < (ssize_t) rows; y++)
733 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
734 if (p == (const PixelPacket *) NULL)
736 for (x=0; x < (ssize_t) columns; x++)
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))));
747 if (LocaleCompare(map,"RGBP") == 0)
749 for (y=0; y < (ssize_t) rows; y++)
751 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
752 if (p == (const PixelPacket *) NULL)
754 for (x=0; x < (ssize_t) columns; x++)
756 *q++=(float) (QuantumScale*GetRedPixelComponent(p));
757 *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
758 *q++=(float) (QuantumScale*GetBluePixelComponent(p));
765 for (y=0; y < (ssize_t) rows; y++)
767 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
768 if (p == (const PixelPacket *) NULL)
770 indexes=GetVirtualIndexQueue(image);
771 for (x=0; x < (ssize_t) columns; x++)
773 for (i=0; i < (ssize_t) length; i++)
776 switch (quantum_map[i])
781 *q=(float) (QuantumScale*GetRedPixelComponent(p));
787 *q=(float) (QuantumScale*GetGreenPixelComponent(p));
793 *q=(float) (QuantumScale*GetBluePixelComponent(p));
798 *q=(float) (QuantumScale*((Quantum) (GetAlphaPixelComponent(p))));
803 *q=(float) (QuantumScale*GetOpacityPixelComponent(p));
808 if (image->colorspace == CMYKColorspace)
809 *q=(float) (QuantumScale*indexes[x]);
814 *q=(float) (QuantumScale*PixelIntensityToQuantum(p));
829 register unsigned int
832 q=(unsigned int *) pixels;
833 if (LocaleCompare(map,"BGR") == 0)
835 for (y=0; y < (ssize_t) rows; y++)
837 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
838 if (p == (const PixelPacket *) NULL)
840 for (x=0; x < (ssize_t) columns; x++)
842 *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
843 *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
844 *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
850 if (LocaleCompare(map,"BGRA") == 0)
852 for (y=0; y < (ssize_t) rows; y++)
854 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
855 if (p == (const PixelPacket *) NULL)
857 for (x=0; x < (ssize_t) columns; x++)
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)));
869 if (LocaleCompare(map,"BGRP") == 0)
871 for (y=0; y < (ssize_t) rows; y++)
873 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
874 if (p == (const PixelPacket *) NULL)
876 for (x=0; x < (ssize_t) columns; x++)
878 *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
879 *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
880 *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
887 if (LocaleCompare(map,"I") == 0)
889 for (y=0; y < (ssize_t) rows; y++)
891 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
892 if (p == (const PixelPacket *) NULL)
894 for (x=0; x < (ssize_t) columns; x++)
897 ScaleQuantumToLong(PixelIntensityToQuantum(p));
903 if (LocaleCompare(map,"RGB") == 0)
905 for (y=0; y < (ssize_t) rows; y++)
907 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
908 if (p == (const PixelPacket *) NULL)
910 for (x=0; x < (ssize_t) columns; x++)
912 *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
913 *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
914 *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
920 if (LocaleCompare(map,"RGBA") == 0)
922 for (y=0; y < (ssize_t) rows; y++)
924 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
925 if (p == (const PixelPacket *) NULL)
927 for (x=0; x < (ssize_t) columns; x++)
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)));
939 if (LocaleCompare(map,"RGBP") == 0)
941 for (y=0; y < (ssize_t) rows; y++)
943 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
944 if (p == (const PixelPacket *) NULL)
946 for (x=0; x < (ssize_t) columns; x++)
948 *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
949 *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
950 *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
957 for (y=0; y < (ssize_t) rows; y++)
959 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
960 if (p == (const PixelPacket *) NULL)
962 indexes=GetVirtualIndexQueue(image);
963 for (x=0; x < (ssize_t) columns; x++)
965 for (i=0; i < (ssize_t) length; i++)
968 switch (quantum_map[i])
973 *q=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
979 *q=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
985 *q=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
990 *q=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
991 GetOpacityPixelComponent(p)));
996 *q=(unsigned int) ScaleQuantumToLong(GetOpacityPixelComponent(p));
1001 if (image->colorspace == CMYKColorspace)
1002 *q=(unsigned int) ScaleQuantumToLong(indexes[x]);
1008 ScaleQuantumToLong(PixelIntensityToQuantum(p));
1026 q=(size_t *) pixels;
1027 if (LocaleCompare(map,"BGR") == 0)
1029 for (y=0; y < (ssize_t) rows; y++)
1031 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1032 if (p == (const PixelPacket *) NULL)
1034 for (x=0; x < (ssize_t) columns; x++)
1036 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1037 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1038 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1044 if (LocaleCompare(map,"BGRA") == 0)
1046 for (y=0; y < (ssize_t) rows; y++)
1048 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1049 if (p == (const PixelPacket *) NULL)
1051 for (x=0; x < (ssize_t) columns; x++)
1053 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1054 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1055 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1056 *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1062 if (LocaleCompare(map,"BGRP") == 0)
1064 for (y=0; y < (ssize_t) rows; y++)
1066 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1067 if (p == (const PixelPacket *) NULL)
1069 for (x=0; x < (ssize_t) columns; x++)
1071 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1072 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1073 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1080 if (LocaleCompare(map,"I") == 0)
1082 for (y=0; y < (ssize_t) rows; y++)
1084 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1085 if (p == (const PixelPacket *) NULL)
1087 for (x=0; x < (ssize_t) columns; x++)
1089 *q++=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1095 if (LocaleCompare(map,"RGB") == 0)
1097 for (y=0; y < (ssize_t) rows; y++)
1099 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1100 if (p == (const PixelPacket *) NULL)
1102 for (x=0; x < (ssize_t) columns; x++)
1104 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1105 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1106 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1112 if (LocaleCompare(map,"RGBA") == 0)
1114 for (y=0; y < (ssize_t) rows; y++)
1116 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1117 if (p == (const PixelPacket *) NULL)
1119 for (x=0; x < (ssize_t) columns; x++)
1121 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1122 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1123 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1124 *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1130 if (LocaleCompare(map,"RGBP") == 0)
1132 for (y=0; y < (ssize_t) rows; y++)
1134 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1135 if (p == (const PixelPacket *) NULL)
1137 for (x=0; x < (ssize_t) columns; x++)
1139 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1140 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1141 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1148 for (y=0; y < (ssize_t) rows; y++)
1150 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1151 if (p == (const PixelPacket *) NULL)
1153 indexes=GetVirtualIndexQueue(image);
1154 for (x=0; x < (ssize_t) columns; x++)
1156 for (i=0; i < (ssize_t) length; i++)
1159 switch (quantum_map[i])
1164 *q=ScaleQuantumToLong(GetRedPixelComponent(p));
1168 case MagentaQuantum:
1170 *q=ScaleQuantumToLong(GetGreenPixelComponent(p));
1176 *q=ScaleQuantumToLong(GetBluePixelComponent(p));
1181 *q=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1184 case OpacityQuantum:
1186 *q=ScaleQuantumToLong(GetOpacityPixelComponent(p));
1191 if (image->colorspace == CMYKColorspace)
1192 *q=ScaleQuantumToLong(indexes[x]);
1197 *q=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1215 q=(Quantum *) pixels;
1216 if (LocaleCompare(map,"BGR") == 0)
1218 for (y=0; y < (ssize_t) rows; y++)
1220 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1221 if (p == (const PixelPacket *) NULL)
1223 for (x=0; x < (ssize_t) columns; x++)
1225 *q++=GetBluePixelComponent(p);
1226 *q++=GetGreenPixelComponent(p);
1227 *q++=GetRedPixelComponent(p);
1233 if (LocaleCompare(map,"BGRA") == 0)
1235 for (y=0; y < (ssize_t) rows; y++)
1237 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1238 if (p == (const PixelPacket *) NULL)
1240 for (x=0; x < (ssize_t) columns; x++)
1242 *q++=GetBluePixelComponent(p);
1243 *q++=GetGreenPixelComponent(p);
1244 *q++=GetRedPixelComponent(p);
1245 *q++=(Quantum) (GetAlphaPixelComponent(p));
1251 if (LocaleCompare(map,"BGRP") == 0)
1253 for (y=0; y < (ssize_t) rows; y++)
1255 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1256 if (p == (const PixelPacket *) NULL)
1258 for (x=0; x < (ssize_t) columns; x++)
1260 *q++=GetBluePixelComponent(p);
1261 *q++=GetGreenPixelComponent(p);
1262 *q++=GetRedPixelComponent(p);
1269 if (LocaleCompare(map,"I") == 0)
1271 for (y=0; y < (ssize_t) rows; y++)
1273 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1274 if (p == (const PixelPacket *) NULL)
1276 for (x=0; x < (ssize_t) columns; x++)
1278 *q++=PixelIntensityToQuantum(p);
1284 if (LocaleCompare(map,"RGB") == 0)
1286 for (y=0; y < (ssize_t) rows; y++)
1288 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1289 if (p == (const PixelPacket *) NULL)
1291 for (x=0; x < (ssize_t) columns; x++)
1293 *q++=GetRedPixelComponent(p);
1294 *q++=GetGreenPixelComponent(p);
1295 *q++=GetBluePixelComponent(p);
1301 if (LocaleCompare(map,"RGBA") == 0)
1303 for (y=0; y < (ssize_t) rows; y++)
1305 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1306 if (p == (const PixelPacket *) NULL)
1308 for (x=0; x < (ssize_t) columns; x++)
1310 *q++=GetRedPixelComponent(p);
1311 *q++=GetGreenPixelComponent(p);
1312 *q++=GetBluePixelComponent(p);
1313 *q++=(Quantum) (GetAlphaPixelComponent(p));
1319 if (LocaleCompare(map,"RGBP") == 0)
1321 for (y=0; y < (ssize_t) rows; y++)
1323 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1324 if (p == (const PixelPacket *) NULL)
1326 for (x=0; x < (ssize_t) columns; x++)
1328 *q++=GetRedPixelComponent(p);
1329 *q++=GetGreenPixelComponent(p);
1330 *q++=GetBluePixelComponent(p);
1337 for (y=0; y < (ssize_t) rows; y++)
1339 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1340 if (p == (const PixelPacket *) NULL)
1342 indexes=GetVirtualIndexQueue(image);
1343 for (x=0; x < (ssize_t) columns; x++)
1345 for (i=0; i < (ssize_t) length; i++)
1348 switch (quantum_map[i])
1353 *q=GetRedPixelComponent(p);
1357 case MagentaQuantum:
1359 *q=GetGreenPixelComponent(p);
1365 *q=GetBluePixelComponent(p);
1370 *q=(Quantum) (GetAlphaPixelComponent(p));
1373 case OpacityQuantum:
1375 *q=GetOpacityPixelComponent(p);
1380 if (image->colorspace == CMYKColorspace)
1386 *q=(PixelIntensityToQuantum(p));
1401 register unsigned short
1404 q=(unsigned short *) pixels;
1405 if (LocaleCompare(map,"BGR") == 0)
1407 for (y=0; y < (ssize_t) rows; y++)
1409 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1410 if (p == (const PixelPacket *) NULL)
1412 for (x=0; x < (ssize_t) columns; x++)
1414 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1415 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1416 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1422 if (LocaleCompare(map,"BGRA") == 0)
1424 for (y=0; y < (ssize_t) rows; y++)
1426 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1427 if (p == (const PixelPacket *) NULL)
1429 for (x=0; x < (ssize_t) columns; x++)
1431 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1432 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1433 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1434 *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1440 if (LocaleCompare(map,"BGRP") == 0)
1442 for (y=0; y < (ssize_t) rows; y++)
1444 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1445 if (p == (const PixelPacket *) NULL)
1447 for (x=0; x < (ssize_t) columns; x++)
1449 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1450 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1451 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1458 if (LocaleCompare(map,"I") == 0)
1460 for (y=0; y < (ssize_t) rows; y++)
1462 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1463 if (p == (const PixelPacket *) NULL)
1465 for (x=0; x < (ssize_t) columns; x++)
1467 *q++=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1473 if (LocaleCompare(map,"RGB") == 0)
1475 for (y=0; y < (ssize_t) rows; y++)
1477 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1478 if (p == (const PixelPacket *) NULL)
1480 for (x=0; x < (ssize_t) columns; x++)
1482 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1483 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1484 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1490 if (LocaleCompare(map,"RGBA") == 0)
1492 for (y=0; y < (ssize_t) rows; y++)
1494 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1495 if (p == (const PixelPacket *) NULL)
1497 for (x=0; x < (ssize_t) columns; x++)
1499 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1500 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1501 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1502 *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1508 if (LocaleCompare(map,"RGBP") == 0)
1510 for (y=0; y < (ssize_t) rows; y++)
1512 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1513 if (p == (const PixelPacket *) NULL)
1515 for (x=0; x < (ssize_t) columns; x++)
1517 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1518 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1519 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1526 for (y=0; y < (ssize_t) rows; y++)
1528 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1529 if (p == (const PixelPacket *) NULL)
1531 indexes=GetVirtualIndexQueue(image);
1532 for (x=0; x < (ssize_t) columns; x++)
1534 for (i=0; i < (ssize_t) length; i++)
1537 switch (quantum_map[i])
1542 *q=ScaleQuantumToShort(GetRedPixelComponent(p));
1546 case MagentaQuantum:
1548 *q=ScaleQuantumToShort(GetGreenPixelComponent(p));
1554 *q=ScaleQuantumToShort(GetBluePixelComponent(p));
1559 *q=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1562 case OpacityQuantum:
1564 *q=ScaleQuantumToShort(GetOpacityPixelComponent(p));
1569 if (image->colorspace == CMYKColorspace)
1570 *q=ScaleQuantumToShort(indexes[x]);
1575 *q=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1590 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1591 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1592 "UnrecognizedPixelMap","`%s'",map);
1596 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1601 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1605 % G e t M a g i c k P i x e l P a c k e t %
1609 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1611 % GetMagickPixelPacket() initializes the MagickPixelPacket structure.
1613 % The format of the GetMagickPixelPacket method is:
1615 % GetMagickPixelPacket(const Image *image,MagickPixelPacket *pixel)
1617 % A description of each parameter follows:
1619 % o image: the image.
1621 % o pixel: Specifies a pointer to a PixelPacket structure.
1624 MagickExport void GetMagickPixelPacket(const Image *image,
1625 MagickPixelPacket *pixel)
1627 pixel->storage_class=DirectClass;
1628 pixel->colorspace=RGBColorspace;
1629 pixel->matte=MagickFalse;
1631 pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
1635 pixel->opacity=(MagickRealType) OpaqueOpacity;
1637 if (image == (const Image *) NULL)
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;
1647 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1651 % I m p o r t I m a g e P i x e l s %
1655 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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.
1662 % Suppose your want to upload the first scanline of a 640x480 image from
1663 % character data in red-green-blue order:
1665 % ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
1667 % The format of the ImportImagePixels method is:
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)
1674 % A description of each parameter follows:
1676 % o image: the image.
1678 % o x_offset,y_offset,columns,rows: These values define the perimeter
1679 % of a region of pixels you want to define.
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),
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
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.
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,
1711 register IndexPacket
1725 Allocate image structure.
1727 assert(image != (Image *) NULL);
1728 assert(image->signature == MagickSignature);
1729 if (image->debug != MagickFalse)
1730 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1732 quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
1733 if (quantum_map == (QuantumType *) NULL)
1734 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1736 for (i=0; i < (ssize_t) length; i++)
1743 quantum_map[i]=AlphaQuantum;
1744 image->matte=MagickTrue;
1750 quantum_map[i]=BlueQuantum;
1756 quantum_map[i]=CyanQuantum;
1757 (void) SetImageColorspace(image,CMYKColorspace);
1763 quantum_map[i]=GreenQuantum;
1769 quantum_map[i]=BlackQuantum;
1770 (void) SetImageColorspace(image,CMYKColorspace);
1776 quantum_map[i]=IndexQuantum;
1782 quantum_map[i]=MagentaQuantum;
1783 (void) SetImageColorspace(image,CMYKColorspace);
1789 quantum_map[i]=OpacityQuantum;
1790 image->matte=MagickTrue;
1796 quantum_map[i]=UndefinedQuantum;
1802 quantum_map[i]=RedQuantum;
1808 quantum_map[i]=YellowQuantum;
1809 (void) SetImageColorspace(image,CMYKColorspace);
1814 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1815 (void) ThrowMagickException(&image->exception,GetMagickModule(),
1816 OptionError,"UnrecognizedPixelMap","`%s'",map);
1817 return(MagickFalse);
1821 if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1822 return(MagickFalse);
1824 Transfer the pixels from the pixel datarray to the image.
1826 exception=(&image->exception);
1831 register const unsigned char
1834 p=(const unsigned char *) pixels;
1835 if (LocaleCompare(map,"BGR") == 0)
1837 for (y=0; y < (ssize_t) rows; y++)
1839 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1840 if (q == (PixelPacket *) NULL)
1842 for (x=0; x < (ssize_t) columns; x++)
1844 q->blue=ScaleCharToQuantum(*p++);
1845 q->green=ScaleCharToQuantum(*p++);
1846 q->red=ScaleCharToQuantum(*p++);
1849 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1854 if (LocaleCompare(map,"BGRA") == 0)
1856 for (y=0; y < (ssize_t) rows; y++)
1858 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1859 if (q == (PixelPacket *) NULL)
1861 for (x=0; x < (ssize_t) columns; x++)
1863 q->blue=ScaleCharToQuantum(*p++);
1864 q->green=ScaleCharToQuantum(*p++);
1865 q->red=ScaleCharToQuantum(*p++);
1866 q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
1869 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1874 if (LocaleCompare(map,"BGRO") == 0)
1876 for (y=0; y < (ssize_t) rows; y++)
1878 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1879 if (q == (PixelPacket *) NULL)
1881 for (x=0; x < (ssize_t) columns; x++)
1883 q->blue=ScaleCharToQuantum(*p++);
1884 q->green=ScaleCharToQuantum(*p++);
1885 q->red=ScaleCharToQuantum(*p++);
1886 q->opacity=ScaleCharToQuantum(*p++);
1889 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1894 if (LocaleCompare(map,"BGRP") == 0)
1896 for (y=0; y < (ssize_t) rows; y++)
1898 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1899 if (q == (PixelPacket *) NULL)
1901 for (x=0; x < (ssize_t) columns; x++)
1903 q->blue=ScaleCharToQuantum(*p++);
1904 q->green=ScaleCharToQuantum(*p++);
1905 q->red=ScaleCharToQuantum(*p++);
1909 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1914 if (LocaleCompare(map,"I") == 0)
1916 for (y=0; y < (ssize_t) rows; y++)
1918 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1919 if (q == (PixelPacket *) NULL)
1921 for (x=0; x < (ssize_t) columns; x++)
1923 q->red=ScaleCharToQuantum(*p++);
1928 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1933 if (LocaleCompare(map,"RGB") == 0)
1935 for (y=0; y < (ssize_t) rows; y++)
1937 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1938 if (q == (PixelPacket *) NULL)
1940 for (x=0; x < (ssize_t) columns; x++)
1942 q->red=ScaleCharToQuantum(*p++);
1943 q->green=ScaleCharToQuantum(*p++);
1944 q->blue=ScaleCharToQuantum(*p++);
1947 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1952 if (LocaleCompare(map,"RGBA") == 0)
1954 for (y=0; y < (ssize_t) rows; y++)
1956 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1957 if (q == (PixelPacket *) NULL)
1959 for (x=0; x < (ssize_t) columns; x++)
1961 q->red=ScaleCharToQuantum(*p++);
1962 q->green=ScaleCharToQuantum(*p++);
1963 q->blue=ScaleCharToQuantum(*p++);
1964 q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
1967 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1972 if (LocaleCompare(map,"RGBO") == 0)
1974 for (y=0; y < (ssize_t) rows; y++)
1976 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1977 if (q == (PixelPacket *) NULL)
1979 for (x=0; x < (ssize_t) columns; x++)
1981 q->red=ScaleCharToQuantum(*p++);
1982 q->green=ScaleCharToQuantum(*p++);
1983 q->blue=ScaleCharToQuantum(*p++);
1984 q->opacity=ScaleCharToQuantum(*p++);
1987 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1992 if (LocaleCompare(map,"RGBP") == 0)
1994 for (y=0; y < (ssize_t) rows; y++)
1996 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1997 if (q == (PixelPacket *) NULL)
1999 for (x=0; x < (ssize_t) columns; x++)
2001 q->red=ScaleCharToQuantum(*p++);
2002 q->green=ScaleCharToQuantum(*p++);
2003 q->blue=ScaleCharToQuantum(*p++);
2007 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2012 for (y=0; y < (ssize_t) rows; y++)
2014 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2015 if (q == (PixelPacket *) NULL)
2017 indexes=GetAuthenticIndexQueue(image);
2018 for (x=0; x < (ssize_t) columns; x++)
2020 for (i=0; i < (ssize_t) length; i++)
2022 switch (quantum_map[i])
2027 q->red=ScaleCharToQuantum(*p);
2031 case MagentaQuantum:
2033 q->green=ScaleCharToQuantum(*p);
2039 q->blue=ScaleCharToQuantum(*p);
2044 q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p);
2047 case OpacityQuantum:
2049 q->opacity=ScaleCharToQuantum(*p);
2054 indexes[x]=ScaleCharToQuantum(*p);
2059 q->red=ScaleCharToQuantum(*p);
2071 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2078 register const double
2081 p=(const double *) pixels;
2082 if (LocaleCompare(map,"BGR") == 0)
2084 for (y=0; y < (ssize_t) rows; y++)
2086 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2087 if (q == (PixelPacket *) NULL)
2089 for (x=0; x < (ssize_t) columns; x++)
2091 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2093 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2095 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2099 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2104 if (LocaleCompare(map,"BGRA") == 0)
2106 for (y=0; y < (ssize_t) rows; y++)
2108 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2109 if (q == (PixelPacket *) NULL)
2111 for (x=0; x < (ssize_t) columns; x++)
2113 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2115 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2117 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2119 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2124 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2129 if (LocaleCompare(map,"BGRP") == 0)
2131 for (y=0; y < (ssize_t) rows; y++)
2133 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2134 if (q == (PixelPacket *) NULL)
2136 for (x=0; x < (ssize_t) columns; x++)
2138 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2140 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2142 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2147 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2152 if (LocaleCompare(map,"I") == 0)
2154 for (y=0; y < (ssize_t) rows; y++)
2156 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2157 if (q == (PixelPacket *) NULL)
2159 for (x=0; x < (ssize_t) columns; x++)
2161 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2167 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2172 if (LocaleCompare(map,"RGB") == 0)
2174 for (y=0; y < (ssize_t) rows; y++)
2176 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2177 if (q == (PixelPacket *) NULL)
2179 for (x=0; x < (ssize_t) columns; x++)
2181 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2183 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2185 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2189 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2194 if (LocaleCompare(map,"RGBA") == 0)
2196 for (y=0; y < (ssize_t) rows; y++)
2198 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2199 if (q == (PixelPacket *) NULL)
2201 for (x=0; x < (ssize_t) columns; x++)
2203 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2205 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2207 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2209 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2214 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2219 if (LocaleCompare(map,"RGBP") == 0)
2221 for (y=0; y < (ssize_t) rows; y++)
2223 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2224 if (q == (PixelPacket *) NULL)
2226 for (x=0; x < (ssize_t) columns; x++)
2228 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2230 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2232 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2236 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2241 for (y=0; y < (ssize_t) rows; y++)
2243 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2244 if (q == (PixelPacket *) NULL)
2246 indexes=GetAuthenticIndexQueue(image);
2247 for (x=0; x < (ssize_t) columns; x++)
2249 for (i=0; i < (ssize_t) length; i++)
2251 switch (quantum_map[i])
2256 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2260 case MagentaQuantum:
2262 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2268 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2273 q->opacity=(Quantum) QuantumRange-ClampToQuantum(
2274 (MagickRealType) QuantumRange*(*p));
2277 case OpacityQuantum:
2279 q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2284 indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2289 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2301 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2308 register const float
2311 p=(const float *) pixels;
2312 if (LocaleCompare(map,"BGR") == 0)
2314 for (y=0; y < (ssize_t) rows; y++)
2316 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2317 if (q == (PixelPacket *) NULL)
2319 for (x=0; x < (ssize_t) columns; x++)
2321 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2323 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2325 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2329 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2334 if (LocaleCompare(map,"BGRA") == 0)
2336 for (y=0; y < (ssize_t) rows; y++)
2338 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2339 if (q == (PixelPacket *) NULL)
2341 for (x=0; x < (ssize_t) columns; x++)
2343 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2345 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2347 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2349 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2354 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2359 if (LocaleCompare(map,"BGRP") == 0)
2361 for (y=0; y < (ssize_t) rows; y++)
2363 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2364 if (q == (PixelPacket *) NULL)
2366 for (x=0; x < (ssize_t) columns; x++)
2368 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2370 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2372 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2377 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2382 if (LocaleCompare(map,"I") == 0)
2384 for (y=0; y < (ssize_t) rows; y++)
2386 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2387 if (q == (PixelPacket *) NULL)
2389 for (x=0; x < (ssize_t) columns; x++)
2391 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2397 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2402 if (LocaleCompare(map,"RGB") == 0)
2404 for (y=0; y < (ssize_t) rows; y++)
2406 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2407 if (q == (PixelPacket *) NULL)
2409 for (x=0; x < (ssize_t) columns; x++)
2411 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2413 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2415 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2419 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2424 if (LocaleCompare(map,"RGBA") == 0)
2426 for (y=0; y < (ssize_t) rows; y++)
2428 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2429 if (q == (PixelPacket *) NULL)
2431 for (x=0; x < (ssize_t) columns; x++)
2433 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2435 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2437 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2439 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2444 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2449 if (LocaleCompare(map,"RGBP") == 0)
2451 for (y=0; y < (ssize_t) rows; y++)
2453 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2454 if (q == (PixelPacket *) NULL)
2456 for (x=0; x < (ssize_t) columns; x++)
2458 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2460 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2462 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2466 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2471 for (y=0; y < (ssize_t) rows; y++)
2473 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2474 if (q == (PixelPacket *) NULL)
2476 indexes=GetAuthenticIndexQueue(image);
2477 for (x=0; x < (ssize_t) columns; x++)
2479 for (i=0; i < (ssize_t) length; i++)
2481 switch (quantum_map[i])
2486 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2490 case MagentaQuantum:
2492 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2498 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2503 q->opacity=(Quantum) QuantumRange-ClampToQuantum(
2504 (MagickRealType) QuantumRange*(*p));
2507 case OpacityQuantum:
2509 q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2514 indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2519 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2531 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2538 register const unsigned int
2541 p=(const unsigned int *) pixels;
2542 if (LocaleCompare(map,"BGR") == 0)
2544 for (y=0; y < (ssize_t) rows; y++)
2546 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2547 if (q == (PixelPacket *) NULL)
2549 for (x=0; x < (ssize_t) columns; x++)
2551 q->blue=ScaleLongToQuantum(*p++);
2552 q->green=ScaleLongToQuantum(*p++);
2553 q->red=ScaleLongToQuantum(*p++);
2556 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2561 if (LocaleCompare(map,"BGRA") == 0)
2563 for (y=0; y < (ssize_t) rows; y++)
2565 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2566 if (q == (PixelPacket *) NULL)
2568 for (x=0; x < (ssize_t) columns; x++)
2570 q->blue=ScaleLongToQuantum(*p++);
2571 q->green=ScaleLongToQuantum(*p++);
2572 q->red=ScaleLongToQuantum(*p++);
2573 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2576 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2581 if (LocaleCompare(map,"BGRP") == 0)
2583 for (y=0; y < (ssize_t) rows; y++)
2585 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2586 if (q == (PixelPacket *) NULL)
2588 for (x=0; x < (ssize_t) columns; x++)
2590 q->blue=ScaleLongToQuantum(*p++);
2591 q->green=ScaleLongToQuantum(*p++);
2592 q->red=ScaleLongToQuantum(*p++);
2596 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2601 if (LocaleCompare(map,"I") == 0)
2603 for (y=0; y < (ssize_t) rows; y++)
2605 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2606 if (q == (PixelPacket *) NULL)
2608 for (x=0; x < (ssize_t) columns; x++)
2610 q->red=ScaleLongToQuantum(*p++);
2615 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2620 if (LocaleCompare(map,"RGB") == 0)
2622 for (y=0; y < (ssize_t) rows; y++)
2624 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2625 if (q == (PixelPacket *) NULL)
2627 for (x=0; x < (ssize_t) columns; x++)
2629 q->red=ScaleLongToQuantum(*p++);
2630 q->green=ScaleLongToQuantum(*p++);
2631 q->blue=ScaleLongToQuantum(*p++);
2634 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2639 if (LocaleCompare(map,"RGBA") == 0)
2641 for (y=0; y < (ssize_t) rows; y++)
2643 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2644 if (q == (PixelPacket *) NULL)
2646 for (x=0; x < (ssize_t) columns; x++)
2648 q->red=ScaleLongToQuantum(*p++);
2649 q->green=ScaleLongToQuantum(*p++);
2650 q->blue=ScaleLongToQuantum(*p++);
2651 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2654 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2659 if (LocaleCompare(map,"RGBP") == 0)
2661 for (y=0; y < (ssize_t) rows; y++)
2663 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2664 if (q == (PixelPacket *) NULL)
2666 for (x=0; x < (ssize_t) columns; x++)
2668 q->red=ScaleLongToQuantum(*p++);
2669 q->green=ScaleLongToQuantum(*p++);
2670 q->blue=ScaleLongToQuantum(*p++);
2674 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2679 for (y=0; y < (ssize_t) rows; y++)
2681 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2682 if (q == (PixelPacket *) NULL)
2684 indexes=GetAuthenticIndexQueue(image);
2685 for (x=0; x < (ssize_t) columns; x++)
2687 for (i=0; i < (ssize_t) length; i++)
2689 switch (quantum_map[i])
2694 q->red=ScaleLongToQuantum(*p);
2698 case MagentaQuantum:
2700 q->green=ScaleLongToQuantum(*p);
2706 q->blue=ScaleLongToQuantum(*p);
2711 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
2714 case OpacityQuantum:
2716 q->opacity=ScaleLongToQuantum(*p);
2721 indexes[x]=ScaleLongToQuantum(*p);
2726 q->red=ScaleLongToQuantum(*p);
2738 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2745 register const unsigned int
2748 p=(const unsigned int *) pixels;
2749 if (LocaleCompare(map,"BGR") == 0)
2751 for (y=0; y < (ssize_t) rows; y++)
2753 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2754 if (q == (PixelPacket *) NULL)
2756 for (x=0; x < (ssize_t) columns; x++)
2758 q->blue=ScaleLongToQuantum(*p++);
2759 q->green=ScaleLongToQuantum(*p++);
2760 q->red=ScaleLongToQuantum(*p++);
2763 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2768 if (LocaleCompare(map,"BGRA") == 0)
2770 for (y=0; y < (ssize_t) rows; y++)
2772 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2773 if (q == (PixelPacket *) NULL)
2775 for (x=0; x < (ssize_t) columns; x++)
2777 q->blue=ScaleLongToQuantum(*p++);
2778 q->green=ScaleLongToQuantum(*p++);
2779 q->red=ScaleLongToQuantum(*p++);
2780 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2783 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2788 if (LocaleCompare(map,"BGRP") == 0)
2790 for (y=0; y < (ssize_t) rows; y++)
2792 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2793 if (q == (PixelPacket *) NULL)
2795 for (x=0; x < (ssize_t) columns; x++)
2797 q->blue=ScaleLongToQuantum(*p++);
2798 q->green=ScaleLongToQuantum(*p++);
2799 q->red=ScaleLongToQuantum(*p++);
2803 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2808 if (LocaleCompare(map,"I") == 0)
2810 for (y=0; y < (ssize_t) rows; y++)
2812 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2813 if (q == (PixelPacket *) NULL)
2815 for (x=0; x < (ssize_t) columns; x++)
2817 q->red=ScaleLongToQuantum(*p++);
2822 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2827 if (LocaleCompare(map,"RGB") == 0)
2829 for (y=0; y < (ssize_t) rows; y++)
2831 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2832 if (q == (PixelPacket *) NULL)
2834 for (x=0; x < (ssize_t) columns; x++)
2836 q->red=ScaleLongToQuantum(*p++);
2837 q->green=ScaleLongToQuantum(*p++);
2838 q->blue=ScaleLongToQuantum(*p++);
2841 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2846 if (LocaleCompare(map,"RGBA") == 0)
2848 for (y=0; y < (ssize_t) rows; y++)
2850 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2851 if (q == (PixelPacket *) NULL)
2853 for (x=0; x < (ssize_t) columns; x++)
2855 q->red=ScaleLongToQuantum(*p++);
2856 q->green=ScaleLongToQuantum(*p++);
2857 q->blue=ScaleLongToQuantum(*p++);
2858 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2861 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2866 if (LocaleCompare(map,"RGBP") == 0)
2868 for (y=0; y < (ssize_t) rows; y++)
2870 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2871 if (q == (PixelPacket *) NULL)
2873 for (x=0; x < (ssize_t) columns; x++)
2875 q->red=ScaleLongToQuantum(*p++);
2876 q->green=ScaleLongToQuantum(*p++);
2877 q->blue=ScaleLongToQuantum(*p++);
2881 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2886 for (y=0; y < (ssize_t) rows; y++)
2888 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2889 if (q == (PixelPacket *) NULL)
2891 indexes=GetAuthenticIndexQueue(image);
2892 for (x=0; x < (ssize_t) columns; x++)
2894 for (i=0; i < (ssize_t) length; i++)
2896 switch (quantum_map[i])
2901 q->red=ScaleLongToQuantum(*p);
2905 case MagentaQuantum:
2907 q->green=ScaleLongToQuantum(*p);
2913 q->blue=ScaleLongToQuantum(*p);
2918 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
2921 case OpacityQuantum:
2923 q->opacity=ScaleLongToQuantum(*p);
2928 indexes[x]=ScaleLongToQuantum(*p);
2933 q->red=ScaleLongToQuantum(*p);
2945 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2952 register const Quantum
2955 p=(const Quantum *) pixels;
2956 if (LocaleCompare(map,"BGR") == 0)
2958 for (y=0; y < (ssize_t) rows; y++)
2960 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2961 if (q == (PixelPacket *) NULL)
2963 for (x=0; x < (ssize_t) columns; x++)
2970 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2975 if (LocaleCompare(map,"BGRA") == 0)
2977 for (y=0; y < (ssize_t) rows; y++)
2979 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2980 if (q == (PixelPacket *) NULL)
2982 for (x=0; x < (ssize_t) columns; x++)
2987 q->opacity=(Quantum) QuantumRange-(*p++);
2990 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2995 if (LocaleCompare(map,"BGRP") == 0)
2997 for (y=0; y < (ssize_t) rows; y++)
2999 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3000 if (q == (PixelPacket *) NULL)
3002 for (x=0; x < (ssize_t) columns; x++)
3010 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3015 if (LocaleCompare(map,"I") == 0)
3017 for (y=0; y < (ssize_t) rows; y++)
3019 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3020 if (q == (PixelPacket *) NULL)
3022 for (x=0; x < (ssize_t) columns; x++)
3029 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3034 if (LocaleCompare(map,"RGB") == 0)
3036 for (y=0; y < (ssize_t) rows; y++)
3038 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3039 if (q == (PixelPacket *) NULL)
3041 for (x=0; x < (ssize_t) columns; x++)
3048 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3053 if (LocaleCompare(map,"RGBA") == 0)
3055 for (y=0; y < (ssize_t) rows; y++)
3057 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3058 if (q == (PixelPacket *) NULL)
3060 for (x=0; x < (ssize_t) columns; x++)
3065 q->opacity=(Quantum) QuantumRange-(*p++);
3068 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3073 if (LocaleCompare(map,"RGBP") == 0)
3075 for (y=0; y < (ssize_t) rows; y++)
3077 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3078 if (q == (PixelPacket *) NULL)
3080 for (x=0; x < (ssize_t) columns; x++)
3088 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3093 for (y=0; y < (ssize_t) rows; y++)
3095 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3096 if (q == (PixelPacket *) NULL)
3098 indexes=GetAuthenticIndexQueue(image);
3099 for (x=0; x < (ssize_t) columns; x++)
3101 for (i=0; i < (ssize_t) length; i++)
3103 switch (quantum_map[i])
3112 case MagentaQuantum:
3125 q->opacity=(Quantum) QuantumRange-(*p);
3128 case OpacityQuantum:
3152 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3159 register const unsigned short
3162 p=(const unsigned short *) pixels;
3163 if (LocaleCompare(map,"BGR") == 0)
3165 for (y=0; y < (ssize_t) rows; y++)
3167 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3168 if (q == (PixelPacket *) NULL)
3170 for (x=0; x < (ssize_t) columns; x++)
3172 q->blue=ScaleShortToQuantum(*p++);
3173 q->green=ScaleShortToQuantum(*p++);
3174 q->red=ScaleShortToQuantum(*p++);
3177 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3182 if (LocaleCompare(map,"BGRA") == 0)
3184 for (y=0; y < (ssize_t) rows; y++)
3186 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3187 if (q == (PixelPacket *) NULL)
3189 for (x=0; x < (ssize_t) columns; x++)
3191 q->blue=ScaleShortToQuantum(*p++);
3192 q->green=ScaleShortToQuantum(*p++);
3193 q->red=ScaleShortToQuantum(*p++);
3194 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
3197 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3202 if (LocaleCompare(map,"BGRP") == 0)
3204 for (y=0; y < (ssize_t) rows; y++)
3206 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3207 if (q == (PixelPacket *) NULL)
3209 for (x=0; x < (ssize_t) columns; x++)
3211 q->blue=ScaleShortToQuantum(*p++);
3212 q->green=ScaleShortToQuantum(*p++);
3213 q->red=ScaleShortToQuantum(*p++);
3217 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3222 if (LocaleCompare(map,"I") == 0)
3224 for (y=0; y < (ssize_t) rows; y++)
3226 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3227 if (q == (PixelPacket *) NULL)
3229 for (x=0; x < (ssize_t) columns; x++)
3231 q->red=ScaleShortToQuantum(*p++);
3236 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3241 if (LocaleCompare(map,"RGB") == 0)
3243 for (y=0; y < (ssize_t) rows; y++)
3245 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3246 if (q == (PixelPacket *) NULL)
3248 for (x=0; x < (ssize_t) columns; x++)
3250 q->red=ScaleShortToQuantum(*p++);
3251 q->green=ScaleShortToQuantum(*p++);
3252 q->blue=ScaleShortToQuantum(*p++);
3255 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3260 if (LocaleCompare(map,"RGBA") == 0)
3262 for (y=0; y < (ssize_t) rows; y++)
3264 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3265 if (q == (PixelPacket *) NULL)
3267 for (x=0; x < (ssize_t) columns; x++)
3269 q->red=ScaleShortToQuantum(*p++);
3270 q->green=ScaleShortToQuantum(*p++);
3271 q->blue=ScaleShortToQuantum(*p++);
3272 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
3275 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3280 if (LocaleCompare(map,"RGBP") == 0)
3282 for (y=0; y < (ssize_t) rows; y++)
3284 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3285 if (q == (PixelPacket *) NULL)
3287 for (x=0; x < (ssize_t) columns; x++)
3289 q->red=ScaleShortToQuantum(*p++);
3290 q->green=ScaleShortToQuantum(*p++);
3291 q->blue=ScaleShortToQuantum(*p++);
3295 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3300 for (y=0; y < (ssize_t) rows; y++)
3302 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3303 if (q == (PixelPacket *) NULL)
3305 indexes=GetAuthenticIndexQueue(image);
3306 for (x=0; x < (ssize_t) columns; x++)
3308 for (i=0; i < (ssize_t) length; i++)
3310 switch (quantum_map[i])
3315 q->red=ScaleShortToQuantum(*p);
3319 case MagentaQuantum:
3321 q->green=ScaleShortToQuantum(*p);
3327 q->blue=ScaleShortToQuantum(*p);
3332 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p);
3335 case OpacityQuantum:
3337 q->opacity=ScaleShortToQuantum(*p);
3342 indexes[x]=ScaleShortToQuantum(*p);
3347 q->red=ScaleShortToQuantum(*p);
3359 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3366 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3367 (void) ThrowMagickException(&image->exception,GetMagickModule(),
3368 OptionError,"UnrecognizedPixelMap","`%s'",map);
3372 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);