MagickCore 6.9.13
Loading...
Searching...
No Matches
quantum-export.c
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% Cristy %
22% October 1998 %
23% %
24% %
25% Copyright 1999 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% https://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. It returns the number of exported pixels.
88%
89% The format of the ExportQuantumPixels method is:
90%
91% size_t ExportQuantumPixels(const Image *image,
92% const CacheView *image_view,const QuantumInfo *quantum_info,
93% const QuantumType quantum_type,unsigned char *magick_restrict pixels,
94% 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 *PopQuantumDoublePixel(QuantumInfo *quantum_info,
114 const double pixel,unsigned char *magick_restrict pixels)
115{
116 double
117 *p;
118
119 unsigned char
120 quantum[8];
121
122 (void) memset(quantum,0,sizeof(quantum));
123 p=(double *) quantum;
124 *p=(double) (pixel*quantum_info->state.inverse_scale+quantum_info->minimum);
125 if (quantum_info->endian == LSBEndian)
126 {
127 *pixels++=quantum[0];
128 *pixels++=quantum[1];
129 *pixels++=quantum[2];
130 *pixels++=quantum[3];
131 *pixels++=quantum[4];
132 *pixels++=quantum[5];
133 *pixels++=quantum[6];
134 *pixels++=quantum[7];
135 return(pixels);
136 }
137 *pixels++=quantum[7];
138 *pixels++=quantum[6];
139 *pixels++=quantum[5];
140 *pixels++=quantum[4];
141 *pixels++=quantum[3];
142 *pixels++=quantum[2];
143 *pixels++=quantum[1];
144 *pixels++=quantum[0];
145 return(pixels);
146}
147
148static inline unsigned char *PopQuantumFloatPixel(QuantumInfo *quantum_info,
149 const float pixel,unsigned char *magick_restrict pixels)
150{
151 float
152 *p;
153
154 unsigned char
155 quantum[4];
156
157 (void) memset(quantum,0,sizeof(quantum));
158 p=(float *) quantum;
159 *p=(float) ((double) pixel*quantum_info->state.inverse_scale+
160 quantum_info->minimum);
161 if (quantum_info->endian == LSBEndian)
162 {
163 *pixels++=quantum[0];
164 *pixels++=quantum[1];
165 *pixels++=quantum[2];
166 *pixels++=quantum[3];
167 return(pixels);
168 }
169 *pixels++=quantum[3];
170 *pixels++=quantum[2];
171 *pixels++=quantum[1];
172 *pixels++=quantum[0];
173 return(pixels);
174}
175
176static inline unsigned char *PopQuantumPixel(QuantumInfo *quantum_info,
177 const QuantumAny pixel,unsigned char *magick_restrict pixels)
178{
179 ssize_t
180 i;
181
182 size_t
183 quantum_bits;
184
185 if (quantum_info->state.bits == 0UL)
186 quantum_info->state.bits=8U;
187 for (i=(ssize_t) quantum_info->depth; i > 0L; )
188 {
189 quantum_bits=(size_t) i;
190 if (quantum_bits > quantum_info->state.bits)
191 quantum_bits=quantum_info->state.bits;
192 i-=(ssize_t) quantum_bits;
193 if (i < 0)
194 i=0;
195 if (quantum_info->state.bits == 8UL)
196 *pixels='\0';
197 quantum_info->state.bits-=quantum_bits;
198 *pixels|=(((pixel >> i) &~ ((~0UL) << quantum_bits)) <<
199 quantum_info->state.bits);
200 if (quantum_info->state.bits == 0UL)
201 {
202 pixels++;
203 quantum_info->state.bits=8UL;
204 }
205 }
206 return(pixels);
207}
208
209static inline unsigned char *PopQuantumLongPixel(QuantumInfo *quantum_info,
210 const size_t pixel,unsigned char *magick_restrict pixels)
211{
212 ssize_t
213 i;
214
215 size_t
216 quantum_bits;
217
218 if (quantum_info->state.bits == 0U)
219 quantum_info->state.bits=32UL;
220 for (i=(ssize_t) quantum_info->depth; i > 0; )
221 {
222 quantum_bits=(size_t) i;
223 if (quantum_bits > quantum_info->state.bits)
224 quantum_bits=quantum_info->state.bits;
225 quantum_info->state.pixel|=(((pixel >> (quantum_info->depth-i)) &
226 quantum_info->state.mask[quantum_bits]) <<
227 (32U-quantum_info->state.bits));
228 i-=(ssize_t) quantum_bits;
229 quantum_info->state.bits-=quantum_bits;
230 if (quantum_info->state.bits == 0U)
231 {
232 pixels=PopLongPixel(quantum_info->endian,quantum_info->state.pixel,
233 pixels);
234 quantum_info->state.pixel=0U;
235 quantum_info->state.bits=32U;
236 }
237 }
238 return(pixels);
239}
240
241static void ExportAlphaQuantum(QuantumInfo *quantum_info,
242 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
243 unsigned char *magick_restrict q)
244{
245 QuantumAny
246 range;
247
248 ssize_t
249 x;
250
251 switch (quantum_info->depth)
252 {
253 case 8:
254 {
255 unsigned char
256 pixel;
257
258 for (x=0; x < (ssize_t) number_pixels; x++)
259 {
260 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetPixelOpacity(p)));
261 q=PopCharPixel(pixel,q);
262 p++;
263 q+=(ptrdiff_t) quantum_info->pad;
264 }
265 break;
266 }
267 case 16:
268 {
269 unsigned short
270 pixel;
271
272 if (quantum_info->format == FloatingPointQuantumFormat)
273 {
274 for (x=0; x < (ssize_t) number_pixels; x++)
275 {
276 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
277 q=PopShortPixel(quantum_info->endian,pixel,q);
278 p++;
279 q+=(ptrdiff_t) quantum_info->pad;
280 }
281 break;
282 }
283 for (x=0; x < (ssize_t) number_pixels; x++)
284 {
285 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetPixelOpacity(p)));
286 q=PopShortPixel(quantum_info->endian,pixel,q);
287 p++;
288 q+=(ptrdiff_t) quantum_info->pad;
289 }
290 break;
291 }
292 case 32:
293 {
294 unsigned int
295 pixel;
296
297 if (quantum_info->format == FloatingPointQuantumFormat)
298 {
299 for (x=0; x < (ssize_t) number_pixels; x++)
300 {
301 float
302 pixel;
303
304 pixel=(float) (GetPixelAlpha(p));
305 q=PopQuantumFloatPixel(quantum_info,pixel,q);
306 p++;
307 q+=(ptrdiff_t) quantum_info->pad;
308 }
309 break;
310 }
311 for (x=0; x < (ssize_t) number_pixels; x++)
312 {
313 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetPixelOpacity(p)));
314 q=PopLongPixel(quantum_info->endian,pixel,q);
315 p++;
316 q+=(ptrdiff_t) quantum_info->pad;
317 }
318 break;
319 }
320 case 64:
321 {
322 if (quantum_info->format == FloatingPointQuantumFormat)
323 {
324 for (x=0; x < (ssize_t) number_pixels; x++)
325 {
326 double
327 pixel;
328
329 pixel=(double) (GetPixelAlpha(p));
330 q=PopQuantumDoublePixel(quantum_info,pixel,q);
331 p++;
332 q+=(ptrdiff_t) quantum_info->pad;
333 }
334 break;
335 }
336 magick_fallthrough;
337 }
338 default:
339 {
340 range=GetQuantumRange(quantum_info->depth);
341 for (x=0; x < (ssize_t) number_pixels; x++)
342 {
343 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny((Quantum)
344 (GetPixelAlpha(p)),range),q);
345 p++;
346 q+=(ptrdiff_t) quantum_info->pad;
347 }
348 break;
349 }
350 }
351}
352
353static void ExportBGRQuantum(QuantumInfo *quantum_info,
354 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
355 unsigned char *magick_restrict q)
356{
357 QuantumAny
358 range;
359
360 ssize_t
361 x;
362
363 ssize_t
364 bit;
365
366 switch (quantum_info->depth)
367 {
368 case 8:
369 {
370 for (x=0; x < (ssize_t) number_pixels; x++)
371 {
372 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(p)),q);
373 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(p)),q);
374 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(p)),q);
375 p++;
376 q+=(ptrdiff_t) quantum_info->pad;
377 }
378 break;
379 }
380 case 10:
381 {
382 unsigned int
383 pixel;
384
385 range=GetQuantumRange(quantum_info->depth);
386 if (quantum_info->pack == MagickFalse)
387 {
388 for (x=0; x < (ssize_t) number_pixels; x++)
389 {
390 pixel=(unsigned int) (
391 ScaleQuantumToAny(GetPixelRed(p),range) << 22 |
392 ScaleQuantumToAny(GetPixelGreen(p),range) << 12 |
393 ScaleQuantumToAny(GetPixelBlue(p),range) << 2);
394 q=PopLongPixel(quantum_info->endian,pixel,q);
395 p++;
396 q+=(ptrdiff_t) quantum_info->pad;
397 }
398 break;
399 }
400 if (quantum_info->quantum == 32UL)
401 {
402 for (x=0; x < (ssize_t) number_pixels; x++)
403 {
404 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
405 q=PopQuantumLongPixel(quantum_info,pixel,q);
406 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
407 q=PopQuantumLongPixel(quantum_info,pixel,q);
408 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
409 q=PopQuantumLongPixel(quantum_info,pixel,q);
410 p++;
411 q+=(ptrdiff_t) quantum_info->pad;
412 }
413 break;
414 }
415 for (x=0; x < (ssize_t) number_pixels; x++)
416 {
417 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
418 q=PopQuantumPixel(quantum_info,pixel,q);
419 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
420 q=PopQuantumPixel(quantum_info,pixel,q);
421 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
422 q=PopQuantumPixel(quantum_info,pixel,q);
423 p++;
424 q+=(ptrdiff_t) quantum_info->pad;
425 }
426 break;
427 }
428 case 12:
429 {
430 unsigned int
431 pixel;
432
433 range=GetQuantumRange(quantum_info->depth);
434 if (quantum_info->pack == MagickFalse)
435 {
436 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
437 {
438 switch (x % 3)
439 {
440 default:
441 case 0:
442 {
443 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
444 break;
445 }
446 case 1:
447 {
448 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
449 break;
450 }
451 case 2:
452 {
453 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
454 p++;
455 break;
456 }
457 }
458 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),q);
459 switch ((x+1) % 3)
460 {
461 default:
462 case 0:
463 {
464 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
465 break;
466 }
467 case 1:
468 {
469 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
470 break;
471 }
472 case 2:
473 {
474 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
475 p++;
476 break;
477 }
478 }
479 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),q);
480 q+=(ptrdiff_t) quantum_info->pad;
481 }
482 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
483 {
484 switch ((x+bit) % 3)
485 {
486 default:
487 case 0:
488 {
489 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
490 break;
491 }
492 case 1:
493 {
494 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
495 break;
496 }
497 case 2:
498 {
499 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
500 p++;
501 break;
502 }
503 }
504 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),q);
505 q+=(ptrdiff_t) quantum_info->pad;
506 }
507 if (bit != 0)
508 p++;
509 break;
510 }
511 if (quantum_info->quantum == 32UL)
512 {
513 for (x=0; x < (ssize_t) number_pixels; x++)
514 {
515 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
516 q=PopQuantumLongPixel(quantum_info,pixel,q);
517 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
518 q=PopQuantumLongPixel(quantum_info,pixel,q);
519 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
520 q=PopQuantumLongPixel(quantum_info,pixel,q);
521 p++;
522 q+=(ptrdiff_t) quantum_info->pad;
523 }
524 break;
525 }
526 for (x=0; x < (ssize_t) number_pixels; x++)
527 {
528 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
529 q=PopQuantumPixel(quantum_info,pixel,q);
530 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
531 q=PopQuantumPixel(quantum_info,pixel,q);
532 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
533 q=PopQuantumPixel(quantum_info,pixel,q);
534 p++;
535 q+=(ptrdiff_t) quantum_info->pad;
536 }
537 break;
538 }
539 case 16:
540 {
541 unsigned short
542 pixel;
543
544 if (quantum_info->format == FloatingPointQuantumFormat)
545 {
546 for (x=0; x < (ssize_t) number_pixels; x++)
547 {
548 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
549 q=PopShortPixel(quantum_info->endian,pixel,q);
550 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
551 q=PopShortPixel(quantum_info->endian,pixel,q);
552 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
553 q=PopShortPixel(quantum_info->endian,pixel,q);
554 p++;
555 q+=(ptrdiff_t) quantum_info->pad;
556 }
557 break;
558 }
559 for (x=0; x < (ssize_t) number_pixels; x++)
560 {
561 pixel=ScaleQuantumToShort(GetPixelBlue(p));
562 q=PopShortPixel(quantum_info->endian,pixel,q);
563 pixel=ScaleQuantumToShort(GetPixelGreen(p));
564 q=PopShortPixel(quantum_info->endian,pixel,q);
565 pixel=ScaleQuantumToShort(GetPixelRed(p));
566 q=PopShortPixel(quantum_info->endian,pixel,q);
567 p++;
568 q+=(ptrdiff_t) quantum_info->pad;
569 }
570 break;
571 }
572 case 32:
573 {
574 unsigned int
575 pixel;
576
577 if (quantum_info->format == FloatingPointQuantumFormat)
578 {
579 for (x=0; x < (ssize_t) number_pixels; x++)
580 {
581 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(p),q);
582 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(p),q);
583 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(p),q);
584 p++;
585 q+=(ptrdiff_t) quantum_info->pad;
586 }
587 break;
588 }
589 for (x=0; x < (ssize_t) number_pixels; x++)
590 {
591 pixel=ScaleQuantumToLong(GetPixelBlue(p));
592 q=PopLongPixel(quantum_info->endian,pixel,q);
593 pixel=ScaleQuantumToLong(GetPixelGreen(p));
594 q=PopLongPixel(quantum_info->endian,pixel,q);
595 pixel=ScaleQuantumToLong(GetPixelRed(p));
596 q=PopLongPixel(quantum_info->endian,pixel,q);
597 p++;
598 q+=(ptrdiff_t) quantum_info->pad;
599 }
600 break;
601 }
602 case 64:
603 {
604 if (quantum_info->format == FloatingPointQuantumFormat)
605 {
606 for (x=0; x < (ssize_t) number_pixels; x++)
607 {
608 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(p),q);
609 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(p),q);
610 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(p),q);
611 p++;
612 q+=(ptrdiff_t) quantum_info->pad;
613 }
614 break;
615 }
616 magick_fallthrough;
617 }
618 default:
619 {
620 range=GetQuantumRange(quantum_info->depth);
621 for (x=0; x < (ssize_t) number_pixels; x++)
622 {
623 q=PopQuantumPixel(quantum_info,
624 ScaleQuantumToAny(GetPixelRed(p),range),q);
625 q=PopQuantumPixel(quantum_info,
626 ScaleQuantumToAny(GetPixelGreen(p),range),q);
627 q=PopQuantumPixel(quantum_info,
628 ScaleQuantumToAny(GetPixelBlue(p),range),q);
629 p++;
630 q+=(ptrdiff_t) quantum_info->pad;
631 }
632 break;
633 }
634 }
635}
636
637static void ExportBGRAQuantum(QuantumInfo *quantum_info,
638 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
639 unsigned char *magick_restrict q)
640{
641 QuantumAny
642 range;
643
644 ssize_t
645 x;
646
647 switch (quantum_info->depth)
648 {
649 case 8:
650 {
651 unsigned char
652 pixel;
653
654 for (x=0; x < (ssize_t) number_pixels; x++)
655 {
656 pixel=ScaleQuantumToChar(GetPixelBlue(p));
657 q=PopCharPixel(pixel,q);
658 pixel=ScaleQuantumToChar(GetPixelGreen(p));
659 q=PopCharPixel(pixel,q);
660 pixel=ScaleQuantumToChar(GetPixelRed(p));
661 q=PopCharPixel(pixel,q);
662 pixel=ScaleQuantumToChar((Quantum) GetPixelAlpha(p));
663 q=PopCharPixel(pixel,q);
664 p++;
665 q+=(ptrdiff_t) quantum_info->pad;
666 }
667 break;
668 }
669 case 10:
670 {
671 unsigned int
672 pixel;
673
674 range=GetQuantumRange(quantum_info->depth);
675 if (quantum_info->pack == MagickFalse)
676 {
677 ssize_t
678 i;
679
680 size_t
681 quantum;
682
683 ssize_t
684 n;
685
686 n=0;
687 quantum=0;
688 pixel=0;
689 for (x=0; x < (ssize_t) number_pixels; x++)
690 {
691 for (i=0; i < 4; i++)
692 {
693 switch (i)
694 {
695 case 0: quantum=(size_t) GetPixelRed(p); break;
696 case 1: quantum=(size_t) GetPixelGreen(p); break;
697 case 2: quantum=(size_t) GetPixelBlue(p); break;
698 case 3: quantum=(size_t) GetPixelAlpha(p); break;
699 }
700 switch (n % 3)
701 {
702 case 0:
703 {
704 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
705 range) << 22);
706 break;
707 }
708 case 1:
709 {
710 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
711 range) << 12);
712 break;
713 }
714 case 2:
715 {
716 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
717 range) << 2);
718 q=PopLongPixel(quantum_info->endian,pixel,q);
719 pixel=0;
720 break;
721 }
722 }
723 n++;
724 }
725 p++;
726 q+=(ptrdiff_t) quantum_info->pad;
727 }
728 break;
729 }
730 if (quantum_info->quantum == 32UL)
731 {
732 for (x=0; x < (ssize_t) number_pixels; x++)
733 {
734 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
735 q=PopQuantumLongPixel(quantum_info,pixel,q);
736 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
737 q=PopQuantumLongPixel(quantum_info,pixel,q);
738 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
739 q=PopQuantumLongPixel(quantum_info,pixel,q);
740 pixel=(unsigned int) ScaleQuantumToAny((Quantum) GetPixelAlpha(p),
741 range);
742 q=PopQuantumLongPixel(quantum_info,pixel,q);
743 p++;
744 q+=(ptrdiff_t) quantum_info->pad;
745 }
746 break;
747 }
748 for (x=0; x < (ssize_t) number_pixels; x++)
749 {
750 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
751 q=PopQuantumPixel(quantum_info,pixel,q);
752 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
753 q=PopQuantumPixel(quantum_info,pixel,q);
754 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
755 q=PopQuantumPixel(quantum_info,pixel,q);
756 pixel=(unsigned int) ScaleQuantumToAny((Quantum) GetPixelAlpha(p),
757 range);
758 q=PopQuantumPixel(quantum_info,pixel,q);
759 p++;
760 q+=(ptrdiff_t) quantum_info->pad;
761 }
762 break;
763 }
764 case 16:
765 {
766 unsigned short
767 pixel;
768
769 if (quantum_info->format == FloatingPointQuantumFormat)
770 {
771 for (x=0; x < (ssize_t) number_pixels; x++)
772 {
773 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
774 q=PopShortPixel(quantum_info->endian,pixel,q);
775 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
776 q=PopShortPixel(quantum_info->endian,pixel,q);
777 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
778 q=PopShortPixel(quantum_info->endian,pixel,q);
779 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
780 q=PopShortPixel(quantum_info->endian,pixel,q);
781 p++;
782 q+=(ptrdiff_t) quantum_info->pad;
783 }
784 break;
785 }
786 for (x=0; x < (ssize_t) number_pixels; x++)
787 {
788 pixel=ScaleQuantumToShort(GetPixelBlue(p));
789 q=PopShortPixel(quantum_info->endian,pixel,q);
790 pixel=ScaleQuantumToShort(GetPixelGreen(p));
791 q=PopShortPixel(quantum_info->endian,pixel,q);
792 pixel=ScaleQuantumToShort(GetPixelRed(p));
793 q=PopShortPixel(quantum_info->endian,pixel,q);
794 pixel=ScaleQuantumToShort((Quantum) GetPixelAlpha(p));
795 q=PopShortPixel(quantum_info->endian,pixel,q);
796 p++;
797 q+=(ptrdiff_t) quantum_info->pad;
798 }
799 break;
800 }
801 case 32:
802 {
803 unsigned int
804 pixel;
805
806 if (quantum_info->format == FloatingPointQuantumFormat)
807 {
808 for (x=0; x < (ssize_t) number_pixels; x++)
809 {
810 float
811 pixel;
812
813 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(p),q);
814 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(p),q);
815 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(p),q);
816 pixel=(float) GetPixelAlpha(p);
817 q=PopQuantumFloatPixel(quantum_info,pixel,q);
818 p++;
819 q+=(ptrdiff_t) quantum_info->pad;
820 }
821 break;
822 }
823 for (x=0; x < (ssize_t) number_pixels; x++)
824 {
825 pixel=ScaleQuantumToLong(GetPixelBlue(p));
826 q=PopLongPixel(quantum_info->endian,pixel,q);
827 pixel=ScaleQuantumToLong(GetPixelGreen(p));
828 q=PopLongPixel(quantum_info->endian,pixel,q);
829 pixel=ScaleQuantumToLong(GetPixelRed(p));
830 q=PopLongPixel(quantum_info->endian,pixel,q);
831 pixel=ScaleQuantumToLong((Quantum) GetPixelAlpha(p));
832 q=PopLongPixel(quantum_info->endian,pixel,q);
833 p++;
834 q+=(ptrdiff_t) quantum_info->pad;
835 }
836 break;
837 }
838 case 64:
839 {
840 if (quantum_info->format == FloatingPointQuantumFormat)
841 {
842 double
843 pixel;
844
845 for (x=0; x < (ssize_t) number_pixels; x++)
846 {
847 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(p),q);
848 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(p),q);
849 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(p),q);
850 pixel=(double) GetPixelAlpha(p);
851 q=PopQuantumDoublePixel(quantum_info,pixel,q);
852 p++;
853 q+=(ptrdiff_t) quantum_info->pad;
854 }
855 break;
856 }
857 magick_fallthrough;
858 }
859 default:
860 {
861 range=GetQuantumRange(quantum_info->depth);
862 for (x=0; x < (ssize_t) number_pixels; x++)
863 {
864 q=PopQuantumPixel(quantum_info,
865 ScaleQuantumToAny(GetPixelBlue(p),range),q);
866 q=PopQuantumPixel(quantum_info,
867 ScaleQuantumToAny(GetPixelGreen(p),range),q);
868 q=PopQuantumPixel(quantum_info,
869 ScaleQuantumToAny(GetPixelRed(p),range),q);
870 q=PopQuantumPixel(quantum_info,
871 ScaleQuantumToAny((Quantum) GetPixelAlpha(p),range),q);
872 p++;
873 q+=(ptrdiff_t) quantum_info->pad;
874 }
875 break;
876 }
877 }
878}
879
880static void ExportBGROQuantum(QuantumInfo *quantum_info,
881 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
882 unsigned char *magick_restrict q)
883{
884 QuantumAny
885 range;
886
887 ssize_t
888 x;
889
890 switch (quantum_info->depth)
891 {
892 case 8:
893 {
894 unsigned char
895 pixel;
896
897 for (x=0; x < (ssize_t) number_pixels; x++)
898 {
899 pixel=ScaleQuantumToChar(GetPixelBlue(p));
900 q=PopCharPixel(pixel,q);
901 pixel=ScaleQuantumToChar(GetPixelGreen(p));
902 q=PopCharPixel(pixel,q);
903 pixel=ScaleQuantumToChar(GetPixelRed(p));
904 q=PopCharPixel(pixel,q);
905 pixel=ScaleQuantumToChar(GetPixelOpacity(p));
906 q=PopCharPixel(pixel,q);
907 p++;
908 q+=(ptrdiff_t) quantum_info->pad;
909 }
910 break;
911 }
912 case 10:
913 {
914 unsigned int
915 pixel;
916
917 range=GetQuantumRange(quantum_info->depth);
918 if (quantum_info->pack == MagickFalse)
919 {
920 ssize_t
921 i;
922
923 size_t
924 quantum;
925
926 ssize_t
927 n;
928
929 n=0;
930 quantum=0;
931 pixel=0;
932 for (x=0; x < (ssize_t) number_pixels; x++)
933 {
934 for (i=0; i < 4; i++)
935 {
936 switch (i)
937 {
938 case 0: quantum=(size_t) GetPixelRed(p); break;
939 case 1: quantum=(size_t) GetPixelGreen(p); break;
940 case 2: quantum=(size_t) GetPixelBlue(p); break;
941 case 3: quantum=(size_t) GetPixelOpacity(p); break;
942 }
943 switch (n % 3)
944 {
945 case 0:
946 {
947 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
948 range) << 22);
949 break;
950 }
951 case 1:
952 {
953 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
954 range) << 12);
955 break;
956 }
957 case 2:
958 {
959 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
960 range) << 2);
961 q=PopLongPixel(quantum_info->endian,pixel,q);
962 pixel=0;
963 break;
964 }
965 }
966 n++;
967 }
968 p++;
969 q+=(ptrdiff_t) quantum_info->pad;
970 }
971 break;
972 }
973 if (quantum_info->quantum == 32UL)
974 {
975 for (x=0; x < (ssize_t) number_pixels; x++)
976 {
977 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
978 q=PopQuantumLongPixel(quantum_info,pixel,q);
979 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
980 q=PopQuantumLongPixel(quantum_info,pixel,q);
981 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
982 q=PopQuantumLongPixel(quantum_info,pixel,q);
983 pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(p),range);
984 q=PopQuantumLongPixel(quantum_info,pixel,q);
985 p++;
986 q+=(ptrdiff_t) quantum_info->pad;
987 }
988 break;
989 }
990 for (x=0; x < (ssize_t) number_pixels; x++)
991 {
992 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
993 q=PopQuantumPixel(quantum_info,pixel,q);
994 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
995 q=PopQuantumPixel(quantum_info,pixel,q);
996 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
997 q=PopQuantumPixel(quantum_info,pixel,q);
998 pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(p),range);
999 q=PopQuantumPixel(quantum_info,pixel,q);
1000 p++;
1001 q+=(ptrdiff_t) quantum_info->pad;
1002 }
1003 break;
1004 }
1005 case 16:
1006 {
1007 unsigned short
1008 pixel;
1009
1010 if (quantum_info->format == FloatingPointQuantumFormat)
1011 {
1012 for (x=0; x < (ssize_t) number_pixels; x++)
1013 {
1014 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
1015 q=PopShortPixel(quantum_info->endian,pixel,q);
1016 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
1017 q=PopShortPixel(quantum_info->endian,pixel,q);
1018 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
1019 q=PopShortPixel(quantum_info->endian,pixel,q);
1020 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelOpacity(p));
1021 q=PopShortPixel(quantum_info->endian,pixel,q);
1022 p++;
1023 q+=(ptrdiff_t) quantum_info->pad;
1024 }
1025 break;
1026 }
1027 for (x=0; x < (ssize_t) number_pixels; x++)
1028 {
1029 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1030 q=PopShortPixel(quantum_info->endian,pixel,q);
1031 pixel=ScaleQuantumToShort(GetPixelGreen(p));
1032 q=PopShortPixel(quantum_info->endian,pixel,q);
1033 pixel=ScaleQuantumToShort(GetPixelRed(p));
1034 q=PopShortPixel(quantum_info->endian,pixel,q);
1035 pixel=ScaleQuantumToShort(GetPixelOpacity(p));
1036 q=PopShortPixel(quantum_info->endian,pixel,q);
1037 p++;
1038 q+=(ptrdiff_t) quantum_info->pad;
1039 }
1040 break;
1041 }
1042 case 32:
1043 {
1044 unsigned int
1045 pixel;
1046
1047 if (quantum_info->format == FloatingPointQuantumFormat)
1048 {
1049 for (x=0; x < (ssize_t) number_pixels; x++)
1050 {
1051 float
1052 pixel;
1053
1054 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(p),q);
1055 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(p),q);
1056 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(p),q);
1057 pixel=(float) GetPixelOpacity(p);
1058 q=PopQuantumFloatPixel(quantum_info,pixel,q);
1059 p++;
1060 q+=(ptrdiff_t) quantum_info->pad;
1061 }
1062 break;
1063 }
1064 for (x=0; x < (ssize_t) number_pixels; x++)
1065 {
1066 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1067 q=PopLongPixel(quantum_info->endian,pixel,q);
1068 pixel=ScaleQuantumToLong(GetPixelGreen(p));
1069 q=PopLongPixel(quantum_info->endian,pixel,q);
1070 pixel=ScaleQuantumToLong(GetPixelRed(p));
1071 q=PopLongPixel(quantum_info->endian,pixel,q);
1072 pixel=ScaleQuantumToLong(GetPixelOpacity(p));
1073 q=PopLongPixel(quantum_info->endian,pixel,q);
1074 p++;
1075 q+=(ptrdiff_t) quantum_info->pad;
1076 }
1077 break;
1078 }
1079 case 64:
1080 {
1081 if (quantum_info->format == FloatingPointQuantumFormat)
1082 {
1083 double
1084 pixel;
1085
1086 for (x=0; x < (ssize_t) number_pixels; x++)
1087 {
1088 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(p),q);
1089 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(p),q);
1090 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(p),q);
1091 pixel=(double) GetPixelOpacity(p);
1092 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1093 p++;
1094 q+=(ptrdiff_t) quantum_info->pad;
1095 }
1096 break;
1097 }
1098 magick_fallthrough;
1099 }
1100 default:
1101 {
1102 range=GetQuantumRange(quantum_info->depth);
1103 for (x=0; x < (ssize_t) number_pixels; x++)
1104 {
1105 q=PopQuantumPixel(quantum_info,
1106 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1107 q=PopQuantumPixel(quantum_info,
1108 ScaleQuantumToAny(GetPixelGreen(p),range),q);
1109 q=PopQuantumPixel(quantum_info,
1110 ScaleQuantumToAny(GetPixelRed(p),range),q);
1111 q=PopQuantumPixel(quantum_info,
1112 ScaleQuantumToAny(GetPixelOpacity(p),range),q);
1113 p++;
1114 q+=(ptrdiff_t) quantum_info->pad;
1115 }
1116 break;
1117 }
1118 }
1119}
1120
1121static void ExportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
1122 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
1123 const IndexPacket *magick_restrict indexes,unsigned char *magick_restrict q,
1124 ExceptionInfo *exception)
1125{
1126 ssize_t
1127 x;
1128
1129 if (image->colorspace != CMYKColorspace)
1130 {
1131 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1132 "ColorSeparatedImageRequired","`%s'",image->filename);
1133 return;
1134 }
1135 switch (quantum_info->depth)
1136 {
1137 case 8:
1138 {
1139 unsigned char
1140 pixel;
1141
1142 for (x=0; x < (ssize_t) number_pixels; x++)
1143 {
1144 pixel=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1145 q=PopCharPixel(pixel,q);
1146 p++;
1147 q+=(ptrdiff_t) quantum_info->pad;
1148 }
1149 break;
1150 }
1151 case 16:
1152 {
1153 unsigned short
1154 pixel;
1155
1156 if (quantum_info->format == FloatingPointQuantumFormat)
1157 {
1158 for (x=0; x < (ssize_t) number_pixels; x++)
1159 {
1160 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelIndex(indexes+x));
1161 q=PopShortPixel(quantum_info->endian,pixel,q);
1162 p++;
1163 q+=(ptrdiff_t) quantum_info->pad;
1164 }
1165 break;
1166 }
1167 for (x=0; x < (ssize_t) number_pixels; x++)
1168 {
1169 pixel=ScaleQuantumToShort(GetPixelIndex(indexes+x));
1170 q=PopShortPixel(quantum_info->endian,pixel,q);
1171 p++;
1172 q+=(ptrdiff_t) quantum_info->pad;
1173 }
1174 break;
1175 }
1176 case 32:
1177 {
1178 unsigned int
1179 pixel;
1180
1181 if (quantum_info->format == FloatingPointQuantumFormat)
1182 {
1183 for (x=0; x < (ssize_t) number_pixels; x++)
1184 {
1185 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelIndex(indexes+x),q);
1186 p++;
1187 q+=(ptrdiff_t) quantum_info->pad;
1188 }
1189 break;
1190 }
1191 for (x=0; x < (ssize_t) number_pixels; x++)
1192 {
1193 pixel=ScaleQuantumToLong(GetPixelIndex(indexes+x));
1194 q=PopLongPixel(quantum_info->endian,pixel,q);
1195 p++;
1196 q+=(ptrdiff_t) quantum_info->pad;
1197 }
1198 break;
1199 }
1200 case 64:
1201 {
1202 if (quantum_info->format == FloatingPointQuantumFormat)
1203 {
1204 for (x=0; x < (ssize_t) number_pixels; x++)
1205 {
1206 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelIndex(indexes+x),
1207 q);
1208 p++;
1209 q+=(ptrdiff_t) quantum_info->pad;
1210 }
1211 break;
1212 }
1213 magick_fallthrough;
1214 }
1215 default:
1216 {
1217 QuantumAny
1218 range;
1219
1220 range=GetQuantumRange(quantum_info->depth);
1221 for (x=0; x < (ssize_t) number_pixels; x++)
1222 {
1223 q=PopQuantumPixel(quantum_info,
1224 ScaleQuantumToAny((Quantum) GetPixelIndex(indexes+x),range),q);
1225 p++;
1226 q+=(ptrdiff_t) quantum_info->pad;
1227 }
1228 break;
1229 }
1230 }
1231}
1232
1233static void ExportBlueQuantum(QuantumInfo *quantum_info,
1234 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
1235 unsigned char *magick_restrict q)
1236{
1237 QuantumAny
1238 range;
1239
1240 ssize_t
1241 x;
1242
1243 switch (quantum_info->depth)
1244 {
1245 case 8:
1246 {
1247 unsigned char
1248 pixel;
1249
1250 for (x=0; x < (ssize_t) number_pixels; x++)
1251 {
1252 pixel=ScaleQuantumToChar(GetPixelBlue(p));
1253 q=PopCharPixel(pixel,q);
1254 p++;
1255 q+=(ptrdiff_t) quantum_info->pad;
1256 }
1257 break;
1258 }
1259 case 16:
1260 {
1261 unsigned short
1262 pixel;
1263
1264 if (quantum_info->format == FloatingPointQuantumFormat)
1265 {
1266 for (x=0; x < (ssize_t) number_pixels; x++)
1267 {
1268 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
1269 q=PopShortPixel(quantum_info->endian,pixel,q);
1270 p++;
1271 q+=(ptrdiff_t) quantum_info->pad;
1272 }
1273 break;
1274 }
1275 for (x=0; x < (ssize_t) number_pixels; x++)
1276 {
1277 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1278 q=PopShortPixel(quantum_info->endian,pixel,q);
1279 p++;
1280 q+=(ptrdiff_t) quantum_info->pad;
1281 }
1282 break;
1283 }
1284 case 32:
1285 {
1286 unsigned int
1287 pixel;
1288
1289 if (quantum_info->format == FloatingPointQuantumFormat)
1290 {
1291 for (x=0; x < (ssize_t) number_pixels; x++)
1292 {
1293 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(p),q);
1294 p++;
1295 q+=(ptrdiff_t) quantum_info->pad;
1296 }
1297 break;
1298 }
1299 for (x=0; x < (ssize_t) number_pixels; x++)
1300 {
1301 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1302 q=PopLongPixel(quantum_info->endian,pixel,q);
1303 p++;
1304 q+=(ptrdiff_t) quantum_info->pad;
1305 }
1306 break;
1307 }
1308 case 64:
1309 {
1310 if (quantum_info->format == FloatingPointQuantumFormat)
1311 {
1312 for (x=0; x < (ssize_t) number_pixels; x++)
1313 {
1314 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(p),q);
1315 p++;
1316 q+=(ptrdiff_t) quantum_info->pad;
1317 }
1318 break;
1319 }
1320 magick_fallthrough;
1321 }
1322 default:
1323 {
1324 range=GetQuantumRange(quantum_info->depth);
1325 for (x=0; x < (ssize_t) number_pixels; x++)
1326 {
1327 q=PopQuantumPixel(quantum_info,
1328 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1329 p++;
1330 q+=(ptrdiff_t) quantum_info->pad;
1331 }
1332 break;
1333 }
1334 }
1335}
1336
1337static void ExportCbYCrYQuantum(QuantumInfo *quantum_info,
1338 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
1339 unsigned char *magick_restrict q)
1340{
1341 Quantum
1342 cbcr[4];
1343
1344 QuantumAny
1345 range;
1346
1347 ssize_t
1348 i,
1349 x;
1350
1351 unsigned int
1352 pixel;
1353
1354 size_t
1355 quantum;
1356
1357 ssize_t
1358 n;
1359
1360 n=0;
1361 quantum=0;
1362 range=GetQuantumRange(quantum_info->depth);
1363 switch (quantum_info->depth)
1364 {
1365 case 10:
1366 {
1367 if (quantum_info->pack == MagickFalse)
1368 {
1369 for (x=0; x < (ssize_t) number_pixels; x+=2)
1370 {
1371 for (i=0; i < 4; i++)
1372 {
1373 switch (n % 3)
1374 {
1375 case 0:
1376 {
1377 quantum=(size_t) GetPixelRed(p);
1378 break;
1379 }
1380 case 1:
1381 {
1382 quantum=(size_t) GetPixelGreen(p);
1383 break;
1384 }
1385 case 2:
1386 {
1387 quantum=(size_t) GetPixelBlue(p);
1388 break;
1389 }
1390 }
1391 cbcr[i]=(Quantum) quantum;
1392 n++;
1393 }
1394 pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 | (size_t)
1395 (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
1396 q=PopLongPixel(quantum_info->endian,pixel,q);
1397 p++;
1398 pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 | (size_t)
1399 (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
1400 q=PopLongPixel(quantum_info->endian,pixel,q);
1401 p++;
1402 q+=(ptrdiff_t) quantum_info->pad;
1403 }
1404 break;
1405 }
1406 break;
1407 }
1408 default:
1409 {
1410 for (x=0; x < (ssize_t) number_pixels; x+=2)
1411 {
1412 for (i=0; i < 4; i++)
1413 {
1414 switch (n % 3)
1415 {
1416 case 0:
1417 {
1418 quantum=(size_t) GetPixelRed(p);
1419 break;
1420 }
1421 case 1:
1422 {
1423 quantum=(size_t) GetPixelGreen(p);
1424 break;
1425 }
1426 case 2:
1427 {
1428 quantum=(size_t) GetPixelBlue(p);
1429 break;
1430 }
1431 }
1432 cbcr[i]=(Quantum) quantum;
1433 n++;
1434 }
1435 q=PopQuantumPixel(quantum_info,
1436 ScaleQuantumToAny(cbcr[1],range),q);
1437 q=PopQuantumPixel(quantum_info,
1438 ScaleQuantumToAny(cbcr[0],range),q);
1439 q=PopQuantumPixel(quantum_info,
1440 ScaleQuantumToAny(cbcr[2],range),q);
1441 p++;
1442 q=PopQuantumPixel(quantum_info,
1443 ScaleQuantumToAny(cbcr[3],range),q);
1444 q=PopQuantumPixel(quantum_info,
1445 ScaleQuantumToAny(cbcr[0],range),q);
1446 q=PopQuantumPixel(quantum_info,
1447 ScaleQuantumToAny(cbcr[2],range),q);
1448 p++;
1449 q+=(ptrdiff_t) quantum_info->pad;
1450 }
1451 break;
1452 }
1453 }
1454}
1455
1456static void ExportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
1457 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
1458 const IndexPacket *magick_restrict indexes,unsigned char *magick_restrict q,
1459 ExceptionInfo *exception)
1460{
1461 QuantumAny
1462 range;
1463
1464 ssize_t
1465 x;
1466
1467 if (image->colorspace != CMYKColorspace)
1468 {
1469 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1470 "ColorSeparatedImageRequired","`%s'",image->filename);
1471 return;
1472 }
1473 switch (quantum_info->depth)
1474 {
1475 case 8:
1476 {
1477 unsigned char
1478 pixel;
1479
1480 for (x=0; x < (ssize_t) number_pixels; x++)
1481 {
1482 pixel=ScaleQuantumToChar(GetPixelRed(p));
1483 q=PopCharPixel(pixel,q);
1484 pixel=ScaleQuantumToChar(GetPixelGreen(p));
1485 q=PopCharPixel(pixel,q);
1486 pixel=ScaleQuantumToChar(GetPixelBlue(p));
1487 q=PopCharPixel(pixel,q);
1488 pixel=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1489 q=PopCharPixel(pixel,q);
1490 p++;
1491 q+=(ptrdiff_t) quantum_info->pad;
1492 }
1493 break;
1494 }
1495 case 16:
1496 {
1497 unsigned short
1498 pixel;
1499
1500 if (quantum_info->format == FloatingPointQuantumFormat)
1501 {
1502 for (x=0; x < (ssize_t) number_pixels; x++)
1503 {
1504 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
1505 q=PopShortPixel(quantum_info->endian,pixel,q);
1506 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
1507 q=PopShortPixel(quantum_info->endian,pixel,q);
1508 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
1509 q=PopShortPixel(quantum_info->endian,pixel,q);
1510 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelIndex(indexes+x));
1511 q=PopShortPixel(quantum_info->endian,pixel,q);
1512 p++;
1513 q+=(ptrdiff_t) quantum_info->pad;
1514 }
1515 break;
1516 }
1517 for (x=0; x < (ssize_t) number_pixels; x++)
1518 {
1519 pixel=ScaleQuantumToShort(GetPixelRed(p));
1520 q=PopShortPixel(quantum_info->endian,pixel,q);
1521 pixel=ScaleQuantumToShort(GetPixelGreen(p));
1522 q=PopShortPixel(quantum_info->endian,pixel,q);
1523 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1524 q=PopShortPixel(quantum_info->endian,pixel,q);
1525 pixel=ScaleQuantumToShort(GetPixelIndex(indexes+x));
1526 q=PopShortPixel(quantum_info->endian,pixel,q);
1527 p++;
1528 q+=(ptrdiff_t) quantum_info->pad;
1529 }
1530 break;
1531 }
1532 case 32:
1533 {
1534 unsigned int
1535 pixel;
1536
1537 if (quantum_info->format == FloatingPointQuantumFormat)
1538 {
1539 for (x=0; x < (ssize_t) number_pixels; x++)
1540 {
1541 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(p),q);
1542 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(p),q);
1543 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(p),q);
1544 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelIndex(indexes+x),q);
1545 p++;
1546 q+=(ptrdiff_t) quantum_info->pad;
1547 }
1548 break;
1549 }
1550 for (x=0; x < (ssize_t) number_pixels; x++)
1551 {
1552 pixel=ScaleQuantumToLong(GetPixelRed(p));
1553 q=PopLongPixel(quantum_info->endian,pixel,q);
1554 pixel=ScaleQuantumToLong(GetPixelGreen(p));
1555 q=PopLongPixel(quantum_info->endian,pixel,q);
1556 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1557 q=PopLongPixel(quantum_info->endian,pixel,q);
1558 pixel=ScaleQuantumToLong(GetPixelIndex(indexes+x));
1559 q=PopLongPixel(quantum_info->endian,pixel,q);
1560 p++;
1561 q+=(ptrdiff_t) quantum_info->pad;
1562 }
1563 break;
1564 }
1565 case 64:
1566 {
1567 if (quantum_info->format == FloatingPointQuantumFormat)
1568 {
1569 for (x=0; x < (ssize_t) number_pixels; x++)
1570 {
1571 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(p),q);
1572 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(p),q);
1573 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(p),q);
1574 q=PopQuantumDoublePixel(quantum_info,(double)
1575 GetPixelIndex(indexes+x),q);
1576 p++;
1577 q+=(ptrdiff_t) quantum_info->pad;
1578 }
1579 break;
1580 }
1581 magick_fallthrough;
1582 }
1583 default:
1584 {
1585 range=GetQuantumRange(quantum_info->depth);
1586 for (x=0; x < (ssize_t) number_pixels; x++)
1587 {
1588 q=PopQuantumPixel(quantum_info,
1589 ScaleQuantumToAny(GetPixelRed(p),range),q);
1590 q=PopQuantumPixel(quantum_info,
1591 ScaleQuantumToAny(GetPixelGreen(p),range),q);
1592 q=PopQuantumPixel(quantum_info,
1593 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1594 q=PopQuantumPixel(quantum_info,
1595 ScaleQuantumToAny(GetPixelIndex(indexes+x),range),q);
1596 p++;
1597 q+=(ptrdiff_t) quantum_info->pad;
1598 }
1599 break;
1600 }
1601 }
1602}
1603
1604static void ExportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
1605 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
1606 const IndexPacket *magick_restrict indexes,unsigned char *magick_restrict q,
1607 ExceptionInfo *exception)
1608{
1609 QuantumAny
1610 range;
1611
1612 ssize_t
1613 x;
1614
1615 if (image->colorspace != CMYKColorspace)
1616 {
1617 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1618 "ColorSeparatedImageRequired","`%s'",image->filename);
1619 return;
1620 }
1621 switch (quantum_info->depth)
1622 {
1623 case 8:
1624 {
1625 unsigned char
1626 pixel;
1627
1628 for (x=0; x < (ssize_t) number_pixels; x++)
1629 {
1630 pixel=ScaleQuantumToChar(GetPixelRed(p));
1631 q=PopCharPixel(pixel,q);
1632 pixel=ScaleQuantumToChar(GetPixelGreen(p));
1633 q=PopCharPixel(pixel,q);
1634 pixel=ScaleQuantumToChar(GetPixelBlue(p));
1635 q=PopCharPixel(pixel,q);
1636 pixel=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1637 q=PopCharPixel(pixel,q);
1638 pixel=ScaleQuantumToChar((Quantum) GetPixelAlpha(p));
1639 q=PopCharPixel(pixel,q);
1640 p++;
1641 q+=(ptrdiff_t) quantum_info->pad;
1642 }
1643 break;
1644 }
1645 case 16:
1646 {
1647 unsigned short
1648 pixel;
1649
1650 if (quantum_info->format == FloatingPointQuantumFormat)
1651 {
1652 for (x=0; x < (ssize_t) number_pixels; x++)
1653 {
1654 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
1655 q=PopShortPixel(quantum_info->endian,pixel,q);
1656 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
1657 q=PopShortPixel(quantum_info->endian,pixel,q);
1658 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
1659 q=PopShortPixel(quantum_info->endian,pixel,q);
1660 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelIndex(indexes+x));
1661 q=PopShortPixel(quantum_info->endian,pixel,q);
1662 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
1663 q=PopShortPixel(quantum_info->endian,pixel,q);
1664 p++;
1665 q+=(ptrdiff_t) quantum_info->pad;
1666 }
1667 break;
1668 }
1669 for (x=0; x < (ssize_t) number_pixels; x++)
1670 {
1671 pixel=ScaleQuantumToShort(GetPixelRed(p));
1672 q=PopShortPixel(quantum_info->endian,pixel,q);
1673 pixel=ScaleQuantumToShort(GetPixelGreen(p));
1674 q=PopShortPixel(quantum_info->endian,pixel,q);
1675 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1676 q=PopShortPixel(quantum_info->endian,pixel,q);
1677 pixel=ScaleQuantumToShort(GetPixelIndex(indexes+x));
1678 q=PopShortPixel(quantum_info->endian,pixel,q);
1679 pixel=ScaleQuantumToShort((Quantum) GetPixelAlpha(p));
1680 q=PopShortPixel(quantum_info->endian,pixel,q);
1681 p++;
1682 q+=(ptrdiff_t) quantum_info->pad;
1683 }
1684 break;
1685 }
1686 case 32:
1687 {
1688 unsigned int
1689 pixel;
1690
1691 if (quantum_info->format == FloatingPointQuantumFormat)
1692 {
1693 for (x=0; x < (ssize_t) number_pixels; x++)
1694 {
1695 float
1696 pixel;
1697
1698 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(p),q);
1699 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(p),q);
1700 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(p),q);
1701 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelIndex(indexes+x),q);
1702 pixel=(float) (GetPixelAlpha(p));
1703 q=PopQuantumFloatPixel(quantum_info,pixel,q);
1704 p++;
1705 q+=(ptrdiff_t) quantum_info->pad;
1706 }
1707 break;
1708 }
1709 for (x=0; x < (ssize_t) number_pixels; x++)
1710 {
1711 pixel=ScaleQuantumToLong(GetPixelRed(p));
1712 q=PopLongPixel(quantum_info->endian,pixel,q);
1713 pixel=ScaleQuantumToLong(GetPixelGreen(p));
1714 q=PopLongPixel(quantum_info->endian,pixel,q);
1715 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1716 q=PopLongPixel(quantum_info->endian,pixel,q);
1717 pixel=ScaleQuantumToLong(GetPixelIndex(indexes+x));
1718 q=PopLongPixel(quantum_info->endian,pixel,q);
1719 pixel=ScaleQuantumToLong((Quantum) GetPixelAlpha(p));
1720 q=PopLongPixel(quantum_info->endian,pixel,q);
1721 p++;
1722 q+=(ptrdiff_t) quantum_info->pad;
1723 }
1724 break;
1725 }
1726 case 64:
1727 {
1728 if (quantum_info->format == FloatingPointQuantumFormat)
1729 {
1730 double
1731 pixel;
1732
1733 for (x=0; x < (ssize_t) number_pixels; x++)
1734 {
1735 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(p),q);
1736 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(p),q);
1737 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(p),q);
1738 q=PopQuantumDoublePixel(quantum_info,(double)
1739 GetPixelIndex(indexes+x),q);
1740 pixel=(double) (GetPixelAlpha(p));
1741 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1742 p++;
1743 q+=(ptrdiff_t) quantum_info->pad;
1744 }
1745 break;
1746 }
1747 magick_fallthrough;
1748 }
1749 default:
1750 {
1751 range=GetQuantumRange(quantum_info->depth);
1752 for (x=0; x < (ssize_t) number_pixels; x++)
1753 {
1754 q=PopQuantumPixel(quantum_info,
1755 ScaleQuantumToAny(GetPixelRed(p),range),q);
1756 q=PopQuantumPixel(quantum_info,
1757 ScaleQuantumToAny(GetPixelGreen(p),range),q);
1758 q=PopQuantumPixel(quantum_info,
1759 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1760 q=PopQuantumPixel(quantum_info,
1761 ScaleQuantumToAny(GetPixelIndex(indexes+x),range),q);
1762 q=PopQuantumPixel(quantum_info,
1763 ScaleQuantumToAny((Quantum) GetPixelAlpha(p),range),q);
1764 p++;
1765 q+=(ptrdiff_t) quantum_info->pad;
1766 }
1767 break;
1768 }
1769 }
1770}
1771
1772static void ExportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
1773 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
1774 const IndexPacket *magick_restrict indexes,unsigned char *magick_restrict q,
1775 ExceptionInfo *exception)
1776{
1777 QuantumAny
1778 range;
1779
1780 ssize_t
1781 x;
1782
1783 if (image->colorspace != CMYKColorspace)
1784 {
1785 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1786 "ColorSeparatedImageRequired","`%s'",image->filename);
1787 return;
1788 }
1789 switch (quantum_info->depth)
1790 {
1791 case 8:
1792 {
1793 unsigned char
1794 pixel;
1795
1796 for (x=0; x < (ssize_t) number_pixels; x++)
1797 {
1798 pixel=ScaleQuantumToChar(GetPixelRed(p));
1799 q=PopCharPixel(pixel,q);
1800 pixel=ScaleQuantumToChar(GetPixelGreen(p));
1801 q=PopCharPixel(pixel,q);
1802 pixel=ScaleQuantumToChar(GetPixelBlue(p));
1803 q=PopCharPixel(pixel,q);
1804 pixel=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1805 q=PopCharPixel(pixel,q);
1806 pixel=ScaleQuantumToChar(GetPixelOpacity(p));
1807 q=PopCharPixel(pixel,q);
1808 p++;
1809 q+=(ptrdiff_t) quantum_info->pad;
1810 }
1811 break;
1812 }
1813 case 16:
1814 {
1815 unsigned short
1816 pixel;
1817
1818 if (quantum_info->format == FloatingPointQuantumFormat)
1819 {
1820 for (x=0; x < (ssize_t) number_pixels; x++)
1821 {
1822 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
1823 q=PopShortPixel(quantum_info->endian,pixel,q);
1824 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
1825 q=PopShortPixel(quantum_info->endian,pixel,q);
1826 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
1827 q=PopShortPixel(quantum_info->endian,pixel,q);
1828 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelIndex(indexes+x));
1829 q=PopShortPixel(quantum_info->endian,pixel,q);
1830 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelOpacity(p));
1831 q=PopShortPixel(quantum_info->endian,pixel,q);
1832 p++;
1833 q+=(ptrdiff_t) quantum_info->pad;
1834 }
1835 break;
1836 }
1837 for (x=0; x < (ssize_t) number_pixels; x++)
1838 {
1839 pixel=ScaleQuantumToShort(GetPixelRed(p));
1840 q=PopShortPixel(quantum_info->endian,pixel,q);
1841 pixel=ScaleQuantumToShort(GetPixelGreen(p));
1842 q=PopShortPixel(quantum_info->endian,pixel,q);
1843 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1844 q=PopShortPixel(quantum_info->endian,pixel,q);
1845 pixel=ScaleQuantumToShort(GetPixelIndex(indexes+x));
1846 q=PopShortPixel(quantum_info->endian,pixel,q);
1847 pixel=ScaleQuantumToShort(GetPixelOpacity(p));
1848 q=PopShortPixel(quantum_info->endian,pixel,q);
1849 p++;
1850 q+=(ptrdiff_t) quantum_info->pad;
1851 }
1852 break;
1853 }
1854 case 32:
1855 {
1856 unsigned int
1857 pixel;
1858
1859 if (quantum_info->format == FloatingPointQuantumFormat)
1860 {
1861 for (x=0; x < (ssize_t) number_pixels; x++)
1862 {
1863 float
1864 pixel;
1865
1866 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(p),q);
1867 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(p),q);
1868 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(p),q);
1869 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelIndex(indexes+x),q);
1870 pixel=(float) (GetPixelOpacity(p));
1871 q=PopQuantumFloatPixel(quantum_info,pixel,q);
1872 p++;
1873 q+=(ptrdiff_t) quantum_info->pad;
1874 }
1875 break;
1876 }
1877 for (x=0; x < (ssize_t) number_pixels; x++)
1878 {
1879 pixel=ScaleQuantumToLong(GetPixelRed(p));
1880 q=PopLongPixel(quantum_info->endian,pixel,q);
1881 pixel=ScaleQuantumToLong(GetPixelGreen(p));
1882 q=PopLongPixel(quantum_info->endian,pixel,q);
1883 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1884 q=PopLongPixel(quantum_info->endian,pixel,q);
1885 pixel=ScaleQuantumToLong(GetPixelIndex(indexes+x));
1886 q=PopLongPixel(quantum_info->endian,pixel,q);
1887 pixel=ScaleQuantumToLong(GetPixelOpacity(p));
1888 q=PopLongPixel(quantum_info->endian,pixel,q);
1889 p++;
1890 q+=(ptrdiff_t) quantum_info->pad;
1891 }
1892 break;
1893 }
1894 case 64:
1895 {
1896 if (quantum_info->format == FloatingPointQuantumFormat)
1897 {
1898 double
1899 pixel;
1900
1901 for (x=0; x < (ssize_t) number_pixels; x++)
1902 {
1903 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(p),q);
1904 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(p),q);
1905 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(p),q);
1906 q=PopQuantumDoublePixel(quantum_info,(double)
1907 GetPixelIndex(indexes+x),q);
1908 pixel=(double) (GetPixelOpacity(p));
1909 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1910 p++;
1911 q+=(ptrdiff_t) quantum_info->pad;
1912 }
1913 break;
1914 }
1915 magick_fallthrough;
1916 }
1917 default:
1918 {
1919 range=GetQuantumRange(quantum_info->depth);
1920 for (x=0; x < (ssize_t) number_pixels; x++)
1921 {
1922 q=PopQuantumPixel(quantum_info,
1923 ScaleQuantumToAny(GetPixelRed(p),range),q);
1924 q=PopQuantumPixel(quantum_info,
1925 ScaleQuantumToAny(GetPixelGreen(p),range),q);
1926 q=PopQuantumPixel(quantum_info,
1927 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1928 q=PopQuantumPixel(quantum_info,
1929 ScaleQuantumToAny(GetPixelIndex(indexes+x),range),q);
1930 q=PopQuantumPixel(quantum_info,
1931 ScaleQuantumToAny(GetPixelOpacity(p),range),q);
1932 p++;
1933 q+=(ptrdiff_t) quantum_info->pad;
1934 }
1935 break;
1936 }
1937 }
1938}
1939
1940static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
1941 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
1942 unsigned char *magick_restrict q)
1943{
1944 QuantumAny
1945 range;
1946
1947 ssize_t
1948 x;
1949
1950 ssize_t
1951 bit;
1952
1953 switch (quantum_info->depth)
1954 {
1955 case 1:
1956 {
1957 MagickRealType
1958 threshold;
1959
1960 unsigned char
1961 black,
1962 white;
1963
1964 black=0x00;
1965 white=0x01;
1966 if (quantum_info->min_is_white != MagickFalse)
1967 {
1968 black=0x01;
1969 white=0x00;
1970 }
1971 threshold=(MagickRealType) QuantumRange/2.0;
1972 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
1973 {
1974 *q='\0';
1975 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 7;
1976 p++;
1977 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 6;
1978 p++;
1979 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 5;
1980 p++;
1981 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 4;
1982 p++;
1983 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 3;
1984 p++;
1985 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 2;
1986 p++;
1987 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 1;
1988 p++;
1989 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 0;
1990 p++;
1991 q++;
1992 }
1993 if ((number_pixels % 8) != 0)
1994 {
1995 *q='\0';
1996 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
1997 {
1998 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << bit;
1999 p++;
2000 }
2001 q++;
2002 }
2003 break;
2004 }
2005 case 4:
2006 {
2007 unsigned char
2008 pixel;
2009
2010 for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
2011 {
2012 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2013 *q=(((pixel >> 4) & 0xf) << 4);
2014 p++;
2015 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2016 *q|=pixel >> 4;
2017 p++;
2018 q++;
2019 }
2020 if ((number_pixels % 2) != 0)
2021 {
2022 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2023 *q=(((pixel >> 4) & 0xf) << 4);
2024 p++;
2025 q++;
2026 }
2027 break;
2028 }
2029 case 8:
2030 {
2031 unsigned char
2032 pixel;
2033
2034 for (x=0; x < (ssize_t) number_pixels; x++)
2035 {
2036 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2037 q=PopCharPixel(pixel,q);
2038 p++;
2039 q+=(ptrdiff_t) quantum_info->pad;
2040 }
2041 break;
2042 }
2043 case 10:
2044 {
2045 range=GetQuantumRange(quantum_info->depth);
2046 if (quantum_info->pack == MagickFalse)
2047 {
2048 unsigned int
2049 pixel;
2050
2051 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
2052 {
2053 pixel=(unsigned int) (
2054 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+2)),range) << 22 |
2055 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+1)),range) << 12 |
2056 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+0)),range) << 2);
2057 q=PopLongPixel(quantum_info->endian,pixel,q);
2058 p+=(ptrdiff_t) 3;
2059 q+=(ptrdiff_t) quantum_info->pad;
2060 }
2061 if (x < (ssize_t) number_pixels)
2062 {
2063 pixel=0U;
2064 if (x++ < (ssize_t) (number_pixels-1))
2065 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,
2066 p+1)),range) << 12;
2067 if (x++ < (ssize_t) number_pixels)
2068 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,
2069 p+0)),range) << 2;
2070 q=PopLongPixel(quantum_info->endian,pixel,q);
2071 }
2072 break;
2073 }
2074 for (x=0; x < (ssize_t) number_pixels; x++)
2075 {
2076 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2077 GetPixelLuma(image,p)),range),q);
2078 p++;
2079 q+=(ptrdiff_t) quantum_info->pad;
2080 }
2081 break;
2082 }
2083 case 12:
2084 {
2085 unsigned short
2086 pixel;
2087
2088 range=GetQuantumRange(quantum_info->depth);
2089 if (quantum_info->pack == MagickFalse)
2090 {
2091 for (x=0; x < (ssize_t) number_pixels; x++)
2092 {
2093 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2094 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel >> 4),q);
2095 p++;
2096 q+=(ptrdiff_t) quantum_info->pad;
2097 }
2098 break;
2099 }
2100 for (x=0; x < (ssize_t) number_pixels; x++)
2101 {
2102 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2103 GetPixelLuma(image,p)),range),q);
2104 p++;
2105 q+=(ptrdiff_t) quantum_info->pad;
2106 }
2107 break;
2108 }
2109 case 16:
2110 {
2111 unsigned short
2112 pixel;
2113
2114 if (quantum_info->format == FloatingPointQuantumFormat)
2115 {
2116 for (x=0; x < (ssize_t) number_pixels; x++)
2117 {
2118 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelLuma(image,p));
2119 q=PopShortPixel(quantum_info->endian,pixel,q);
2120 p++;
2121 q+=(ptrdiff_t) quantum_info->pad;
2122 }
2123 break;
2124 }
2125 for (x=0; x < (ssize_t) number_pixels; x++)
2126 {
2127 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2128 q=PopShortPixel(quantum_info->endian,pixel,q);
2129 p++;
2130 q+=(ptrdiff_t) quantum_info->pad;
2131 }
2132 break;
2133 }
2134 case 32:
2135 {
2136 unsigned int
2137 pixel;
2138
2139 if (quantum_info->format == FloatingPointQuantumFormat)
2140 {
2141 for (x=0; x < (ssize_t) number_pixels; x++)
2142 {
2143 float
2144 pixel;
2145
2146 pixel=(float) GetPixelLuma(image,p);
2147 q=PopQuantumFloatPixel(quantum_info,pixel,q);
2148 p++;
2149 q+=(ptrdiff_t) quantum_info->pad;
2150 }
2151 break;
2152 }
2153 for (x=0; x < (ssize_t) number_pixels; x++)
2154 {
2155 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2156 q=PopLongPixel(quantum_info->endian,pixel,q);
2157 p++;
2158 q+=(ptrdiff_t) quantum_info->pad;
2159 }
2160 break;
2161 }
2162 case 64:
2163 {
2164 if (quantum_info->format == FloatingPointQuantumFormat)
2165 {
2166 for (x=0; x < (ssize_t) number_pixels; x++)
2167 {
2168 double
2169 pixel;
2170
2171 pixel=(double) GetPixelLuma(image,p);
2172 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2173 p++;
2174 q+=(ptrdiff_t) quantum_info->pad;
2175 }
2176 break;
2177 }
2178 magick_fallthrough;
2179 }
2180 default:
2181 {
2182 range=GetQuantumRange(quantum_info->depth);
2183 for (x=0; x < (ssize_t) number_pixels; x++)
2184 {
2185 q=PopQuantumPixel(quantum_info,
2186 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),range),q);
2187 p++;
2188 q+=(ptrdiff_t) quantum_info->pad;
2189 }
2190 break;
2191 }
2192 }
2193}
2194
2195static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
2196 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
2197 unsigned char *magick_restrict q)
2198{
2199 QuantumAny
2200 range;
2201
2202 ssize_t
2203 x;
2204
2205 ssize_t
2206 bit;
2207
2208 switch (quantum_info->depth)
2209 {
2210 case 1:
2211 {
2212 MagickRealType
2213 threshold;
2214
2215 unsigned char
2216 black,
2217 pixel,
2218 white;
2219
2220 black=0x00;
2221 white=0x01;
2222 if (quantum_info->min_is_white != MagickFalse)
2223 {
2224 black=0x01;
2225 white=0x00;
2226 }
2227 threshold=(MagickRealType) QuantumRange/2.0;
2228 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2229 {
2230 *q='\0';
2231 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 7;
2232 pixel=(unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2233 0x00 : 0x01);
2234 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
2235 p++;
2236 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 5;
2237 pixel=(unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2238 0x00 : 0x01);
2239 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
2240 p++;
2241 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 3;
2242 pixel=(unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2243 0x00 : 0x01);
2244 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
2245 p++;
2246 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 1;
2247 pixel=(unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2248 0x00 : 0x01);
2249 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
2250 p++;
2251 q++;
2252 }
2253 if ((number_pixels % 4) != 0)
2254 {
2255 *q='\0';
2256 for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
2257 {
2258 *q|=(GetPixelLuma(image,p) > threshold ? black : white) <<
2259 (7-bit);
2260 pixel=(unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ? 0x00 :
2261 0x01);
2262 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char) (7-bit-1));
2263 p++;
2264 }
2265 q++;
2266 }
2267 break;
2268 }
2269 case 4:
2270 {
2271 unsigned char
2272 pixel;
2273
2274 for (x=0; x < (ssize_t) number_pixels ; x++)
2275 {
2276 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2277 *q=(((pixel >> 4) & 0xf) << 4);
2278 pixel=(unsigned char) (16*QuantumScale*((MagickRealType) QuantumRange-
2279 (MagickRealType) GetPixelOpacity(p))+0.5);
2280 *q|=pixel & 0xf;
2281 p++;
2282 q++;
2283 }
2284 break;
2285 }
2286 case 8:
2287 {
2288 unsigned char
2289 pixel;
2290
2291 for (x=0; x < (ssize_t) number_pixels; x++)
2292 {
2293 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2294 q=PopCharPixel(pixel,q);
2295 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetPixelOpacity(p)));
2296 q=PopCharPixel(pixel,q);
2297 p++;
2298 q+=(ptrdiff_t) quantum_info->pad;
2299 }
2300 break;
2301 }
2302 case 16:
2303 {
2304 unsigned short
2305 pixel;
2306
2307 if (quantum_info->format == FloatingPointQuantumFormat)
2308 {
2309 for (x=0; x < (ssize_t) number_pixels; x++)
2310 {
2311 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelLuma(image,p));
2312 q=PopShortPixel(quantum_info->endian,pixel,q);
2313 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
2314 q=PopShortPixel(quantum_info->endian,pixel,q);
2315 p++;
2316 q+=(ptrdiff_t) quantum_info->pad;
2317 }
2318 break;
2319 }
2320 for (x=0; x < (ssize_t) number_pixels; x++)
2321 {
2322 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2323 q=PopShortPixel(quantum_info->endian,pixel,q);
2324 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetPixelOpacity(p)));
2325 q=PopShortPixel(quantum_info->endian,pixel,q);
2326 p++;
2327 q+=(ptrdiff_t) quantum_info->pad;
2328 }
2329 break;
2330 }
2331 case 32:
2332 {
2333 unsigned int
2334 pixel;
2335
2336 if (quantum_info->format == FloatingPointQuantumFormat)
2337 {
2338 for (x=0; x < (ssize_t) number_pixels; x++)
2339 {
2340 float
2341 pixel;
2342
2343 pixel=(float) GetPixelLuma(image,p);
2344 q=PopQuantumFloatPixel(quantum_info,pixel,q);
2345 pixel=(float) (GetPixelAlpha(p));
2346 q=PopQuantumFloatPixel(quantum_info,pixel,q);
2347 p++;
2348 q+=(ptrdiff_t) quantum_info->pad;
2349 }
2350 break;
2351 }
2352 for (x=0; x < (ssize_t) number_pixels; x++)
2353 {
2354 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2355 q=PopLongPixel(quantum_info->endian,pixel,q);
2356 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetPixelOpacity(p)));
2357 q=PopLongPixel(quantum_info->endian,pixel,q);
2358 p++;
2359 q+=(ptrdiff_t) quantum_info->pad;
2360 }
2361 break;
2362 }
2363 case 64:
2364 {
2365 if (quantum_info->format == FloatingPointQuantumFormat)
2366 {
2367 for (x=0; x < (ssize_t) number_pixels; x++)
2368 {
2369 double
2370 pixel;
2371
2372 pixel=(double) GetPixelLuma(image,p);
2373 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2374 pixel=(double) (GetPixelAlpha(p));
2375 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2376 p++;
2377 q+=(ptrdiff_t) quantum_info->pad;
2378 }
2379 break;
2380 }
2381 magick_fallthrough;
2382 }
2383 default:
2384 {
2385 range=GetQuantumRange(quantum_info->depth);
2386 for (x=0; x < (ssize_t) number_pixels; x++)
2387 {
2388 q=PopQuantumPixel(quantum_info,
2389 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),range),q);
2390 q=PopQuantumPixel(quantum_info,
2391 ScaleQuantumToAny((Quantum) (GetPixelAlpha(p)),range),q);
2392 p++;
2393 q+=(ptrdiff_t) quantum_info->pad;
2394 }
2395 break;
2396 }
2397 }
2398}
2399
2400static void ExportGreenQuantum(QuantumInfo *quantum_info,
2401 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
2402 unsigned char *magick_restrict q)
2403{
2404 QuantumAny
2405 range;
2406
2407 ssize_t
2408 x;
2409
2410 switch (quantum_info->depth)
2411 {
2412 case 8:
2413 {
2414 unsigned char
2415 pixel;
2416
2417 for (x=0; x < (ssize_t) number_pixels; x++)
2418 {
2419 pixel=ScaleQuantumToChar(GetPixelGreen(p));
2420 q=PopCharPixel(pixel,q);
2421 p++;
2422 q+=(ptrdiff_t) quantum_info->pad;
2423 }
2424 break;
2425 }
2426 case 16:
2427 {
2428 unsigned short
2429 pixel;
2430
2431 if (quantum_info->format == FloatingPointQuantumFormat)
2432 {
2433 for (x=0; x < (ssize_t) number_pixels; x++)
2434 {
2435 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
2436 q=PopShortPixel(quantum_info->endian,pixel,q);
2437 p++;
2438 q+=(ptrdiff_t) quantum_info->pad;
2439 }
2440 break;
2441 }
2442 for (x=0; x < (ssize_t) number_pixels; x++)
2443 {
2444 pixel=ScaleQuantumToShort(GetPixelGreen(p));
2445 q=PopShortPixel(quantum_info->endian,pixel,q);
2446 p++;
2447 q+=(ptrdiff_t) quantum_info->pad;
2448 }
2449 break;
2450 }
2451 case 32:
2452 {
2453 unsigned int
2454 pixel;
2455
2456 if (quantum_info->format == FloatingPointQuantumFormat)
2457 {
2458 for (x=0; x < (ssize_t) number_pixels; x++)
2459 {
2460 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(p),q);
2461 p++;
2462 q+=(ptrdiff_t) quantum_info->pad;
2463 }
2464 break;
2465 }
2466 for (x=0; x < (ssize_t) number_pixels; x++)
2467 {
2468 pixel=ScaleQuantumToLong(GetPixelGreen(p));
2469 q=PopLongPixel(quantum_info->endian,pixel,q);
2470 p++;
2471 q+=(ptrdiff_t) quantum_info->pad;
2472 }
2473 break;
2474 }
2475 case 64:
2476 {
2477 if (quantum_info->format == FloatingPointQuantumFormat)
2478 {
2479 for (x=0; x < (ssize_t) number_pixels; x++)
2480 {
2481 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(p),q);
2482 p++;
2483 q+=(ptrdiff_t) quantum_info->pad;
2484 }
2485 break;
2486 }
2487 magick_fallthrough;
2488 }
2489 default:
2490 {
2491 range=GetQuantumRange(quantum_info->depth);
2492 for (x=0; x < (ssize_t) number_pixels; x++)
2493 {
2494 q=PopQuantumPixel(quantum_info,
2495 ScaleQuantumToAny(GetPixelGreen(p),range),q);
2496 p++;
2497 q+=(ptrdiff_t) quantum_info->pad;
2498 }
2499 break;
2500 }
2501 }
2502}
2503
2504static void ExportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
2505 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
2506 const IndexPacket *magick_restrict indexes,unsigned char *magick_restrict q,
2507 ExceptionInfo *exception)
2508{
2509 ssize_t
2510 x;
2511
2512 ssize_t
2513 bit;
2514
2515 if (image->storage_class != PseudoClass)
2516 {
2517 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2518 "ColormappedImageRequired","`%s'",image->filename);
2519 return;
2520 }
2521 switch (quantum_info->depth)
2522 {
2523 case 1:
2524 {
2525 unsigned char
2526 pixel;
2527
2528 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
2529 {
2530 pixel=(unsigned char) ((ssize_t) *indexes++);
2531 *q=((pixel & 0x01) << 7);
2532 pixel=(unsigned char) ((ssize_t) *indexes++);
2533 *q|=((pixel & 0x01) << 6);
2534 pixel=(unsigned char) ((ssize_t) *indexes++);
2535 *q|=((pixel & 0x01) << 5);
2536 pixel=(unsigned char) ((ssize_t) *indexes++);
2537 *q|=((pixel & 0x01) << 4);
2538 pixel=(unsigned char) ((ssize_t) *indexes++);
2539 *q|=((pixel & 0x01) << 3);
2540 pixel=(unsigned char) ((ssize_t) *indexes++);
2541 *q|=((pixel & 0x01) << 2);
2542 pixel=(unsigned char) ((ssize_t) *indexes++);
2543 *q|=((pixel & 0x01) << 1);
2544 pixel=(unsigned char) ((ssize_t) *indexes++);
2545 *q|=((pixel & 0x01) << 0);
2546 q++;
2547 }
2548 if ((number_pixels % 8) != 0)
2549 {
2550 *q='\0';
2551 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
2552 {
2553 pixel=(unsigned char) ((ssize_t) *indexes++);
2554 *q|=((pixel & 0x01) << (unsigned char) bit);
2555 }
2556 q++;
2557 }
2558 break;
2559 }
2560 case 4:
2561 {
2562 unsigned char
2563 pixel;
2564
2565 for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
2566 {
2567 pixel=(unsigned char) ((ssize_t) *indexes++);
2568 *q=((pixel & 0xf) << 4);
2569 pixel=(unsigned char) ((ssize_t) *indexes++);
2570 *q|=((pixel & 0xf) << 0);
2571 q++;
2572 }
2573 if ((number_pixels % 2) != 0)
2574 {
2575 pixel=(unsigned char) ((ssize_t) *indexes++);
2576 *q=((pixel & 0xf) << 4);
2577 q++;
2578 }
2579 break;
2580 }
2581 case 8:
2582 {
2583 for (x=0; x < (ssize_t) number_pixels; x++)
2584 {
2585 q=PopCharPixel((unsigned char) GetPixelIndex(indexes+x),q);
2586 q+=(ptrdiff_t) quantum_info->pad;
2587 }
2588 break;
2589 }
2590 case 16:
2591 {
2592 if (quantum_info->format == FloatingPointQuantumFormat)
2593 {
2594 for (x=0; x < (ssize_t) number_pixels; x++)
2595 {
2596 q=PopShortPixel(quantum_info->endian,SinglePrecisionToHalf(
2597 QuantumScale*(MagickRealType) GetPixelIndex(indexes+x)),q);
2598 q+=(ptrdiff_t) quantum_info->pad;
2599 }
2600 break;
2601 }
2602 for (x=0; x < (ssize_t) number_pixels; x++)
2603 {
2604 q=PopShortPixel(quantum_info->endian,(unsigned short) GetPixelIndex(indexes+x),q);
2605 q+=(ptrdiff_t) quantum_info->pad;
2606 }
2607 break;
2608 }
2609 case 32:
2610 {
2611 if (quantum_info->format == FloatingPointQuantumFormat)
2612 {
2613 for (x=0; x < (ssize_t) number_pixels; x++)
2614 {
2615 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelIndex(indexes+x),q);
2616 p++;
2617 q+=(ptrdiff_t) quantum_info->pad;
2618 }
2619 break;
2620 }
2621 for (x=0; x < (ssize_t) number_pixels; x++)
2622 {
2623 q=PopLongPixel(quantum_info->endian,(unsigned int) GetPixelIndex(indexes+x),q);
2624 q+=(ptrdiff_t) quantum_info->pad;
2625 }
2626 break;
2627 }
2628 case 64:
2629 {
2630 if (quantum_info->format == FloatingPointQuantumFormat)
2631 {
2632 for (x=0; x < (ssize_t) number_pixels; x++)
2633 {
2634 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelIndex(indexes+x),
2635 q);
2636 p++;
2637 q+=(ptrdiff_t) quantum_info->pad;
2638 }
2639 break;
2640 }
2641 magick_fallthrough;
2642 }
2643 default:
2644 {
2645 for (x=0; x < (ssize_t) number_pixels; x++)
2646 {
2647 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(indexes+x),q);
2648 p++;
2649 q+=(ptrdiff_t) quantum_info->pad;
2650 }
2651 break;
2652 }
2653 }
2654}
2655
2656static void ExportIndexAlphaQuantum(const Image *image,
2657 QuantumInfo *quantum_info,const MagickSizeType number_pixels,
2658 const PixelPacket *magick_restrict p,
2659 const IndexPacket *magick_restrict indexes,unsigned char *magick_restrict q,
2660 ExceptionInfo *exception)
2661{
2662 ssize_t
2663 x;
2664
2665 ssize_t
2666 bit;
2667
2668 if (image->storage_class != PseudoClass)
2669 {
2670 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2671 "ColormappedImageRequired","`%s'",image->filename);
2672 return;
2673 }
2674 switch (quantum_info->depth)
2675 {
2676 case 1:
2677 {
2678 unsigned char
2679 pixel;
2680
2681 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2682 {
2683 pixel=(unsigned char) ((ssize_t) *indexes++);
2684 *q=((pixel & 0x01) << 7);
2685 pixel=(unsigned char) (GetPixelOpacity(p) == (Quantum)
2686 TransparentOpacity ? 1 : 0);
2687 *q|=((pixel & 0x01) << 6);
2688 p++;
2689 pixel=(unsigned char) ((ssize_t) *indexes++);
2690 *q|=((pixel & 0x01) << 5);
2691 pixel=(unsigned char) (GetPixelOpacity(p) == (Quantum)
2692 TransparentOpacity ? 1 : 0);
2693 *q|=((pixel & 0x01) << 4);
2694 p++;
2695 pixel=(unsigned char) ((ssize_t) *indexes++);
2696 *q|=((pixel & 0x01) << 3);
2697 pixel=(unsigned char) (GetPixelOpacity(p) == (Quantum)
2698 TransparentOpacity ? 1 : 0);
2699 *q|=((pixel & 0x01) << 2);
2700 p++;
2701 pixel=(unsigned char) ((ssize_t) *indexes++);
2702 *q|=((pixel & 0x01) << 1);
2703 pixel=(unsigned char) (GetPixelOpacity(p) == (Quantum)
2704 TransparentOpacity ? 1 : 0);
2705 *q|=((pixel & 0x01) << 0);
2706 p++;
2707 q++;
2708 }
2709 if ((number_pixels % 4) != 0)
2710 {
2711 *q='\0';
2712 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2713 {
2714 pixel=(unsigned char) ((ssize_t) *indexes++);
2715 *q|=((pixel & 0x01) << (unsigned char) (bit+4));
2716 pixel=(unsigned char) (GetPixelOpacity(p) == (Quantum)
2717 TransparentOpacity ? 1 : 0);
2718 *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
2719 p++;
2720 }
2721 q++;
2722 }
2723 break;
2724 }
2725 case 4:
2726 {
2727 unsigned char
2728 pixel;
2729
2730 for (x=0; x < (ssize_t) number_pixels ; x++)
2731 {
2732 pixel=(unsigned char) ((ssize_t) *indexes++);
2733 *q=((pixel & 0xf) << 4);
2734 pixel=(unsigned char) ((ssize_t) (16*QuantumScale*((MagickRealType)
2735 QuantumRange-(MagickRealType) GetPixelOpacity(p))+0.5));
2736 *q|=((pixel & 0xf) << 0);
2737 p++;
2738 q++;
2739 }
2740 break;
2741 }
2742 case 8:
2743 {
2744 unsigned char
2745 pixel;
2746
2747 for (x=0; x < (ssize_t) number_pixels; x++)
2748 {
2749 q=PopCharPixel((unsigned char) GetPixelIndex(indexes+x),q);
2750 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetPixelOpacity(p)));
2751 q=PopCharPixel(pixel,q);
2752 p++;
2753 q+=(ptrdiff_t) quantum_info->pad;
2754 }
2755 break;
2756 }
2757 case 16:
2758 {
2759 unsigned short
2760 pixel;
2761
2762 if (quantum_info->format == FloatingPointQuantumFormat)
2763 {
2764 for (x=0; x < (ssize_t) number_pixels; x++)
2765 {
2766 q=PopShortPixel(quantum_info->endian,(unsigned short)
2767 ((ssize_t) GetPixelIndex(indexes+x)),q);
2768 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
2769 q=PopShortPixel(quantum_info->endian,pixel,q);
2770 p++;
2771 q+=(ptrdiff_t) quantum_info->pad;
2772 }
2773 break;
2774 }
2775 for (x=0; x < (ssize_t) number_pixels; x++)
2776 {
2777 q=PopShortPixel(quantum_info->endian,(unsigned short)
2778 ((ssize_t) GetPixelIndex(indexes+x)),q);
2779 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetPixelOpacity(p)));
2780 q=PopShortPixel(quantum_info->endian,pixel,q);
2781 p++;
2782 q+=(ptrdiff_t) quantum_info->pad;
2783 }
2784 break;
2785 }
2786 case 32:
2787 {
2788 unsigned int
2789 pixel;
2790
2791 if (quantum_info->format == FloatingPointQuantumFormat)
2792 {
2793 for (x=0; x < (ssize_t) number_pixels; x++)
2794 {
2795 float
2796 pixel;
2797
2798 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelIndex(indexes+x),q);
2799 pixel=(float) (GetPixelAlpha(p));
2800 q=PopQuantumFloatPixel(quantum_info,pixel,q);
2801 p++;
2802 q+=(ptrdiff_t) quantum_info->pad;
2803 }
2804 break;
2805 }
2806 for (x=0; x < (ssize_t) number_pixels; x++)
2807 {
2808 q=PopLongPixel(quantum_info->endian,(unsigned int)
2809 GetPixelIndex(indexes+x),q);
2810 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetPixelOpacity(p)));
2811 q=PopLongPixel(quantum_info->endian,pixel,q);
2812 p++;
2813 q+=(ptrdiff_t) quantum_info->pad;
2814 }
2815 break;
2816 }
2817 case 64:
2818 {
2819 if (quantum_info->format == FloatingPointQuantumFormat)
2820 {
2821 for (x=0; x < (ssize_t) number_pixels; x++)
2822 {
2823 double
2824 pixel;
2825
2826 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelIndex(indexes+x),
2827 q);
2828 pixel=(double) (GetPixelAlpha(p));
2829 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2830 p++;
2831 q+=(ptrdiff_t) quantum_info->pad;
2832 }
2833 break;
2834 }
2835 magick_fallthrough;
2836 }
2837 default:
2838 {
2839 QuantumAny
2840 range;
2841
2842 range=GetQuantumRange(quantum_info->depth);
2843 for (x=0; x < (ssize_t) number_pixels; x++)
2844 {
2845 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(indexes+x),q);
2846 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny((Quantum)
2847 (GetPixelAlpha(p)),range),q);
2848 p++;
2849 q+=(ptrdiff_t) quantum_info->pad;
2850 }
2851 break;
2852 }
2853 }
2854}
2855
2856static void ExportOpacityQuantum(QuantumInfo *quantum_info,
2857 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
2858 unsigned char *magick_restrict q)
2859{
2860 QuantumAny
2861 range;
2862
2863 ssize_t
2864 x;
2865
2866 switch (quantum_info->depth)
2867 {
2868 case 8:
2869 {
2870 unsigned char
2871 pixel;
2872
2873 for (x=0; x < (ssize_t) number_pixels; x++)
2874 {
2875 pixel=ScaleQuantumToChar(GetPixelOpacity(p));
2876 q=PopCharPixel(pixel,q);
2877 p++;
2878 q+=(ptrdiff_t) quantum_info->pad;
2879 }
2880 break;
2881 }
2882 case 16:
2883 {
2884 unsigned short
2885 pixel;
2886
2887 if (quantum_info->format == FloatingPointQuantumFormat)
2888 {
2889 for (x=0; x < (ssize_t) number_pixels; x++)
2890 {
2891 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelOpacity(p));
2892 q=PopShortPixel(quantum_info->endian,pixel,q);
2893 p++;
2894 q+=(ptrdiff_t) quantum_info->pad;
2895 }
2896 break;
2897 }
2898 for (x=0; x < (ssize_t) number_pixels; x++)
2899 {
2900 pixel=ScaleQuantumToShort(GetPixelOpacity(p));
2901 q=PopShortPixel(quantum_info->endian,pixel,q);
2902 p++;
2903 q+=(ptrdiff_t) quantum_info->pad;
2904 }
2905 break;
2906 }
2907 case 32:
2908 {
2909 unsigned int
2910 pixel;
2911
2912 if (quantum_info->format == FloatingPointQuantumFormat)
2913 {
2914 for (x=0; x < (ssize_t) number_pixels; x++)
2915 {
2916 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelOpacity(p),q);
2917 p++;
2918 q+=(ptrdiff_t) quantum_info->pad;
2919 }
2920 break;
2921 }
2922 for (x=0; x < (ssize_t) number_pixels; x++)
2923 {
2924 pixel=ScaleQuantumToLong(GetPixelOpacity(p));
2925 q=PopLongPixel(quantum_info->endian,pixel,q);
2926 p++;
2927 q+=(ptrdiff_t) quantum_info->pad;
2928 }
2929 break;
2930 }
2931 case 64:
2932 {
2933 if (quantum_info->format == FloatingPointQuantumFormat)
2934 {
2935 for (x=0; x < (ssize_t) number_pixels; x++)
2936 {
2937 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelOpacity(p),q);
2938 p++;
2939 q+=(ptrdiff_t) quantum_info->pad;
2940 }
2941 break;
2942 }
2943 magick_fallthrough;
2944 }
2945 default:
2946 {
2947 range=GetQuantumRange(quantum_info->depth);
2948 for (x=0; x < (ssize_t) number_pixels; x++)
2949 {
2950 q=PopQuantumPixel(quantum_info,
2951 ScaleQuantumToAny(GetPixelOpacity(p),range),q);
2952 p++;
2953 q+=(ptrdiff_t) quantum_info->pad;
2954 }
2955 break;
2956 }
2957 }
2958}
2959
2960static void ExportRedQuantum(QuantumInfo *quantum_info,
2961 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
2962 unsigned char *magick_restrict q)
2963{
2964 QuantumAny
2965 range;
2966
2967 ssize_t
2968 x;
2969
2970 switch (quantum_info->depth)
2971 {
2972 case 8:
2973 {
2974 unsigned char
2975 pixel;
2976
2977 for (x=0; x < (ssize_t) number_pixels; x++)
2978 {
2979 pixel=ScaleQuantumToChar(GetPixelRed(p));
2980 q=PopCharPixel(pixel,q);
2981 p++;
2982 q+=(ptrdiff_t) quantum_info->pad;
2983 }
2984 break;
2985 }
2986 case 16:
2987 {
2988 unsigned short
2989 pixel;
2990
2991 if (quantum_info->format == FloatingPointQuantumFormat)
2992 {
2993 for (x=0; x < (ssize_t) number_pixels; x++)
2994 {
2995 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
2996 q=PopShortPixel(quantum_info->endian,pixel,q);
2997 p++;
2998 q+=(ptrdiff_t) quantum_info->pad;
2999 }
3000 break;
3001 }
3002 for (x=0; x < (ssize_t) number_pixels; x++)
3003 {
3004 pixel=ScaleQuantumToShort(GetPixelRed(p));
3005 q=PopShortPixel(quantum_info->endian,pixel,q);
3006 p++;
3007 q+=(ptrdiff_t) quantum_info->pad;
3008 }
3009 break;
3010 }
3011 case 32:
3012 {
3013 unsigned int
3014 pixel;
3015
3016 if (quantum_info->format == FloatingPointQuantumFormat)
3017 {
3018 for (x=0; x < (ssize_t) number_pixels; x++)
3019 {
3020 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(p),q);
3021 p++;
3022 q+=(ptrdiff_t) quantum_info->pad;
3023 }
3024 break;
3025 }
3026 for (x=0; x < (ssize_t) number_pixels; x++)
3027 {
3028 pixel=ScaleQuantumToLong(GetPixelRed(p));
3029 q=PopLongPixel(quantum_info->endian,pixel,q);
3030 p++;
3031 q+=(ptrdiff_t) quantum_info->pad;
3032 }
3033 break;
3034 }
3035 case 64:
3036 {
3037 if (quantum_info->format == FloatingPointQuantumFormat)
3038 {
3039 for (x=0; x < (ssize_t) number_pixels; x++)
3040 {
3041 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(p),q);
3042 p++;
3043 q+=(ptrdiff_t) quantum_info->pad;
3044 }
3045 break;
3046 }
3047 magick_fallthrough;
3048 }
3049 default:
3050 {
3051 range=GetQuantumRange(quantum_info->depth);
3052 for (x=0; x < (ssize_t) number_pixels; x++)
3053 {
3054 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(p),range),
3055 q);
3056 p++;
3057 q+=(ptrdiff_t) quantum_info->pad;
3058 }
3059 break;
3060 }
3061 }
3062}
3063
3064static void ExportRGBQuantum(QuantumInfo *quantum_info,
3065 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
3066 unsigned char *magick_restrict q)
3067{
3068 QuantumAny
3069 range;
3070
3071 ssize_t
3072 x;
3073
3074 ssize_t
3075 bit;
3076
3077 switch (quantum_info->depth)
3078 {
3079 case 8:
3080 {
3081 for (x=0; x < (ssize_t) number_pixels; x++)
3082 {
3083 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(p)),q);
3084 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(p)),q);
3085 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(p)),q);
3086 p++;
3087 q+=(ptrdiff_t) quantum_info->pad;
3088 }
3089 break;
3090 }
3091 case 10:
3092 {
3093 unsigned int
3094 pixel;
3095
3096 range=GetQuantumRange(quantum_info->depth);
3097 if (quantum_info->pack == MagickFalse)
3098 {
3099 for (x=0; x < (ssize_t) number_pixels; x++)
3100 {
3101 pixel=(unsigned int) (
3102 ScaleQuantumToAny(GetPixelRed(p),range) << 22 |
3103 ScaleQuantumToAny(GetPixelGreen(p),range) << 12 |
3104 ScaleQuantumToAny(GetPixelBlue(p),range) << 2);
3105 q=PopLongPixel(quantum_info->endian,pixel,q);
3106 p++;
3107 q+=(ptrdiff_t) quantum_info->pad;
3108 }
3109 break;
3110 }
3111 if (quantum_info->quantum == 32UL)
3112 {
3113 for (x=0; x < (ssize_t) number_pixels; x++)
3114 {
3115 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3116 q=PopQuantumLongPixel(quantum_info,pixel,q);
3117 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3118 q=PopQuantumLongPixel(quantum_info,pixel,q);
3119 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3120 q=PopQuantumLongPixel(quantum_info,pixel,q);
3121 p++;
3122 q+=(ptrdiff_t) quantum_info->pad;
3123 }
3124 break;
3125 }
3126 for (x=0; x < (ssize_t) number_pixels; x++)
3127 {
3128 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3129 q=PopQuantumPixel(quantum_info,pixel,q);
3130 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3131 q=PopQuantumPixel(quantum_info,pixel,q);
3132 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3133 q=PopQuantumPixel(quantum_info,pixel,q);
3134 p++;
3135 q+=(ptrdiff_t) quantum_info->pad;
3136 }
3137 break;
3138 }
3139 case 12:
3140 {
3141 unsigned int
3142 pixel;
3143
3144 range=GetQuantumRange(quantum_info->depth);
3145 if (quantum_info->pack == MagickFalse)
3146 {
3147 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
3148 {
3149 switch (x % 3)
3150 {
3151 default:
3152 case 0:
3153 {
3154 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3155 break;
3156 }
3157 case 1:
3158 {
3159 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3160 break;
3161 }
3162 case 2:
3163 {
3164 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3165 p++;
3166 break;
3167 }
3168 }
3169 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
3170 q);
3171 switch ((x+1) % 3)
3172 {
3173 default:
3174 case 0:
3175 {
3176 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3177 break;
3178 }
3179 case 1:
3180 {
3181 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3182 break;
3183 }
3184 case 2:
3185 {
3186 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3187 p++;
3188 break;
3189 }
3190 }
3191 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
3192 q);
3193 q+=(ptrdiff_t) quantum_info->pad;
3194 }
3195 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
3196 {
3197 switch ((x+bit) % 3)
3198 {
3199 default:
3200 case 0:
3201 {
3202 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3203 break;
3204 }
3205 case 1:
3206 {
3207 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3208 break;
3209 }
3210 case 2:
3211 {
3212 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3213 p++;
3214 break;
3215 }
3216 }
3217 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
3218 q);
3219 q+=(ptrdiff_t) quantum_info->pad;
3220 }
3221 if (bit != 0)
3222 p++;
3223 break;
3224 }
3225 if (quantum_info->quantum == 32UL)
3226 {
3227 for (x=0; x < (ssize_t) number_pixels; x++)
3228 {
3229 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3230 q=PopQuantumLongPixel(quantum_info,pixel,q);
3231 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3232 q=PopQuantumLongPixel(quantum_info,pixel,q);
3233 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3234 q=PopQuantumLongPixel(quantum_info,pixel,q);
3235 p++;
3236 q+=(ptrdiff_t) quantum_info->pad;
3237 }
3238 break;
3239 }
3240 for (x=0; x < (ssize_t) number_pixels; x++)
3241 {
3242 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3243 q=PopQuantumPixel(quantum_info,pixel,q);
3244 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3245 q=PopQuantumPixel(quantum_info,pixel,q);
3246 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3247 q=PopQuantumPixel(quantum_info,pixel,q);
3248 p++;
3249 q+=(ptrdiff_t) quantum_info->pad;
3250 }
3251 break;
3252 }
3253 case 16:
3254 {
3255 unsigned short
3256 pixel;
3257
3258 if (quantum_info->format == FloatingPointQuantumFormat)
3259 {
3260 for (x=0; x < (ssize_t) number_pixels; x++)
3261 {
3262 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
3263 q=PopShortPixel(quantum_info->endian,pixel,q);
3264 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
3265 q=PopShortPixel(quantum_info->endian,pixel,q);
3266 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
3267 q=PopShortPixel(quantum_info->endian,pixel,q);
3268 p++;
3269 q+=(ptrdiff_t) quantum_info->pad;
3270 }
3271 break;
3272 }
3273 for (x=0; x < (ssize_t) number_pixels; x++)
3274 {
3275 pixel=ScaleQuantumToShort(GetPixelRed(p));
3276 q=PopShortPixel(quantum_info->endian,pixel,q);
3277 pixel=ScaleQuantumToShort(GetPixelGreen(p));
3278 q=PopShortPixel(quantum_info->endian,pixel,q);
3279 pixel=ScaleQuantumToShort(GetPixelBlue(p));
3280 q=PopShortPixel(quantum_info->endian,pixel,q);
3281 p++;
3282 q+=(ptrdiff_t) quantum_info->pad;
3283 }
3284 break;
3285 }
3286 case 32:
3287 {
3288 unsigned int
3289 pixel;
3290
3291 if (quantum_info->format == FloatingPointQuantumFormat)
3292 {
3293 for (x=0; x < (ssize_t) number_pixels; x++)
3294 {
3295 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(p),q);
3296 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(p),q);
3297 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(p),q);
3298 p++;
3299 q+=(ptrdiff_t) quantum_info->pad;
3300 }
3301 break;
3302 }
3303 for (x=0; x < (ssize_t) number_pixels; x++)
3304 {
3305 pixel=ScaleQuantumToLong(GetPixelRed(p));
3306 q=PopLongPixel(quantum_info->endian,pixel,q);
3307 pixel=ScaleQuantumToLong(GetPixelGreen(p));
3308 q=PopLongPixel(quantum_info->endian,pixel,q);
3309 pixel=ScaleQuantumToLong(GetPixelBlue(p));
3310 q=PopLongPixel(quantum_info->endian,pixel,q);
3311 p++;
3312 q+=(ptrdiff_t) quantum_info->pad;
3313 }
3314 break;
3315 }
3316 case 64:
3317 {
3318 if (quantum_info->format == FloatingPointQuantumFormat)
3319 {
3320 for (x=0; x < (ssize_t) number_pixels; x++)
3321 {
3322 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(p),q);
3323 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(p),q);
3324 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(p),q);
3325 p++;
3326 q+=(ptrdiff_t) quantum_info->pad;
3327 }
3328 break;
3329 }
3330 magick_fallthrough;
3331 }
3332 default:
3333 {
3334 range=GetQuantumRange(quantum_info->depth);
3335 for (x=0; x < (ssize_t) number_pixels; x++)
3336 {
3337 q=PopQuantumPixel(quantum_info,
3338 ScaleQuantumToAny(GetPixelRed(p),range),q);
3339 q=PopQuantumPixel(quantum_info,
3340 ScaleQuantumToAny(GetPixelGreen(p),range),q);
3341 q=PopQuantumPixel(quantum_info,
3342 ScaleQuantumToAny(GetPixelBlue(p),range),q);
3343 p++;
3344 q+=(ptrdiff_t) quantum_info->pad;
3345 }
3346 break;
3347 }
3348 }
3349}
3350
3351static void ExportRGBAQuantum(QuantumInfo *quantum_info,
3352 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
3353 unsigned char *magick_restrict q)
3354{
3355 QuantumAny
3356 range;
3357
3358 ssize_t
3359 x;
3360
3361 switch (quantum_info->depth)
3362 {
3363 case 8:
3364 {
3365 unsigned char
3366 pixel;
3367
3368 for (x=0; x < (ssize_t) number_pixels; x++)
3369 {
3370 pixel=ScaleQuantumToChar(GetPixelRed(p));
3371 q=PopCharPixel(pixel,q);
3372 pixel=ScaleQuantumToChar(GetPixelGreen(p));
3373 q=PopCharPixel(pixel,q);
3374 pixel=ScaleQuantumToChar(GetPixelBlue(p));
3375 q=PopCharPixel(pixel,q);
3376 pixel=ScaleQuantumToChar((Quantum) GetPixelAlpha(p));
3377 q=PopCharPixel(pixel,q);
3378 p++;
3379 q+=(ptrdiff_t) quantum_info->pad;
3380 }
3381 break;
3382 }
3383 case 10:
3384 {
3385 unsigned int
3386 pixel;
3387
3388 range=GetQuantumRange(quantum_info->depth);
3389 if (quantum_info->pack == MagickFalse)
3390 {
3391 ssize_t
3392 i;
3393
3394 size_t
3395 quantum;
3396
3397 ssize_t
3398 n;
3399
3400 n=0;
3401 quantum=0;
3402 pixel=0;
3403 for (x=0; x < (ssize_t) number_pixels; x++)
3404 {
3405 for (i=0; i < 4; i++)
3406 {
3407 switch (i)
3408 {
3409 case 0: quantum=(size_t) GetPixelRed(p); break;
3410 case 1: quantum=(size_t) GetPixelGreen(p); break;
3411 case 2: quantum=(size_t) GetPixelBlue(p); break;
3412 case 3: quantum=(size_t) GetPixelAlpha(p); break;
3413 }
3414 switch (n % 3)
3415 {
3416 case 0:
3417 {
3418 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3419 range) << 22);
3420 break;
3421 }
3422 case 1:
3423 {
3424 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3425 range) << 12);
3426 break;
3427 }
3428 case 2:
3429 {
3430 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3431 range) << 2);
3432 q=PopLongPixel(quantum_info->endian,pixel,q);
3433 pixel=0;
3434 break;
3435 }
3436 }
3437 n++;
3438 }
3439 p++;
3440 q+=(ptrdiff_t) quantum_info->pad;
3441 }
3442 break;
3443 }
3444 if (quantum_info->quantum == 32UL)
3445 {
3446 for (x=0; x < (ssize_t) number_pixels; x++)
3447 {
3448 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3449 q=PopQuantumLongPixel(quantum_info,pixel,q);
3450 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3451 q=PopQuantumLongPixel(quantum_info,pixel,q);
3452 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3453 q=PopQuantumLongPixel(quantum_info,pixel,q);
3454 pixel=(unsigned int) ScaleQuantumToAny((Quantum) GetPixelAlpha(p),
3455 range);
3456 q=PopQuantumLongPixel(quantum_info,pixel,q);
3457 p++;
3458 q+=(ptrdiff_t) quantum_info->pad;
3459 }
3460 break;
3461 }
3462 for (x=0; x < (ssize_t) number_pixels; x++)
3463 {
3464 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3465 q=PopQuantumPixel(quantum_info,pixel,q);
3466 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3467 q=PopQuantumPixel(quantum_info,pixel,q);
3468 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3469 q=PopQuantumPixel(quantum_info,pixel,q);
3470 pixel=(unsigned int) ScaleQuantumToAny((Quantum) GetPixelAlpha(p),
3471 range);
3472 q=PopQuantumPixel(quantum_info,pixel,q);
3473 p++;
3474 q+=(ptrdiff_t) quantum_info->pad;
3475 }
3476 break;
3477 }
3478 case 16:
3479 {
3480 unsigned short
3481 pixel;
3482
3483 if (quantum_info->format == FloatingPointQuantumFormat)
3484 {
3485 for (x=0; x < (ssize_t) number_pixels; x++)
3486 {
3487 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
3488 q=PopShortPixel(quantum_info->endian,pixel,q);
3489 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
3490 q=PopShortPixel(quantum_info->endian,pixel,q);
3491 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
3492 q=PopShortPixel(quantum_info->endian,pixel,q);
3493 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
3494 q=PopShortPixel(quantum_info->endian,pixel,q);
3495 p++;
3496 q+=(ptrdiff_t) quantum_info->pad;
3497 }
3498 break;
3499 }
3500 for (x=0; x < (ssize_t) number_pixels; x++)
3501 {
3502 pixel=ScaleQuantumToShort(GetPixelRed(p));
3503 q=PopShortPixel(quantum_info->endian,pixel,q);
3504 pixel=ScaleQuantumToShort(GetPixelGreen(p));
3505 q=PopShortPixel(quantum_info->endian,pixel,q);
3506 pixel=ScaleQuantumToShort(GetPixelBlue(p));
3507 q=PopShortPixel(quantum_info->endian,pixel,q);
3508 pixel=ScaleQuantumToShort((Quantum) GetPixelAlpha(p));
3509 q=PopShortPixel(quantum_info->endian,pixel,q);
3510 p++;
3511 q+=(ptrdiff_t) quantum_info->pad;
3512 }
3513 break;
3514 }
3515 case 32:
3516 {
3517 unsigned int
3518 pixel;
3519
3520 if (quantum_info->format == FloatingPointQuantumFormat)
3521 {
3522 for (x=0; x < (ssize_t) number_pixels; x++)
3523 {
3524 float
3525 pixel;
3526
3527 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(p),q);
3528 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(p),q);
3529 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(p),q);
3530 pixel=(float) GetPixelAlpha(p);
3531 q=PopQuantumFloatPixel(quantum_info,pixel,q);
3532 p++;
3533 q+=(ptrdiff_t) quantum_info->pad;
3534 }
3535 break;
3536 }
3537 for (x=0; x < (ssize_t) number_pixels; x++)
3538 {
3539 pixel=ScaleQuantumToLong(GetPixelRed(p));
3540 q=PopLongPixel(quantum_info->endian,pixel,q);
3541 pixel=ScaleQuantumToLong(GetPixelGreen(p));
3542 q=PopLongPixel(quantum_info->endian,pixel,q);
3543 pixel=ScaleQuantumToLong(GetPixelBlue(p));
3544 q=PopLongPixel(quantum_info->endian,pixel,q);
3545 pixel=ScaleQuantumToLong((Quantum) GetPixelAlpha(p));
3546 q=PopLongPixel(quantum_info->endian,pixel,q);
3547 p++;
3548 q+=(ptrdiff_t) quantum_info->pad;
3549 }
3550 break;
3551 }
3552 case 64:
3553 {
3554 if (quantum_info->format == FloatingPointQuantumFormat)
3555 {
3556 double
3557 pixel;
3558
3559 for (x=0; x < (ssize_t) number_pixels; x++)
3560 {
3561 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(p),q);
3562 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(p),q);
3563 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(p),q);
3564 pixel=(double) GetPixelAlpha(p);
3565 q=PopQuantumDoublePixel(quantum_info,pixel,q);
3566 p++;
3567 q+=(ptrdiff_t) quantum_info->pad;
3568 }
3569 break;
3570 }
3571 magick_fallthrough;
3572 }
3573 default:
3574 {
3575 range=GetQuantumRange(quantum_info->depth);
3576 for (x=0; x < (ssize_t) number_pixels; x++)
3577 {
3578 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(p),
3579 range),q);
3580 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(p),
3581 range),q);
3582 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(p),
3583 range),q);
3584 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny((Quantum)
3585 GetPixelAlpha(p),range),q);
3586 p++;
3587 q+=(ptrdiff_t) quantum_info->pad;
3588 }
3589 break;
3590 }
3591 }
3592}
3593
3594static void ExportRGBOQuantum(QuantumInfo *quantum_info,
3595 const MagickSizeType number_pixels,const PixelPacket *magick_restrict p,
3596 unsigned char *magick_restrict q)
3597{
3598 QuantumAny
3599 range;
3600
3601 ssize_t
3602 x;
3603
3604 switch (quantum_info->depth)
3605 {
3606 case 8:
3607 {
3608 unsigned char
3609 pixel;
3610
3611 for (x=0; x < (ssize_t) number_pixels; x++)
3612 {
3613 pixel=ScaleQuantumToChar(GetPixelRed(p));
3614 q=PopCharPixel(pixel,q);
3615 pixel=ScaleQuantumToChar(GetPixelGreen(p));
3616 q=PopCharPixel(pixel,q);
3617 pixel=ScaleQuantumToChar(GetPixelBlue(p));
3618 q=PopCharPixel(pixel,q);
3619 pixel=ScaleQuantumToChar(GetPixelOpacity(p));
3620 q=PopCharPixel(pixel,q);
3621 p++;
3622 q+=(ptrdiff_t) quantum_info->pad;
3623 }
3624 break;
3625 }
3626 case 10:
3627 {
3628 unsigned int
3629 pixel;
3630
3631 range=GetQuantumRange(quantum_info->depth);
3632 if (quantum_info->pack == MagickFalse)
3633 {
3634 ssize_t
3635 i;
3636
3637 size_t
3638 quantum;
3639
3640 ssize_t
3641 n;
3642
3643 n=0;
3644 quantum=0;
3645 pixel=0;
3646 for (x=0; x < (ssize_t) number_pixels; x++)
3647 {
3648 for (i=0; i < 4; i++)
3649 {
3650 switch (i)
3651 {
3652 case 0: quantum=(size_t) GetPixelRed(p); break;
3653 case 1: quantum=(size_t) GetPixelGreen(p); break;
3654 case 2: quantum=(size_t) GetPixelBlue(p); break;
3655 case 3: quantum=(size_t) GetPixelOpacity(p); break;
3656 }
3657 switch (n % 3)
3658 {
3659 case 0:
3660 {
3661 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3662 range) << 22);
3663 break;
3664 }
3665 case 1:
3666 {
3667 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3668 range) << 12);
3669 break;
3670 }
3671 case 2:
3672 {
3673 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3674 range) << 2);
3675 q=PopLongPixel(quantum_info->endian,pixel,q);
3676 pixel=0;
3677 break;
3678 }
3679 }
3680 n++;
3681 }
3682 p++;
3683 q+=(ptrdiff_t) quantum_info->pad;
3684 }
3685 break;
3686 }
3687 if (quantum_info->quantum == 32UL)
3688 {
3689 for (x=0; x < (ssize_t) number_pixels; x++)
3690 {
3691 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3692 q=PopQuantumLongPixel(quantum_info,pixel,q);
3693 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3694 q=PopQuantumLongPixel(quantum_info,pixel,q);
3695 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3696 q=PopQuantumLongPixel(quantum_info,pixel,q);
3697 pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(p),range);
3698 q=PopQuantumLongPixel(quantum_info,pixel,q);
3699 p++;
3700 q+=(ptrdiff_t) quantum_info->pad;
3701 }
3702 break;
3703 }
3704 for (x=0; x < (ssize_t) number_pixels; x++)
3705 {
3706 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3707 q=PopQuantumPixel(quantum_info,pixel,q);
3708 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3709 q=PopQuantumPixel(quantum_info,pixel,q);
3710 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3711 q=PopQuantumPixel(quantum_info,pixel,q);
3712 pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(p),range);
3713 q=PopQuantumPixel(quantum_info,pixel,q);
3714 p++;
3715 q+=(ptrdiff_t) quantum_info->pad;
3716 }
3717 break;
3718 }
3719 case 16:
3720 {
3721 unsigned short
3722 pixel;
3723
3724 if (quantum_info->format == FloatingPointQuantumFormat)
3725 {
3726 for (x=0; x < (ssize_t) number_pixels; x++)
3727 {
3728 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
3729 q=PopShortPixel(quantum_info->endian,pixel,q);
3730 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
3731 q=PopShortPixel(quantum_info->endian,pixel,q);
3732 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
3733 q=PopShortPixel(quantum_info->endian,pixel,q);
3734 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelOpacity(p));
3735 q=PopShortPixel(quantum_info->endian,pixel,q);
3736 p++;
3737 q+=(ptrdiff_t) quantum_info->pad;
3738 }
3739 break;
3740 }
3741 for (x=0; x < (ssize_t) number_pixels; x++)
3742 {
3743 pixel=ScaleQuantumToShort(GetPixelRed(p));
3744 q=PopShortPixel(quantum_info->endian,pixel,q);
3745 pixel=ScaleQuantumToShort(GetPixelGreen(p));
3746 q=PopShortPixel(quantum_info->endian,pixel,q);
3747 pixel=ScaleQuantumToShort(GetPixelBlue(p));
3748 q=PopShortPixel(quantum_info->endian,pixel,q);
3749 pixel=ScaleQuantumToShort(GetPixelOpacity(p));
3750 q=PopShortPixel(quantum_info->endian,pixel,q);
3751 p++;
3752 q+=(ptrdiff_t) quantum_info->pad;
3753 }
3754 break;
3755 }
3756 case 32:
3757 {
3758 unsigned int
3759 pixel;
3760
3761 if (quantum_info->format == FloatingPointQuantumFormat)
3762 {
3763 for (x=0; x < (ssize_t) number_pixels; x++)
3764 {
3765 float
3766 pixel;
3767
3768 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(p),q);
3769 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(p),q);
3770 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(p),q);
3771 pixel=(float) GetPixelOpacity(p);
3772 q=PopQuantumFloatPixel(quantum_info,pixel,q);
3773 p++;
3774 q+=(ptrdiff_t) quantum_info->pad;
3775 }
3776 break;
3777 }
3778 for (x=0; x < (ssize_t) number_pixels; x++)
3779 {
3780 pixel=ScaleQuantumToLong(GetPixelRed(p));
3781 q=PopLongPixel(quantum_info->endian,pixel,q);
3782 pixel=ScaleQuantumToLong(GetPixelGreen(p));
3783 q=PopLongPixel(quantum_info->endian,pixel,q);
3784 pixel=ScaleQuantumToLong(GetPixelBlue(p));
3785 q=PopLongPixel(quantum_info->endian,pixel,q);
3786 pixel=ScaleQuantumToLong(GetPixelOpacity(p));
3787 q=PopLongPixel(quantum_info->endian,pixel,q);
3788 p++;
3789 q+=(ptrdiff_t) quantum_info->pad;
3790 }
3791 break;
3792 }
3793 case 64:
3794 {
3795 if (quantum_info->format == FloatingPointQuantumFormat)
3796 {
3797 double
3798 pixel;
3799
3800 for (x=0; x < (ssize_t) number_pixels; x++)
3801 {
3802 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(p),q);
3803 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(p),q);
3804 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(p),q);
3805 pixel=(double) GetPixelOpacity(p);
3806 q=PopQuantumDoublePixel(quantum_info,pixel,q);
3807 p++;
3808 q+=(ptrdiff_t) quantum_info->pad;
3809 }
3810 break;
3811 }
3812 magick_fallthrough;
3813 }
3814 default:
3815 {
3816 range=GetQuantumRange(quantum_info->depth);
3817 for (x=0; x < (ssize_t) number_pixels; x++)
3818 {
3819 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(p),
3820 range),q);
3821 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(p),
3822 range),q);
3823 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(p),
3824 range),q);
3825 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(p),
3826 range),q);
3827 p++;
3828 q+=(ptrdiff_t) quantum_info->pad;
3829 }
3830 break;
3831 }
3832 }
3833}
3834
3835MagickExport size_t ExportQuantumPixels(const Image *image,
3836 const CacheView *image_view,const QuantumInfo *quantum_info,
3837 const QuantumType quantum_type,unsigned char *magick_restrict pixels,
3838 ExceptionInfo *exception)
3839{
3840 MagickRealType
3841 alpha;
3842
3843 MagickSizeType
3844 number_pixels;
3845
3846 const IndexPacket
3847 *magick_restrict indexes;
3848
3849 const PixelPacket
3850 *magick_restrict p;
3851
3852 ssize_t
3853 x;
3854
3855 unsigned char
3856 *magick_restrict q;
3857
3858 size_t
3859 extent;
3860
3861 assert(image != (Image *) NULL);
3862 assert(image->signature == MagickCoreSignature);
3863 if (IsEventLogging() != MagickFalse)
3864 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3865 assert(quantum_info != (QuantumInfo *) NULL);
3866 assert(quantum_info->signature == MagickCoreSignature);
3867 if (pixels == (unsigned char *) NULL)
3868 pixels=GetQuantumPixels(quantum_info);
3869 if (image_view == (CacheView *) NULL)
3870 {
3871 number_pixels=GetImageExtent(image);
3872 p=GetVirtualPixelQueue(image);
3873 indexes=GetVirtualIndexQueue(image);
3874 }
3875 else
3876 {
3877 number_pixels=GetCacheViewExtent(image_view);
3878 p=GetCacheViewVirtualPixelQueue(image_view);
3879 indexes=GetCacheViewVirtualIndexQueue(image_view);
3880 }
3881 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
3882 {
3883 PixelPacket
3884 *magick_restrict q;
3885
3886 /*
3887 Associate alpha.
3888 */
3889 if (image_view == (CacheView *) NULL)
3890 q=GetAuthenticPixelQueue(image);
3891 else
3892 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3893 for (x=0; x < (ssize_t) image->columns; x++)
3894 {
3895 alpha=QuantumScale*(MagickRealType) GetPixelAlpha(q);
3896 SetPixelRed(q,ClampToQuantum(alpha*(MagickRealType) GetPixelRed(q)));
3897 SetPixelGreen(q,ClampToQuantum(alpha*(MagickRealType)
3898 GetPixelGreen(q)));
3899 SetPixelBlue(q,ClampToQuantum(alpha*(MagickRealType) GetPixelBlue(q)));
3900 q++;
3901 }
3902 }
3903 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3904 {
3905 Quantum
3906 quantum;
3907
3908 PixelPacket
3909 *magick_restrict q;
3910
3911 if (image_view == (CacheView *) NULL)
3912 q=GetAuthenticPixelQueue(image);
3913 else
3914 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3915 for (x=0; x < (ssize_t) number_pixels; x++)
3916 {
3917 quantum=GetPixelRed(q);
3918 SetPixelRed(q,GetPixelGreen(q));
3919 SetPixelGreen(q,quantum);
3920 q++;
3921 }
3922 }
3923 x=0;
3924 q=pixels;
3925 ResetQuantumState((QuantumInfo *) quantum_info);
3926 extent=GetQuantumExtent(image,quantum_info,quantum_type);
3927 switch (quantum_type)
3928 {
3929 case AlphaQuantum:
3930 {
3931 ExportAlphaQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
3932 break;
3933 }
3934 case BGRQuantum:
3935 {
3936 ExportBGRQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
3937 break;
3938 }
3939 case BGRAQuantum:
3940 {
3941 ExportBGRAQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
3942 break;
3943 }
3944 case BGROQuantum:
3945 {
3946 ExportBGROQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
3947 break;
3948 }
3949 case BlackQuantum:
3950 {
3951 ExportBlackQuantum(image,(QuantumInfo *) quantum_info,number_pixels,p,
3952 indexes,q,exception);
3953 break;
3954 }
3955 case BlueQuantum:
3956 case YellowQuantum:
3957 {
3958 ExportBlueQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
3959 break;
3960 }
3961 case CbYCrYQuantum:
3962 {
3963 ExportCbYCrYQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
3964 break;
3965 }
3966 case CMYKQuantum:
3967 {
3968 ExportCMYKQuantum(image,(QuantumInfo *) quantum_info,number_pixels,p,
3969 indexes,q,exception);
3970 break;
3971 }
3972 case CMYKAQuantum:
3973 {
3974 ExportCMYKAQuantum(image,(QuantumInfo *) quantum_info,number_pixels,p,
3975 indexes,q,exception);
3976 break;
3977 }
3978 case CMYKOQuantum:
3979 {
3980 ExportCMYKOQuantum(image,(QuantumInfo *) quantum_info,number_pixels,p,
3981 indexes,q,exception);
3982 break;
3983 }
3984 case GrayQuantum:
3985 {
3986 ExportGrayQuantum(image,(QuantumInfo *) quantum_info,number_pixels,p,q);
3987 break;
3988 }
3989 case GrayAlphaQuantum:
3990 {
3991 ExportGrayAlphaQuantum(image,(QuantumInfo *) quantum_info,number_pixels,
3992 p,q);
3993 break;
3994 }
3995 case GreenQuantum:
3996 case MagentaQuantum:
3997 {
3998 ExportGreenQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
3999 break;
4000 }
4001 case IndexQuantum:
4002 {
4003 ExportIndexQuantum(image,(QuantumInfo *) quantum_info,number_pixels,p,
4004 indexes,q,exception);
4005 break;
4006 }
4007 case IndexAlphaQuantum:
4008 {
4009 ExportIndexAlphaQuantum(image,(QuantumInfo *) quantum_info,number_pixels,
4010 p,indexes,q,exception);
4011 break;
4012 }
4013 case OpacityQuantum:
4014 {
4015 ExportOpacityQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
4016 break;
4017 }
4018 case RedQuantum:
4019 case CyanQuantum:
4020 {
4021 ExportRedQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
4022 break;
4023 }
4024 case RGBQuantum:
4025 case CbYCrQuantum:
4026 {
4027 ExportRGBQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
4028 break;
4029 }
4030 case RGBAQuantum:
4031 case CbYCrAQuantum:
4032 {
4033 ExportRGBAQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
4034 break;
4035 }
4036 case RGBOQuantum:
4037 {
4038 ExportRGBOQuantum((QuantumInfo *) quantum_info,number_pixels,p,q);
4039 break;
4040 }
4041 default:
4042 break;
4043 }
4044 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
4045 {
4046 Quantum
4047 quantum;
4048
4049 PixelPacket
4050 *magick_restrict q;
4051
4052 if (image_view == (CacheView *) NULL)
4053 q=GetAuthenticPixelQueue(image);
4054 else
4055 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
4056 for (x=0; x < (ssize_t) number_pixels; x++)
4057 {
4058 quantum=GetPixelRed(q);
4059 SetPixelRed(q,GetPixelGreen(q));
4060 SetPixelGreen(q,quantum);
4061 q++;
4062 }
4063 }
4064 return(extent);
4065}
_CacheView
Definition cache-view.c:66
_ExceptionInfo
Definition exception.h:103
_Image
Definition image.h:134
_PixelPacket
Definition pixel.h:132
_QuantumInfo
Definition quantum-private.h:46