Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / ImageMagick / 3ed852eea50f9d4cd633efb8c2b054b8e33c2530 / . / magick / quantum-export.c
blob: c3b9d1827338222dbe2918cbf1bb416ee26c6b48 [file] [log] [blame]
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame^]1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% QQQ U U AAA N N TTTTT U U M M %
7% Q Q U U A A NN N T U U MM MM %
8% Q Q U U AAAAA N N N T U U M M M %
9% Q QQ U U A A N NN T U U M M %
10% QQQQ UUU A A N N T UUU M M %
11% %
12% EEEEE X X PPPP OOO RRRR TTTTT %
13% E X X P P O O R R T %
14% EEE X PPPP O O RRRR T %
15% E X X P O O R R T %
16% EEEEE X X P OOO R R T %
17% %
18% MagickCore Methods to Export Quantum Pixels %
19% %
20% Software Design %
21% John Cristy %
22% October 1998 %
23% %
24% %
25% Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization %
26% dedicated to making software imaging solutions freely available. %
27% %
28% You may not use this file except in compliance with the License. You may %
29% obtain a copy of the License at %
30% %
31% http://www.imagemagick.org/script/license.php %
32% %
33% Unless required by applicable law or agreed to in writing, software %
34% distributed under the License is distributed on an "AS IS" BASIS, %
35% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
36% See the License for the specific language governing permissions and %
37% limitations under the License. %
38% %
39%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
40%
41%
42*/
43
44/*
45 Include declarations.
46*/
47#include "magick/studio.h"
48#include "magick/property.h"
49#include "magick/blob.h"
50#include "magick/blob-private.h"
51#include "magick/color-private.h"
52#include "magick/exception.h"
53#include "magick/exception-private.h"
54#include "magick/cache.h"
55#include "magick/constitute.h"
56#include "magick/delegate.h"
57#include "magick/geometry.h"
58#include "magick/list.h"
59#include "magick/magick.h"
60#include "magick/memory_.h"
61#include "magick/monitor.h"
62#include "magick/option.h"
63#include "magick/pixel.h"
64#include "magick/pixel-private.h"
65#include "magick/quantum.h"
66#include "magick/quantum-private.h"
67#include "magick/resource_.h"
68#include "magick/semaphore.h"
69#include "magick/statistic.h"
70#include "magick/stream.h"
71#include "magick/string_.h"
72#include "magick/utility.h"
73
74/*
75%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
76% %
77% %
78% %
79+ E x p o r t Q u a n t u m P i x e l s %
80% %
81% %
82% %
83%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
84%
85% ExportQuantumPixels() transfers one or more pixel components from the image
86% pixel cache to a user supplied buffer. The pixels are returned in network
87% byte order. MagickTrue is returned if the pixels are successfully
88% transferred, otherwise MagickFalse.
89%
90% The format of the ExportQuantumPixels method is:
91%
92% size_t ExportQuantumPixels(const Image *image,const CacheView *image_view,
93% const QuantumInfo *quantum_info,const QuantumType quantum_type,
94% unsigned char *pixels,ExceptionInfo *exception)
95%
96% A description of each parameter follows:
97%
98% o image: the image.
99%
100% o image_view: the image cache view.
101%
102% o quantum_info: the quantum info.
103%
104% o quantum_type: Declare which pixel components to transfer (RGB, RGBA,
105% etc).
106%
107% o pixels: The components are transferred to this buffer.
108%
109% o exception: return any errors or warnings in this structure.
110%
111*/
112
113static inline unsigned char *PopDoublePixel(const QuantumState *quantum_state,
114 const double pixel,unsigned char *pixels)
115{
116 double
117 *p;
118
119 unsigned char
120 quantum[8];
121
122 p=(double *) quantum;
123 *p=(double) (pixel*quantum_state->inverse_scale+quantum_state->minimum);
124 if (quantum_state->endian != LSBEndian)
125 {
126 *pixels++=quantum[7];
127 *pixels++=quantum[6];
128 *pixels++=quantum[5];
129 *pixels++=quantum[4];
130 *pixels++=quantum[3];
131 *pixels++=quantum[2];
132 *pixels++=quantum[1];
133 *pixels++=quantum[0];
134 return(pixels);
135 }
136 *pixels++=quantum[0];
137 *pixels++=quantum[1];
138 *pixels++=quantum[2];
139 *pixels++=quantum[3];
140 *pixels++=quantum[4];
141 *pixels++=quantum[5];
142 *pixels++=quantum[6];
143 *pixels++=quantum[7];
144 return(pixels);
145}
146
147static inline unsigned char *PopFloatPixel(const QuantumState *quantum_state,
148 const float pixel,unsigned char *pixels)
149{
150 float
151 *p;
152
153 unsigned char
154 quantum[4];
155
156 p=(float *) quantum;
157 *p=(float) ((double) pixel*quantum_state->inverse_scale+
158 quantum_state->minimum);
159 if (quantum_state->endian != LSBEndian)
160 {
161 *pixels++=quantum[3];
162 *pixels++=quantum[2];
163 *pixels++=quantum[1];
164 *pixels++=quantum[0];
165 return(pixels);
166 }
167 *pixels++=quantum[0];
168 *pixels++=quantum[1];
169 *pixels++=quantum[2];
170 *pixels++=quantum[3];
171 return(pixels);
172}
173
174static inline unsigned char *PopQuantumPixel(QuantumState *quantum_state,
175 const unsigned long depth,const QuantumAny pixel,unsigned char *pixels)
176{
177 register long
178 i;
179
180 register unsigned long
181 quantum_bits;
182
183 if (quantum_state->bits == 0UL)
184 quantum_state->bits=8UL;
185 for (i=(long) depth; i > 0L; )
186 {
187 quantum_bits=(unsigned long) i;
188 if (quantum_bits > quantum_state->bits)
189 quantum_bits=quantum_state->bits;
190 i-=quantum_bits;
191 if (quantum_state->bits == 8)
192 *pixels='\0';
193 quantum_state->bits-=quantum_bits;
194 *pixels|=(((pixel >> i) &~ ((~0UL) << quantum_bits)) <<
195 quantum_state->bits);
196 if (quantum_state->bits == 0UL)
197 {
198 pixels++;
199 quantum_state->bits=8UL;
200 }
201 }
202 return(pixels);
203}
204
205static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state,
206 const unsigned long depth,const unsigned long pixel,unsigned char *pixels)
207{
208 register long
209 i;
210
211 unsigned long
212 quantum_bits;
213
214 if (quantum_state->bits == 0UL)
215 quantum_state->bits=32UL;
216 for (i=(long) depth; i > 0; )
217 {
218 quantum_bits=(unsigned long) i;
219 if (quantum_bits > quantum_state->bits)
220 quantum_bits=quantum_state->bits;
221 quantum_state->pixel|=(((pixel >> (depth-i)) &
222 quantum_state->mask[quantum_bits]) << (32UL-quantum_state->bits));
223 i-=quantum_bits;
224 quantum_state->bits-=quantum_bits;
225 if (quantum_state->bits == 0U)
226 {
227 pixels=PopLongPixel(quantum_state->endian,quantum_state->pixel,pixels);
228 quantum_state->pixel=0U;
229 quantum_state->bits=32UL;
230 }
231 }
232 return(pixels);
233}
234
235MagickExport size_t ExportQuantumPixels(const Image *image,
236 const CacheView *image_view,const QuantumInfo *quantum_info,
237 const QuantumType quantum_type,unsigned char *pixels,ExceptionInfo *exception)
238{
239 EndianType
240 endian;
241
242 long
243 bit;
244
245 MagickRealType
246 alpha;
247
248 MagickSizeType
249 number_pixels;
250
251 QuantumAny
252 range;
253
254 QuantumState
255 quantum_state;
256
257 register const IndexPacket
258 *indexes;
259
260 register const PixelPacket
261 *p;
262
263 register long
264 x;
265
266 register unsigned char
267 *q;
268
269 size_t
270 extent;
271
272 assert(image != (Image *) NULL);
273 assert(image->signature == MagickSignature);
274 if (image->debug != MagickFalse)
275 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
276 assert(quantum_info != (QuantumInfo *) NULL);
277 assert(quantum_info->signature == MagickSignature);
278 if (pixels == (unsigned char *) NULL)
279 pixels=GetQuantumPixels(quantum_info);
280 number_pixels=GetImageExtent(image);
281 p=GetVirtualPixelQueue(image);
282 indexes=GetVirtualIndexQueue(image);
283 if (image_view != (CacheView *) NULL)
284 {
285 number_pixels=GetCacheViewExtent(image_view);
286 p=GetCacheViewVirtualPixelQueue(image_view);
287 indexes=GetCacheViewVirtualIndexQueue(image_view);
288 }
289 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
290 {
291 register PixelPacket
292 *__restrict q;
293
294 /*
295 Associate alpha.
296 */
297 q=GetAuthenticPixelQueue(image);
298 if (image_view != (CacheView *) NULL)
299 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
300 for (x=0; x < (long) image->columns; x++)
301 {
302 alpha=QuantumScale*((double) QuantumRange-q->opacity);
303 q->red=RoundToQuantum(alpha*q->red);
304 q->green=RoundToQuantum(alpha*q->green);
305 q->blue=RoundToQuantum(alpha*q->blue);
306 q++;
307 }
308 }
309 if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
310 {
311 register PixelPacket
312 *__restrict q;
313
314 q=GetAuthenticPixelQueue(image);
315 if (image_view != (CacheView *) NULL)
316 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
317 for (x=0; x < (long) number_pixels; x++)
318 {
319 q->opacity=(Quantum) (QuantumRange-q->opacity);
320 q++;
321 }
322 }
323 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
324 {
325 Quantum
326 quantum;
327
328 register PixelPacket
329 *__restrict q;
330
331 q=GetAuthenticPixelQueue(image);
332 if (image_view != (CacheView *) NULL)
333 q=GetAuthenticPixelQueue(image);
334 for (x=0; x < (long) number_pixels; x++)
335 {
336 quantum=q->red;
337 q->red=q->green;
338 q->green=quantum;
339 q++;
340 }
341 }
342 x=0;
343 q=pixels;
344 InitializeQuantumState(quantum_info,image->endian,&quantum_state);
345 extent=GetQuantumExtent(image,quantum_info,quantum_type);
346 endian=quantum_state.endian;
347 switch (quantum_type)
348 {
349 case IndexQuantum:
350 {
351 if (image->storage_class != PseudoClass)
352 {
353 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
354 "ColormappedImageRequired","`%s'",image->filename);
355 return(extent);
356 }
357 switch (quantum_info->depth)
358 {
359 case 1:
360 {
361 register unsigned char
362 pixel;
363
364 for (x=((long) number_pixels-7); x > 0; x-=8)
365 {
366 pixel=(unsigned char) *indexes++;
367 *q=((pixel & 0x01) << 7);
368 pixel=(unsigned char) *indexes++;
369 *q|=((pixel & 0x01) << 6);
370 pixel=(unsigned char) *indexes++;
371 *q|=((pixel & 0x01) << 5);
372 pixel=(unsigned char) *indexes++;
373 *q|=((pixel & 0x01) << 4);
374 pixel=(unsigned char) *indexes++;
375 *q|=((pixel & 0x01) << 3);
376 pixel=(unsigned char) *indexes++;
377 *q|=((pixel & 0x01) << 2);
378 pixel=(unsigned char) *indexes++;
379 *q|=((pixel & 0x01) << 1);
380 pixel=(unsigned char) *indexes++;
381 *q|=((pixel & 0x01) << 0);
382 q++;
383 }
384 if ((number_pixels % 8) != 0)
385 {
386 *q='\0';
387 for (bit=7; bit >= (long) (8-(number_pixels % 8)); bit--)
388 {
389 pixel=(unsigned char) *indexes++;
390 *q|=((pixel & 0x01) << (unsigned char) bit);
391 }
392 q++;
393 }
394 break;
395 }
396 case 4:
397 {
398 register unsigned char
399 pixel;
400
401 for (x=0; x < (long) (number_pixels-1) ; x+=2)
402 {
403 pixel=(unsigned char) *indexes++;
404 *q=((pixel & 0xf) << 4);
405 pixel=(unsigned char) *indexes++;
406 *q|=((pixel & 0xf) << 0);
407 q++;
408 }
409 if ((number_pixels % 2) != 0)
410 {
411 pixel=(unsigned char) *indexes++;
412 *q=((pixel & 0xf) << 4);
413 q++;
414 }
415 break;
416 }
417 case 8:
418 {
419 for (x=0; x < (long) number_pixels; x++)
420 {
421 q=PopCharPixel((unsigned char) indexes[x],q);
422 q+=quantum_info->pad;
423 }
424 break;
425 }
426 case 16:
427 {
428 for (x=0; x < (long) number_pixels; x++)
429 {
430 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
431 q+=quantum_info->pad;
432 }
433 break;
434 }
435 case 32:
436 {
437 if (quantum_info->format == FloatingPointQuantumFormat)
438 {
439 for (x=0; x < (long) number_pixels; x++)
440 {
441 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
442 p++;
443 q+=quantum_info->pad;
444 }
445 break;
446 }
447 for (x=0; x < (long) number_pixels; x++)
448 {
449 q=PopLongPixel(endian,(unsigned long) indexes[x],q);
450 q+=quantum_info->pad;
451 }
452 break;
453 }
454 case 64:
455 {
456 if (quantum_info->format == FloatingPointQuantumFormat)
457 {
458 for (x=0; x < (long) number_pixels; x++)
459 {
460 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
461 p++;
462 q+=quantum_info->pad;
463 }
464 break;
465 }
466 }
467 default:
468 {
469 for (x=0; x < (long) number_pixels; x++)
470 {
471 q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
472 p++;
473 q+=quantum_info->pad;
474 }
475 break;
476 }
477 }
478 break;
479 }
480 case IndexAlphaQuantum:
481 {
482 if (image->storage_class != PseudoClass)
483 {
484 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
485 "ColormappedImageRequired","`%s'",image->filename);
486 return(extent);
487 }
488 switch (quantum_info->depth)
489 {
490 case 1:
491 {
492 register unsigned char
493 pixel;
494
495 for (x=((long) number_pixels-3); x > 0; x-=4)
496 {
497 pixel=(unsigned char) *indexes++;
498 *q=((pixel & 0x01) << 7);
499 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
500 1 : 0);
501 *q|=((pixel & 0x01) << 6);
502 p++;
503 pixel=(unsigned char) *indexes++;
504 *q|=((pixel & 0x01) << 5);
505 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
506 1 : 0);
507 *q|=((pixel & 0x01) << 4);
508 p++;
509 pixel=(unsigned char) *indexes++;
510 *q|=((pixel & 0x01) << 3);
511 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
512 1 : 0);
513 *q|=((pixel & 0x01) << 2);
514 p++;
515 pixel=(unsigned char) *indexes++;
516 *q|=((pixel & 0x01) << 1);
517 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
518 1 : 0);
519 *q|=((pixel & 0x01) << 0);
520 p++;
521 q++;
522 }
523 if ((number_pixels % 4) != 0)
524 {
525 *q='\0';
526 for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
527 {
528 pixel=(unsigned char) *indexes++;
529 *q|=((pixel & 0x01) << (unsigned char) bit);
530 pixel=(unsigned char) (p->opacity == (Quantum)
531 TransparentOpacity ? 1 : 0);
532 *q|=((pixel & 0x01) << (unsigned char) (bit-1));
533 p++;
534 }
535 q++;
536 }
537 break;
538 }
539 case 4:
540 {
541 register unsigned char
542 pixel;
543
544 for (x=0; x < (long) number_pixels ; x++)
545 {
546 pixel=(unsigned char) *indexes++;
547 *q=((pixel & 0xf) << 4);
548 pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
549 p->opacity))+0.5);
550 *q|=((pixel & 0xf) << 0);
551 p++;
552 q++;
553 }
554 break;
555 }
556 case 8:
557 {
558 register unsigned char
559 pixel;
560
561 for (x=0; x < (long) number_pixels; x++)
562 {
563 q=PopCharPixel((unsigned char) indexes[x],q);
564 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
565 q=PopCharPixel(pixel,q);
566 p++;
567 q+=quantum_info->pad;
568 }
569 break;
570 }
571 case 16:
572 {
573 register unsigned short
574 pixel;
575
576 for (x=0; x < (long) number_pixels; x++)
577 {
578 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
579 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
580 q=PopShortPixel(endian,pixel,q);
581 p++;
582 q+=quantum_info->pad;
583 }
584 break;
585 }
586 case 32:
587 {
588 register unsigned long
589 pixel;
590
591 if (quantum_info->format == FloatingPointQuantumFormat)
592 {
593 for (x=0; x < (long) number_pixels; x++)
594 {
595 float
596 pixel;
597
598 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
599 pixel=(float) (QuantumRange-p->opacity);
600 q=PopFloatPixel(&quantum_state,pixel,q);
601 p++;
602 q+=quantum_info->pad;
603 }
604 break;
605 }
606 for (x=0; x < (long) number_pixels; x++)
607 {
608 q=PopLongPixel(endian,(unsigned long) indexes[x],q);
609 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
610 q=PopLongPixel(endian,pixel,q);
611 p++;
612 q+=quantum_info->pad;
613 }
614 break;
615 }
616 case 64:
617 {
618 if (quantum_info->format == FloatingPointQuantumFormat)
619 {
620 for (x=0; x < (long) number_pixels; x++)
621 {
622 double
623 pixel;
624
625 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
626 pixel=(double) (QuantumRange-p->opacity);
627 q=PopDoublePixel(&quantum_state,pixel,q);
628 p++;
629 q+=quantum_info->pad;
630 }
631 break;
632 }
633 }
634 default:
635 {
636 range=GetQuantumRange(image->depth);
637 for (x=0; x < (long) number_pixels; x++)
638 {
639 q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
640 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
641 (Quantum) (QuantumRange-p->opacity),range),q);
642 p++;
643 q+=quantum_info->pad;
644 }
645 break;
646 }
647 }
648 break;
649 }
650 case GrayQuantum:
651 {
652 switch (quantum_info->depth)
653 {
654 case 1:
655 {
656 register Quantum
657 threshold;
658
659 register unsigned char
660 black,
661 white;
662
663 black=0x00;
664 white=0x01;
665 if (quantum_info->min_is_white != MagickFalse)
666 {
667 black=0x01;
668 white=0x00;
669 }
670 threshold=(Quantum) (QuantumRange/2);
671 for (x=((long) number_pixels-7); x > 0; x-=8)
672 {
673 *q='\0';
674 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
675 p++;
676 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 6;
677 p++;
678 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
679 p++;
680 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 4;
681 p++;
682 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
683 p++;
684 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 2;
685 p++;
686 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
687 p++;
688 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 0;
689 p++;
690 q++;
691 }
692 if ((number_pixels % 8) != 0)
693 {
694 *q='\0';
695 for (bit=7; bit >= (long) (8-(number_pixels % 8)); bit--)
696 {
697 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
698 bit;
699 p++;
700 }
701 q++;
702 }
703 break;
704 }
705 case 4:
706 {
707 register unsigned char
708 pixel;
709
710 for (x=0; x < (long) (number_pixels-1) ; x+=2)
711 {
712 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
713 *q=(((pixel >> 4) & 0xf) << 4);
714 p++;
715 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
716 *q|=pixel >> 4;
717 p++;
718 q++;
719 }
720 if ((number_pixels % 2) != 0)
721 {
722 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
723 *q=(((pixel >> 4) & 0xf) << 4);
724 p++;
725 q++;
726 }
727 break;
728 }
729 case 8:
730 {
731 register unsigned char
732 pixel;
733
734 for (x=0; x < (long) number_pixels; x++)
735 {
736 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
737 q=PopCharPixel(pixel,q);
738 p++;
739 q+=quantum_info->pad;
740 }
741 break;
742 }
743 case 10:
744 {
745 register unsigned short
746 pixel;
747
748 range=GetQuantumRange(image->depth);
749 if (quantum_info->pack == MagickFalse)
750 {
751 for (x=0; x < (long) number_pixels; x++)
752 {
753 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
754 q=PopShortPixel(endian,(unsigned short) ScaleQuantumToAny(
755 (Quantum) pixel,range),q);
756 p++;
757 q+=quantum_info->pad;
758 }
759 break;
760 }
761 for (x=0; x < (long) number_pixels; x++)
762 {
763 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
764 PixelIntensityToQuantum(p),range),q);
765 p++;
766 q+=quantum_info->pad;
767 }
768 break;
769 }
770 case 12:
771 {
772 register unsigned short
773 pixel;
774
775 range=GetQuantumRange(image->depth);
776 if (quantum_info->pack == MagickFalse)
777 {
778 for (x=0; x < (long) number_pixels; x++)
779 {
780 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
781 q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
782 p++;
783 q+=quantum_info->pad;
784 }
785 break;
786 }
787 for (x=0; x < (long) number_pixels; x++)
788 {
789 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
790 PixelIntensityToQuantum(p),range),q);
791 p++;
792 q+=quantum_info->pad;
793 }
794 break;
795 }
796 case 16:
797 {
798 register unsigned short
799 pixel;
800
801 for (x=0; x < (long) number_pixels; x++)
802 {
803 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
804 q=PopShortPixel(endian,pixel,q);
805 p++;
806 q+=quantum_info->pad;
807 }
808 break;
809 }
810 case 32:
811 {
812 register unsigned long
813 pixel;
814
815 if (quantum_info->format == FloatingPointQuantumFormat)
816 {
817 for (x=0; x < (long) number_pixels; x++)
818 {
819 float
820 pixel;
821
822 pixel=(float) PixelIntensityToQuantum(p);
823 q=PopFloatPixel(&quantum_state,pixel,q);
824 p++;
825 q+=quantum_info->pad;
826 }
827 break;
828 }
829 for (x=0; x < (long) number_pixels; x++)
830 {
831 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
832 q=PopLongPixel(endian,pixel,q);
833 p++;
834 q+=quantum_info->pad;
835 }
836 break;
837 }
838 case 64:
839 {
840 if (quantum_info->format == FloatingPointQuantumFormat)
841 {
842 for (x=0; x < (long) number_pixels; x++)
843 {
844 double
845 pixel;
846
847 pixel=(double) PixelIntensityToQuantum(p);
848 q=PopDoublePixel(&quantum_state,pixel,q);
849 p++;
850 q+=quantum_info->pad;
851 }
852 break;
853 }
854 }
855 default:
856 {
857 range=GetQuantumRange(image->depth);
858 for (x=0; x < (long) number_pixels; x++)
859 {
860 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
861 PixelIntensityToQuantum(p),range),q);
862 p++;
863 q+=quantum_info->pad;
864 }
865 break;
866 }
867 }
868 break;
869 }
870 case GrayAlphaQuantum:
871 {
872 switch (quantum_info->depth)
873 {
874 case 1:
875 {
876 register Quantum
877 threshold;
878
879 register unsigned char
880 black,
881 pixel,
882 white;
883
884 black=0x00;
885 white=0x01;
886 if (quantum_info->min_is_white == MagickFalse)
887 {
888 black=0x01;
889 white=0x00;
890 }
891 threshold=(Quantum) (QuantumRange/2);
892 for (x=((long) number_pixels-3); x > 0; x-=4)
893 {
894 *q='\0';
895 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
896 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
897 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
898 p++;
899 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
900 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
901 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
902 p++;
903 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
904 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
905 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
906 p++;
907 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
908 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
909 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
910 p++;
911 q++;
912 }
913 if ((number_pixels % 4) != 0)
914 {
915 *q='\0';
916 for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
917 {
918 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
919 bit;
920 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
921 0x01);
922 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
923 (bit-1));
924 p++;
925 }
926 q++;
927 }
928 break;
929 }
930 case 4:
931 {
932 register unsigned char
933 pixel;
934
935 for (x=0; x < (long) number_pixels ; x++)
936 {
937 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
938 *q=(((pixel >> 4) & 0xf) << 4);
939 pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
940 p->opacity))+0.5);
941 *q|=pixel & 0xf;
942 p++;
943 q++;
944 }
945 break;
946 }
947 case 8:
948 {
949 register unsigned char
950 pixel;
951
952 for (x=0; x < (long) number_pixels; x++)
953 {
954 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
955 q=PopCharPixel(pixel,q);
956 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
957 q=PopCharPixel(pixel,q);
958 p++;
959 q+=quantum_info->pad;
960 }
961 break;
962 }
963 case 16:
964 {
965 register unsigned short
966 pixel;
967
968 for (x=0; x < (long) number_pixels; x++)
969 {
970 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
971 q=PopShortPixel(endian,pixel,q);
972 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
973 q=PopShortPixel(endian,pixel,q);
974 p++;
975 q+=quantum_info->pad;
976 }
977 break;
978 }
979 case 32:
980 {
981 register unsigned long
982 pixel;
983
984 if (quantum_info->format == FloatingPointQuantumFormat)
985 {
986 for (x=0; x < (long) number_pixels; x++)
987 {
988 float
989 pixel;
990
991 pixel=(float) PixelIntensityToQuantum(p);
992 q=PopFloatPixel(&quantum_state,pixel,q);
993 pixel=(float) (QuantumRange-p->opacity);
994 q=PopFloatPixel(&quantum_state,pixel,q);
995 p++;
996 q+=quantum_info->pad;
997 }
998 break;
999 }
1000 for (x=0; x < (long) number_pixels; x++)
1001 {
1002 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1003 q=PopLongPixel(endian,pixel,q);
1004 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
1005 q=PopLongPixel(endian,pixel,q);
1006 p++;
1007 q+=quantum_info->pad;
1008 }
1009 break;
1010 }
1011 case 64:
1012 {
1013 if (quantum_info->format == FloatingPointQuantumFormat)
1014 {
1015 for (x=0; x < (long) number_pixels; x++)
1016 {
1017 double
1018 pixel;
1019
1020 pixel=(double) PixelIntensityToQuantum(p);
1021 q=PopDoublePixel(&quantum_state,pixel,q);
1022 pixel=(double) (QuantumRange-p->opacity);
1023 q=PopDoublePixel(&quantum_state,pixel,q);
1024 p++;
1025 q+=quantum_info->pad;
1026 }
1027 break;
1028 }
1029 }
1030 default:
1031 {
1032 range=GetQuantumRange(image->depth);
1033 for (x=0; x < (long) number_pixels; x++)
1034 {
1035 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1036 PixelIntensityToQuantum(p),range),q);
1037 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1038 (Quantum) (QuantumRange-p->opacity),range),q);
1039 p++;
1040 q+=quantum_info->pad;
1041 }
1042 break;
1043 }
1044 }
1045 break;
1046 }
1047 case RedQuantum:
1048 case CyanQuantum:
1049 {
1050 switch (quantum_info->depth)
1051 {
1052 case 8:
1053 {
1054 register unsigned char
1055 pixel;
1056
1057 for (x=0; x < (long) number_pixels; x++)
1058 {
1059 pixel=ScaleQuantumToChar(p->red);
1060 q=PopCharPixel(pixel,q);
1061 p++;
1062 q+=quantum_info->pad;
1063 }
1064 break;
1065 }
1066 case 16:
1067 {
1068 register unsigned short
1069 pixel;
1070
1071 for (x=0; x < (long) number_pixels; x++)
1072 {
1073 pixel=ScaleQuantumToShort(p->red);
1074 q=PopShortPixel(endian,pixel,q);
1075 p++;
1076 q+=quantum_info->pad;
1077 }
1078 break;
1079 }
1080 case 32:
1081 {
1082 register unsigned long
1083 pixel;
1084
1085 if (quantum_info->format == FloatingPointQuantumFormat)
1086 {
1087 for (x=0; x < (long) number_pixels; x++)
1088 {
1089 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1090 p++;
1091 q+=quantum_info->pad;
1092 }
1093 break;
1094 }
1095 for (x=0; x < (long) number_pixels; x++)
1096 {
1097 pixel=ScaleQuantumToLong(p->red);
1098 q=PopLongPixel(endian,pixel,q);
1099 p++;
1100 q+=quantum_info->pad;
1101 }
1102 break;
1103 }
1104 case 64:
1105 {
1106 if (quantum_info->format == FloatingPointQuantumFormat)
1107 {
1108 for (x=0; x < (long) number_pixels; x++)
1109 {
1110 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1111 p++;
1112 q+=quantum_info->pad;
1113 }
1114 break;
1115 }
1116 }
1117 default:
1118 {
1119 range=GetQuantumRange(image->depth);
1120 for (x=0; x < (long) number_pixels; x++)
1121 {
1122 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1123 p->red,range),q);
1124 p++;
1125 q+=quantum_info->pad;
1126 }
1127 break;
1128 }
1129 }
1130 break;
1131 }
1132 case GreenQuantum:
1133 case MagentaQuantum:
1134 {
1135 switch (quantum_info->depth)
1136 {
1137 case 8:
1138 {
1139 register unsigned char
1140 pixel;
1141
1142 for (x=0; x < (long) number_pixels; x++)
1143 {
1144 pixel=ScaleQuantumToChar(p->green);
1145 q=PopCharPixel(pixel,q);
1146 p++;
1147 q+=quantum_info->pad;
1148 }
1149 break;
1150 }
1151 case 16:
1152 {
1153 register unsigned short
1154 pixel;
1155
1156 for (x=0; x < (long) number_pixels; x++)
1157 {
1158 pixel=ScaleQuantumToShort(p->green);
1159 q=PopShortPixel(endian,pixel,q);
1160 p++;
1161 q+=quantum_info->pad;
1162 }
1163 break;
1164 }
1165 case 32:
1166 {
1167 register unsigned long
1168 pixel;
1169
1170 if (quantum_info->format == FloatingPointQuantumFormat)
1171 {
1172 for (x=0; x < (long) number_pixels; x++)
1173 {
1174 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1175 p++;
1176 q+=quantum_info->pad;
1177 }
1178 break;
1179 }
1180 for (x=0; x < (long) number_pixels; x++)
1181 {
1182 pixel=ScaleQuantumToLong(p->green);
1183 q=PopLongPixel(endian,pixel,q);
1184 p++;
1185 q+=quantum_info->pad;
1186 }
1187 break;
1188 }
1189 case 64:
1190 {
1191 if (quantum_info->format == FloatingPointQuantumFormat)
1192 {
1193 for (x=0; x < (long) number_pixels; x++)
1194 {
1195 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1196 p++;
1197 q+=quantum_info->pad;
1198 }
1199 break;
1200 }
1201 }
1202 default:
1203 {
1204 range=GetQuantumRange(image->depth);
1205 for (x=0; x < (long) number_pixels; x++)
1206 {
1207 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1208 p->green,range),q);
1209 p++;
1210 q+=quantum_info->pad;
1211 }
1212 break;
1213 }
1214 }
1215 break;
1216 }
1217 case BlueQuantum:
1218 case YellowQuantum:
1219 {
1220 switch (quantum_info->depth)
1221 {
1222 case 8:
1223 {
1224 register unsigned char
1225 pixel;
1226
1227 for (x=0; x < (long) number_pixels; x++)
1228 {
1229 pixel=ScaleQuantumToChar(p->blue);
1230 q=PopCharPixel(pixel,q);
1231 p++;
1232 q+=quantum_info->pad;
1233 }
1234 break;
1235 }
1236 case 16:
1237 {
1238 register unsigned short
1239 pixel;
1240
1241 for (x=0; x < (long) number_pixels; x++)
1242 {
1243 pixel=ScaleQuantumToShort(p->blue);
1244 q=PopShortPixel(endian,pixel,q);
1245 p++;
1246 q+=quantum_info->pad;
1247 }
1248 break;
1249 }
1250 case 32:
1251 {
1252 register unsigned long
1253 pixel;
1254
1255 if (quantum_info->format == FloatingPointQuantumFormat)
1256 {
1257 for (x=0; x < (long) number_pixels; x++)
1258 {
1259 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1260 p++;
1261 q+=quantum_info->pad;
1262 }
1263 break;
1264 }
1265 for (x=0; x < (long) number_pixels; x++)
1266 {
1267 pixel=ScaleQuantumToLong(p->blue);
1268 q=PopLongPixel(endian,pixel,q);
1269 p++;
1270 q+=quantum_info->pad;
1271 }
1272 break;
1273 }
1274 case 64:
1275 {
1276 if (quantum_info->format == FloatingPointQuantumFormat)
1277 {
1278 for (x=0; x < (long) number_pixels; x++)
1279 {
1280 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1281 p++;
1282 q+=quantum_info->pad;
1283 }
1284 break;
1285 }
1286 }
1287 default:
1288 {
1289 range=GetQuantumRange(image->depth);
1290 for (x=0; x < (long) number_pixels; x++)
1291 {
1292 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1293 p->blue,range),q);
1294 p++;
1295 q+=quantum_info->pad;
1296 }
1297 break;
1298 }
1299 }
1300 break;
1301 }
1302 case AlphaQuantum:
1303 {
1304 switch (quantum_info->depth)
1305 {
1306 case 8:
1307 {
1308 register unsigned char
1309 pixel;
1310
1311 for (x=0; x < (long) number_pixels; x++)
1312 {
1313 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
1314 q=PopCharPixel(pixel,q);
1315 p++;
1316 q+=quantum_info->pad;
1317 }
1318 break;
1319 }
1320 case 16:
1321 {
1322 register unsigned short
1323 pixel;
1324
1325 for (x=0; x < (long) number_pixels; x++)
1326 {
1327 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
1328 q=PopShortPixel(endian,pixel,q);
1329 p++;
1330 q+=quantum_info->pad;
1331 }
1332 break;
1333 }
1334 case 32:
1335 {
1336 register unsigned long
1337 pixel;
1338
1339 if (quantum_info->format == FloatingPointQuantumFormat)
1340 {
1341 for (x=0; x < (long) number_pixels; x++)
1342 {
1343 float
1344 pixel;
1345
1346 pixel=(float) (QuantumRange-p->opacity);
1347 q=PopFloatPixel(&quantum_state,pixel,q);
1348 p++;
1349 q+=quantum_info->pad;
1350 }
1351 break;
1352 }
1353 for (x=0; x < (long) number_pixels; x++)
1354 {
1355 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
1356 q=PopLongPixel(endian,pixel,q);
1357 p++;
1358 q+=quantum_info->pad;
1359 }
1360 break;
1361 }
1362 case 64:
1363 {
1364 if (quantum_info->format == FloatingPointQuantumFormat)
1365 {
1366 for (x=0; x < (long) number_pixels; x++)
1367 {
1368 double
1369 pixel;
1370
1371 pixel=(double) (QuantumRange-p->opacity);
1372 q=PopDoublePixel(&quantum_state,pixel,q);
1373 p++;
1374 q+=quantum_info->pad;
1375 }
1376 break;
1377 }
1378 }
1379 default:
1380 {
1381 range=GetQuantumRange(image->depth);
1382 for (x=0; x < (long) number_pixels; x++)
1383 {
1384 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1385 (Quantum) (QuantumRange-p->opacity),range),q);
1386 p++;
1387 q+=quantum_info->pad;
1388 }
1389 break;
1390 }
1391 }
1392 break;
1393 }
1394 case OpacityQuantum:
1395 {
1396 switch (quantum_info->depth)
1397 {
1398 case 8:
1399 {
1400 register unsigned char
1401 pixel;
1402
1403 for (x=0; x < (long) number_pixels; x++)
1404 {
1405 pixel=ScaleQuantumToChar(p->opacity);
1406 q=PopCharPixel(pixel,q);
1407 p++;
1408 q+=quantum_info->pad;
1409 }
1410 break;
1411 }
1412 case 16:
1413 {
1414 register unsigned short
1415 pixel;
1416
1417 for (x=0; x < (long) number_pixels; x++)
1418 {
1419 pixel=ScaleQuantumToShort(p->opacity);
1420 q=PopShortPixel(endian,pixel,q);
1421 p++;
1422 q+=quantum_info->pad;
1423 }
1424 break;
1425 }
1426 case 32:
1427 {
1428 register unsigned long
1429 pixel;
1430
1431 if (quantum_info->format == FloatingPointQuantumFormat)
1432 {
1433 for (x=0; x < (long) number_pixels; x++)
1434 {
1435 q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
1436 p++;
1437 q+=quantum_info->pad;
1438 }
1439 break;
1440 }
1441 for (x=0; x < (long) number_pixels; x++)
1442 {
1443 pixel=ScaleQuantumToLong(p->opacity);
1444 q=PopLongPixel(endian,pixel,q);
1445 p++;
1446 q+=quantum_info->pad;
1447 }
1448 break;
1449 }
1450 case 64:
1451 {
1452 if (quantum_info->format == FloatingPointQuantumFormat)
1453 {
1454 for (x=0; x < (long) number_pixels; x++)
1455 {
1456 q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
1457 p++;
1458 q+=quantum_info->pad;
1459 }
1460 break;
1461 }
1462 }
1463 default:
1464 {
1465 range=GetQuantumRange(image->depth);
1466 for (x=0; x < (long) number_pixels; x++)
1467 {
1468 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1469 p->opacity,range),q);
1470 p++;
1471 q+=quantum_info->pad;
1472 }
1473 break;
1474 }
1475 }
1476 break;
1477 }
1478 case BlackQuantum:
1479 {
1480 if (image->colorspace != CMYKColorspace)
1481 {
1482 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1483 "ColorSeparatedImageRequired","`%s'",image->filename);
1484 return(extent);
1485 }
1486 switch (quantum_info->depth)
1487 {
1488 case 8:
1489 {
1490 register unsigned char
1491 pixel;
1492
1493 for (x=0; x < (long) number_pixels; x++)
1494 {
1495 pixel=ScaleQuantumToChar(indexes[x]);
1496 q=PopCharPixel(pixel,q);
1497 p++;
1498 q+=quantum_info->pad;
1499 }
1500 break;
1501 }
1502 case 16:
1503 {
1504 register unsigned short
1505 pixel;
1506
1507 for (x=0; x < (long) number_pixels; x++)
1508 {
1509 pixel=ScaleQuantumToShort(indexes[x]);
1510 q=PopShortPixel(endian,pixel,q);
1511 p++;
1512 q+=quantum_info->pad;
1513 }
1514 break;
1515 }
1516 case 32:
1517 {
1518 register unsigned long
1519 pixel;
1520
1521 if (quantum_info->format == FloatingPointQuantumFormat)
1522 {
1523 for (x=0; x < (long) number_pixels; x++)
1524 {
1525 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
1526 p++;
1527 q+=quantum_info->pad;
1528 }
1529 break;
1530 }
1531 for (x=0; x < (long) number_pixels; x++)
1532 {
1533 pixel=ScaleQuantumToLong(indexes[x]);
1534 q=PopLongPixel(endian,pixel,q);
1535 p++;
1536 q+=quantum_info->pad;
1537 }
1538 break;
1539 }
1540 case 64:
1541 {
1542 if (quantum_info->format == FloatingPointQuantumFormat)
1543 {
1544 for (x=0; x < (long) number_pixels; x++)
1545 {
1546 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
1547 p++;
1548 q+=quantum_info->pad;
1549 }
1550 break;
1551 }
1552 }
1553 default:
1554 {
1555 range=GetQuantumRange(image->depth);
1556 for (x=0; x < (long) number_pixels; x++)
1557 {
1558 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1559 (Quantum) indexes[x],range),q);
1560 p++;
1561 q+=quantum_info->pad;
1562 }
1563 break;
1564 }
1565 }
1566 break;
1567 }
1568 case RGBQuantum:
1569 case CbYCrQuantum:
1570 {
1571 switch (quantum_info->depth)
1572 {
1573 case 8:
1574 {
1575 for (x=0; x < (long) number_pixels; x++)
1576 {
1577 q=PopCharPixel(ScaleQuantumToChar(p->red),q);
1578 q=PopCharPixel(ScaleQuantumToChar(p->green),q);
1579 q=PopCharPixel(ScaleQuantumToChar(p->blue),q);
1580 p++;
1581 q+=quantum_info->pad;
1582 }
1583 break;
1584 }
1585 case 10:
1586 {
1587 register unsigned long
1588 pixel;
1589
1590 range=GetQuantumRange(image->depth);
1591 if (quantum_info->pack == MagickFalse)
1592 {
1593 for (x=0; x < (long) number_pixels; x++)
1594 {
1595 pixel=(unsigned long) (ScaleQuantumToAny(p->red,range) << 22 |
1596 ScaleQuantumToAny(p->green,range) << 12 |
1597 ScaleQuantumToAny(p->blue,range) << 2);
1598 q=PopLongPixel(endian,pixel,q);
1599 p++;
1600 q+=quantum_info->pad;
1601 }
1602 break;
1603 }
1604 if (quantum_info->quantum == 32UL)
1605 {
1606 for (x=0; x < (long) number_pixels; x++)
1607 {
1608 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1609 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1610 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1611 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1612 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1613 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1614 p++;
1615 q+=quantum_info->pad;
1616 }
1617 break;
1618 }
1619 for (x=0; x < (long) number_pixels; x++)
1620 {
1621 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1622 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1623 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1624 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1625 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1626 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1627 p++;
1628 q+=quantum_info->pad;
1629 }
1630 break;
1631 }
1632 case 12:
1633 {
1634 register unsigned long
1635 pixel;
1636
1637 range=GetQuantumRange(image->depth);
1638 if (quantum_info->pack == MagickFalse)
1639 {
1640 for (x=0; x < (long) (3*number_pixels-1); x+=2)
1641 {
1642 switch (x % 3)
1643 {
1644 default:
1645 case 0:
1646 {
1647 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1648 break;
1649 }
1650 case 1:
1651 {
1652 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1653 break;
1654 }
1655 case 2:
1656 {
1657 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1658 p++;
1659 break;
1660 }
1661 }
1662 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1663 switch ((x+1) % 3)
1664 {
1665 default:
1666 case 0:
1667 {
1668 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1669 break;
1670 }
1671 case 1:
1672 {
1673 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1674 break;
1675 }
1676 case 2:
1677 {
1678 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1679 p++;
1680 break;
1681 }
1682 }
1683 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1684 q+=quantum_info->pad;
1685 }
1686 for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
1687 {
1688 switch ((x+bit) % 3)
1689 {
1690 default:
1691 case 0:
1692 {
1693 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1694 break;
1695 }
1696 case 1:
1697 {
1698 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1699 break;
1700 }
1701 case 2:
1702 {
1703 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1704 p++;
1705 break;
1706 }
1707 }
1708 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1709 q+=quantum_info->pad;
1710 }
1711 if (bit != 0)
1712 p++;
1713 break;
1714 }
1715 if (quantum_info->quantum == 32UL)
1716 {
1717 for (x=0; x < (long) number_pixels; x++)
1718 {
1719 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1720 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1721 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1722 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1723 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1724 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1725 p++;
1726 q+=quantum_info->pad;
1727 }
1728 break;
1729 }
1730 for (x=0; x < (long) number_pixels; x++)
1731 {
1732 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1733 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1734 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1735 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1736 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1737 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1738 p++;
1739 q+=quantum_info->pad;
1740 }
1741 break;
1742 }
1743 case 16:
1744 {
1745 register unsigned short
1746 pixel;
1747
1748 for (x=0; x < (long) number_pixels; x++)
1749 {
1750 pixel=ScaleQuantumToShort(p->red);
1751 q=PopShortPixel(endian,pixel,q);
1752 pixel=ScaleQuantumToShort(p->green);
1753 q=PopShortPixel(endian,pixel,q);
1754 pixel=ScaleQuantumToShort(p->blue);
1755 q=PopShortPixel(endian,pixel,q);
1756 p++;
1757 q+=quantum_info->pad;
1758 }
1759 break;
1760 }
1761 case 32:
1762 {
1763 register unsigned long
1764 pixel;
1765
1766 if (quantum_info->format == FloatingPointQuantumFormat)
1767 {
1768 for (x=0; x < (long) number_pixels; x++)
1769 {
1770 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1771 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1772 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1773 p++;
1774 q+=quantum_info->pad;
1775 }
1776 break;
1777 }
1778 for (x=0; x < (long) number_pixels; x++)
1779 {
1780 pixel=ScaleQuantumToLong(p->red);
1781 q=PopLongPixel(endian,pixel,q);
1782 pixel=ScaleQuantumToLong(p->green);
1783 q=PopLongPixel(endian,pixel,q);
1784 pixel=ScaleQuantumToLong(p->blue);
1785 q=PopLongPixel(endian,pixel,q);
1786 p++;
1787 q+=quantum_info->pad;
1788 }
1789 break;
1790 }
1791 case 64:
1792 {
1793 if (quantum_info->format == FloatingPointQuantumFormat)
1794 {
1795 for (x=0; x < (long) number_pixels; x++)
1796 {
1797 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1798 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1799 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1800 p++;
1801 q+=quantum_info->pad;
1802 }
1803 break;
1804 }
1805 }
1806 default:
1807 {
1808 range=GetQuantumRange(image->depth);
1809 for (x=0; x < (long) number_pixels; x++)
1810 {
1811 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1812 p->red,range),q);
1813 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1814 p->green,range),q);
1815 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1816 p->blue,range),q);
1817 p++;
1818 q+=quantum_info->pad;
1819 }
1820 break;
1821 }
1822 }
1823 break;
1824 }
1825 case RGBAQuantum:
1826 case RGBOQuantum:
1827 case CbYCrAQuantum:
1828 {
1829 switch (quantum_info->depth)
1830 {
1831 case 8:
1832 {
1833 register unsigned char
1834 pixel;
1835
1836 for (x=0; x < (long) number_pixels; x++)
1837 {
1838 pixel=ScaleQuantumToChar(p->red);
1839 q=PopCharPixel(pixel,q);
1840 pixel=ScaleQuantumToChar(p->green);
1841 q=PopCharPixel(pixel,q);
1842 pixel=ScaleQuantumToChar(p->blue);
1843 q=PopCharPixel(pixel,q);
1844 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
1845 q=PopCharPixel(pixel,q);
1846 p++;
1847 q+=quantum_info->pad;
1848 }
1849 break;
1850 }
1851 case 16:
1852 {
1853 register unsigned short
1854 pixel;
1855
1856 for (x=0; x < (long) number_pixels; x++)
1857 {
1858 pixel=ScaleQuantumToShort(p->red);
1859 q=PopShortPixel(endian,pixel,q);
1860 pixel=ScaleQuantumToShort(p->green);
1861 q=PopShortPixel(endian,pixel,q);
1862 pixel=ScaleQuantumToShort(p->blue);
1863 q=PopShortPixel(endian,pixel,q);
1864 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
1865 q=PopShortPixel(endian,pixel,q);
1866 p++;
1867 q+=quantum_info->pad;
1868 }
1869 break;
1870 }
1871 case 32:
1872 {
1873 register unsigned long
1874 pixel;
1875
1876 if (quantum_info->format == FloatingPointQuantumFormat)
1877 {
1878 for (x=0; x < (long) number_pixels; x++)
1879 {
1880 float
1881 pixel;
1882
1883 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1884 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1885 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1886 pixel=(float) (QuantumRange-p->opacity);
1887 q=PopFloatPixel(&quantum_state,pixel,q);
1888 p++;
1889 q+=quantum_info->pad;
1890 }
1891 break;
1892 }
1893 for (x=0; x < (long) number_pixels; x++)
1894 {
1895 pixel=ScaleQuantumToLong(p->red);
1896 q=PopLongPixel(endian,pixel,q);
1897 pixel=ScaleQuantumToLong(p->green);
1898 q=PopLongPixel(endian,pixel,q);
1899 pixel=ScaleQuantumToLong(p->blue);
1900 q=PopLongPixel(endian,pixel,q);
1901 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
1902 q=PopLongPixel(endian,pixel,q);
1903 p++;
1904 q+=quantum_info->pad;
1905 }
1906 break;
1907 }
1908 case 64:
1909 {
1910 if (quantum_info->format == FloatingPointQuantumFormat)
1911 {
1912 double
1913 pixel;
1914
1915 for (x=0; x < (long) number_pixels; x++)
1916 {
1917 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1918 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1919 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1920 pixel=(double) (QuantumRange-p->opacity);
1921 q=PopDoublePixel(&quantum_state,pixel,q);
1922 p++;
1923 q+=quantum_info->pad;
1924 }
1925 break;
1926 }
1927 }
1928 default:
1929 {
1930 range=GetQuantumRange(image->depth);
1931 for (x=0; x < (long) number_pixels; x++)
1932 {
1933 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1934 p->red,range),q);
1935 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1936 p->green,range),q);
1937 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1938 p->blue,range),q);
1939 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1940 (Quantum) (QuantumRange-p->opacity),range),q);
1941 p++;
1942 q+=quantum_info->pad;
1943 }
1944 break;
1945 }
1946 }
1947 break;
1948 }
1949 case CMYKQuantum:
1950 {
1951 if (image->colorspace != CMYKColorspace)
1952 {
1953 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1954 "ColorSeparatedImageRequired","`%s'",image->filename);
1955 return(extent);
1956 }
1957 switch (quantum_info->depth)
1958 {
1959 case 8:
1960 {
1961 register unsigned char
1962 pixel;
1963
1964 for (x=0; x < (long) number_pixels; x++)
1965 {
1966 pixel=ScaleQuantumToChar(p->red);
1967 q=PopCharPixel(pixel,q);
1968 pixel=ScaleQuantumToChar(p->green);
1969 q=PopCharPixel(pixel,q);
1970 pixel=ScaleQuantumToChar(p->blue);
1971 q=PopCharPixel(pixel,q);
1972 pixel=ScaleQuantumToChar(indexes[x]);
1973 q=PopCharPixel(pixel,q);
1974 p++;
1975 q+=quantum_info->pad;
1976 }
1977 break;
1978 }
1979 case 16:
1980 {
1981 register unsigned short
1982 pixel;
1983
1984 for (x=0; x < (long) number_pixels; x++)
1985 {
1986 pixel=ScaleQuantumToShort(p->red);
1987 q=PopShortPixel(endian,pixel,q);
1988 pixel=ScaleQuantumToShort(p->green);
1989 q=PopShortPixel(endian,pixel,q);
1990 pixel=ScaleQuantumToShort(p->blue);
1991 q=PopShortPixel(endian,pixel,q);
1992 pixel=ScaleQuantumToShort(indexes[x]);
1993 q=PopShortPixel(endian,pixel,q);
1994 p++;
1995 q+=quantum_info->pad;
1996 }
1997 break;
1998 }
1999 case 32:
2000 {
2001 register unsigned long
2002 pixel;
2003
2004 if (quantum_info->format == FloatingPointQuantumFormat)
2005 {
2006 for (x=0; x < (long) number_pixels; x++)
2007 {
2008 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2009 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2010 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2011 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2012 p++;
2013 q+=quantum_info->pad;
2014 }
2015 break;
2016 }
2017 for (x=0; x < (long) number_pixels; x++)
2018 {
2019 pixel=ScaleQuantumToLong(p->red);
2020 q=PopLongPixel(endian,pixel,q);
2021 pixel=ScaleQuantumToLong(p->green);
2022 q=PopLongPixel(endian,pixel,q);
2023 pixel=ScaleQuantumToLong(p->blue);
2024 q=PopLongPixel(endian,pixel,q);
2025 pixel=ScaleQuantumToLong(indexes[x]);
2026 q=PopLongPixel(endian,pixel,q);
2027 p++;
2028 q+=quantum_info->pad;
2029 }
2030 break;
2031 }
2032 case 64:
2033 {
2034 if (quantum_info->format == FloatingPointQuantumFormat)
2035 {
2036 for (x=0; x < (long) number_pixels; x++)
2037 {
2038 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2039 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2040 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2041 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2042 p++;
2043 q+=quantum_info->pad;
2044 }
2045 break;
2046 }
2047 }
2048 default:
2049 {
2050 range=GetQuantumRange(image->depth);
2051 for (x=0; x < (long) number_pixels; x++)
2052 {
2053 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2054 p->red,range),q);
2055 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2056 p->green,range),q);
2057 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2058 p->blue,range),q);
2059 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2060 indexes[x],range),q);
2061 p++;
2062 q+=quantum_info->pad;
2063 }
2064 break;
2065 }
2066 }
2067 break;
2068 }
2069 case CMYKAQuantum:
2070 case CMYKOQuantum:
2071 {
2072 if (image->colorspace != CMYKColorspace)
2073 {
2074 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2075 "ColorSeparatedImageRequired","`%s'",image->filename);
2076 return(extent);
2077 }
2078 switch (quantum_info->depth)
2079 {
2080 case 8:
2081 {
2082 register unsigned char
2083 pixel;
2084
2085 for (x=0; x < (long) number_pixels; x++)
2086 {
2087 pixel=ScaleQuantumToChar(p->red);
2088 q=PopCharPixel(pixel,q);
2089 pixel=ScaleQuantumToChar(p->green);
2090 q=PopCharPixel(pixel,q);
2091 pixel=ScaleQuantumToChar(p->blue);
2092 q=PopCharPixel(pixel,q);
2093 pixel=ScaleQuantumToChar(indexes[x]);
2094 q=PopCharPixel(pixel,q);
2095 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
2096 q=PopCharPixel(pixel,q);
2097 p++;
2098 q+=quantum_info->pad;
2099 }
2100 break;
2101 }
2102 case 16:
2103 {
2104 register unsigned short
2105 pixel;
2106
2107 for (x=0; x < (long) number_pixels; x++)
2108 {
2109 pixel=ScaleQuantumToShort(p->red);
2110 q=PopShortPixel(endian,pixel,q);
2111 pixel=ScaleQuantumToShort(p->green);
2112 q=PopShortPixel(endian,pixel,q);
2113 pixel=ScaleQuantumToShort(p->blue);
2114 q=PopShortPixel(endian,pixel,q);
2115 pixel=ScaleQuantumToShort(indexes[x]);
2116 q=PopShortPixel(endian,pixel,q);
2117 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
2118 q=PopShortPixel(endian,pixel,q);
2119 p++;
2120 q+=quantum_info->pad;
2121 }
2122 break;
2123 }
2124 case 32:
2125 {
2126 register unsigned long
2127 pixel;
2128
2129 if (quantum_info->format == FloatingPointQuantumFormat)
2130 {
2131 for (x=0; x < (long) number_pixels; x++)
2132 {
2133 float
2134 pixel;
2135
2136 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2137 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2138 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2139 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2140 pixel=(float) (QuantumRange-p->opacity);
2141 q=PopFloatPixel(&quantum_state,pixel,q);
2142 p++;
2143 q+=quantum_info->pad;
2144 }
2145 break;
2146 }
2147 for (x=0; x < (long) number_pixels; x++)
2148 {
2149 pixel=ScaleQuantumToLong(p->red);
2150 q=PopLongPixel(endian,pixel,q);
2151 pixel=ScaleQuantumToLong(p->green);
2152 q=PopLongPixel(endian,pixel,q);
2153 pixel=ScaleQuantumToLong(p->blue);
2154 q=PopLongPixel(endian,pixel,q);
2155 pixel=ScaleQuantumToLong(indexes[x]);
2156 q=PopLongPixel(endian,pixel,q);
2157 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
2158 q=PopLongPixel(endian,pixel,q);
2159 p++;
2160 q+=quantum_info->pad;
2161 }
2162 break;
2163 }
2164 case 64:
2165 {
2166 if (quantum_info->format == FloatingPointQuantumFormat)
2167 {
2168 double
2169 pixel;
2170
2171 for (x=0; x < (long) number_pixels; x++)
2172 {
2173 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2174 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2175 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2176 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2177 pixel=(double) (QuantumRange-p->opacity);
2178 q=PopDoublePixel(&quantum_state,pixel,q);
2179 p++;
2180 q+=quantum_info->pad;
2181 }
2182 break;
2183 }
2184 }
2185 default:
2186 {
2187 range=GetQuantumRange(image->depth);
2188 for (x=0; x < (long) number_pixels; x++)
2189 {
2190 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2191 p->red,range),q);
2192 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2193 p->green,range),q);
2194 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2195 p->blue,range),q);
2196 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2197 indexes[x],range),q);
2198 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2199 p->opacity,range),q);
2200 p++;
2201 q+=quantum_info->pad;
2202 }
2203 break;
2204 }
2205 }
2206 break;
2207 }
2208 case CbYCrYQuantum:
2209 {
2210 long
2211 n;
2212
2213 Quantum
2214 cbcr[4];
2215
2216 register long
2217 i;
2218
2219 register unsigned long
2220 pixel;
2221
2222 unsigned long
2223 quantum;
2224
2225 n=0;
2226 quantum=0;
2227 range=GetQuantumRange(image->depth);
2228 switch (quantum_info->depth)
2229 {
2230 case 10:
2231 {
2232 if (quantum_info->pack == MagickFalse)
2233 {
2234 for (x=0; x < (long) number_pixels; x+=2)
2235 {
2236 for (i=0; i < 4; i++)
2237 {
2238 switch (n % 3)
2239 {
2240 case 0:
2241 {
2242 quantum=p->red;
2243 break;
2244 }
2245 case 1:
2246 {
2247 quantum=p->green;
2248 break;
2249 }
2250 case 2:
2251 {
2252 quantum=p->blue;
2253 break;
2254 }
2255 }
2256 cbcr[i]=(Quantum) quantum;
2257 n++;
2258 }
2259 pixel=(unsigned long) ((unsigned long) (cbcr[1]) << 22 |
2260 (unsigned long) (cbcr[0]) << 12 |
2261 (unsigned long) (cbcr[2]) << 2);
2262 q=PopLongPixel(endian,pixel,q);
2263 p++;
2264 pixel=(unsigned long) ((unsigned long) (cbcr[3]) << 22 |
2265 (unsigned long) (cbcr[0]) << 12 |
2266 (unsigned long) (cbcr[2]) << 2);
2267 q=PopLongPixel(endian,pixel,q);
2268 p++;
2269 q+=quantum_info->pad;
2270 }
2271 break;
2272 }
2273 break;
2274 }
2275 default:
2276 {
2277 for (x=0; x < (long) number_pixels; x+=2)
2278 {
2279 for (i=0; i < 4; i++)
2280 {
2281 switch (n % 3)
2282 {
2283 case 0:
2284 {
2285 quantum=p->red;
2286 break;
2287 }
2288 case 1:
2289 {
2290 quantum=p->green;
2291 break;
2292 }
2293 case 2:
2294 {
2295 quantum=p->blue;
2296 break;
2297 }
2298 }
2299 cbcr[i]=(Quantum) quantum;
2300 n++;
2301 }
2302 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2303 cbcr[1],range),q);
2304 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2305 cbcr[0],range),q);
2306 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2307 cbcr[2],range),q);
2308 p++;
2309 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2310 cbcr[3],range),q);
2311 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2312 cbcr[0],range),q);
2313 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2314 cbcr[2],range),q);
2315 p++;
2316 q+=quantum_info->pad;
2317 }
2318 break;
2319 }
2320 }
2321 break;
2322 }
2323 default:
2324 break;
2325 }
2326 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
2327 {
2328 Quantum
2329 quantum;
2330
2331 register PixelPacket
2332 *__restrict q;
2333
2334 q=GetAuthenticPixelQueue(image);
2335 if (image_view != (CacheView *) NULL)
2336 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2337 for (x=0; x < (long) number_pixels; x++)
2338 {
2339 quantum=q->red;
2340 q->red=q->green;
2341 q->green=quantum;
2342 q++;
2343 }
2344 }
2345 if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
2346 {
2347 register PixelPacket
2348 *__restrict q;
2349
2350 q=GetAuthenticPixelQueue(image);
2351 if (image_view != (CacheView *) NULL)
2352 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2353 for (x=0; x < (long) number_pixels; x++)
2354 {
2355 q->opacity=(Quantum) (QuantumRange-q->opacity);
2356 q++;
2357 }
2358 }
2359 return(extent);
2360}