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