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