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/license/ %
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 < (3*(ssize_t) 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),
1364 q);
1365 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),
1366 q);
1367 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),
1368 q);
1369 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlack(image,p),
1370 q);
1371 p+=(ptrdiff_t) GetPixelChannels(image);
1372 q+=(ptrdiff_t) quantum_info->pad;
1373 }
1374 break;
1375 }
1376 for (x=0; x < (ssize_t) number_pixels; x++)
1377 {
1378 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1379 q=PopLongPixel(quantum_info->endian,pixel,q);
1380 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1381 q=PopLongPixel(quantum_info->endian,pixel,q);
1382 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1383 q=PopLongPixel(quantum_info->endian,pixel,q);
1384 pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1385 q=PopLongPixel(quantum_info->endian,pixel,q);
1386 p+=(ptrdiff_t) GetPixelChannels(image);
1387 q+=(ptrdiff_t) quantum_info->pad;
1388 }
1389 break;
1390 }
1391 case 64:
1392 {
1393 if (quantum_info->format == FloatingPointQuantumFormat)
1394 {
1395 for (x=0; x < (ssize_t) number_pixels; x++)
1396 {
1397 q=PopQuantumDoublePixel(quantum_info,(double)
1398 GetPixelRed(image,p),q);
1399 q=PopQuantumDoublePixel(quantum_info,(double)
1400 GetPixelGreen(image,p),q);
1401 q=PopQuantumDoublePixel(quantum_info,(double)
1402 GetPixelBlue(image,p),q);
1403 q=PopQuantumDoublePixel(quantum_info,(double)
1404 GetPixelBlack(image,p),q);
1405 p+=(ptrdiff_t) GetPixelChannels(image);
1406 q+=(ptrdiff_t) quantum_info->pad;
1407 }
1408 break;
1409 }
1410 magick_fallthrough;
1411 }
1412 default:
1413 {
1414 QuantumAny
1415 range;
1416
1417 range=GetQuantumRange(quantum_info->depth);
1418 for (x=0; x < (ssize_t) number_pixels; x++)
1419 {
1420 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1421 range),q);
1422 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1423 range),q);
1424 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1425 range),q);
1426 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1427 range),q);
1428 p+=(ptrdiff_t) GetPixelChannels(image);
1429 q+=(ptrdiff_t) quantum_info->pad;
1430 }
1431 break;
1432 }
1433 }
1434}
1435
1436static void ExportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
1437 const MagickSizeType number_pixels,const Quantum *magick_restrict p,
1438 unsigned char *magick_restrict q,ExceptionInfo *exception)
1439{
1440 ssize_t
1441 x;
1442
1443 if (image->colorspace != CMYKColorspace)
1444 {
1445 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1446 "ColorSeparatedImageRequired","`%s'",image->filename);
1447 return;
1448 }
1449 switch (quantum_info->depth)
1450 {
1451 case 8:
1452 {
1453 unsigned char
1454 pixel;
1455
1456 for (x=0; x < (ssize_t) number_pixels; x++)
1457 {
1458 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1459 q=PopCharPixel(pixel,q);
1460 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1461 q=PopCharPixel(pixel,q);
1462 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1463 q=PopCharPixel(pixel,q);
1464 pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1465 q=PopCharPixel(pixel,q);
1466 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
1467 q=PopCharPixel(pixel,q);
1468 p+=(ptrdiff_t) GetPixelChannels(image);
1469 q+=(ptrdiff_t) quantum_info->pad;
1470 }
1471 break;
1472 }
1473 case 16:
1474 {
1475 unsigned short
1476 pixel;
1477
1478 if (quantum_info->format == FloatingPointQuantumFormat)
1479 {
1480 for (x=0; x < (ssize_t) number_pixels; x++)
1481 {
1482 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1483 GetPixelRed(image,p));
1484 q=PopShortPixel(quantum_info->endian,pixel,q);
1485 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1486 GetPixelGreen(image,p));
1487 q=PopShortPixel(quantum_info->endian,pixel,q);
1488 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1489 GetPixelBlue(image,p));
1490 q=PopShortPixel(quantum_info->endian,pixel,q);
1491 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1492 GetPixelBlack(image,p));
1493 q=PopShortPixel(quantum_info->endian,pixel,q);
1494 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1495 GetPixelAlpha(image,p));
1496 q=PopShortPixel(quantum_info->endian,pixel,q);
1497 p+=(ptrdiff_t) GetPixelChannels(image);
1498 q+=(ptrdiff_t) quantum_info->pad;
1499 }
1500 break;
1501 }
1502 for (x=0; x < (ssize_t) number_pixels; x++)
1503 {
1504 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1505 q=PopShortPixel(quantum_info->endian,pixel,q);
1506 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1507 q=PopShortPixel(quantum_info->endian,pixel,q);
1508 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1509 q=PopShortPixel(quantum_info->endian,pixel,q);
1510 pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1511 q=PopShortPixel(quantum_info->endian,pixel,q);
1512 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
1513 q=PopShortPixel(quantum_info->endian,pixel,q);
1514 p+=(ptrdiff_t) GetPixelChannels(image);
1515 q+=(ptrdiff_t) quantum_info->pad;
1516 }
1517 break;
1518 }
1519 case 32:
1520 {
1521 unsigned int
1522 pixel;
1523
1524 if (quantum_info->format == FloatingPointQuantumFormat)
1525 {
1526 for (x=0; x < (ssize_t) number_pixels; x++)
1527 {
1528 q=PopQuantumFloatPixel(quantum_info,(float)
1529 GetPixelRed(image,p),q);
1530 q=PopQuantumFloatPixel(quantum_info,(float)
1531 GetPixelGreen(image,p),q);
1532 q=PopQuantumFloatPixel(quantum_info,(float)
1533 GetPixelBlue(image,p),q);
1534 q=PopQuantumFloatPixel(quantum_info,(float)
1535 GetPixelBlack(image,p),q);
1536 q=PopQuantumFloatPixel(quantum_info,(float)
1537 GetPixelAlpha(image,p),q);
1538 p+=(ptrdiff_t) GetPixelChannels(image);
1539 q+=(ptrdiff_t) quantum_info->pad;
1540 }
1541 break;
1542 }
1543 for (x=0; x < (ssize_t) number_pixels; x++)
1544 {
1545 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1546 q=PopLongPixel(quantum_info->endian,pixel,q);
1547 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1548 q=PopLongPixel(quantum_info->endian,pixel,q);
1549 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1550 q=PopLongPixel(quantum_info->endian,pixel,q);
1551 pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1552 q=PopLongPixel(quantum_info->endian,pixel,q);
1553 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
1554 q=PopLongPixel(quantum_info->endian,pixel,q);
1555 p+=(ptrdiff_t) GetPixelChannels(image);
1556 q+=(ptrdiff_t) quantum_info->pad;
1557 }
1558 break;
1559 }
1560 case 64:
1561 {
1562 if (quantum_info->format == FloatingPointQuantumFormat)
1563 {
1564 for (x=0; x < (ssize_t) number_pixels; x++)
1565 {
1566 q=PopQuantumDoublePixel(quantum_info,(double)
1567 GetPixelRed(image,p),q);
1568 q=PopQuantumDoublePixel(quantum_info,(double)
1569 GetPixelGreen(image,p),q);
1570 q=PopQuantumDoublePixel(quantum_info,(double)
1571 GetPixelBlue(image,p),q);
1572 q=PopQuantumDoublePixel(quantum_info,(double)
1573 GetPixelBlack(image,p),q);
1574 q=PopQuantumDoublePixel(quantum_info,(double)
1575 GetPixelAlpha(image,p),q);
1576 p+=(ptrdiff_t) GetPixelChannels(image);
1577 q+=(ptrdiff_t) quantum_info->pad;
1578 }
1579 break;
1580 }
1581 magick_fallthrough;
1582 }
1583 default:
1584 {
1585 QuantumAny
1586 range;
1587
1588 range=GetQuantumRange(quantum_info->depth);
1589 for (x=0; x < (ssize_t) number_pixels; x++)
1590 {
1591 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1592 range),q);
1593 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1594 range),q);
1595 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1596 range),q);
1597 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1598 range),q);
1599 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
1600 range),q);
1601 p+=(ptrdiff_t) GetPixelChannels(image);
1602 q+=(ptrdiff_t) quantum_info->pad;
1603 }
1604 break;
1605 }
1606 }
1607}
1608
1609static void ExportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
1610 const MagickSizeType number_pixels,const Quantum *magick_restrict p,
1611 unsigned char *magick_restrict q,ExceptionInfo *exception)
1612{
1613 ssize_t
1614 x;
1615
1616 if (image->colorspace != CMYKColorspace)
1617 {
1618 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1619 "ColorSeparatedImageRequired","`%s'",image->filename);
1620 return;
1621 }
1622 switch (quantum_info->depth)
1623 {
1624 case 8:
1625 {
1626 unsigned char
1627 pixel;
1628
1629 for (x=0; x < (ssize_t) number_pixels; x++)
1630 {
1631 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1632 q=PopCharPixel(pixel,q);
1633 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1634 q=PopCharPixel(pixel,q);
1635 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1636 q=PopCharPixel(pixel,q);
1637 pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1638 q=PopCharPixel(pixel,q);
1639 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
1640 q=PopCharPixel(pixel,q);
1641 p+=(ptrdiff_t) GetPixelChannels(image);
1642 q+=(ptrdiff_t) quantum_info->pad;
1643 }
1644 break;
1645 }
1646 case 16:
1647 {
1648 unsigned short
1649 pixel;
1650
1651 if (quantum_info->format == FloatingPointQuantumFormat)
1652 {
1653 for (x=0; x < (ssize_t) number_pixels; x++)
1654 {
1655 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1656 GetPixelRed(image,p));
1657 q=PopShortPixel(quantum_info->endian,pixel,q);
1658 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1659 GetPixelGreen(image,p));
1660 q=PopShortPixel(quantum_info->endian,pixel,q);
1661 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1662 GetPixelBlue(image,p));
1663 q=PopShortPixel(quantum_info->endian,pixel,q);
1664 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1665 GetPixelBlack(image,p));
1666 q=PopShortPixel(quantum_info->endian,pixel,q);
1667 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1668 GetPixelOpacity(image,p));
1669 q=PopShortPixel(quantum_info->endian,pixel,q);
1670 p+=(ptrdiff_t) GetPixelChannels(image);
1671 q+=(ptrdiff_t) quantum_info->pad;
1672 }
1673 break;
1674 }
1675 for (x=0; x < (ssize_t) number_pixels; x++)
1676 {
1677 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1678 q=PopShortPixel(quantum_info->endian,pixel,q);
1679 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1680 q=PopShortPixel(quantum_info->endian,pixel,q);
1681 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1682 q=PopShortPixel(quantum_info->endian,pixel,q);
1683 pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1684 q=PopShortPixel(quantum_info->endian,pixel,q);
1685 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
1686 q=PopShortPixel(quantum_info->endian,pixel,q);
1687 p+=(ptrdiff_t) GetPixelChannels(image);
1688 q+=(ptrdiff_t) quantum_info->pad;
1689 }
1690 break;
1691 }
1692 case 32:
1693 {
1694 unsigned int
1695 pixel;
1696
1697 if (quantum_info->format == FloatingPointQuantumFormat)
1698 {
1699 for (x=0; x < (ssize_t) number_pixels; x++)
1700 {
1701 float
1702 float_pixel;
1703
1704 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
1705 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),
1706 q);
1707 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),
1708 q);
1709 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlack(image,p),
1710 q);
1711 float_pixel=(float) (GetPixelOpacity(image,p));
1712 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
1713 p+=(ptrdiff_t) GetPixelChannels(image);
1714 q+=(ptrdiff_t) quantum_info->pad;
1715 }
1716 break;
1717 }
1718 for (x=0; x < (ssize_t) number_pixels; x++)
1719 {
1720 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1721 q=PopLongPixel(quantum_info->endian,pixel,q);
1722 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1723 q=PopLongPixel(quantum_info->endian,pixel,q);
1724 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1725 q=PopLongPixel(quantum_info->endian,pixel,q);
1726 pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1727 q=PopLongPixel(quantum_info->endian,pixel,q);
1728 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
1729 q=PopLongPixel(quantum_info->endian,pixel,q);
1730 p+=(ptrdiff_t) GetPixelChannels(image);
1731 q+=(ptrdiff_t) quantum_info->pad;
1732 }
1733 break;
1734 }
1735 case 64:
1736 {
1737 if (quantum_info->format == FloatingPointQuantumFormat)
1738 {
1739 double
1740 pixel;
1741
1742 for (x=0; x < (ssize_t) number_pixels; x++)
1743 {
1744 q=PopQuantumDoublePixel(quantum_info,(double)
1745 GetPixelRed(image,p),q);
1746 q=PopQuantumDoublePixel(quantum_info,(double)
1747 GetPixelGreen(image,p),q);
1748 q=PopQuantumDoublePixel(quantum_info,(double)
1749 GetPixelBlue(image,p),q);
1750 q=PopQuantumDoublePixel(quantum_info,(double)
1751 GetPixelBlack(image,p),q);
1752 pixel=(double) (GetPixelOpacity(image,p));
1753 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1754 p+=(ptrdiff_t) GetPixelChannels(image);
1755 q+=(ptrdiff_t) quantum_info->pad;
1756 }
1757 break;
1758 }
1759 magick_fallthrough;
1760 }
1761 default:
1762 {
1763 QuantumAny
1764 range;
1765
1766 range=GetQuantumRange(quantum_info->depth);
1767 for (x=0; x < (ssize_t) number_pixels; x++)
1768 {
1769 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1770 range),q);
1771 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1772 range),q);
1773 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1774 range),q);
1775 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1776 range),q);
1777 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
1778 GetPixelOpacity(image,p),range),q);
1779 p+=(ptrdiff_t) GetPixelChannels(image);
1780 q+=(ptrdiff_t) quantum_info->pad;
1781 }
1782 break;
1783 }
1784 }
1785}
1786
1787static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
1788 const MagickSizeType number_pixels,const Quantum *magick_restrict p,
1789 unsigned char *magick_restrict q)
1790{
1791 QuantumAny
1792 range;
1793
1794 ssize_t
1795 x;
1796
1797 switch (quantum_info->depth)
1798 {
1799 case 1:
1800 {
1801 double
1802 threshold;
1803
1804 unsigned char
1805 black,
1806 white;
1807
1808 ssize_t
1809 bit;
1810
1811 black=0x00;
1812 white=0x01;
1813 if (quantum_info->min_is_white != MagickFalse)
1814 {
1815 black=0x01;
1816 white=0x00;
1817 }
1818 threshold=(double) QuantumRange/2.0;
1819 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
1820 {
1821 *q='\0';
1822 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 7;
1823 p+=(ptrdiff_t) GetPixelChannels(image);
1824 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 6;
1825 p+=(ptrdiff_t) GetPixelChannels(image);
1826 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 5;
1827 p+=(ptrdiff_t) GetPixelChannels(image);
1828 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 4;
1829 p+=(ptrdiff_t) GetPixelChannels(image);
1830 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 3;
1831 p+=(ptrdiff_t) GetPixelChannels(image);
1832 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 2;
1833 p+=(ptrdiff_t) GetPixelChannels(image);
1834 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 1;
1835 p+=(ptrdiff_t) GetPixelChannels(image);
1836 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 0;
1837 p+=(ptrdiff_t) GetPixelChannels(image);
1838 q++;
1839 }
1840 if ((number_pixels % 8) != 0)
1841 {
1842 *q='\0';
1843 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
1844 {
1845 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << bit;
1846 p+=(ptrdiff_t) GetPixelChannels(image);
1847 }
1848 q++;
1849 }
1850 break;
1851 }
1852 case 4:
1853 {
1854 unsigned char
1855 pixel;
1856
1857 for (x=0; x < ((ssize_t) number_pixels-1) ; x+=2)
1858 {
1859 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1860 *q=(((pixel >> 4) & 0xf) << 4);
1861 p+=(ptrdiff_t) GetPixelChannels(image);
1862 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1863 *q|=pixel >> 4;
1864 p+=(ptrdiff_t) GetPixelChannels(image);
1865 q++;
1866 }
1867 if ((number_pixels % 2) != 0)
1868 {
1869 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1870 *q=(((pixel >> 4) & 0xf) << 4);
1871 p+=(ptrdiff_t) GetPixelChannels(image);
1872 q++;
1873 }
1874 break;
1875 }
1876 case 8:
1877 {
1878 unsigned char
1879 pixel;
1880
1881 for (x=0; x < (ssize_t) number_pixels; x++)
1882 {
1883 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1884 q=PopCharPixel(pixel,q);
1885 p+=(ptrdiff_t) GetPixelChannels(image);
1886 q+=(ptrdiff_t) quantum_info->pad;
1887 }
1888 break;
1889 }
1890 case 10:
1891 {
1892 range=GetQuantumRange(quantum_info->depth);
1893 if (quantum_info->pack == MagickFalse)
1894 {
1895 unsigned int
1896 pixel;
1897
1898 for (x=0; x < ((ssize_t) number_pixels-2); x+=3)
1899 {
1900 pixel=(unsigned int) (ScaleQuantumToAny(ClampToQuantum(
1901 GetPixelLuma(image,p+2*GetPixelChannels(image))),range) << 22 |
1902 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
1903 GetPixelChannels(image))),range) << 12 | ScaleQuantumToAny(
1904 ClampToQuantum(GetPixelLuma(image,p)),range) << 2);
1905 q=PopLongPixel(quantum_info->endian,pixel,q);
1906 p+=(ptrdiff_t) 3*GetPixelChannels(image);
1907 q+=(ptrdiff_t) quantum_info->pad;
1908 }
1909 if (x < (ssize_t) number_pixels)
1910 {
1911 pixel=0U;
1912 if (x++ < ((ssize_t) number_pixels-1))
1913 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
1914 GetPixelChannels(image))),range) << 12;
1915 if (x++ < (ssize_t) number_pixels)
1916 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),
1917 range) << 2;
1918 q=PopLongPixel(quantum_info->endian,pixel,q);
1919 }
1920 break;
1921 }
1922 for (x=0; x < (ssize_t) number_pixels; x++)
1923 {
1924 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
1925 GetPixelLuma(image,p)),range),q);
1926 p+=(ptrdiff_t) GetPixelChannels(image);
1927 q+=(ptrdiff_t) quantum_info->pad;
1928 }
1929 break;
1930 }
1931 case 12:
1932 {
1933 unsigned short
1934 pixel;
1935
1936 range=GetQuantumRange(quantum_info->depth);
1937 if (quantum_info->pack == MagickFalse)
1938 {
1939 for (x=0; x < (ssize_t) number_pixels; x++)
1940 {
1941 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
1942 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel >> 4),
1943 q);
1944 p+=(ptrdiff_t) GetPixelChannels(image);
1945 q+=(ptrdiff_t) quantum_info->pad;
1946 }
1947 break;
1948 }
1949 for (x=0; x < (ssize_t) number_pixels; x++)
1950 {
1951 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
1952 GetPixelLuma(image,p)),range),q);
1953 p+=(ptrdiff_t) GetPixelChannels(image);
1954 q+=(ptrdiff_t) quantum_info->pad;
1955 }
1956 break;
1957 }
1958 case 16:
1959 {
1960 unsigned short
1961 pixel;
1962
1963 if (quantum_info->format == FloatingPointQuantumFormat)
1964 {
1965 for (x=0; x < (ssize_t) number_pixels; x++)
1966 {
1967 pixel=SinglePrecisionToHalf(QuantumScale*(double)
1968 GetPixelLuma(image,p));
1969 q=PopShortPixel(quantum_info->endian,pixel,q);
1970 p+=(ptrdiff_t) GetPixelChannels(image);
1971 q+=(ptrdiff_t) quantum_info->pad;
1972 }
1973 break;
1974 }
1975 for (x=0; x < (ssize_t) number_pixels; x++)
1976 {
1977 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
1978 q=PopShortPixel(quantum_info->endian,pixel,q);
1979 p+=(ptrdiff_t) GetPixelChannels(image);
1980 q+=(ptrdiff_t) quantum_info->pad;
1981 }
1982 break;
1983 }
1984 case 32:
1985 {
1986 unsigned int
1987 pixel;
1988
1989 if (quantum_info->format == FloatingPointQuantumFormat)
1990 {
1991 for (x=0; x < (ssize_t) number_pixels; x++)
1992 {
1993 float
1994 float_pixel;
1995
1996 float_pixel=(float) GetPixelLuma(image,p);
1997 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
1998 p+=(ptrdiff_t) GetPixelChannels(image);
1999 q+=(ptrdiff_t) quantum_info->pad;
2000 }
2001 break;
2002 }
2003 for (x=0; x < (ssize_t) number_pixels; x++)
2004 {
2005 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2006 q=PopLongPixel(quantum_info->endian,pixel,q);
2007 p+=(ptrdiff_t) GetPixelChannels(image);
2008 q+=(ptrdiff_t) quantum_info->pad;
2009 }
2010 break;
2011 }
2012 case 64:
2013 {
2014 if (quantum_info->format == FloatingPointQuantumFormat)
2015 {
2016 for (x=0; x < (ssize_t) number_pixels; x++)
2017 {
2018 double
2019 pixel;
2020
2021 pixel=GetPixelLuma(image,p);
2022 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2023 p+=(ptrdiff_t) GetPixelChannels(image);
2024 q+=(ptrdiff_t) quantum_info->pad;
2025 }
2026 break;
2027 }
2028 magick_fallthrough;
2029 }
2030 default:
2031 {
2032 range=GetQuantumRange(quantum_info->depth);
2033 for (x=0; x < (ssize_t) number_pixels; x++)
2034 {
2035 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2036 GetPixelLuma(image,p)),range),q);
2037 p+=(ptrdiff_t) GetPixelChannels(image);
2038 q+=(ptrdiff_t) quantum_info->pad;
2039 }
2040 break;
2041 }
2042 }
2043}
2044
2045static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
2046 const MagickSizeType number_pixels,const Quantum *magick_restrict p,
2047 unsigned char *magick_restrict q)
2048{
2049 QuantumAny
2050 range;
2051
2052 ssize_t
2053 x;
2054
2055 switch (quantum_info->depth)
2056 {
2057 case 1:
2058 {
2059 double
2060 threshold;
2061
2062 unsigned char
2063 black,
2064 pixel,
2065 white;
2066
2067 ssize_t
2068 bit;
2069
2070 black=0x00;
2071 white=0x01;
2072 if (quantum_info->min_is_white != MagickFalse)
2073 {
2074 black=0x01;
2075 white=0x00;
2076 }
2077 threshold=(double) QuantumRange/2.0;
2078 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2079 {
2080 *q='\0';
2081 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 7;
2082 pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2083 0x00 : 0x01);
2084 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
2085 p+=(ptrdiff_t) GetPixelChannels(image);
2086 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 5;
2087 pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2088 0x00 : 0x01);
2089 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
2090 p+=(ptrdiff_t) GetPixelChannels(image);
2091 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 3;
2092 pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2093 0x00 : 0x01);
2094 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
2095 p+=(ptrdiff_t) GetPixelChannels(image);
2096 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 1;
2097 pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2098 0x00 : 0x01);
2099 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
2100 p+=(ptrdiff_t) GetPixelChannels(image);
2101 q++;
2102 }
2103 if ((number_pixels % 4) != 0)
2104 {
2105 *q='\0';
2106 for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
2107 {
2108 *q|=(GetPixelLuma(image,p) > threshold ? black : white) <<
2109 (7-bit);
2110 pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2111 0x00 : 0x01);
2112 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
2113 (7-bit-1));
2114 p+=(ptrdiff_t) GetPixelChannels(image);
2115 }
2116 q++;
2117 }
2118 break;
2119 }
2120 case 4:
2121 {
2122 unsigned char
2123 pixel;
2124
2125 for (x=0; x < (ssize_t) number_pixels ; x++)
2126 {
2127 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2128 *q=(((pixel >> 4) & 0xf) << 4);
2129 pixel=(unsigned char) (16.0*QuantumScale*(double)
2130 GetPixelAlpha(image,p)+0.5);
2131 *q|=pixel & 0xf;
2132 p+=(ptrdiff_t) GetPixelChannels(image);
2133 q++;
2134 }
2135 break;
2136 }
2137 case 8:
2138 {
2139 unsigned char
2140 pixel;
2141
2142 for (x=0; x < (ssize_t) number_pixels; x++)
2143 {
2144 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2145 q=PopCharPixel(pixel,q);
2146 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
2147 q=PopCharPixel(pixel,q);
2148 p+=(ptrdiff_t) GetPixelChannels(image);
2149 q+=(ptrdiff_t) quantum_info->pad;
2150 }
2151 break;
2152 }
2153 case 16:
2154 {
2155 unsigned short
2156 pixel;
2157
2158 if (quantum_info->format == FloatingPointQuantumFormat)
2159 {
2160 for (x=0; x < (ssize_t) number_pixels; x++)
2161 {
2162 pixel=SinglePrecisionToHalf(QuantumScale*(double)
2163 GetPixelLuma(image,p));
2164 q=PopShortPixel(quantum_info->endian,pixel,q);
2165 pixel=SinglePrecisionToHalf(QuantumScale*(double)
2166 GetPixelAlpha(image,p));
2167 q=PopShortPixel(quantum_info->endian,pixel,q);
2168 p+=(ptrdiff_t) GetPixelChannels(image);
2169 q+=(ptrdiff_t) quantum_info->pad;
2170 }
2171 break;
2172 }
2173 for (x=0; x < (ssize_t) number_pixels; x++)
2174 {
2175 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2176 q=PopShortPixel(quantum_info->endian,pixel,q);
2177 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
2178 q=PopShortPixel(quantum_info->endian,pixel,q);
2179 p+=(ptrdiff_t) GetPixelChannels(image);
2180 q+=(ptrdiff_t) quantum_info->pad;
2181 }
2182 break;
2183 }
2184 case 32:
2185 {
2186 unsigned int
2187 pixel;
2188
2189 if (quantum_info->format == FloatingPointQuantumFormat)
2190 {
2191 for (x=0; x < (ssize_t) number_pixels; x++)
2192 {
2193 float
2194 float_pixel;
2195
2196 float_pixel=(float) GetPixelLuma(image,p);
2197 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2198 float_pixel=(float) (GetPixelAlpha(image,p));
2199 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2200 p+=(ptrdiff_t) GetPixelChannels(image);
2201 q+=(ptrdiff_t) quantum_info->pad;
2202 }
2203 break;
2204 }
2205 for (x=0; x < (ssize_t) number_pixels; x++)
2206 {
2207 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2208 q=PopLongPixel(quantum_info->endian,pixel,q);
2209 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
2210 q=PopLongPixel(quantum_info->endian,pixel,q);
2211 p+=(ptrdiff_t) GetPixelChannels(image);
2212 q+=(ptrdiff_t) quantum_info->pad;
2213 }
2214 break;
2215 }
2216 case 64:
2217 {
2218 if (quantum_info->format == FloatingPointQuantumFormat)
2219 {
2220 for (x=0; x < (ssize_t) number_pixels; x++)
2221 {
2222 double
2223 pixel;
2224
2225 pixel=GetPixelLuma(image,p);
2226 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2227 pixel=(double) (GetPixelAlpha(image,p));
2228 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2229 p+=(ptrdiff_t) GetPixelChannels(image);
2230 q+=(ptrdiff_t) quantum_info->pad;
2231 }
2232 break;
2233 }
2234 magick_fallthrough;
2235 }
2236 default:
2237 {
2238 range=GetQuantumRange(quantum_info->depth);
2239 for (x=0; x < (ssize_t) number_pixels; x++)
2240 {
2241 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2242 GetPixelLuma(image,p)),range),q);
2243 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
2244 range),q);
2245 p+=(ptrdiff_t) GetPixelChannels(image);
2246 q+=(ptrdiff_t) quantum_info->pad;
2247 }
2248 break;
2249 }
2250 }
2251}
2252
2253static void ExportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
2254 const MagickSizeType number_pixels,const Quantum *magick_restrict p,
2255 unsigned char *magick_restrict q,ExceptionInfo *exception)
2256{
2257 ssize_t
2258 x;
2259
2260 ssize_t
2261 bit;
2262
2263 if (image->storage_class != PseudoClass)
2264 {
2265 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2266 "ColormappedImageRequired","`%s'",image->filename);
2267 return;
2268 }
2269 switch (quantum_info->depth)
2270 {
2271 case 1:
2272 {
2273 unsigned char
2274 pixel;
2275
2276 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
2277 {
2278 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2279 *q=((pixel & 0x01) << 7);
2280 p+=(ptrdiff_t) GetPixelChannels(image);
2281 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2282 *q|=((pixel & 0x01) << 6);
2283 p+=(ptrdiff_t) GetPixelChannels(image);
2284 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2285 *q|=((pixel & 0x01) << 5);
2286 p+=(ptrdiff_t) GetPixelChannels(image);
2287 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2288 *q|=((pixel & 0x01) << 4);
2289 p+=(ptrdiff_t) GetPixelChannels(image);
2290 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2291 *q|=((pixel & 0x01) << 3);
2292 p+=(ptrdiff_t) GetPixelChannels(image);
2293 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2294 *q|=((pixel & 0x01) << 2);
2295 p+=(ptrdiff_t) GetPixelChannels(image);
2296 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2297 *q|=((pixel & 0x01) << 1);
2298 p+=(ptrdiff_t) GetPixelChannels(image);
2299 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2300 *q|=((pixel & 0x01) << 0);
2301 p+=(ptrdiff_t) GetPixelChannels(image);
2302 q++;
2303 }
2304 if ((number_pixels % 8) != 0)
2305 {
2306 *q='\0';
2307 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
2308 {
2309 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2310 *q|=((pixel & 0x01) << (unsigned char) bit);
2311 p+=(ptrdiff_t) GetPixelChannels(image);
2312 }
2313 q++;
2314 }
2315 break;
2316 }
2317 case 4:
2318 {
2319 unsigned char
2320 pixel;
2321
2322 for (x=0; x < ((ssize_t) number_pixels-1) ; x+=2)
2323 {
2324 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2325 *q=((pixel & 0xf) << 4);
2326 p+=(ptrdiff_t) GetPixelChannels(image);
2327 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2328 *q|=((pixel & 0xf) << 0);
2329 p+=(ptrdiff_t) GetPixelChannels(image);
2330 q++;
2331 }
2332 if ((number_pixels % 2) != 0)
2333 {
2334 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2335 *q=((pixel & 0xf) << 4);
2336 p+=(ptrdiff_t) GetPixelChannels(image);
2337 q++;
2338 }
2339 break;
2340 }
2341 case 8:
2342 {
2343 for (x=0; x < (ssize_t) number_pixels; x++)
2344 {
2345 q=PopCharPixel((unsigned char) ((ssize_t) GetPixelIndex(image,p)),q);
2346 p+=(ptrdiff_t) GetPixelChannels(image);
2347 q+=(ptrdiff_t) quantum_info->pad;
2348 }
2349 break;
2350 }
2351 case 16:
2352 {
2353 if (quantum_info->format == FloatingPointQuantumFormat)
2354 {
2355 for (x=0; x < (ssize_t) number_pixels; x++)
2356 {
2357 q=PopShortPixel(quantum_info->endian,SinglePrecisionToHalf(
2358 QuantumScale*(double) GetPixelIndex(image,p)),q);
2359 p+=(ptrdiff_t) GetPixelChannels(image);
2360 q+=(ptrdiff_t) quantum_info->pad;
2361 }
2362 break;
2363 }
2364 for (x=0; x < (ssize_t) number_pixels; x++)
2365 {
2366 q=PopShortPixel(quantum_info->endian,(unsigned short)
2367 GetPixelIndex(image,p),q);
2368 p+=(ptrdiff_t) GetPixelChannels(image);
2369 q+=(ptrdiff_t) quantum_info->pad;
2370 }
2371 break;
2372 }
2373 case 32:
2374 {
2375 if (quantum_info->format == FloatingPointQuantumFormat)
2376 {
2377 for (x=0; x < (ssize_t) number_pixels; x++)
2378 {
2379 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelIndex(image,p),q);
2380 p+=(ptrdiff_t) GetPixelChannels(image);
2381 q+=(ptrdiff_t) quantum_info->pad;
2382 }
2383 break;
2384 }
2385 for (x=0; x < (ssize_t) number_pixels; x++)
2386 {
2387 q=PopLongPixel(quantum_info->endian,(unsigned int)
2388 GetPixelIndex(image,p),q);
2389 p+=(ptrdiff_t) GetPixelChannels(image);
2390 q+=(ptrdiff_t) quantum_info->pad;
2391 }
2392 break;
2393 }
2394 case 64:
2395 {
2396 if (quantum_info->format == FloatingPointQuantumFormat)
2397 {
2398 for (x=0; x < (ssize_t) number_pixels; x++)
2399 {
2400 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelIndex(image,p),q);
2401 p+=(ptrdiff_t) GetPixelChannels(image);
2402 q+=(ptrdiff_t) quantum_info->pad;
2403 }
2404 break;
2405 }
2406 magick_fallthrough;
2407 }
2408 default:
2409 {
2410 for (x=0; x < (ssize_t) number_pixels; x++)
2411 {
2412 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(image,p),q);
2413 p+=(ptrdiff_t) GetPixelChannels(image);
2414 q+=(ptrdiff_t) quantum_info->pad;
2415 }
2416 break;
2417 }
2418 }
2419}
2420
2421static void ExportIndexAlphaQuantum(const Image *image,
2422 QuantumInfo *quantum_info,const MagickSizeType number_pixels,
2423 const Quantum *magick_restrict p,unsigned char *magick_restrict q,
2424 ExceptionInfo *exception)
2425{
2426 ssize_t
2427 x;
2428
2429 ssize_t
2430 bit;
2431
2432 if (image->storage_class != PseudoClass)
2433 {
2434 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2435 "ColormappedImageRequired","`%s'",image->filename);
2436 return;
2437 }
2438 switch (quantum_info->depth)
2439 {
2440 case 1:
2441 {
2442 unsigned char
2443 pixel;
2444
2445 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2446 {
2447 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2448 *q=((pixel & 0x01) << 7);
2449 pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2450 TransparentAlpha ? 1 : 0);
2451 *q|=((pixel & 0x01) << 6);
2452 p+=(ptrdiff_t) GetPixelChannels(image);
2453 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2454 *q|=((pixel & 0x01) << 5);
2455 pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2456 TransparentAlpha ? 1 : 0);
2457 *q|=((pixel & 0x01) << 4);
2458 p+=(ptrdiff_t) GetPixelChannels(image);
2459 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2460 *q|=((pixel & 0x01) << 3);
2461 pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2462 TransparentAlpha ? 1 : 0);
2463 *q|=((pixel & 0x01) << 2);
2464 p+=(ptrdiff_t) GetPixelChannels(image);
2465 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2466 *q|=((pixel & 0x01) << 1);
2467 pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2468 TransparentAlpha ? 1 : 0);
2469 *q|=((pixel & 0x01) << 0);
2470 p+=(ptrdiff_t) GetPixelChannels(image);
2471 q++;
2472 }
2473 if ((number_pixels % 4) != 0)
2474 {
2475 *q='\0';
2476 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2477 {
2478 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2479 *q|=((pixel & 0x01) << (unsigned char) (bit+4));
2480 pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2481 TransparentAlpha ? 1 : 0);
2482 *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
2483 p+=(ptrdiff_t) GetPixelChannels(image);
2484 }
2485 q++;
2486 }
2487 break;
2488 }
2489 case 4:
2490 {
2491 unsigned char
2492 pixel;
2493
2494 for (x=0; x < (ssize_t) number_pixels ; x++)
2495 {
2496 pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2497 *q=((pixel & 0xf) << 4);
2498 pixel=(unsigned char) (16.0*QuantumScale*(double)
2499 GetPixelAlpha(image,p)+0.5);
2500 *q|=((pixel & 0xf) << 0);
2501 p+=(ptrdiff_t) GetPixelChannels(image);
2502 q++;
2503 }
2504 break;
2505 }
2506 case 8:
2507 {
2508 unsigned char
2509 pixel;
2510
2511 for (x=0; x < (ssize_t) number_pixels; x++)
2512 {
2513 q=PopCharPixel((unsigned char) ((ssize_t) GetPixelIndex(image,p)),q);
2514 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
2515 q=PopCharPixel(pixel,q);
2516 p+=(ptrdiff_t) GetPixelChannels(image);
2517 q+=(ptrdiff_t) quantum_info->pad;
2518 }
2519 break;
2520 }
2521 case 16:
2522 {
2523 unsigned short
2524 pixel;
2525
2526 if (quantum_info->format == FloatingPointQuantumFormat)
2527 {
2528 for (x=0; x < (ssize_t) number_pixels; x++)
2529 {
2530 q=PopShortPixel(quantum_info->endian,(unsigned short)
2531 ((ssize_t) GetPixelIndex(image,p)),q);
2532 pixel=SinglePrecisionToHalf(QuantumScale*(double)
2533 GetPixelAlpha(image,p));
2534 q=PopShortPixel(quantum_info->endian,pixel,q);
2535 p+=(ptrdiff_t) GetPixelChannels(image);
2536 q+=(ptrdiff_t) quantum_info->pad;
2537 }
2538 break;
2539 }
2540 for (x=0; x < (ssize_t) number_pixels; x++)
2541 {
2542 q=PopShortPixel(quantum_info->endian,(unsigned short)
2543 ((ssize_t) GetPixelIndex(image,p)),q);
2544 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
2545 q=PopShortPixel(quantum_info->endian,pixel,q);
2546 p+=(ptrdiff_t) GetPixelChannels(image);
2547 q+=(ptrdiff_t) quantum_info->pad;
2548 }
2549 break;
2550 }
2551 case 32:
2552 {
2553 unsigned int
2554 pixel;
2555
2556 if (quantum_info->format == FloatingPointQuantumFormat)
2557 {
2558 for (x=0; x < (ssize_t) number_pixels; x++)
2559 {
2560 float
2561 float_pixel;
2562
2563 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelIndex(image,p),q);
2564 float_pixel=(float) GetPixelAlpha(image,p);
2565 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2566 p+=(ptrdiff_t) GetPixelChannels(image);
2567 q+=(ptrdiff_t) quantum_info->pad;
2568 }
2569 break;
2570 }
2571 for (x=0; x < (ssize_t) number_pixels; x++)
2572 {
2573 q=PopLongPixel(quantum_info->endian,(unsigned int)
2574 GetPixelIndex(image,p),q);
2575 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
2576 q=PopLongPixel(quantum_info->endian,pixel,q);
2577 p+=(ptrdiff_t) GetPixelChannels(image);
2578 q+=(ptrdiff_t) quantum_info->pad;
2579 }
2580 break;
2581 }
2582 case 64:
2583 {
2584 if (quantum_info->format == FloatingPointQuantumFormat)
2585 {
2586 for (x=0; x < (ssize_t) number_pixels; x++)
2587 {
2588 double
2589 pixel;
2590
2591 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelIndex(image,p),q);
2592 pixel=(double) GetPixelAlpha(image,p);
2593 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2594 p+=(ptrdiff_t) GetPixelChannels(image);
2595 q+=(ptrdiff_t) quantum_info->pad;
2596 }
2597 break;
2598 }
2599 magick_fallthrough;
2600 }
2601 default:
2602 {
2603 QuantumAny
2604 range;
2605
2606 range=GetQuantumRange(quantum_info->depth);
2607 for (x=0; x < (ssize_t) number_pixels; x++)
2608 {
2609 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(image,p),q);
2610 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
2611 range),q);
2612 p+=(ptrdiff_t) GetPixelChannels(image);
2613 q+=(ptrdiff_t) quantum_info->pad;
2614 }
2615 break;
2616 }
2617 }
2618}
2619
2620static void ExportMultispectralQuantum(const Image *image,
2621 QuantumInfo *quantum_info,const MagickSizeType number_pixels,
2622 const Quantum *magick_restrict p,unsigned char *magick_restrict q,
2623 ExceptionInfo *exception)
2624{
2625 ssize_t
2626 i,
2627 x;
2628
2629 if (image->number_meta_channels == 0)
2630 {
2631 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2632 "MultispectralImageRequired","`%s'",image->filename);
2633 return;
2634 }
2635 if (quantum_info->meta_channel != 0)
2636 {
2637 ExportPixelChannel(image,quantum_info,number_pixels,p,q,
2638 (PixelChannel) (MetaPixelChannels+quantum_info->meta_channel-1));
2639 return;
2640 }
2641 switch (quantum_info->depth)
2642 {
2643 case 8:
2644 {
2645 unsigned char
2646 pixel;
2647
2648 for (x=0; x < (ssize_t) number_pixels; x++)
2649 {
2650 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2651 {
2652 pixel=ScaleQuantumToChar(p[i]);
2653 q=PopCharPixel(pixel,q);
2654 }
2655 p+=(ptrdiff_t) GetPixelChannels(image);
2656 q+=(ptrdiff_t) quantum_info->pad;
2657 }
2658 break;
2659 }
2660 case 16:
2661 {
2662 unsigned short
2663 pixel;
2664
2665 if (quantum_info->format == FloatingPointQuantumFormat)
2666 {
2667 for (x=0; x < (ssize_t) number_pixels; x++)
2668 {
2669 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2670 {
2671 pixel=SinglePrecisionToHalf(QuantumScale*(double) p[i]);
2672 q=PopShortPixel(quantum_info->endian,pixel,q);
2673 }
2674 p+=(ptrdiff_t) GetPixelChannels(image);
2675 q+=(ptrdiff_t) quantum_info->pad;
2676 }
2677 break;
2678 }
2679 for (x=0; x < (ssize_t) number_pixels; x++)
2680 {
2681 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2682 {
2683 pixel=ScaleQuantumToShort(p[i]);
2684 q=PopShortPixel(quantum_info->endian,pixel,q);
2685 }
2686 p+=(ptrdiff_t) GetPixelChannels(image);
2687 q+=(ptrdiff_t) quantum_info->pad;
2688 }
2689 break;
2690 }
2691 case 32:
2692 {
2693 unsigned int
2694 pixel;
2695
2696 if (quantum_info->format == FloatingPointQuantumFormat)
2697 {
2698 for (x=0; x < (ssize_t) number_pixels; x++)
2699 {
2700 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2701 q=PopQuantumFloatPixel(quantum_info,(float) p[i],q);
2702 p+=(ptrdiff_t) GetPixelChannels(image);
2703 q+=(ptrdiff_t) quantum_info->pad;
2704 }
2705 break;
2706 }
2707 for (x=0; x < (ssize_t) number_pixels; x++)
2708 {
2709 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2710 {
2711 pixel=ScaleQuantumToLong(p[i]);
2712 q=PopLongPixel(quantum_info->endian,pixel,q);
2713 }
2714 p+=(ptrdiff_t) GetPixelChannels(image);
2715 q+=(ptrdiff_t) quantum_info->pad;
2716 }
2717 break;
2718 }
2719 case 64:
2720 {
2721 if (quantum_info->format == FloatingPointQuantumFormat)
2722 {
2723 for (x=0; x < (ssize_t) number_pixels; x++)
2724 {
2725 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2726 q=PopQuantumDoublePixel(quantum_info,(double) p[i],q);
2727 p+=(ptrdiff_t) GetPixelChannels(image);
2728 q+=(ptrdiff_t) quantum_info->pad;
2729 }
2730 break;
2731 }
2732 magick_fallthrough;
2733 }
2734 default:
2735 {
2736 QuantumAny
2737 range;
2738
2739 range=GetQuantumRange(quantum_info->depth);
2740 for (x=0; x < (ssize_t) number_pixels; x++)
2741 {
2742 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2743 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(p[i],range),q);
2744 p+=(ptrdiff_t) GetPixelChannels(image);
2745 q+=(ptrdiff_t) quantum_info->pad;
2746 }
2747 break;
2748 }
2749 }
2750}
2751
2752static void ExportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
2753 const MagickSizeType number_pixels,const Quantum *magick_restrict p,
2754 unsigned char *magick_restrict q,ExceptionInfo *exception)
2755{
2756 QuantumAny
2757 range;
2758
2759 ssize_t
2760 x;
2761
2762 if (image->alpha_trait == UndefinedPixelTrait)
2763 {
2764 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2765 "ImageDoesNotHaveAnAlphaChannel","`%s'",image->filename);
2766 return;
2767 }
2768 switch (quantum_info->depth)
2769 {
2770 case 8:
2771 {
2772 unsigned char
2773 pixel;
2774
2775 for (x=0; x < (ssize_t) number_pixels; x++)
2776 {
2777 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
2778 q=PopCharPixel(pixel,q);
2779 p+=(ptrdiff_t) GetPixelChannels(image);
2780 q+=(ptrdiff_t) quantum_info->pad;
2781 }
2782 break;
2783 }
2784 case 16:
2785 {
2786 unsigned short
2787 pixel;
2788
2789 if (quantum_info->format == FloatingPointQuantumFormat)
2790 {
2791 for (x=0; x < (ssize_t) number_pixels; x++)
2792 {
2793 pixel=SinglePrecisionToHalf(QuantumScale*(double)
2794 GetPixelOpacity(image,p));
2795 q=PopShortPixel(quantum_info->endian,pixel,q);
2796 p+=(ptrdiff_t) GetPixelChannels(image);
2797 q+=(ptrdiff_t) quantum_info->pad;
2798 }
2799 break;
2800 }
2801 for (x=0; x < (ssize_t) number_pixels; x++)
2802 {
2803 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
2804 q=PopShortPixel(quantum_info->endian,pixel,q);
2805 p+=(ptrdiff_t) GetPixelChannels(image);
2806 q+=(ptrdiff_t) quantum_info->pad;
2807 }
2808 break;
2809 }
2810 case 32:
2811 {
2812 unsigned int
2813 pixel;
2814
2815 if (quantum_info->format == FloatingPointQuantumFormat)
2816 {
2817 for (x=0; x < (ssize_t) number_pixels; x++)
2818 {
2819 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelOpacity(image,p),q);
2820 p+=(ptrdiff_t) GetPixelChannels(image);
2821 q+=(ptrdiff_t) quantum_info->pad;
2822 }
2823 break;
2824 }
2825 for (x=0; x < (ssize_t) number_pixels; x++)
2826 {
2827 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
2828 q=PopLongPixel(quantum_info->endian,pixel,q);
2829 p+=(ptrdiff_t) GetPixelChannels(image);
2830 q+=(ptrdiff_t) quantum_info->pad;
2831 }
2832 break;
2833 }
2834 case 64:
2835 {
2836 if (quantum_info->format == FloatingPointQuantumFormat)
2837 {
2838 for (x=0; x < (ssize_t) number_pixels; x++)
2839 {
2840 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelOpacity(image,p),q);
2841 p+=(ptrdiff_t) GetPixelChannels(image);
2842 q+=(ptrdiff_t) quantum_info->pad;
2843 }
2844 break;
2845 }
2846 magick_fallthrough;
2847 }
2848 default:
2849 {
2850 range=GetQuantumRange(quantum_info->depth);
2851 for (x=0; x < (ssize_t) number_pixels; x++)
2852 {
2853 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
2854 GetPixelOpacity(image,p),range),q);
2855 p+=(ptrdiff_t) GetPixelChannels(image);
2856 q+=(ptrdiff_t) quantum_info->pad;
2857 }
2858 break;
2859 }
2860 }
2861}
2862
2863static void ExportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
2864 const MagickSizeType number_pixels,const Quantum *magick_restrict p,
2865 unsigned char *magick_restrict q)
2866{
2867 QuantumAny
2868 range;
2869
2870 ssize_t
2871 x;
2872
2873 ssize_t
2874 bit;
2875
2876 switch (quantum_info->depth)
2877 {
2878 case 8:
2879 {
2880 for (x=0; x < (ssize_t) number_pixels; x++)
2881 {
2882 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
2883 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
2884 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
2885 p+=(ptrdiff_t) GetPixelChannels(image);
2886 q+=(ptrdiff_t) quantum_info->pad;
2887 }
2888 break;
2889 }
2890 case 10:
2891 {
2892 unsigned int
2893 pixel;
2894
2895 range=GetQuantumRange(quantum_info->depth);
2896 if (quantum_info->pack == MagickFalse)
2897 {
2898 for (x=0; x < (ssize_t) number_pixels; x++)
2899 {
2900 pixel=(unsigned int) (
2901 ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
2902 ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
2903 ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
2904 q=PopLongPixel(quantum_info->endian,pixel,q);
2905 p+=(ptrdiff_t) GetPixelChannels(image);
2906 q+=(ptrdiff_t) quantum_info->pad;
2907 }
2908 break;
2909 }
2910 if (quantum_info->quantum == 32UL)
2911 {
2912 for (x=0; x < (ssize_t) number_pixels; x++)
2913 {
2914 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
2915 q=PopQuantumLongPixel(quantum_info,pixel,q);
2916 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
2917 range);
2918 q=PopQuantumLongPixel(quantum_info,pixel,q);
2919 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
2920 q=PopQuantumLongPixel(quantum_info,pixel,q);
2921 p+=(ptrdiff_t) GetPixelChannels(image);
2922 q+=(ptrdiff_t) quantum_info->pad;
2923 }
2924 break;
2925 }
2926 for (x=0; x < (ssize_t) number_pixels; x++)
2927 {
2928 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
2929 q=PopQuantumPixel(quantum_info,pixel,q);
2930 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
2931 q=PopQuantumPixel(quantum_info,pixel,q);
2932 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
2933 q=PopQuantumPixel(quantum_info,pixel,q);
2934 p+=(ptrdiff_t) GetPixelChannels(image);
2935 q+=(ptrdiff_t) quantum_info->pad;
2936 }
2937 break;
2938 }
2939 case 12:
2940 {
2941 unsigned int
2942 pixel;
2943
2944 range=GetQuantumRange(quantum_info->depth);
2945 if (quantum_info->pack == MagickFalse)
2946 {
2947 for (x=0; x < (3*(ssize_t) number_pixels-1); x+=2)
2948 {
2949 switch (x % 3)
2950 {
2951 default:
2952 case 0:
2953 {
2954 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
2955 range);
2956 break;
2957 }
2958 case 1:
2959 {
2960 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
2961 range);
2962 break;
2963 }
2964 case 2:
2965 {
2966 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
2967 range);
2968 p+=(ptrdiff_t) GetPixelChannels(image);
2969 break;
2970 }
2971 }
2972 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
2973 q);
2974 switch ((x+1) % 3)
2975 {
2976 default:
2977 case 0:
2978 {
2979 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
2980 range);
2981 break;
2982 }
2983 case 1:
2984 {
2985 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
2986 range);
2987 break;
2988 }
2989 case 2:
2990 {
2991 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
2992 range);
2993 p+=(ptrdiff_t) GetPixelChannels(image);
2994 break;
2995 }
2996 }
2997 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
2998 q);
2999 q+=(ptrdiff_t) quantum_info->pad;
3000 }
3001 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
3002 {
3003 switch ((x+bit) % 3)
3004 {
3005 default:
3006 case 0:
3007 {
3008 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
3009 range);
3010 break;
3011 }
3012 case 1:
3013 {
3014 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3015 range);
3016 break;
3017 }
3018 case 2:
3019 {
3020 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
3021 range);
3022 p+=(ptrdiff_t) GetPixelChannels(image);
3023 break;
3024 }
3025 }
3026 q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
3027 q);
3028 q+=(ptrdiff_t) quantum_info->pad;
3029 }
3030 if (bit != 0)
3031 p+=(ptrdiff_t) GetPixelChannels(image);
3032 break;
3033 }
3034 if (quantum_info->quantum == 32UL)
3035 {
3036 for (x=0; x < (ssize_t) number_pixels; x++)
3037 {
3038 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3039 q=PopQuantumLongPixel(quantum_info,pixel,q);
3040 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3041 range);
3042 q=PopQuantumLongPixel(quantum_info,pixel,q);
3043 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3044 q=PopQuantumLongPixel(quantum_info,pixel,q);
3045 p+=(ptrdiff_t) GetPixelChannels(image);
3046 q+=(ptrdiff_t) quantum_info->pad;
3047 }
3048 break;
3049 }
3050 for (x=0; x < (ssize_t) number_pixels; x++)
3051 {
3052 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3053 q=PopQuantumPixel(quantum_info,pixel,q);
3054 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3055 q=PopQuantumPixel(quantum_info,pixel,q);
3056 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3057 q=PopQuantumPixel(quantum_info,pixel,q);
3058 p+=(ptrdiff_t) GetPixelChannels(image);
3059 q+=(ptrdiff_t) quantum_info->pad;
3060 }
3061 break;
3062 }
3063 case 16:
3064 {
3065 unsigned short
3066 pixel;
3067
3068 if (quantum_info->format == FloatingPointQuantumFormat)
3069 {
3070 for (x=0; x < (ssize_t) number_pixels; x++)
3071 {
3072 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3073 GetPixelRed(image,p));
3074 q=PopShortPixel(quantum_info->endian,pixel,q);
3075 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3076 GetPixelGreen(image,p));
3077 q=PopShortPixel(quantum_info->endian,pixel,q);
3078 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3079 GetPixelBlue(image,p));
3080 q=PopShortPixel(quantum_info->endian,pixel,q);
3081 p+=(ptrdiff_t) GetPixelChannels(image);
3082 q+=(ptrdiff_t) quantum_info->pad;
3083 }
3084 break;
3085 }
3086 for (x=0; x < (ssize_t) number_pixels; x++)
3087 {
3088 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3089 q=PopShortPixel(quantum_info->endian,pixel,q);
3090 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3091 q=PopShortPixel(quantum_info->endian,pixel,q);
3092 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3093 q=PopShortPixel(quantum_info->endian,pixel,q);
3094 p+=(ptrdiff_t) GetPixelChannels(image);
3095 q+=(ptrdiff_t) quantum_info->pad;
3096 }
3097 break;
3098 }
3099 case 32:
3100 {
3101 unsigned int
3102 pixel;
3103
3104 if (quantum_info->format == FloatingPointQuantumFormat)
3105 {
3106 for (x=0; x < (ssize_t) number_pixels; x++)
3107 {
3108 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),
3109 q);
3110 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),
3111 q);
3112 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),
3113 q);
3114 p+=(ptrdiff_t) GetPixelChannels(image);
3115 q+=(ptrdiff_t) quantum_info->pad;
3116 }
3117 break;
3118 }
3119 for (x=0; x < (ssize_t) number_pixels; x++)
3120 {
3121 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3122 q=PopLongPixel(quantum_info->endian,pixel,q);
3123 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3124 q=PopLongPixel(quantum_info->endian,pixel,q);
3125 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3126 q=PopLongPixel(quantum_info->endian,pixel,q);
3127 p+=(ptrdiff_t) GetPixelChannels(image);
3128 q+=(ptrdiff_t) quantum_info->pad;
3129 }
3130 break;
3131 }
3132 case 64:
3133 {
3134 if (quantum_info->format == FloatingPointQuantumFormat)
3135 {
3136 for (x=0; x < (ssize_t) number_pixels; x++)
3137 {
3138 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
3139 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
3140 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
3141 p+=(ptrdiff_t) GetPixelChannels(image);
3142 q+=(ptrdiff_t) quantum_info->pad;
3143 }
3144 break;
3145 }
3146 magick_fallthrough;
3147 }
3148 default:
3149 {
3150 range=GetQuantumRange(quantum_info->depth);
3151 for (x=0; x < (ssize_t) number_pixels; x++)
3152 {
3153 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3154 range),q);
3155 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3156 range),q);
3157 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3158 range),q);
3159 p+=(ptrdiff_t) GetPixelChannels(image);
3160 q+=(ptrdiff_t) quantum_info->pad;
3161 }
3162 break;
3163 }
3164 }
3165}
3166
3167static void ExportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
3168 const MagickSizeType number_pixels,const Quantum *magick_restrict p,
3169 unsigned char *magick_restrict q)
3170{
3171 QuantumAny
3172 range;
3173
3174 ssize_t
3175 x;
3176
3177 switch (quantum_info->depth)
3178 {
3179 case 8:
3180 {
3181 unsigned char
3182 pixel;
3183
3184 for (x=0; x < (ssize_t) number_pixels; x++)
3185 {
3186 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
3187 q=PopCharPixel(pixel,q);
3188 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
3189 q=PopCharPixel(pixel,q);
3190 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
3191 q=PopCharPixel(pixel,q);
3192 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
3193 q=PopCharPixel(pixel,q);
3194 p+=(ptrdiff_t) GetPixelChannels(image);
3195 q+=(ptrdiff_t) quantum_info->pad;
3196 }
3197 break;
3198 }
3199 case 10:
3200 {
3201 unsigned int
3202 pixel;
3203
3204 range=GetQuantumRange(quantum_info->depth);
3205 if (quantum_info->pack == MagickFalse)
3206 {
3207 ssize_t
3208 i;
3209
3210 size_t
3211 quantum;
3212
3213 ssize_t
3214 n;
3215
3216 n=0;
3217 quantum=0;
3218 pixel=0;
3219 for (x=0; x < (ssize_t) number_pixels; x++)
3220 {
3221 for (i=0; i < 4; i++)
3222 {
3223 switch (i)
3224 {
3225 case 0: quantum=(size_t) GetPixelRed(image,p); break;
3226 case 1: quantum=(size_t) GetPixelGreen(image,p); break;
3227 case 2: quantum=(size_t) GetPixelBlue(image,p); break;
3228 case 3: quantum=(size_t) GetPixelAlpha(image,p); break;
3229 }
3230 switch (n % 3)
3231 {
3232 case 0:
3233 {
3234 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3235 range) << 22);
3236 break;
3237 }
3238 case 1:
3239 {
3240 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3241 range) << 12);
3242 break;
3243 }
3244 case 2:
3245 {
3246 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3247 range) << 2);
3248 q=PopLongPixel(quantum_info->endian,pixel,q);
3249 pixel=0;
3250 break;
3251 }
3252 }
3253 n++;
3254 }
3255 p+=(ptrdiff_t) GetPixelChannels(image);
3256 q+=(ptrdiff_t) quantum_info->pad;
3257 }
3258 break;
3259 }
3260 if (quantum_info->quantum == 32UL)
3261 {
3262 for (x=0; x < (ssize_t) number_pixels; x++)
3263 {
3264 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3265 q=PopQuantumLongPixel(quantum_info,pixel,q);
3266 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3267 range);
3268 q=PopQuantumLongPixel(quantum_info,pixel,q);
3269 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3270 q=PopQuantumLongPixel(quantum_info,pixel,q);
3271 pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
3272 range);
3273 q=PopQuantumLongPixel(quantum_info,pixel,q);
3274 p+=(ptrdiff_t) GetPixelChannels(image);
3275 q+=(ptrdiff_t) quantum_info->pad;
3276 }
3277 break;
3278 }
3279 for (x=0; x < (ssize_t) number_pixels; x++)
3280 {
3281 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3282 q=PopQuantumPixel(quantum_info,pixel,q);
3283 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3284 q=PopQuantumPixel(quantum_info,pixel,q);
3285 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3286 q=PopQuantumPixel(quantum_info,pixel,q);
3287 pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
3288 q=PopQuantumPixel(quantum_info,pixel,q);
3289 p+=(ptrdiff_t) GetPixelChannels(image);
3290 q+=(ptrdiff_t) quantum_info->pad;
3291 }
3292 break;
3293 }
3294 case 16:
3295 {
3296 unsigned short
3297 pixel;
3298
3299 if (quantum_info->format == FloatingPointQuantumFormat)
3300 {
3301 for (x=0; x < (ssize_t) number_pixels; x++)
3302 {
3303 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3304 GetPixelRed(image,p));
3305 q=PopShortPixel(quantum_info->endian,pixel,q);
3306 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3307 GetPixelGreen(image,p));
3308 q=PopShortPixel(quantum_info->endian,pixel,q);
3309 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3310 GetPixelBlue(image,p));
3311 q=PopShortPixel(quantum_info->endian,pixel,q);
3312 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3313 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 for (x=0; x < (ssize_t) number_pixels; x++)
3321 {
3322 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3323 q=PopShortPixel(quantum_info->endian,pixel,q);
3324 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3325 q=PopShortPixel(quantum_info->endian,pixel,q);
3326 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3327 q=PopShortPixel(quantum_info->endian,pixel,q);
3328 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
3329 q=PopShortPixel(quantum_info->endian,pixel,q);
3330 p+=(ptrdiff_t) GetPixelChannels(image);
3331 q+=(ptrdiff_t) quantum_info->pad;
3332 }
3333 break;
3334 }
3335 case 32:
3336 {
3337 unsigned int
3338 pixel;
3339
3340 if (quantum_info->format == FloatingPointQuantumFormat)
3341 {
3342 for (x=0; x < (ssize_t) number_pixels; x++)
3343 {
3344 float
3345 float_pixel;
3346
3347 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
3348 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
3349 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
3350 float_pixel=(float) GetPixelAlpha(image,p);
3351 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
3352 p+=(ptrdiff_t) GetPixelChannels(image);
3353 q+=(ptrdiff_t) quantum_info->pad;
3354 }
3355 break;
3356 }
3357 for (x=0; x < (ssize_t) number_pixels; x++)
3358 {
3359 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3360 q=PopLongPixel(quantum_info->endian,pixel,q);
3361 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3362 q=PopLongPixel(quantum_info->endian,pixel,q);
3363 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3364 q=PopLongPixel(quantum_info->endian,pixel,q);
3365 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
3366 q=PopLongPixel(quantum_info->endian,pixel,q);
3367 p+=(ptrdiff_t) GetPixelChannels(image);
3368 q+=(ptrdiff_t) quantum_info->pad;
3369 }
3370 break;
3371 }
3372 case 64:
3373 {
3374 if (quantum_info->format == FloatingPointQuantumFormat)
3375 {
3376 double
3377 pixel;
3378
3379 for (x=0; x < (ssize_t) number_pixels; x++)
3380 {
3381 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
3382 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
3383 q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
3384 pixel=(double) GetPixelAlpha(image,p);
3385 q=PopQuantumDoublePixel(quantum_info,pixel,q);
3386 p+=(ptrdiff_t) GetPixelChannels(image);
3387 q+=(ptrdiff_t) quantum_info->pad;
3388 }
3389 break;
3390 }
3391 magick_fallthrough;
3392 }
3393 default:
3394 {
3395 range=GetQuantumRange(quantum_info->depth);
3396 for (x=0; x < (ssize_t) number_pixels; x++)
3397 {
3398 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3399 range),q);
3400 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3401 range),q);
3402 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3403 range),q);
3404 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
3405 range),q);
3406 p+=(ptrdiff_t) GetPixelChannels(image);
3407 q+=(ptrdiff_t) quantum_info->pad;
3408 }
3409 break;
3410 }
3411 }
3412}
3413
3414static void ExportRGBOQuantum(const Image *image,QuantumInfo *quantum_info,
3415 const MagickSizeType number_pixels,const Quantum *magick_restrict p,
3416 unsigned char *magick_restrict q)
3417{
3418 QuantumAny
3419 range;
3420
3421 ssize_t
3422 x;
3423
3424 switch (quantum_info->depth)
3425 {
3426 case 8:
3427 {
3428 unsigned char
3429 pixel;
3430
3431 for (x=0; x < (ssize_t) number_pixels; x++)
3432 {
3433 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
3434 q=PopCharPixel(pixel,q);
3435 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
3436 q=PopCharPixel(pixel,q);
3437 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
3438 q=PopCharPixel(pixel,q);
3439 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
3440 q=PopCharPixel(pixel,q);
3441 p+=(ptrdiff_t) GetPixelChannels(image);
3442 q+=(ptrdiff_t) quantum_info->pad;
3443 }
3444 break;
3445 }
3446 case 10:
3447 {
3448 unsigned int
3449 pixel;
3450
3451 range=GetQuantumRange(quantum_info->depth);
3452 if (quantum_info->pack == MagickFalse)
3453 {
3454 ssize_t
3455 i;
3456
3457 size_t
3458 quantum;
3459
3460 ssize_t
3461 n;
3462
3463 n=0;
3464 quantum=0;
3465 pixel=0;
3466 for (x=0; x < (ssize_t) number_pixels; x++)
3467 {
3468 for (i=0; i < 4; i++)
3469 {
3470 switch (i)
3471 {
3472 case 0: quantum=(size_t) GetPixelRed(image,p); break;
3473 case 1: quantum=(size_t) GetPixelGreen(image,p); break;
3474 case 2: quantum=(size_t) GetPixelBlue(image,p); break;
3475 case 3: quantum=(size_t) GetPixelOpacity(image,p); break;
3476 }
3477 switch (n % 3)
3478 {
3479 case 0:
3480 {
3481 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3482 range) << 22);
3483 break;
3484 }
3485 case 1:
3486 {
3487 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3488 range) << 12);
3489 break;
3490 }
3491 case 2:
3492 {
3493 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3494 range) << 2);
3495 q=PopLongPixel(quantum_info->endian,pixel,q);
3496 pixel=0;
3497 break;
3498 }
3499 }
3500 n++;
3501 }
3502 p+=(ptrdiff_t) GetPixelChannels(image);
3503 q+=(ptrdiff_t) quantum_info->pad;
3504 }
3505 break;
3506 }
3507 if (quantum_info->quantum == 32UL)
3508 {
3509 for (x=0; x < (ssize_t) number_pixels; x++)
3510 {
3511 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3512 q=PopQuantumLongPixel(quantum_info,pixel,q);
3513 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3514 range);
3515 q=PopQuantumLongPixel(quantum_info,pixel,q);
3516 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3517 q=PopQuantumLongPixel(quantum_info,pixel,q);
3518 pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),
3519 range);
3520 q=PopQuantumLongPixel(quantum_info,pixel,q);
3521 p+=(ptrdiff_t) GetPixelChannels(image);
3522 q+=(ptrdiff_t) quantum_info->pad;
3523 }
3524 break;
3525 }
3526 for (x=0; x < (ssize_t) number_pixels; x++)
3527 {
3528 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3529 q=PopQuantumPixel(quantum_info,pixel,q);
3530 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3531 q=PopQuantumPixel(quantum_info,pixel,q);
3532 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3533 q=PopQuantumPixel(quantum_info,pixel,q);
3534 pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),range);
3535 q=PopQuantumPixel(quantum_info,pixel,q);
3536 p+=(ptrdiff_t) GetPixelChannels(image);
3537 q+=(ptrdiff_t) quantum_info->pad;
3538 }
3539 break;
3540 }
3541 case 16:
3542 {
3543 unsigned short
3544 pixel;
3545
3546 if (quantum_info->format == FloatingPointQuantumFormat)
3547 {
3548 for (x=0; x < (ssize_t) number_pixels; x++)
3549 {
3550 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3551 GetPixelRed(image,p));
3552 q=PopShortPixel(quantum_info->endian,pixel,q);
3553 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3554 GetPixelGreen(image,p));
3555 q=PopShortPixel(quantum_info->endian,pixel,q);
3556 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3557 GetPixelBlue(image,p));
3558 q=PopShortPixel(quantum_info->endian,pixel,q);
3559 pixel=SinglePrecisionToHalf(QuantumScale*(double)
3560 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 for (x=0; x < (ssize_t) number_pixels; x++)
3568 {
3569 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3570 q=PopShortPixel(quantum_info->endian,pixel,q);
3571 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3572 q=PopShortPixel(quantum_info->endian,pixel,q);
3573 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3574 q=PopShortPixel(quantum_info->endian,pixel,q);
3575 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
3576 q=PopShortPixel(quantum_info->endian,pixel,q);
3577 p+=(ptrdiff_t) GetPixelChannels(image);
3578 q+=(ptrdiff_t) quantum_info->pad;
3579 }
3580 break;
3581 }
3582 case 32:
3583 {
3584 unsigned int
3585 pixel;
3586
3587 if (quantum_info->format == FloatingPointQuantumFormat)
3588 {
3589 for (x=0; x < (ssize_t) number_pixels; x++)
3590 {
3591 float
3592 float_pixel;
3593
3594 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),
3595 q);
3596 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),
3597 q);
3598 q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),
3599 q);
3600 float_pixel=(float) GetPixelOpacity(image,p);
3601 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
3602 p+=(ptrdiff_t) GetPixelChannels(image);
3603 q+=(ptrdiff_t) quantum_info->pad;
3604 }
3605 break;
3606 }
3607 for (x=0; x < (ssize_t) number_pixels; x++)
3608 {
3609 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3610 q=PopLongPixel(quantum_info->endian,pixel,q);
3611 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3612 q=PopLongPixel(quantum_info->endian,pixel,q);
3613 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3614 q=PopLongPixel(quantum_info->endian,pixel,q);
3615 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
3616 q=PopLongPixel(quantum_info->endian,pixel,q);
3617 p+=(ptrdiff_t) GetPixelChannels(image);
3618 q+=(ptrdiff_t) quantum_info->pad;
3619 }
3620 break;
3621 }
3622 case 64:
3623 {
3624 if (quantum_info->format == FloatingPointQuantumFormat)
3625 {
3626 double
3627 pixel;
3628
3629 for (x=0; x < (ssize_t) number_pixels; x++)
3630 {
3631 q=PopQuantumDoublePixel(quantum_info,(double)
3632 GetPixelRed(image,p),q);
3633 q=PopQuantumDoublePixel(quantum_info,(double)
3634 GetPixelGreen(image,p),q);
3635 q=PopQuantumDoublePixel(quantum_info,(double)
3636 GetPixelBlue(image,p),q);
3637 pixel=(double) GetPixelOpacity(image,p);
3638 q=PopQuantumDoublePixel(quantum_info,pixel,q);
3639 p+=(ptrdiff_t) GetPixelChannels(image);
3640 q+=(ptrdiff_t) quantum_info->pad;
3641 }
3642 break;
3643 }
3644 magick_fallthrough;
3645 }
3646 default:
3647 {
3648 range=GetQuantumRange(quantum_info->depth);
3649 for (x=0; x < (ssize_t) number_pixels; x++)
3650 {
3651 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3652 range),q);
3653 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3654 range),q);
3655 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3656 range),q);
3657 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(image,p),
3658 range),q);
3659 p+=(ptrdiff_t) GetPixelChannels(image);
3660 q+=(ptrdiff_t) quantum_info->pad;
3661 }
3662 break;
3663 }
3664 }
3665}
3666
3667MagickExport size_t ExportQuantumPixels(const Image *image,
3668 CacheView *image_view,QuantumInfo *quantum_info,
3669 const QuantumType quantum_type,unsigned char *magick_restrict pixels,
3670 ExceptionInfo *exception)
3671{
3672 const Quantum
3673 *magick_restrict p;
3674
3675 MagickSizeType
3676 number_pixels;
3677
3678 size_t
3679 extent;
3680
3681 ssize_t
3682 x;
3683
3684 unsigned char
3685 *magick_restrict q;
3686
3687 assert(image != (Image *) NULL);
3688 assert(image->signature == MagickCoreSignature);
3689 assert(quantum_info != (QuantumInfo *) NULL);
3690 assert(quantum_info->signature == MagickCoreSignature);
3691 assert(exception != (ExceptionInfo *) NULL);
3692 assert(exception->signature == MagickCoreSignature);
3693 if (IsEventLogging() != MagickFalse)
3694 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3695 if (pixels == (unsigned char *) NULL)
3696 pixels=(unsigned char *) GetQuantumPixels(quantum_info);
3697 if (image_view == (CacheView *) NULL)
3698 {
3699 number_pixels=GetImageExtent(image);
3700 p=GetVirtualPixelQueue(image);
3701 }
3702 else
3703 {
3704 number_pixels=GetCacheViewExtent(image_view);
3705 p=GetCacheViewVirtualPixelQueue(image_view);
3706 }
3707 if (p == (Quantum *) NULL)
3708 return(0);
3709 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
3710 {
3711 double
3712 Sa;
3713
3714 Quantum
3715 *magick_restrict r;
3716
3717 /*
3718 Associate alpha.
3719 */
3720 if (image_view == (CacheView *) NULL)
3721 r=GetAuthenticPixelQueue(image);
3722 else
3723 r=GetCacheViewAuthenticPixelQueue(image_view);
3724 for (x=0; x < (ssize_t) image->columns; x++)
3725 {
3726 ssize_t
3727 i;
3728
3729 Sa=QuantumScale*(double) GetPixelAlpha(image,r);
3730 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
3731 {
3732 PixelChannel channel = GetPixelChannelChannel(image,i);
3733 PixelTrait traits = GetPixelChannelTraits(image,channel);
3734 if ((traits & UpdatePixelTrait) == 0)
3735 continue;
3736 r[i]=ClampToQuantum(Sa*(double) r[i]);
3737 }
3738 r+=(ptrdiff_t) GetPixelChannels(image);
3739 }
3740 }
3741 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3742 {
3743 Quantum
3744 quantum;
3745
3746 Quantum
3747 *magick_restrict r;
3748
3749 if (image_view == (CacheView *) NULL)
3750 r=GetAuthenticPixelQueue(image);
3751 else
3752 r=GetCacheViewAuthenticPixelQueue(image_view);
3753 for (x=0; x < (ssize_t) number_pixels; x++)
3754 {
3755 quantum=GetPixelRed(image,r);
3756 SetPixelRed(image,GetPixelGreen(image,r),r);
3757 SetPixelGreen(image,quantum,r);
3758 r+=(ptrdiff_t) GetPixelChannels(image);
3759 }
3760 }
3761 q=pixels;
3762 ResetQuantumState(quantum_info);
3763 extent=GetQuantumExtent(image,quantum_info,quantum_type);
3764 switch (quantum_type)
3765 {
3766 case AlphaQuantum:
3767 {
3768 ExportAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
3769 break;
3770 }
3771 case BGRQuantum:
3772 {
3773 ExportBGRQuantum(image,quantum_info,number_pixels,p,q);
3774 break;
3775 }
3776 case BGRAQuantum:
3777 {
3778 ExportBGRAQuantum(image,quantum_info,number_pixels,p,q);
3779 break;
3780 }
3781 case BGROQuantum:
3782 {
3783 ExportBGROQuantum(image,quantum_info,number_pixels,p,q);
3784 break;
3785 }
3786 case BlackQuantum:
3787 {
3788 ExportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
3789 break;
3790 }
3791 case BlueQuantum:
3792 case YellowQuantum:
3793 {
3794 ExportPixelChannel(image,quantum_info,number_pixels,p,q,BluePixelChannel);
3795 break;
3796 }
3797 case CMYKQuantum:
3798 {
3799 ExportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
3800 break;
3801 }
3802 case CMYKAQuantum:
3803 {
3804 ExportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
3805 break;
3806 }
3807 case MultispectralQuantum:
3808 {
3809 ExportMultispectralQuantum(image,quantum_info,number_pixels,p,q,exception);
3810 break;
3811 }
3812 case CMYKOQuantum:
3813 {
3814 ExportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
3815 break;
3816 }
3817 case CbYCrYQuantum:
3818 {
3819 ExportCbYCrYQuantum(image,quantum_info,number_pixels,p,q);
3820 break;
3821 }
3822 case GrayQuantum:
3823 {
3824 ExportGrayQuantum(image,quantum_info,number_pixels,p,q);
3825 break;
3826 }
3827 case GrayAlphaQuantum:
3828 {
3829 ExportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q);
3830 break;
3831 }
3832 case GreenQuantum:
3833 case MagentaQuantum:
3834 {
3835 ExportPixelChannel(image,quantum_info,number_pixels,p,q,
3836 GreenPixelChannel);
3837 break;
3838 }
3839 case IndexQuantum:
3840 {
3841 ExportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
3842 break;
3843 }
3844 case IndexAlphaQuantum:
3845 {
3846 ExportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
3847 break;
3848 }
3849 case RedQuantum:
3850 case CyanQuantum:
3851 {
3852 ExportPixelChannel(image,quantum_info,number_pixels,p,q,RedPixelChannel);
3853 break;
3854 }
3855 case OpacityQuantum:
3856 {
3857 ExportOpacityQuantum(image,quantum_info,number_pixels,p,q,exception);
3858 break;
3859 }
3860 case RGBQuantum:
3861 case CbYCrQuantum:
3862 {
3863 ExportRGBQuantum(image,quantum_info,number_pixels,p,q);
3864 break;
3865 }
3866 case RGBAQuantum:
3867 case CbYCrAQuantum:
3868 {
3869 ExportRGBAQuantum(image,quantum_info,number_pixels,p,q);
3870 break;
3871 }
3872 case RGBOQuantum:
3873 {
3874 ExportRGBOQuantum(image,quantum_info,number_pixels,p,q);
3875 break;
3876 }
3877 default:
3878 break;
3879 }
3880 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3881 {
3882 Quantum
3883 quantum;
3884
3885 Quantum
3886 *magick_restrict r;
3887
3888 if (image_view == (CacheView *) NULL)
3889 r=GetAuthenticPixelQueue(image);
3890 else
3891 r=GetCacheViewAuthenticPixelQueue(image_view);
3892 for (x=0; x < (ssize_t) number_pixels; x++)
3893 {
3894 quantum=GetPixelRed(image,r);
3895 SetPixelRed(image,GetPixelGreen(image,r),r);
3896 SetPixelGreen(image,quantum,r);
3897 r+=(ptrdiff_t) GetPixelChannels(image);
3898 }
3899 }
3900 return(extent);
3901}