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