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