Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / ImageMagick / c9672a94adef17dee351f074e7c9915405ef29e1 / . / magick / quantum-export.c
blob: ad85321f68f349faf659707121aa45d0d8f9be49 [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;
cristy82b15832009-10-06 19:17:37 +0000[diff] [blame]123 *p=(double) (pixel*quantum_state->inverse_scale+quantum_state->minimum);
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]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+
cristy82b15832009-10-06 19:17:37 +0000[diff] [blame]158 quantum_state->minimum);
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]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
cristyaebafa22009-11-26 01:48:56 +0000[diff] [blame]258 *restrict indexes;
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]259
260 register const PixelPacket
cristyaebafa22009-11-26 01:48:56 +0000[diff] [blame]261 *restrict p;
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]262
263 register long
264 x;
265
266 register unsigned char
cristyaebafa22009-11-26 01:48:56 +0000[diff] [blame]267 *restrict q;
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]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
cristyc47d1f82009-11-26 01:44:43 +0000[diff] [blame]292 *restrict q;
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]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
cristyc47d1f82009-11-26 01:44:43 +0000[diff] [blame]312 *restrict q;
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]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
cristyc47d1f82009-11-26 01:44:43 +0000[diff] [blame]329 *restrict q;
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]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 {
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]428 if (quantum_info->format == FloatingPointQuantumFormat)
429 {
430 for (x=0; x < (long) number_pixels; x++)
431 {
432 q=PopShortPixel(endian,ScaleFloatToHalf(QuantumScale*
433 indexes[x]),q);
434 q+=quantum_info->pad;
435 }
436 break;
437 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]438 for (x=0; x < (long) number_pixels; x++)
439 {
440 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
441 q+=quantum_info->pad;
442 }
443 break;
444 }
445 case 32:
446 {
447 if (quantum_info->format == FloatingPointQuantumFormat)
448 {
449 for (x=0; x < (long) number_pixels; x++)
450 {
451 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
452 p++;
453 q+=quantum_info->pad;
454 }
455 break;
456 }
457 for (x=0; x < (long) number_pixels; x++)
458 {
459 q=PopLongPixel(endian,(unsigned long) indexes[x],q);
460 q+=quantum_info->pad;
461 }
462 break;
463 }
464 case 64:
465 {
466 if (quantum_info->format == FloatingPointQuantumFormat)
467 {
468 for (x=0; x < (long) number_pixels; x++)
469 {
470 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
471 p++;
472 q+=quantum_info->pad;
473 }
474 break;
475 }
476 }
477 default:
478 {
479 for (x=0; x < (long) number_pixels; x++)
480 {
481 q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
482 p++;
483 q+=quantum_info->pad;
484 }
485 break;
486 }
487 }
488 break;
489 }
490 case IndexAlphaQuantum:
491 {
492 if (image->storage_class != PseudoClass)
493 {
494 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
495 "ColormappedImageRequired","`%s'",image->filename);
496 return(extent);
497 }
498 switch (quantum_info->depth)
499 {
500 case 1:
501 {
502 register unsigned char
503 pixel;
504
505 for (x=((long) number_pixels-3); x > 0; x-=4)
506 {
507 pixel=(unsigned char) *indexes++;
508 *q=((pixel & 0x01) << 7);
509 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
510 1 : 0);
511 *q|=((pixel & 0x01) << 6);
512 p++;
513 pixel=(unsigned char) *indexes++;
514 *q|=((pixel & 0x01) << 5);
515 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
516 1 : 0);
517 *q|=((pixel & 0x01) << 4);
518 p++;
519 pixel=(unsigned char) *indexes++;
520 *q|=((pixel & 0x01) << 3);
521 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
522 1 : 0);
523 *q|=((pixel & 0x01) << 2);
524 p++;
525 pixel=(unsigned char) *indexes++;
526 *q|=((pixel & 0x01) << 1);
527 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
528 1 : 0);
529 *q|=((pixel & 0x01) << 0);
530 p++;
531 q++;
532 }
533 if ((number_pixels % 4) != 0)
534 {
535 *q='\0';
536 for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
537 {
538 pixel=(unsigned char) *indexes++;
cristyb32b90a2009-09-07 21:45:48 +0000[diff] [blame]539 *q|=((pixel & 0x01) << (unsigned char) (bit+4));
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]540 pixel=(unsigned char) (p->opacity == (Quantum)
541 TransparentOpacity ? 1 : 0);
cristyb32b90a2009-09-07 21:45:48 +0000[diff] [blame]542 *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]543 p++;
544 }
545 q++;
546 }
547 break;
548 }
549 case 4:
550 {
551 register unsigned char
552 pixel;
553
554 for (x=0; x < (long) number_pixels ; x++)
555 {
556 pixel=(unsigned char) *indexes++;
557 *q=((pixel & 0xf) << 4);
558 pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
559 p->opacity))+0.5);
560 *q|=((pixel & 0xf) << 0);
561 p++;
562 q++;
563 }
564 break;
565 }
566 case 8:
567 {
568 register unsigned char
569 pixel;
570
571 for (x=0; x < (long) number_pixels; x++)
572 {
573 q=PopCharPixel((unsigned char) indexes[x],q);
574 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
575 q=PopCharPixel(pixel,q);
576 p++;
577 q+=quantum_info->pad;
578 }
579 break;
580 }
581 case 16:
582 {
583 register unsigned short
584 pixel;
585
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]586 if (quantum_info->format == FloatingPointQuantumFormat)
587 {
588 for (x=0; x < (long) number_pixels; x++)
589 {
590 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
591 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-p->opacity));
592 q=PopShortPixel(endian,pixel,q);
593 p++;
594 q+=quantum_info->pad;
595 }
596 break;
597 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]598 for (x=0; x < (long) number_pixels; x++)
599 {
600 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
601 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
602 q=PopShortPixel(endian,pixel,q);
603 p++;
604 q+=quantum_info->pad;
605 }
606 break;
607 }
608 case 32:
609 {
610 register unsigned long
611 pixel;
612
613 if (quantum_info->format == FloatingPointQuantumFormat)
614 {
615 for (x=0; x < (long) number_pixels; x++)
616 {
617 float
618 pixel;
619
620 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
621 pixel=(float) (QuantumRange-p->opacity);
622 q=PopFloatPixel(&quantum_state,pixel,q);
623 p++;
624 q+=quantum_info->pad;
625 }
626 break;
627 }
628 for (x=0; x < (long) number_pixels; x++)
629 {
630 q=PopLongPixel(endian,(unsigned long) indexes[x],q);
631 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
632 q=PopLongPixel(endian,pixel,q);
633 p++;
634 q+=quantum_info->pad;
635 }
636 break;
637 }
638 case 64:
639 {
640 if (quantum_info->format == FloatingPointQuantumFormat)
641 {
642 for (x=0; x < (long) number_pixels; x++)
643 {
644 double
645 pixel;
646
647 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
648 pixel=(double) (QuantumRange-p->opacity);
649 q=PopDoublePixel(&quantum_state,pixel,q);
650 p++;
651 q+=quantum_info->pad;
652 }
653 break;
654 }
655 }
656 default:
657 {
658 range=GetQuantumRange(image->depth);
659 for (x=0; x < (long) number_pixels; x++)
660 {
661 q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
662 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
663 (Quantum) (QuantumRange-p->opacity),range),q);
664 p++;
665 q+=quantum_info->pad;
666 }
667 break;
668 }
669 }
670 break;
671 }
672 case GrayQuantum:
673 {
674 switch (quantum_info->depth)
675 {
676 case 1:
677 {
678 register Quantum
679 threshold;
680
681 register unsigned char
682 black,
683 white;
684
685 black=0x00;
686 white=0x01;
687 if (quantum_info->min_is_white != MagickFalse)
688 {
689 black=0x01;
690 white=0x00;
691 }
692 threshold=(Quantum) (QuantumRange/2);
693 for (x=((long) number_pixels-7); x > 0; x-=8)
694 {
695 *q='\0';
696 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
697 p++;
698 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 6;
699 p++;
700 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
701 p++;
702 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 4;
703 p++;
704 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
705 p++;
706 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 2;
707 p++;
708 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
709 p++;
710 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 0;
711 p++;
712 q++;
713 }
714 if ((number_pixels % 8) != 0)
715 {
716 *q='\0';
717 for (bit=7; bit >= (long) (8-(number_pixels % 8)); bit--)
718 {
719 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
720 bit;
721 p++;
722 }
723 q++;
724 }
725 break;
726 }
727 case 4:
728 {
729 register unsigned char
730 pixel;
731
732 for (x=0; x < (long) (number_pixels-1) ; x+=2)
733 {
734 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
735 *q=(((pixel >> 4) & 0xf) << 4);
736 p++;
737 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
738 *q|=pixel >> 4;
739 p++;
740 q++;
741 }
742 if ((number_pixels % 2) != 0)
743 {
744 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
745 *q=(((pixel >> 4) & 0xf) << 4);
746 p++;
747 q++;
748 }
749 break;
750 }
751 case 8:
752 {
753 register unsigned char
754 pixel;
755
756 for (x=0; x < (long) number_pixels; x++)
757 {
758 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
759 q=PopCharPixel(pixel,q);
760 p++;
761 q+=quantum_info->pad;
762 }
763 break;
764 }
765 case 10:
766 {
767 register unsigned short
768 pixel;
769
770 range=GetQuantumRange(image->depth);
771 if (quantum_info->pack == MagickFalse)
772 {
773 for (x=0; x < (long) number_pixels; x++)
774 {
775 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
776 q=PopShortPixel(endian,(unsigned short) ScaleQuantumToAny(
777 (Quantum) pixel,range),q);
778 p++;
779 q+=quantum_info->pad;
780 }
781 break;
782 }
783 for (x=0; x < (long) number_pixels; x++)
784 {
785 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
786 PixelIntensityToQuantum(p),range),q);
787 p++;
788 q+=quantum_info->pad;
789 }
790 break;
791 }
792 case 12:
793 {
794 register unsigned short
795 pixel;
796
797 range=GetQuantumRange(image->depth);
798 if (quantum_info->pack == MagickFalse)
799 {
800 for (x=0; x < (long) number_pixels; x++)
801 {
802 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
803 q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
804 p++;
805 q+=quantum_info->pad;
806 }
807 break;
808 }
809 for (x=0; x < (long) number_pixels; x++)
810 {
811 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
812 PixelIntensityToQuantum(p),range),q);
813 p++;
814 q+=quantum_info->pad;
815 }
816 break;
817 }
818 case 16:
819 {
820 register unsigned short
821 pixel;
822
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]823 if (quantum_info->format == FloatingPointQuantumFormat)
824 {
825 for (x=0; x < (long) number_pixels; x++)
826 {
827 pixel=ScaleFloatToHalf(QuantumScale*PixelIntensityToQuantum(p));
828 q=PopShortPixel(endian,pixel,q);
829 p++;
830 q+=quantum_info->pad;
831 }
832 break;
833 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]834 for (x=0; x < (long) number_pixels; x++)
835 {
836 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
837 q=PopShortPixel(endian,pixel,q);
838 p++;
839 q+=quantum_info->pad;
840 }
841 break;
842 }
843 case 32:
844 {
845 register unsigned long
846 pixel;
847
848 if (quantum_info->format == FloatingPointQuantumFormat)
849 {
850 for (x=0; x < (long) number_pixels; x++)
851 {
852 float
853 pixel;
854
855 pixel=(float) PixelIntensityToQuantum(p);
856 q=PopFloatPixel(&quantum_state,pixel,q);
857 p++;
858 q+=quantum_info->pad;
859 }
860 break;
861 }
862 for (x=0; x < (long) number_pixels; x++)
863 {
864 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
865 q=PopLongPixel(endian,pixel,q);
866 p++;
867 q+=quantum_info->pad;
868 }
869 break;
870 }
871 case 64:
872 {
873 if (quantum_info->format == FloatingPointQuantumFormat)
874 {
875 for (x=0; x < (long) number_pixels; x++)
876 {
877 double
878 pixel;
879
880 pixel=(double) PixelIntensityToQuantum(p);
881 q=PopDoublePixel(&quantum_state,pixel,q);
882 p++;
883 q+=quantum_info->pad;
884 }
885 break;
886 }
887 }
888 default:
889 {
890 range=GetQuantumRange(image->depth);
891 for (x=0; x < (long) number_pixels; x++)
892 {
893 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
894 PixelIntensityToQuantum(p),range),q);
895 p++;
896 q+=quantum_info->pad;
897 }
898 break;
899 }
900 }
901 break;
902 }
903 case GrayAlphaQuantum:
904 {
905 switch (quantum_info->depth)
906 {
907 case 1:
908 {
909 register Quantum
910 threshold;
911
912 register unsigned char
913 black,
914 pixel,
915 white;
916
917 black=0x00;
918 white=0x01;
919 if (quantum_info->min_is_white == MagickFalse)
920 {
921 black=0x01;
922 white=0x00;
923 }
924 threshold=(Quantum) (QuantumRange/2);
925 for (x=((long) number_pixels-3); x > 0; x-=4)
926 {
927 *q='\0';
928 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
929 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
930 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
931 p++;
932 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
933 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
934 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
935 p++;
936 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
937 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
938 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
939 p++;
940 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
941 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
942 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
943 p++;
944 q++;
945 }
946 if ((number_pixels % 4) != 0)
947 {
948 *q='\0';
949 for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
950 {
951 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
cristyb32b90a2009-09-07 21:45:48 +0000[diff] [blame]952 (bit+4);
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]953 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
954 0x01);
955 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
cristyb32b90a2009-09-07 21:45:48 +0000[diff] [blame]956 (bit+4-1));
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]957 p++;
958 }
959 q++;
960 }
961 break;
962 }
963 case 4:
964 {
965 register unsigned char
966 pixel;
967
968 for (x=0; x < (long) number_pixels ; x++)
969 {
970 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
971 *q=(((pixel >> 4) & 0xf) << 4);
972 pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
973 p->opacity))+0.5);
974 *q|=pixel & 0xf;
975 p++;
976 q++;
977 }
978 break;
979 }
980 case 8:
981 {
982 register unsigned char
983 pixel;
984
985 for (x=0; x < (long) number_pixels; x++)
986 {
987 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
988 q=PopCharPixel(pixel,q);
989 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
990 q=PopCharPixel(pixel,q);
991 p++;
992 q+=quantum_info->pad;
993 }
994 break;
995 }
996 case 16:
997 {
998 register unsigned short
999 pixel;
1000
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]1001 if (quantum_info->format == FloatingPointQuantumFormat)
1002 {
1003 for (x=0; x < (long) number_pixels; x++)
1004 {
1005 pixel=ScaleFloatToHalf(QuantumScale*PixelIntensityToQuantum(p));
1006 q=PopShortPixel(endian,pixel,q);
1007 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-p->opacity));
1008 q=PopShortPixel(endian,pixel,q);
1009 p++;
1010 q+=quantum_info->pad;
1011 }
1012 break;
1013 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]1014 for (x=0; x < (long) number_pixels; x++)
1015 {
1016 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1017 q=PopShortPixel(endian,pixel,q);
1018 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
1019 q=PopShortPixel(endian,pixel,q);
1020 p++;
1021 q+=quantum_info->pad;
1022 }
1023 break;
1024 }
1025 case 32:
1026 {
1027 register unsigned long
1028 pixel;
1029
1030 if (quantum_info->format == FloatingPointQuantumFormat)
1031 {
1032 for (x=0; x < (long) number_pixels; x++)
1033 {
1034 float
1035 pixel;
1036
1037 pixel=(float) PixelIntensityToQuantum(p);
1038 q=PopFloatPixel(&quantum_state,pixel,q);
1039 pixel=(float) (QuantumRange-p->opacity);
1040 q=PopFloatPixel(&quantum_state,pixel,q);
1041 p++;
1042 q+=quantum_info->pad;
1043 }
1044 break;
1045 }
1046 for (x=0; x < (long) number_pixels; x++)
1047 {
1048 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1049 q=PopLongPixel(endian,pixel,q);
1050 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
1051 q=PopLongPixel(endian,pixel,q);
1052 p++;
1053 q+=quantum_info->pad;
1054 }
1055 break;
1056 }
1057 case 64:
1058 {
1059 if (quantum_info->format == FloatingPointQuantumFormat)
1060 {
1061 for (x=0; x < (long) number_pixels; x++)
1062 {
1063 double
1064 pixel;
1065
1066 pixel=(double) PixelIntensityToQuantum(p);
1067 q=PopDoublePixel(&quantum_state,pixel,q);
1068 pixel=(double) (QuantumRange-p->opacity);
1069 q=PopDoublePixel(&quantum_state,pixel,q);
1070 p++;
1071 q+=quantum_info->pad;
1072 }
1073 break;
1074 }
1075 }
1076 default:
1077 {
1078 range=GetQuantumRange(image->depth);
1079 for (x=0; x < (long) number_pixels; x++)
1080 {
1081 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1082 PixelIntensityToQuantum(p),range),q);
1083 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1084 (Quantum) (QuantumRange-p->opacity),range),q);
1085 p++;
1086 q+=quantum_info->pad;
1087 }
1088 break;
1089 }
1090 }
1091 break;
1092 }
1093 case RedQuantum:
1094 case CyanQuantum:
1095 {
1096 switch (quantum_info->depth)
1097 {
1098 case 8:
1099 {
1100 register unsigned char
1101 pixel;
1102
1103 for (x=0; x < (long) number_pixels; x++)
1104 {
1105 pixel=ScaleQuantumToChar(p->red);
1106 q=PopCharPixel(pixel,q);
1107 p++;
1108 q+=quantum_info->pad;
1109 }
1110 break;
1111 }
1112 case 16:
1113 {
1114 register unsigned short
1115 pixel;
1116
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]1117 if (quantum_info->format == FloatingPointQuantumFormat)
1118 {
1119 for (x=0; x < (long) number_pixels; x++)
1120 {
1121 pixel=ScaleFloatToHalf(QuantumScale*p->red);
1122 q=PopShortPixel(endian,pixel,q);
1123 p++;
1124 q+=quantum_info->pad;
1125 }
1126 break;
1127 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]1128 for (x=0; x < (long) number_pixels; x++)
1129 {
1130 pixel=ScaleQuantumToShort(p->red);
1131 q=PopShortPixel(endian,pixel,q);
1132 p++;
1133 q+=quantum_info->pad;
1134 }
1135 break;
1136 }
1137 case 32:
1138 {
1139 register unsigned long
1140 pixel;
1141
1142 if (quantum_info->format == FloatingPointQuantumFormat)
1143 {
1144 for (x=0; x < (long) number_pixels; x++)
1145 {
1146 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1147 p++;
1148 q+=quantum_info->pad;
1149 }
1150 break;
1151 }
1152 for (x=0; x < (long) number_pixels; x++)
1153 {
1154 pixel=ScaleQuantumToLong(p->red);
1155 q=PopLongPixel(endian,pixel,q);
1156 p++;
1157 q+=quantum_info->pad;
1158 }
1159 break;
1160 }
1161 case 64:
1162 {
1163 if (quantum_info->format == FloatingPointQuantumFormat)
1164 {
1165 for (x=0; x < (long) number_pixels; x++)
1166 {
1167 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1168 p++;
1169 q+=quantum_info->pad;
1170 }
1171 break;
1172 }
1173 }
1174 default:
1175 {
1176 range=GetQuantumRange(image->depth);
1177 for (x=0; x < (long) number_pixels; x++)
1178 {
1179 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1180 p->red,range),q);
1181 p++;
1182 q+=quantum_info->pad;
1183 }
1184 break;
1185 }
1186 }
1187 break;
1188 }
1189 case GreenQuantum:
1190 case MagentaQuantum:
1191 {
1192 switch (quantum_info->depth)
1193 {
1194 case 8:
1195 {
1196 register unsigned char
1197 pixel;
1198
1199 for (x=0; x < (long) number_pixels; x++)
1200 {
1201 pixel=ScaleQuantumToChar(p->green);
1202 q=PopCharPixel(pixel,q);
1203 p++;
1204 q+=quantum_info->pad;
1205 }
1206 break;
1207 }
1208 case 16:
1209 {
1210 register unsigned short
1211 pixel;
1212
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]1213 if (quantum_info->format == FloatingPointQuantumFormat)
1214 {
1215 for (x=0; x < (long) number_pixels; x++)
1216 {
1217 pixel=ScaleFloatToHalf(QuantumScale*p->green);
1218 q=PopShortPixel(endian,pixel,q);
1219 p++;
1220 q+=quantum_info->pad;
1221 }
1222 break;
1223 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]1224 for (x=0; x < (long) number_pixels; x++)
1225 {
1226 pixel=ScaleQuantumToShort(p->green);
1227 q=PopShortPixel(endian,pixel,q);
1228 p++;
1229 q+=quantum_info->pad;
1230 }
1231 break;
1232 }
1233 case 32:
1234 {
1235 register unsigned long
1236 pixel;
1237
1238 if (quantum_info->format == FloatingPointQuantumFormat)
1239 {
1240 for (x=0; x < (long) number_pixels; x++)
1241 {
1242 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1243 p++;
1244 q+=quantum_info->pad;
1245 }
1246 break;
1247 }
1248 for (x=0; x < (long) number_pixels; x++)
1249 {
1250 pixel=ScaleQuantumToLong(p->green);
1251 q=PopLongPixel(endian,pixel,q);
1252 p++;
1253 q+=quantum_info->pad;
1254 }
1255 break;
1256 }
1257 case 64:
1258 {
1259 if (quantum_info->format == FloatingPointQuantumFormat)
1260 {
1261 for (x=0; x < (long) number_pixels; x++)
1262 {
1263 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1264 p++;
1265 q+=quantum_info->pad;
1266 }
1267 break;
1268 }
1269 }
1270 default:
1271 {
1272 range=GetQuantumRange(image->depth);
1273 for (x=0; x < (long) number_pixels; x++)
1274 {
1275 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1276 p->green,range),q);
1277 p++;
1278 q+=quantum_info->pad;
1279 }
1280 break;
1281 }
1282 }
1283 break;
1284 }
1285 case BlueQuantum:
1286 case YellowQuantum:
1287 {
1288 switch (quantum_info->depth)
1289 {
1290 case 8:
1291 {
1292 register unsigned char
1293 pixel;
1294
1295 for (x=0; x < (long) number_pixels; x++)
1296 {
1297 pixel=ScaleQuantumToChar(p->blue);
1298 q=PopCharPixel(pixel,q);
1299 p++;
1300 q+=quantum_info->pad;
1301 }
1302 break;
1303 }
1304 case 16:
1305 {
1306 register unsigned short
1307 pixel;
1308
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]1309 if (quantum_info->format == FloatingPointQuantumFormat)
1310 {
1311 for (x=0; x < (long) number_pixels; x++)
1312 {
1313 pixel=ScaleFloatToHalf(QuantumScale*p->blue);
1314 q=PopShortPixel(endian,pixel,q);
1315 p++;
1316 q+=quantum_info->pad;
1317 }
1318 break;
1319 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]1320 for (x=0; x < (long) number_pixels; x++)
1321 {
1322 pixel=ScaleQuantumToShort(p->blue);
1323 q=PopShortPixel(endian,pixel,q);
1324 p++;
1325 q+=quantum_info->pad;
1326 }
1327 break;
1328 }
1329 case 32:
1330 {
1331 register unsigned long
1332 pixel;
1333
1334 if (quantum_info->format == FloatingPointQuantumFormat)
1335 {
1336 for (x=0; x < (long) number_pixels; x++)
1337 {
1338 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1339 p++;
1340 q+=quantum_info->pad;
1341 }
1342 break;
1343 }
1344 for (x=0; x < (long) number_pixels; x++)
1345 {
1346 pixel=ScaleQuantumToLong(p->blue);
1347 q=PopLongPixel(endian,pixel,q);
1348 p++;
1349 q+=quantum_info->pad;
1350 }
1351 break;
1352 }
1353 case 64:
1354 {
1355 if (quantum_info->format == FloatingPointQuantumFormat)
1356 {
1357 for (x=0; x < (long) number_pixels; x++)
1358 {
1359 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1360 p++;
1361 q+=quantum_info->pad;
1362 }
1363 break;
1364 }
1365 }
1366 default:
1367 {
1368 range=GetQuantumRange(image->depth);
1369 for (x=0; x < (long) number_pixels; x++)
1370 {
1371 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1372 p->blue,range),q);
1373 p++;
1374 q+=quantum_info->pad;
1375 }
1376 break;
1377 }
1378 }
1379 break;
1380 }
1381 case AlphaQuantum:
1382 {
1383 switch (quantum_info->depth)
1384 {
1385 case 8:
1386 {
1387 register unsigned char
1388 pixel;
1389
1390 for (x=0; x < (long) number_pixels; x++)
1391 {
1392 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
1393 q=PopCharPixel(pixel,q);
1394 p++;
1395 q+=quantum_info->pad;
1396 }
1397 break;
1398 }
1399 case 16:
1400 {
1401 register unsigned short
1402 pixel;
1403
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]1404 if (quantum_info->format == FloatingPointQuantumFormat)
1405 {
1406 for (x=0; x < (long) number_pixels; x++)
1407 {
1408 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-p->opacity));
1409 q=PopShortPixel(endian,pixel,q);
1410 p++;
1411 q+=quantum_info->pad;
1412 }
1413 break;
1414 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]1415 for (x=0; x < (long) number_pixels; x++)
1416 {
1417 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
1418 q=PopShortPixel(endian,pixel,q);
1419 p++;
1420 q+=quantum_info->pad;
1421 }
1422 break;
1423 }
1424 case 32:
1425 {
1426 register unsigned long
1427 pixel;
1428
1429 if (quantum_info->format == FloatingPointQuantumFormat)
1430 {
1431 for (x=0; x < (long) number_pixels; x++)
1432 {
1433 float
1434 pixel;
1435
1436 pixel=(float) (QuantumRange-p->opacity);
1437 q=PopFloatPixel(&quantum_state,pixel,q);
1438 p++;
1439 q+=quantum_info->pad;
1440 }
1441 break;
1442 }
1443 for (x=0; x < (long) number_pixels; x++)
1444 {
1445 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
1446 q=PopLongPixel(endian,pixel,q);
1447 p++;
1448 q+=quantum_info->pad;
1449 }
1450 break;
1451 }
1452 case 64:
1453 {
1454 if (quantum_info->format == FloatingPointQuantumFormat)
1455 {
1456 for (x=0; x < (long) number_pixels; x++)
1457 {
1458 double
1459 pixel;
1460
1461 pixel=(double) (QuantumRange-p->opacity);
1462 q=PopDoublePixel(&quantum_state,pixel,q);
1463 p++;
1464 q+=quantum_info->pad;
1465 }
1466 break;
1467 }
1468 }
1469 default:
1470 {
1471 range=GetQuantumRange(image->depth);
1472 for (x=0; x < (long) number_pixels; x++)
1473 {
1474 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1475 (Quantum) (QuantumRange-p->opacity),range),q);
1476 p++;
1477 q+=quantum_info->pad;
1478 }
1479 break;
1480 }
1481 }
1482 break;
1483 }
1484 case OpacityQuantum:
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(p->opacity);
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
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]1507 if (quantum_info->format == FloatingPointQuantumFormat)
1508 {
1509 for (x=0; x < (long) number_pixels; x++)
1510 {
1511 pixel=ScaleFloatToHalf(QuantumScale*p->opacity);
1512 q=PopShortPixel(endian,pixel,q);
1513 p++;
1514 q+=quantum_info->pad;
1515 }
1516 break;
1517 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]1518 for (x=0; x < (long) number_pixels; x++)
1519 {
1520 pixel=ScaleQuantumToShort(p->opacity);
1521 q=PopShortPixel(endian,pixel,q);
1522 p++;
1523 q+=quantum_info->pad;
1524 }
1525 break;
1526 }
1527 case 32:
1528 {
1529 register unsigned long
1530 pixel;
1531
1532 if (quantum_info->format == FloatingPointQuantumFormat)
1533 {
1534 for (x=0; x < (long) number_pixels; x++)
1535 {
1536 q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
1537 p++;
1538 q+=quantum_info->pad;
1539 }
1540 break;
1541 }
1542 for (x=0; x < (long) number_pixels; x++)
1543 {
1544 pixel=ScaleQuantumToLong(p->opacity);
1545 q=PopLongPixel(endian,pixel,q);
1546 p++;
1547 q+=quantum_info->pad;
1548 }
1549 break;
1550 }
1551 case 64:
1552 {
1553 if (quantum_info->format == FloatingPointQuantumFormat)
1554 {
1555 for (x=0; x < (long) number_pixels; x++)
1556 {
1557 q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
1558 p++;
1559 q+=quantum_info->pad;
1560 }
1561 break;
1562 }
1563 }
1564 default:
1565 {
1566 range=GetQuantumRange(image->depth);
1567 for (x=0; x < (long) number_pixels; x++)
1568 {
1569 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1570 p->opacity,range),q);
1571 p++;
1572 q+=quantum_info->pad;
1573 }
1574 break;
1575 }
1576 }
1577 break;
1578 }
1579 case BlackQuantum:
1580 {
1581 if (image->colorspace != CMYKColorspace)
1582 {
1583 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1584 "ColorSeparatedImageRequired","`%s'",image->filename);
1585 return(extent);
1586 }
1587 switch (quantum_info->depth)
1588 {
1589 case 8:
1590 {
1591 register unsigned char
1592 pixel;
1593
1594 for (x=0; x < (long) number_pixels; x++)
1595 {
1596 pixel=ScaleQuantumToChar(indexes[x]);
1597 q=PopCharPixel(pixel,q);
1598 p++;
1599 q+=quantum_info->pad;
1600 }
1601 break;
1602 }
1603 case 16:
1604 {
1605 register unsigned short
1606 pixel;
1607
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]1608 if (quantum_info->format == FloatingPointQuantumFormat)
1609 {
1610 for (x=0; x < (long) number_pixels; x++)
1611 {
1612 pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
1613 q=PopShortPixel(endian,pixel,q);
1614 p++;
1615 q+=quantum_info->pad;
1616 }
1617 break;
1618 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]1619 for (x=0; x < (long) number_pixels; x++)
1620 {
1621 pixel=ScaleQuantumToShort(indexes[x]);
1622 q=PopShortPixel(endian,pixel,q);
1623 p++;
1624 q+=quantum_info->pad;
1625 }
1626 break;
1627 }
1628 case 32:
1629 {
1630 register unsigned long
1631 pixel;
1632
1633 if (quantum_info->format == FloatingPointQuantumFormat)
1634 {
1635 for (x=0; x < (long) number_pixels; x++)
1636 {
1637 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
1638 p++;
1639 q+=quantum_info->pad;
1640 }
1641 break;
1642 }
1643 for (x=0; x < (long) number_pixels; x++)
1644 {
1645 pixel=ScaleQuantumToLong(indexes[x]);
1646 q=PopLongPixel(endian,pixel,q);
1647 p++;
1648 q+=quantum_info->pad;
1649 }
1650 break;
1651 }
1652 case 64:
1653 {
1654 if (quantum_info->format == FloatingPointQuantumFormat)
1655 {
1656 for (x=0; x < (long) number_pixels; x++)
1657 {
1658 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
1659 p++;
1660 q+=quantum_info->pad;
1661 }
1662 break;
1663 }
1664 }
1665 default:
1666 {
1667 range=GetQuantumRange(image->depth);
1668 for (x=0; x < (long) number_pixels; x++)
1669 {
1670 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1671 (Quantum) indexes[x],range),q);
1672 p++;
1673 q+=quantum_info->pad;
1674 }
1675 break;
1676 }
1677 }
1678 break;
1679 }
1680 case RGBQuantum:
1681 case CbYCrQuantum:
1682 {
1683 switch (quantum_info->depth)
1684 {
1685 case 8:
1686 {
1687 for (x=0; x < (long) number_pixels; x++)
1688 {
1689 q=PopCharPixel(ScaleQuantumToChar(p->red),q);
1690 q=PopCharPixel(ScaleQuantumToChar(p->green),q);
1691 q=PopCharPixel(ScaleQuantumToChar(p->blue),q);
1692 p++;
1693 q+=quantum_info->pad;
1694 }
1695 break;
1696 }
1697 case 10:
1698 {
1699 register unsigned long
1700 pixel;
1701
1702 range=GetQuantumRange(image->depth);
1703 if (quantum_info->pack == MagickFalse)
1704 {
1705 for (x=0; x < (long) number_pixels; x++)
1706 {
1707 pixel=(unsigned long) (ScaleQuantumToAny(p->red,range) << 22 |
1708 ScaleQuantumToAny(p->green,range) << 12 |
1709 ScaleQuantumToAny(p->blue,range) << 2);
1710 q=PopLongPixel(endian,pixel,q);
1711 p++;
1712 q+=quantum_info->pad;
1713 }
1714 break;
1715 }
1716 if (quantum_info->quantum == 32UL)
1717 {
1718 for (x=0; x < (long) number_pixels; x++)
1719 {
1720 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1721 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1722 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1723 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1724 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1725 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1726 p++;
1727 q+=quantum_info->pad;
1728 }
1729 break;
1730 }
1731 for (x=0; x < (long) number_pixels; x++)
1732 {
1733 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1734 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1735 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1736 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1737 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1738 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1739 p++;
1740 q+=quantum_info->pad;
1741 }
1742 break;
1743 }
1744 case 12:
1745 {
1746 register unsigned long
1747 pixel;
1748
1749 range=GetQuantumRange(image->depth);
1750 if (quantum_info->pack == MagickFalse)
1751 {
1752 for (x=0; x < (long) (3*number_pixels-1); x+=2)
1753 {
1754 switch (x % 3)
1755 {
1756 default:
1757 case 0:
1758 {
1759 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1760 break;
1761 }
1762 case 1:
1763 {
1764 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1765 break;
1766 }
1767 case 2:
1768 {
1769 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1770 p++;
1771 break;
1772 }
1773 }
1774 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1775 switch ((x+1) % 3)
1776 {
1777 default:
1778 case 0:
1779 {
1780 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1781 break;
1782 }
1783 case 1:
1784 {
1785 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1786 break;
1787 }
1788 case 2:
1789 {
1790 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1791 p++;
1792 break;
1793 }
1794 }
1795 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1796 q+=quantum_info->pad;
1797 }
1798 for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
1799 {
1800 switch ((x+bit) % 3)
1801 {
1802 default:
1803 case 0:
1804 {
1805 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1806 break;
1807 }
1808 case 1:
1809 {
1810 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1811 break;
1812 }
1813 case 2:
1814 {
1815 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1816 p++;
1817 break;
1818 }
1819 }
1820 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1821 q+=quantum_info->pad;
1822 }
1823 if (bit != 0)
1824 p++;
1825 break;
1826 }
1827 if (quantum_info->quantum == 32UL)
1828 {
1829 for (x=0; x < (long) number_pixels; x++)
1830 {
1831 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1832 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1833 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1834 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1835 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1836 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1837 p++;
1838 q+=quantum_info->pad;
1839 }
1840 break;
1841 }
1842 for (x=0; x < (long) number_pixels; x++)
1843 {
1844 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1845 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1846 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1847 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1848 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1849 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1850 p++;
1851 q+=quantum_info->pad;
1852 }
1853 break;
1854 }
1855 case 16:
1856 {
1857 register unsigned short
1858 pixel;
1859
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]1860 if (quantum_info->format == FloatingPointQuantumFormat)
1861 {
1862 for (x=0; x < (long) number_pixels; x++)
1863 {
1864 pixel=ScaleFloatToHalf(QuantumScale*p->red);
1865 q=PopShortPixel(endian,pixel,q);
1866 pixel=ScaleFloatToHalf(QuantumScale*p->green);
1867 q=PopShortPixel(endian,pixel,q);
1868 pixel=ScaleFloatToHalf(QuantumScale*p->blue);
1869 q=PopShortPixel(endian,pixel,q);
1870 p++;
1871 q+=quantum_info->pad;
1872 }
1873 break;
1874 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]1875 for (x=0; x < (long) number_pixels; x++)
1876 {
1877 pixel=ScaleQuantumToShort(p->red);
1878 q=PopShortPixel(endian,pixel,q);
1879 pixel=ScaleQuantumToShort(p->green);
1880 q=PopShortPixel(endian,pixel,q);
1881 pixel=ScaleQuantumToShort(p->blue);
1882 q=PopShortPixel(endian,pixel,q);
1883 p++;
1884 q+=quantum_info->pad;
1885 }
1886 break;
1887 }
1888 case 32:
1889 {
1890 register unsigned long
1891 pixel;
1892
1893 if (quantum_info->format == FloatingPointQuantumFormat)
1894 {
1895 for (x=0; x < (long) number_pixels; x++)
1896 {
1897 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1898 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1899 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1900 p++;
1901 q+=quantum_info->pad;
1902 }
1903 break;
1904 }
1905 for (x=0; x < (long) number_pixels; x++)
1906 {
1907 pixel=ScaleQuantumToLong(p->red);
1908 q=PopLongPixel(endian,pixel,q);
1909 pixel=ScaleQuantumToLong(p->green);
1910 q=PopLongPixel(endian,pixel,q);
1911 pixel=ScaleQuantumToLong(p->blue);
1912 q=PopLongPixel(endian,pixel,q);
1913 p++;
1914 q+=quantum_info->pad;
1915 }
1916 break;
1917 }
1918 case 64:
1919 {
1920 if (quantum_info->format == FloatingPointQuantumFormat)
1921 {
1922 for (x=0; x < (long) number_pixels; x++)
1923 {
1924 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1925 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1926 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1927 p++;
1928 q+=quantum_info->pad;
1929 }
1930 break;
1931 }
1932 }
1933 default:
1934 {
1935 range=GetQuantumRange(image->depth);
1936 for (x=0; x < (long) number_pixels; x++)
1937 {
1938 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1939 p->red,range),q);
1940 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1941 p->green,range),q);
1942 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1943 p->blue,range),q);
1944 p++;
1945 q+=quantum_info->pad;
1946 }
1947 break;
1948 }
1949 }
1950 break;
1951 }
1952 case RGBAQuantum:
1953 case RGBOQuantum:
1954 case CbYCrAQuantum:
1955 {
1956 switch (quantum_info->depth)
1957 {
1958 case 8:
1959 {
1960 register unsigned char
1961 pixel;
1962
1963 for (x=0; x < (long) number_pixels; x++)
1964 {
1965 pixel=ScaleQuantumToChar(p->red);
1966 q=PopCharPixel(pixel,q);
1967 pixel=ScaleQuantumToChar(p->green);
1968 q=PopCharPixel(pixel,q);
1969 pixel=ScaleQuantumToChar(p->blue);
1970 q=PopCharPixel(pixel,q);
1971 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
1972 q=PopCharPixel(pixel,q);
1973 p++;
1974 q+=quantum_info->pad;
1975 }
1976 break;
1977 }
1978 case 16:
1979 {
1980 register unsigned short
1981 pixel;
1982
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]1983 if (quantum_info->format == FloatingPointQuantumFormat)
1984 {
1985 for (x=0; x < (long) number_pixels; x++)
1986 {
1987 pixel=ScaleFloatToHalf(QuantumScale*p->red);
1988 q=PopShortPixel(endian,pixel,q);
1989 pixel=ScaleFloatToHalf(QuantumScale*p->green);
1990 q=PopShortPixel(endian,pixel,q);
1991 pixel=ScaleFloatToHalf(QuantumScale*p->blue);
1992 q=PopShortPixel(endian,pixel,q);
1993 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-p->opacity));
1994 q=PopShortPixel(endian,pixel,q);
1995 p++;
1996 q+=quantum_info->pad;
1997 }
1998 break;
1999 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]2000 for (x=0; x < (long) number_pixels; x++)
2001 {
2002 pixel=ScaleQuantumToShort(p->red);
2003 q=PopShortPixel(endian,pixel,q);
2004 pixel=ScaleQuantumToShort(p->green);
2005 q=PopShortPixel(endian,pixel,q);
2006 pixel=ScaleQuantumToShort(p->blue);
2007 q=PopShortPixel(endian,pixel,q);
2008 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
2009 q=PopShortPixel(endian,pixel,q);
2010 p++;
2011 q+=quantum_info->pad;
2012 }
2013 break;
2014 }
2015 case 32:
2016 {
2017 register unsigned long
2018 pixel;
2019
2020 if (quantum_info->format == FloatingPointQuantumFormat)
2021 {
2022 for (x=0; x < (long) number_pixels; x++)
2023 {
2024 float
2025 pixel;
2026
2027 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2028 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2029 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2030 pixel=(float) (QuantumRange-p->opacity);
2031 q=PopFloatPixel(&quantum_state,pixel,q);
2032 p++;
2033 q+=quantum_info->pad;
2034 }
2035 break;
2036 }
2037 for (x=0; x < (long) number_pixels; x++)
2038 {
2039 pixel=ScaleQuantumToLong(p->red);
2040 q=PopLongPixel(endian,pixel,q);
2041 pixel=ScaleQuantumToLong(p->green);
2042 q=PopLongPixel(endian,pixel,q);
2043 pixel=ScaleQuantumToLong(p->blue);
2044 q=PopLongPixel(endian,pixel,q);
2045 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
2046 q=PopLongPixel(endian,pixel,q);
2047 p++;
2048 q+=quantum_info->pad;
2049 }
2050 break;
2051 }
2052 case 64:
2053 {
2054 if (quantum_info->format == FloatingPointQuantumFormat)
2055 {
2056 double
2057 pixel;
2058
2059 for (x=0; x < (long) number_pixels; x++)
2060 {
2061 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2062 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2063 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2064 pixel=(double) (QuantumRange-p->opacity);
2065 q=PopDoublePixel(&quantum_state,pixel,q);
2066 p++;
2067 q+=quantum_info->pad;
2068 }
2069 break;
2070 }
2071 }
2072 default:
2073 {
2074 range=GetQuantumRange(image->depth);
2075 for (x=0; x < (long) number_pixels; x++)
2076 {
2077 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2078 p->red,range),q);
2079 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2080 p->green,range),q);
2081 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2082 p->blue,range),q);
2083 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2084 (Quantum) (QuantumRange-p->opacity),range),q);
2085 p++;
2086 q+=quantum_info->pad;
2087 }
2088 break;
2089 }
2090 }
2091 break;
2092 }
2093 case CMYKQuantum:
2094 {
2095 if (image->colorspace != CMYKColorspace)
2096 {
2097 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2098 "ColorSeparatedImageRequired","`%s'",image->filename);
2099 return(extent);
2100 }
2101 switch (quantum_info->depth)
2102 {
2103 case 8:
2104 {
2105 register unsigned char
2106 pixel;
2107
2108 for (x=0; x < (long) number_pixels; x++)
2109 {
2110 pixel=ScaleQuantumToChar(p->red);
2111 q=PopCharPixel(pixel,q);
2112 pixel=ScaleQuantumToChar(p->green);
2113 q=PopCharPixel(pixel,q);
2114 pixel=ScaleQuantumToChar(p->blue);
2115 q=PopCharPixel(pixel,q);
2116 pixel=ScaleQuantumToChar(indexes[x]);
2117 q=PopCharPixel(pixel,q);
2118 p++;
2119 q+=quantum_info->pad;
2120 }
2121 break;
2122 }
2123 case 16:
2124 {
2125 register unsigned short
2126 pixel;
2127
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]2128 if (quantum_info->format == FloatingPointQuantumFormat)
2129 {
2130 for (x=0; x < (long) number_pixels; x++)
2131 {
2132 pixel=ScaleFloatToHalf(QuantumScale*p->red);
2133 q=PopShortPixel(endian,pixel,q);
2134 pixel=ScaleFloatToHalf(QuantumScale*p->green);
2135 q=PopShortPixel(endian,pixel,q);
2136 pixel=ScaleFloatToHalf(QuantumScale*p->blue);
2137 q=PopShortPixel(endian,pixel,q);
2138 pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
2139 q=PopShortPixel(endian,pixel,q);
2140 p++;
2141 q+=quantum_info->pad;
2142 }
2143 break;
2144 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]2145 for (x=0; x < (long) number_pixels; x++)
2146 {
2147 pixel=ScaleQuantumToShort(p->red);
2148 q=PopShortPixel(endian,pixel,q);
2149 pixel=ScaleQuantumToShort(p->green);
2150 q=PopShortPixel(endian,pixel,q);
2151 pixel=ScaleQuantumToShort(p->blue);
2152 q=PopShortPixel(endian,pixel,q);
2153 pixel=ScaleQuantumToShort(indexes[x]);
2154 q=PopShortPixel(endian,pixel,q);
2155 p++;
2156 q+=quantum_info->pad;
2157 }
2158 break;
2159 }
2160 case 32:
2161 {
2162 register unsigned long
2163 pixel;
2164
2165 if (quantum_info->format == FloatingPointQuantumFormat)
2166 {
2167 for (x=0; x < (long) number_pixels; x++)
2168 {
2169 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2170 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2171 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2172 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2173 p++;
2174 q+=quantum_info->pad;
2175 }
2176 break;
2177 }
2178 for (x=0; x < (long) number_pixels; x++)
2179 {
2180 pixel=ScaleQuantumToLong(p->red);
2181 q=PopLongPixel(endian,pixel,q);
2182 pixel=ScaleQuantumToLong(p->green);
2183 q=PopLongPixel(endian,pixel,q);
2184 pixel=ScaleQuantumToLong(p->blue);
2185 q=PopLongPixel(endian,pixel,q);
2186 pixel=ScaleQuantumToLong(indexes[x]);
2187 q=PopLongPixel(endian,pixel,q);
2188 p++;
2189 q+=quantum_info->pad;
2190 }
2191 break;
2192 }
2193 case 64:
2194 {
2195 if (quantum_info->format == FloatingPointQuantumFormat)
2196 {
2197 for (x=0; x < (long) number_pixels; x++)
2198 {
2199 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2200 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2201 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2202 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2203 p++;
2204 q+=quantum_info->pad;
2205 }
2206 break;
2207 }
2208 }
2209 default:
2210 {
2211 range=GetQuantumRange(image->depth);
2212 for (x=0; x < (long) number_pixels; x++)
2213 {
2214 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2215 p->red,range),q);
2216 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2217 p->green,range),q);
2218 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2219 p->blue,range),q);
2220 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2221 indexes[x],range),q);
2222 p++;
2223 q+=quantum_info->pad;
2224 }
2225 break;
2226 }
2227 }
2228 break;
2229 }
2230 case CMYKAQuantum:
2231 case CMYKOQuantum:
2232 {
2233 if (image->colorspace != CMYKColorspace)
2234 {
2235 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2236 "ColorSeparatedImageRequired","`%s'",image->filename);
2237 return(extent);
2238 }
2239 switch (quantum_info->depth)
2240 {
2241 case 8:
2242 {
2243 register unsigned char
2244 pixel;
2245
2246 for (x=0; x < (long) number_pixels; x++)
2247 {
2248 pixel=ScaleQuantumToChar(p->red);
2249 q=PopCharPixel(pixel,q);
2250 pixel=ScaleQuantumToChar(p->green);
2251 q=PopCharPixel(pixel,q);
2252 pixel=ScaleQuantumToChar(p->blue);
2253 q=PopCharPixel(pixel,q);
2254 pixel=ScaleQuantumToChar(indexes[x]);
2255 q=PopCharPixel(pixel,q);
2256 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
2257 q=PopCharPixel(pixel,q);
2258 p++;
2259 q+=quantum_info->pad;
2260 }
2261 break;
2262 }
2263 case 16:
2264 {
2265 register unsigned short
2266 pixel;
2267
cristyc9672a92010-01-06 00:57:45 +0000[diff] [blame^]2268 if (quantum_info->format == FloatingPointQuantumFormat)
2269 {
2270 for (x=0; x < (long) number_pixels; x++)
2271 {
2272 pixel=ScaleFloatToHalf(QuantumScale*p->red);
2273 q=PopShortPixel(endian,pixel,q);
2274 pixel=ScaleFloatToHalf(QuantumScale*p->green);
2275 q=PopShortPixel(endian,pixel,q);
2276 pixel=ScaleFloatToHalf(QuantumScale*p->blue);
2277 q=PopShortPixel(endian,pixel,q);
2278 pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
2279 q=PopShortPixel(endian,pixel,q);
2280 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-p->opacity));
2281 q=PopShortPixel(endian,pixel,q);
2282 p++;
2283 q+=quantum_info->pad;
2284 }
2285 break;
2286 }
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]2287 for (x=0; x < (long) number_pixels; x++)
2288 {
2289 pixel=ScaleQuantumToShort(p->red);
2290 q=PopShortPixel(endian,pixel,q);
2291 pixel=ScaleQuantumToShort(p->green);
2292 q=PopShortPixel(endian,pixel,q);
2293 pixel=ScaleQuantumToShort(p->blue);
2294 q=PopShortPixel(endian,pixel,q);
2295 pixel=ScaleQuantumToShort(indexes[x]);
2296 q=PopShortPixel(endian,pixel,q);
2297 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
2298 q=PopShortPixel(endian,pixel,q);
2299 p++;
2300 q+=quantum_info->pad;
2301 }
2302 break;
2303 }
2304 case 32:
2305 {
2306 register unsigned long
2307 pixel;
2308
2309 if (quantum_info->format == FloatingPointQuantumFormat)
2310 {
2311 for (x=0; x < (long) number_pixels; x++)
2312 {
2313 float
2314 pixel;
2315
2316 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2317 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2318 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2319 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2320 pixel=(float) (QuantumRange-p->opacity);
2321 q=PopFloatPixel(&quantum_state,pixel,q);
2322 p++;
2323 q+=quantum_info->pad;
2324 }
2325 break;
2326 }
2327 for (x=0; x < (long) number_pixels; x++)
2328 {
2329 pixel=ScaleQuantumToLong(p->red);
2330 q=PopLongPixel(endian,pixel,q);
2331 pixel=ScaleQuantumToLong(p->green);
2332 q=PopLongPixel(endian,pixel,q);
2333 pixel=ScaleQuantumToLong(p->blue);
2334 q=PopLongPixel(endian,pixel,q);
2335 pixel=ScaleQuantumToLong(indexes[x]);
2336 q=PopLongPixel(endian,pixel,q);
2337 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
2338 q=PopLongPixel(endian,pixel,q);
2339 p++;
2340 q+=quantum_info->pad;
2341 }
2342 break;
2343 }
2344 case 64:
2345 {
2346 if (quantum_info->format == FloatingPointQuantumFormat)
2347 {
2348 double
2349 pixel;
2350
2351 for (x=0; x < (long) number_pixels; x++)
2352 {
2353 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2354 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2355 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2356 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2357 pixel=(double) (QuantumRange-p->opacity);
2358 q=PopDoublePixel(&quantum_state,pixel,q);
2359 p++;
2360 q+=quantum_info->pad;
2361 }
2362 break;
2363 }
2364 }
2365 default:
2366 {
2367 range=GetQuantumRange(image->depth);
2368 for (x=0; x < (long) number_pixels; x++)
2369 {
2370 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2371 p->red,range),q);
2372 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2373 p->green,range),q);
2374 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2375 p->blue,range),q);
2376 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2377 indexes[x],range),q);
2378 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2379 p->opacity,range),q);
2380 p++;
2381 q+=quantum_info->pad;
2382 }
2383 break;
2384 }
2385 }
2386 break;
2387 }
2388 case CbYCrYQuantum:
2389 {
2390 long
2391 n;
2392
2393 Quantum
2394 cbcr[4];
2395
2396 register long
2397 i;
2398
2399 register unsigned long
2400 pixel;
2401
2402 unsigned long
2403 quantum;
2404
2405 n=0;
2406 quantum=0;
2407 range=GetQuantumRange(image->depth);
2408 switch (quantum_info->depth)
2409 {
2410 case 10:
2411 {
2412 if (quantum_info->pack == MagickFalse)
2413 {
2414 for (x=0; x < (long) number_pixels; x+=2)
2415 {
2416 for (i=0; i < 4; i++)
2417 {
2418 switch (n % 3)
2419 {
2420 case 0:
2421 {
2422 quantum=p->red;
2423 break;
2424 }
2425 case 1:
2426 {
2427 quantum=p->green;
2428 break;
2429 }
2430 case 2:
2431 {
2432 quantum=p->blue;
2433 break;
2434 }
2435 }
2436 cbcr[i]=(Quantum) quantum;
2437 n++;
2438 }
2439 pixel=(unsigned long) ((unsigned long) (cbcr[1]) << 22 |
2440 (unsigned long) (cbcr[0]) << 12 |
2441 (unsigned long) (cbcr[2]) << 2);
2442 q=PopLongPixel(endian,pixel,q);
2443 p++;
2444 pixel=(unsigned long) ((unsigned long) (cbcr[3]) << 22 |
2445 (unsigned long) (cbcr[0]) << 12 |
2446 (unsigned long) (cbcr[2]) << 2);
2447 q=PopLongPixel(endian,pixel,q);
2448 p++;
2449 q+=quantum_info->pad;
2450 }
2451 break;
2452 }
2453 break;
2454 }
2455 default:
2456 {
2457 for (x=0; x < (long) number_pixels; x+=2)
2458 {
2459 for (i=0; i < 4; i++)
2460 {
2461 switch (n % 3)
2462 {
2463 case 0:
2464 {
2465 quantum=p->red;
2466 break;
2467 }
2468 case 1:
2469 {
2470 quantum=p->green;
2471 break;
2472 }
2473 case 2:
2474 {
2475 quantum=p->blue;
2476 break;
2477 }
2478 }
2479 cbcr[i]=(Quantum) quantum;
2480 n++;
2481 }
2482 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2483 cbcr[1],range),q);
2484 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2485 cbcr[0],range),q);
2486 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2487 cbcr[2],range),q);
2488 p++;
2489 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2490 cbcr[3],range),q);
2491 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2492 cbcr[0],range),q);
2493 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2494 cbcr[2],range),q);
2495 p++;
2496 q+=quantum_info->pad;
2497 }
2498 break;
2499 }
2500 }
2501 break;
2502 }
2503 default:
2504 break;
2505 }
2506 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
2507 {
2508 Quantum
2509 quantum;
2510
2511 register PixelPacket
cristyc47d1f82009-11-26 01:44:43 +0000[diff] [blame]2512 *restrict q;
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]2513
2514 q=GetAuthenticPixelQueue(image);
2515 if (image_view != (CacheView *) NULL)
2516 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2517 for (x=0; x < (long) number_pixels; x++)
2518 {
2519 quantum=q->red;
2520 q->red=q->green;
2521 q->green=quantum;
2522 q++;
2523 }
2524 }
2525 if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
2526 {
2527 register PixelPacket
cristyc47d1f82009-11-26 01:44:43 +0000[diff] [blame]2528 *restrict q;
cristy3ed852e2009-09-05 21:47:34 +0000[diff] [blame]2529
2530 q=GetAuthenticPixelQueue(image);
2531 if (image_view != (CacheView *) NULL)
2532 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2533 for (x=0; x < (long) number_pixels; x++)
2534 {
2535 q->opacity=(Quantum) (QuantumRange-q->opacity);
2536 q++;
2537 }
2538 }
2539 return(extent);
2540}