MagickCore 7.1.1
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
quantum-import.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% QQQ U U AAA N N TTTTT U U M M %
7% Q Q U U A A NN N T U U MM MM %
8% Q Q U U AAAAA N N N T U U M M M %
9% Q QQ U U A A N NN T U U M M %
10% QQQQ UUU A A N N T UUU M M %
11% %
12% IIIII M M PPPP OOO RRRR TTTTT %
13% I MM MM P P O O R R T %
14% I M M M PPPP O O RRRR T %
15% I M M P O O R R T %
16% IIIII M M P OOO R R T %
17% %
18% MagickCore Methods to Import Quantum Pixels %
19% %
20% Software Design %
21% Cristy %
22% October 1998 %
23% %
24% %
25% Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization %
26% dedicated to making software imaging solutions freely available. %
27% %
28% You may not use this file except in compliance with the License. You may %
29% obtain a copy of the License at %
30% %
31% https://imagemagick.org/script/license.php %
32% %
33% Unless required by applicable law or agreed to in writing, software %
34% distributed under the License is distributed on an "AS IS" BASIS, %
35% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
36% See the License for the specific language governing permissions and %
37% limitations under the License. %
38% %
39%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
40%
41%
42*/
43
44/*
45 Include declarations.
46*/
47#include "MagickCore/studio.h"
48#include "MagickCore/property.h"
49#include "MagickCore/blob.h"
50#include "MagickCore/blob-private.h"
51#include "MagickCore/color-private.h"
52#include "MagickCore/exception.h"
53#include "MagickCore/exception-private.h"
54#include "MagickCore/cache.h"
55#include "MagickCore/constitute.h"
56#include "MagickCore/delegate.h"
57#include "MagickCore/geometry.h"
58#include "MagickCore/list.h"
59#include "MagickCore/magick.h"
60#include "MagickCore/memory_.h"
61#include "MagickCore/monitor.h"
62#include "MagickCore/option.h"
63#include "MagickCore/pixel.h"
64#include "MagickCore/pixel-accessor.h"
65#include "MagickCore/quantum.h"
66#include "MagickCore/quantum-private.h"
67#include "MagickCore/resource_.h"
68#include "MagickCore/semaphore.h"
69#include "MagickCore/statistic.h"
70#include "MagickCore/stream.h"
71#include "MagickCore/string_.h"
72#include "MagickCore/utility.h"
73
74/*
75%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
76% %
77% %
78% %
79% I m p o r t Q u a n t u m P i x e l s %
80% %
81% %
82% %
83%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
84%
85% ImportQuantumPixels() transfers one or more pixel components from a user
86% supplied buffer into the image pixel cache of an image. The pixels are
87% expected in network byte order. It returns MagickTrue if the pixels are
88% successfully transferred, otherwise MagickFalse.
89%
90% The format of the ImportQuantumPixels method is:
91%
92% size_t ImportQuantumPixels(const Image *image,CacheView *image_view,
93% QuantumInfo *quantum_info,const QuantumType quantum_type,
94% const 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 (red, green,
105% blue, opacity, RGB, or RGBA).
106%
107% o pixels: The pixel components are transferred from this buffer.
108%
109% o exception: return any errors or warnings in this structure.
110%
111*/
112
113static inline Quantum PushColormapIndex(const Image *image,const size_t index,
114 MagickBooleanType *range_exception)
115{
116 if (index < image->colors)
117 return((Quantum) index);
118 *range_exception=MagickTrue;
119 return((Quantum) 0);
120}
121
122static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
123 const unsigned char *magick_restrict pixels,double *pixel)
124{
125 double
126 *p;
127
128 unsigned char
129 quantum[8];
130
131 if (quantum_info->endian == LSBEndian)
132 {
133 quantum[0]=(*pixels++);
134 quantum[1]=(*pixels++);
135 quantum[2]=(*pixels++);
136 quantum[3]=(*pixels++);
137 quantum[4]=(*pixels++);
138 quantum[5]=(*pixels++);
139 quantum[6]=(*pixels++);
140 quantum[7]=(*pixels++);
141 }
142 else
143 {
144 quantum[7]=(*pixels++);
145 quantum[6]=(*pixels++);
146 quantum[5]=(*pixels++);
147 quantum[4]=(*pixels++);
148 quantum[3]=(*pixels++);
149 quantum[2]=(*pixels++);
150 quantum[1]=(*pixels++);
151 quantum[0]=(*pixels++);
152 }
153 p=(double *) quantum;
154 *pixel=(*p);
155 *pixel-=quantum_info->minimum;
156 *pixel*=quantum_info->scale;
157 return(pixels);
158}
159
160static inline float ScaleFloatPixel(const QuantumInfo *quantum_info,
161 const unsigned char *quantum)
162{
163 double
164 pixel;
165
166 pixel=(double) (*((float *) quantum));
167 pixel-=quantum_info->minimum;
168 pixel*=quantum_info->scale;
169 if (pixel < (double) -FLT_MAX)
170 return(-FLT_MAX);
171 if (pixel > (double) FLT_MAX)
172 return(FLT_MAX);
173 return(pixel);
174}
175
176static inline const unsigned char *PushQuantumFloatPixel(
177 const QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,
178 float *pixel)
179{
180 unsigned char
181 quantum[4];
182
183 if (quantum_info->endian == LSBEndian)
184 {
185 quantum[0]=(*pixels++);
186 quantum[1]=(*pixels++);
187 quantum[2]=(*pixels++);
188 quantum[3]=(*pixels++);
189 }
190 else
191 {
192 quantum[3]=(*pixels++);
193 quantum[2]=(*pixels++);
194 quantum[1]=(*pixels++);
195 quantum[0]=(*pixels++);
196 }
197 *pixel=ScaleFloatPixel(quantum_info,quantum);
198 return(pixels);
199}
200
201static inline const unsigned char *PushQuantumFloat24Pixel(
202 const QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,
203 float *pixel)
204{
205 unsigned char
206 quantum[4];
207
208 if (quantum_info->endian == LSBEndian)
209 {
210 quantum[0]=(*pixels++);
211 quantum[1]=(*pixels++);
212 quantum[2]=(*pixels++);
213 }
214 else
215 {
216 quantum[2]=(*pixels++);
217 quantum[1]=(*pixels++);
218 quantum[0]=(*pixels++);
219 }
220 if ((quantum[0] | quantum[1] | quantum[2]) == 0U)
221 quantum[3]=0;
222 else
223 {
224 unsigned char
225 exponent,
226 sign_bit;
227
228 sign_bit=(quantum[2] & 0x80);
229 exponent=(quantum[2] & 0x7F);
230 if (exponent != 0)
231 exponent=exponent-63+127;
232 quantum[3]=sign_bit | (exponent >> 1);
233 quantum[2]=((exponent & 1) << 7) | ((quantum[1] & 0xFE) >> 1);
234 quantum[1]=((quantum[1] & 0x01) << 7) | ((quantum[0] & 0xFE) >> 1);
235 quantum[0]=(quantum[0] & 0x01) << 7;
236 }
237 *pixel=ScaleFloatPixel(quantum_info,quantum);
238 return(pixels);
239}
240
241static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,
242 const unsigned char *magick_restrict pixels,unsigned int *quantum)
243{
244 ssize_t
245 i;
246
247 size_t
248 quantum_bits;
249
250 *quantum=(QuantumAny) 0;
251 for (i=(ssize_t) quantum_info->depth; i > 0L; )
252 {
253 if (quantum_info->state.bits == 0UL)
254 {
255 quantum_info->state.pixel=(*pixels++);
256 quantum_info->state.bits=8UL;
257 }
258 quantum_bits=(size_t) i;
259 if (quantum_bits > quantum_info->state.bits)
260 quantum_bits=quantum_info->state.bits;
261 i-=(ssize_t) quantum_bits;
262 quantum_info->state.bits-=quantum_bits;
263 if (quantum_bits < 64)
264 *quantum=(unsigned int) (((MagickSizeType) *quantum << quantum_bits) |
265 ((quantum_info->state.pixel >> quantum_info->state.bits) &~
266 ((~0UL) << quantum_bits)));
267 }
268 return(pixels);
269}
270
271static inline const unsigned char *PushQuantumLongPixel(
272 QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,
273 unsigned int *quantum)
274{
275 ssize_t
276 i;
277
278 size_t
279 quantum_bits;
280
281 *quantum=0UL;
282 for (i=(ssize_t) quantum_info->depth; i > 0; )
283 {
284 if (quantum_info->state.bits == 0)
285 {
286 pixels=PushLongPixel(quantum_info->endian,pixels,
287 &quantum_info->state.pixel);
288 quantum_info->state.bits=32U;
289 }
290 quantum_bits=(size_t) i;
291 if (quantum_bits > quantum_info->state.bits)
292 quantum_bits=quantum_info->state.bits;
293 *quantum|=(((quantum_info->state.pixel >> (32U-quantum_info->state.bits)) &
294 quantum_info->state.mask[quantum_bits]) << ((ssize_t)
295 quantum_info->depth-i));
296 i-=(ssize_t) quantum_bits;
297 quantum_info->state.bits-=quantum_bits;
298 }
299 return(pixels);
300}
301
302static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
303 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
304 Quantum *magick_restrict q)
305{
306 QuantumAny
307 range;
308
309 ssize_t
310 x;
311
312 assert(image != (Image *) NULL);
313 assert(image->signature == MagickCoreSignature);
314 switch (quantum_info->depth)
315 {
316 case 8:
317 {
318 unsigned char
319 pixel;
320
321 for (x=0; x < (ssize_t) number_pixels; x++)
322 {
323 p=PushCharPixel(p,&pixel);
324 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
325 p+=quantum_info->pad;
326 q+=GetPixelChannels(image);
327 }
328 break;
329 }
330 case 16:
331 {
332 unsigned short
333 pixel;
334
335 if (quantum_info->format == FloatingPointQuantumFormat)
336 {
337 for (x=0; x < (ssize_t) number_pixels; x++)
338 {
339 p=PushShortPixel(quantum_info->endian,p,&pixel);
340 SetPixelAlpha(image,ClampToQuantum((double) QuantumRange*(double)
341 HalfToSinglePrecision(pixel)),q);
342 p+=quantum_info->pad;
343 q+=GetPixelChannels(image);
344 }
345 break;
346 }
347 for (x=0; x < (ssize_t) number_pixels; x++)
348 {
349 p=PushShortPixel(quantum_info->endian,p,&pixel);
350 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
351 p+=quantum_info->pad;
352 q+=GetPixelChannels(image);
353 }
354 break;
355 }
356 case 32:
357 {
358 if (quantum_info->format == FloatingPointQuantumFormat)
359 {
360 float
361 pixel;
362
363 for (x=0; x < (ssize_t) number_pixels; x++)
364 {
365 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
366 SetPixelAlpha(image,ClampToQuantum(pixel),q);
367 p+=quantum_info->pad;
368 q+=GetPixelChannels(image);
369 }
370 break;
371 }
372 else
373 {
374 unsigned int
375 pixel;
376
377 for (x=0; x < (ssize_t) number_pixels; x++)
378 {
379 p=PushLongPixel(quantum_info->endian,p,&pixel);
380 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
381 p+=quantum_info->pad;
382 q+=GetPixelChannels(image);
383 }
384 break;
385 }
386 }
387 case 24:
388 {
389 if (quantum_info->format == FloatingPointQuantumFormat)
390 {
391 float
392 pixel;
393
394 for (x=0; x < (ssize_t) number_pixels; x++)
395 {
396 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
397 SetPixelAlpha(image,ClampToQuantum(pixel),q);
398 p+=quantum_info->pad;
399 q+=GetPixelChannels(image);
400 }
401 break;
402 }
403 magick_fallthrough;
404 }
405 case 64:
406 {
407 if (quantum_info->format == FloatingPointQuantumFormat)
408 {
409 double
410 pixel;
411
412 for (x=0; x < (ssize_t) number_pixels; x++)
413 {
414 p=PushDoublePixel(quantum_info,p,&pixel);
415 SetPixelAlpha(image,ClampToQuantum(pixel),q);
416 p+=quantum_info->pad;
417 q+=GetPixelChannels(image);
418 }
419 break;
420 }
421 magick_fallthrough;
422 }
423 default:
424 {
425 unsigned int
426 pixel;
427
428 range=GetQuantumRange(quantum_info->depth);
429 for (x=0; x < (ssize_t) number_pixels; x++)
430 {
431 p=PushQuantumPixel(quantum_info,p,&pixel);
432 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
433 p+=quantum_info->pad;
434 q+=GetPixelChannels(image);
435 }
436 break;
437 }
438 }
439}
440
441static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
442 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
443 Quantum *magick_restrict q)
444{
445 QuantumAny
446 range;
447
448 ssize_t
449 x;
450
451 ssize_t
452 bit;
453
454 assert(image != (Image *) NULL);
455 assert(image->signature == MagickCoreSignature);
456 switch (quantum_info->depth)
457 {
458 case 8:
459 {
460 unsigned char
461 pixel;
462
463 for (x=0; x < (ssize_t) number_pixels; x++)
464 {
465 p=PushCharPixel(p,&pixel);
466 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
467 p=PushCharPixel(p,&pixel);
468 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
469 p=PushCharPixel(p,&pixel);
470 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
471 SetPixelAlpha(image,OpaqueAlpha,q);
472 p+=quantum_info->pad;
473 q+=GetPixelChannels(image);
474 }
475 break;
476 }
477 case 10:
478 {
479 unsigned int
480 pixel;
481
482 range=GetQuantumRange(quantum_info->depth);
483 if (quantum_info->pack == MagickFalse)
484 {
485 for (x=0; x < (ssize_t) number_pixels; x++)
486 {
487 p=PushLongPixel(quantum_info->endian,p,&pixel);
488 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
489 SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
490 q);
491 SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
492 p+=quantum_info->pad;
493 q+=GetPixelChannels(image);
494 }
495 break;
496 }
497 if (quantum_info->quantum == 32U)
498 {
499 for (x=0; x < (ssize_t) number_pixels; x++)
500 {
501 p=PushQuantumLongPixel(quantum_info,p,&pixel);
502 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
503 p=PushQuantumLongPixel(quantum_info,p,&pixel);
504 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
505 p=PushQuantumLongPixel(quantum_info,p,&pixel);
506 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
507 q+=GetPixelChannels(image);
508 }
509 break;
510 }
511 for (x=0; x < (ssize_t) number_pixels; x++)
512 {
513 p=PushQuantumPixel(quantum_info,p,&pixel);
514 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
515 p=PushQuantumPixel(quantum_info,p,&pixel);
516 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
517 p=PushQuantumPixel(quantum_info,p,&pixel);
518 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
519 q+=GetPixelChannels(image);
520 }
521 break;
522 }
523 case 12:
524 {
525 range=GetQuantumRange(quantum_info->depth);
526 if (quantum_info->pack == MagickFalse)
527 {
528 unsigned short
529 pixel;
530
531 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
532 {
533 p=PushShortPixel(quantum_info->endian,p,&pixel);
534 switch (x % 3)
535 {
536 default:
537 case 0:
538 {
539 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
540 range),q);
541 break;
542 }
543 case 1:
544 {
545 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
546 range),q);
547 break;
548 }
549 case 2:
550 {
551 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
552 range),q);
553 q+=GetPixelChannels(image);
554 break;
555 }
556 }
557 p=PushShortPixel(quantum_info->endian,p,&pixel);
558 switch ((x+1) % 3)
559 {
560 default:
561 case 0:
562 {
563 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
564 range),q);
565 break;
566 }
567 case 1:
568 {
569 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
570 range),q);
571 break;
572 }
573 case 2:
574 {
575 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
576 range),q);
577 q+=GetPixelChannels(image);
578 break;
579 }
580 }
581 p+=quantum_info->pad;
582 }
583 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
584 {
585 p=PushShortPixel(quantum_info->endian,p,&pixel);
586 switch ((x+bit) % 3)
587 {
588 default:
589 case 0:
590 {
591 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
592 range),q);
593 break;
594 }
595 case 1:
596 {
597 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
598 range),q);
599 break;
600 }
601 case 2:
602 {
603 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
604 range),q);
605 q+=GetPixelChannels(image);
606 break;
607 }
608 }
609 p+=quantum_info->pad;
610 }
611 if (bit != 0)
612 p++;
613 break;
614 }
615 else
616 {
617 unsigned int
618 pixel;
619
620 if (quantum_info->quantum == 32U)
621 {
622 for (x=0; x < (ssize_t) number_pixels; x++)
623 {
624 p=PushQuantumLongPixel(quantum_info,p,&pixel);
625 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
626 p=PushQuantumLongPixel(quantum_info,p,&pixel);
627 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
628 p=PushQuantumLongPixel(quantum_info,p,&pixel);
629 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
630 q+=GetPixelChannels(image);
631 }
632 break;
633 }
634 for (x=0; x < (ssize_t) number_pixels; x++)
635 {
636 p=PushQuantumPixel(quantum_info,p,&pixel);
637 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
638 p=PushQuantumPixel(quantum_info,p,&pixel);
639 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
640 p=PushQuantumPixel(quantum_info,p,&pixel);
641 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
642 q+=GetPixelChannels(image);
643 }
644 break;
645 }
646 }
647 case 16:
648 {
649 unsigned short
650 pixel;
651
652 if (quantum_info->format == FloatingPointQuantumFormat)
653 {
654 for (x=0; x < (ssize_t) number_pixels; x++)
655 {
656 p=PushShortPixel(quantum_info->endian,p,&pixel);
657 SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)
658 HalfToSinglePrecision(pixel)),q);
659 p=PushShortPixel(quantum_info->endian,p,&pixel);
660 SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)
661 HalfToSinglePrecision(pixel)),q);
662 p=PushShortPixel(quantum_info->endian,p,&pixel);
663 SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)
664 HalfToSinglePrecision(pixel)),q);
665 p+=quantum_info->pad;
666 q+=GetPixelChannels(image);
667 }
668 break;
669 }
670 for (x=0; x < (ssize_t) number_pixels; x++)
671 {
672 p=PushShortPixel(quantum_info->endian,p,&pixel);
673 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
674 p=PushShortPixel(quantum_info->endian,p,&pixel);
675 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
676 p=PushShortPixel(quantum_info->endian,p,&pixel);
677 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
678 p+=quantum_info->pad;
679 q+=GetPixelChannels(image);
680 }
681 break;
682 }
683 case 32:
684 {
685 if (quantum_info->format == FloatingPointQuantumFormat)
686 {
687 float
688 pixel;
689
690 for (x=0; x < (ssize_t) number_pixels; x++)
691 {
692 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
693 SetPixelRed(image,ClampToQuantum(pixel),q);
694 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
695 SetPixelGreen(image,ClampToQuantum(pixel),q);
696 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
697 SetPixelBlue(image,ClampToQuantum(pixel),q);
698 p+=quantum_info->pad;
699 q+=GetPixelChannels(image);
700 }
701 break;
702 }
703 else
704 {
705 unsigned int
706 pixel;
707
708 for (x=0; x < (ssize_t) number_pixels; x++)
709 {
710 p=PushLongPixel(quantum_info->endian,p,&pixel);
711 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
712 p=PushLongPixel(quantum_info->endian,p,&pixel);
713 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
714 p=PushLongPixel(quantum_info->endian,p,&pixel);
715 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
716 p+=quantum_info->pad;
717 q+=GetPixelChannels(image);
718 }
719 break;
720 }
721 }
722 case 24:
723 {
724 if (quantum_info->format == FloatingPointQuantumFormat)
725 {
726 float
727 pixel;
728
729 for (x=0; x < (ssize_t) number_pixels; x++)
730 {
731 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
732 SetPixelRed(image,ClampToQuantum(pixel),q);
733 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
734 SetPixelGreen(image,ClampToQuantum(pixel),q);
735 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
736 SetPixelBlue(image,ClampToQuantum(pixel),q);
737 p+=quantum_info->pad;
738 q+=GetPixelChannels(image);
739 }
740 break;
741 }
742 magick_fallthrough;
743 }
744 case 64:
745 {
746 if (quantum_info->format == FloatingPointQuantumFormat)
747 {
748 double
749 pixel;
750
751 for (x=0; x < (ssize_t) number_pixels; x++)
752 {
753 p=PushDoublePixel(quantum_info,p,&pixel);
754 SetPixelRed(image,ClampToQuantum(pixel),q);
755 p=PushDoublePixel(quantum_info,p,&pixel);
756 SetPixelGreen(image,ClampToQuantum(pixel),q);
757 p=PushDoublePixel(quantum_info,p,&pixel);
758 SetPixelBlue(image,ClampToQuantum(pixel),q);
759 p+=quantum_info->pad;
760 q+=GetPixelChannels(image);
761 }
762 break;
763 }
764 magick_fallthrough;
765 }
766 default:
767 {
768 unsigned int
769 pixel;
770
771 range=GetQuantumRange(quantum_info->depth);
772 for (x=0; x < (ssize_t) number_pixels; x++)
773 {
774 p=PushQuantumPixel(quantum_info,p,&pixel);
775 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
776 p=PushQuantumPixel(quantum_info,p,&pixel);
777 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
778 p=PushQuantumPixel(quantum_info,p,&pixel);
779 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
780 q+=GetPixelChannels(image);
781 }
782 break;
783 }
784 }
785}
786
787static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
788 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
789 Quantum *magick_restrict q)
790{
791 QuantumAny
792 range;
793
794 ssize_t
795 x;
796
797 assert(image != (Image *) NULL);
798 assert(image->signature == MagickCoreSignature);
799 switch (quantum_info->depth)
800 {
801 case 8:
802 {
803 unsigned char
804 pixel;
805
806 for (x=0; x < (ssize_t) number_pixels; x++)
807 {
808 p=PushCharPixel(p,&pixel);
809 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
810 p=PushCharPixel(p,&pixel);
811 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
812 p=PushCharPixel(p,&pixel);
813 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
814 p=PushCharPixel(p,&pixel);
815 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
816 p+=quantum_info->pad;
817 q+=GetPixelChannels(image);
818 }
819 break;
820 }
821 case 10:
822 {
823 unsigned int
824 pixel;
825
826 pixel=0;
827 if (quantum_info->pack == MagickFalse)
828 {
829 ssize_t
830 i;
831
832 size_t
833 quantum;
834
835 ssize_t
836 n;
837
838 n=0;
839 quantum=0;
840 for (x=0; x < (ssize_t) number_pixels; x++)
841 {
842 for (i=0; i < 4; i++)
843 {
844 switch (n % 3)
845 {
846 case 0:
847 {
848 p=PushLongPixel(quantum_info->endian,p,&pixel);
849 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
850 (((pixel >> 22) & 0x3ff) << 6)));
851 break;
852 }
853 case 1:
854 {
855 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
856 (((pixel >> 12) & 0x3ff) << 6)));
857 break;
858 }
859 case 2:
860 {
861 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
862 (((pixel >> 2) & 0x3ff) << 6)));
863 break;
864 }
865 }
866 switch (i)
867 {
868 case 0: SetPixelRed(image,(Quantum) quantum,q); break;
869 case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
870 case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
871 case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
872 }
873 n++;
874 }
875 p+=quantum_info->pad;
876 q+=GetPixelChannels(image);
877 }
878 break;
879 }
880 for (x=0; x < (ssize_t) number_pixels; x++)
881 {
882 p=PushQuantumPixel(quantum_info,p,&pixel);
883 SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
884 p=PushQuantumPixel(quantum_info,p,&pixel);
885 SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
886 q);
887 p=PushQuantumPixel(quantum_info,p,&pixel);
888 SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
889 q);
890 p=PushQuantumPixel(quantum_info,p,&pixel);
891 SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
892 q);
893 q+=GetPixelChannels(image);
894 }
895 break;
896 }
897 case 16:
898 {
899 unsigned short
900 pixel;
901
902 if (quantum_info->format == FloatingPointQuantumFormat)
903 {
904 for (x=0; x < (ssize_t) number_pixels; x++)
905 {
906 p=PushShortPixel(quantum_info->endian,p,&pixel);
907 SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)
908 HalfToSinglePrecision(pixel)),q);
909 p=PushShortPixel(quantum_info->endian,p,&pixel);
910 SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)
911 HalfToSinglePrecision(pixel)),q);
912 p=PushShortPixel(quantum_info->endian,p,&pixel);
913 SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)
914 HalfToSinglePrecision(pixel)),q);
915 p=PushShortPixel(quantum_info->endian,p,&pixel);
916 SetPixelAlpha(image,ClampToQuantum((double) QuantumRange*(double)
917 HalfToSinglePrecision(pixel)),q);
918 p+=quantum_info->pad;
919 q+=GetPixelChannels(image);
920 }
921 break;
922 }
923 for (x=0; x < (ssize_t) number_pixels; x++)
924 {
925 p=PushShortPixel(quantum_info->endian,p,&pixel);
926 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
927 p=PushShortPixel(quantum_info->endian,p,&pixel);
928 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
929 p=PushShortPixel(quantum_info->endian,p,&pixel);
930 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
931 p=PushShortPixel(quantum_info->endian,p,&pixel);
932 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
933 p+=quantum_info->pad;
934 q+=GetPixelChannels(image);
935 }
936 break;
937 }
938 case 32:
939 {
940 if (quantum_info->format == FloatingPointQuantumFormat)
941 {
942 float
943 pixel;
944
945 for (x=0; x < (ssize_t) number_pixels; x++)
946 {
947 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
948 SetPixelRed(image,ClampToQuantum(pixel),q);
949 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
950 SetPixelGreen(image,ClampToQuantum(pixel),q);
951 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
952 SetPixelBlue(image,ClampToQuantum(pixel),q);
953 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
954 SetPixelAlpha(image,ClampToQuantum(pixel),q);
955 p+=quantum_info->pad;
956 q+=GetPixelChannels(image);
957 }
958 break;
959 }
960 else
961 {
962 unsigned int
963 pixel;
964
965 for (x=0; x < (ssize_t) number_pixels; x++)
966 {
967 p=PushLongPixel(quantum_info->endian,p,&pixel);
968 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
969 p=PushLongPixel(quantum_info->endian,p,&pixel);
970 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
971 p=PushLongPixel(quantum_info->endian,p,&pixel);
972 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
973 p=PushLongPixel(quantum_info->endian,p,&pixel);
974 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
975 p+=quantum_info->pad;
976 q+=GetPixelChannels(image);
977 }
978 break;
979 }
980 }
981 case 24:
982 {
983 if (quantum_info->format == FloatingPointQuantumFormat)
984 {
985 float
986 pixel;
987
988 for (x=0; x < (ssize_t) number_pixels; x++)
989 {
990 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
991 SetPixelRed(image,ClampToQuantum(pixel),q);
992 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
993 SetPixelGreen(image,ClampToQuantum(pixel),q);
994 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
995 SetPixelBlue(image,ClampToQuantum(pixel),q);
996 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
997 SetPixelAlpha(image,ClampToQuantum(pixel),q);
998 p+=quantum_info->pad;
999 q+=GetPixelChannels(image);
1000 }
1001 break;
1002 }
1003 magick_fallthrough;
1004 }
1005 case 64:
1006 {
1007 if (quantum_info->format == FloatingPointQuantumFormat)
1008 {
1009 double
1010 pixel;
1011
1012 for (x=0; x < (ssize_t) number_pixels; x++)
1013 {
1014 p=PushDoublePixel(quantum_info,p,&pixel);
1015 SetPixelRed(image,ClampToQuantum(pixel),q);
1016 p=PushDoublePixel(quantum_info,p,&pixel);
1017 SetPixelGreen(image,ClampToQuantum(pixel),q);
1018 p=PushDoublePixel(quantum_info,p,&pixel);
1019 SetPixelBlue(image,ClampToQuantum(pixel),q);
1020 p=PushDoublePixel(quantum_info,p,&pixel);
1021 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1022 p+=quantum_info->pad;
1023 q+=GetPixelChannels(image);
1024 }
1025 break;
1026 }
1027 magick_fallthrough;
1028 }
1029 default:
1030 {
1031 unsigned int
1032 pixel;
1033
1034 range=GetQuantumRange(quantum_info->depth);
1035 for (x=0; x < (ssize_t) number_pixels; x++)
1036 {
1037 p=PushQuantumPixel(quantum_info,p,&pixel);
1038 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1039 p=PushQuantumPixel(quantum_info,p,&pixel);
1040 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1041 p=PushQuantumPixel(quantum_info,p,&pixel);
1042 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1043 p=PushQuantumPixel(quantum_info,p,&pixel);
1044 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
1045 q+=GetPixelChannels(image);
1046 }
1047 break;
1048 }
1049 }
1050}
1051
1052static void ImportBGROQuantum(const Image *image,QuantumInfo *quantum_info,
1053 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1054 Quantum *magick_restrict q)
1055{
1056 QuantumAny
1057 range;
1058
1059 ssize_t
1060 x;
1061
1062 assert(image != (Image *) NULL);
1063 assert(image->signature == MagickCoreSignature);
1064 switch (quantum_info->depth)
1065 {
1066 case 8:
1067 {
1068 unsigned char
1069 pixel;
1070
1071 for (x=0; x < (ssize_t) number_pixels; x++)
1072 {
1073 p=PushCharPixel(p,&pixel);
1074 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1075 p=PushCharPixel(p,&pixel);
1076 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1077 p=PushCharPixel(p,&pixel);
1078 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1079 p=PushCharPixel(p,&pixel);
1080 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
1081 p+=quantum_info->pad;
1082 q+=GetPixelChannels(image);
1083 }
1084 break;
1085 }
1086 case 10:
1087 {
1088 unsigned int
1089 pixel;
1090
1091 pixel=0;
1092 if (quantum_info->pack == MagickFalse)
1093 {
1094 ssize_t
1095 i;
1096
1097 size_t
1098 quantum;
1099
1100 ssize_t
1101 n;
1102
1103 n=0;
1104 quantum=0;
1105 for (x=0; x < (ssize_t) number_pixels; x++)
1106 {
1107 for (i=0; i < 4; i++)
1108 {
1109 switch (n % 3)
1110 {
1111 case 0:
1112 {
1113 p=PushLongPixel(quantum_info->endian,p,&pixel);
1114 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1115 (((pixel >> 22) & 0x3ff) << 6)));
1116 break;
1117 }
1118 case 1:
1119 {
1120 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1121 (((pixel >> 12) & 0x3ff) << 6)));
1122 break;
1123 }
1124 case 2:
1125 {
1126 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1127 (((pixel >> 2) & 0x3ff) << 6)));
1128 break;
1129 }
1130 }
1131 switch (i)
1132 {
1133 case 0: SetPixelRed(image,(Quantum) quantum,q); break;
1134 case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
1135 case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
1136 case 3: SetPixelOpacity(image,(Quantum) quantum,q); break;
1137 }
1138 n++;
1139 }
1140 p+=quantum_info->pad;
1141 q+=GetPixelChannels(image);
1142 }
1143 break;
1144 }
1145 for (x=0; x < (ssize_t) number_pixels; x++)
1146 {
1147 p=PushQuantumPixel(quantum_info,p,&pixel);
1148 SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
1149 p=PushQuantumPixel(quantum_info,p,&pixel);
1150 SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
1151 q);
1152 p=PushQuantumPixel(quantum_info,p,&pixel);
1153 SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
1154 q);
1155 p=PushQuantumPixel(quantum_info,p,&pixel);
1156 SetPixelOpacity(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
1157 q);
1158 q+=GetPixelChannels(image);
1159 }
1160 break;
1161 }
1162 case 16:
1163 {
1164 unsigned short
1165 pixel;
1166
1167 if (quantum_info->format == FloatingPointQuantumFormat)
1168 {
1169 for (x=0; x < (ssize_t) number_pixels; x++)
1170 {
1171 p=PushShortPixel(quantum_info->endian,p,&pixel);
1172 SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)
1173 HalfToSinglePrecision(pixel)),q);
1174 p=PushShortPixel(quantum_info->endian,p,&pixel);
1175 SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)
1176 HalfToSinglePrecision(pixel)),q);
1177 p=PushShortPixel(quantum_info->endian,p,&pixel);
1178 SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)
1179 HalfToSinglePrecision(pixel)),q);
1180 p=PushShortPixel(quantum_info->endian,p,&pixel);
1181 SetPixelOpacity(image,ClampToQuantum((double) QuantumRange*(double)
1182 HalfToSinglePrecision(pixel)),q);
1183 p+=quantum_info->pad;
1184 q+=GetPixelChannels(image);
1185 }
1186 break;
1187 }
1188 for (x=0; x < (ssize_t) number_pixels; x++)
1189 {
1190 p=PushShortPixel(quantum_info->endian,p,&pixel);
1191 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1192 p=PushShortPixel(quantum_info->endian,p,&pixel);
1193 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1194 p=PushShortPixel(quantum_info->endian,p,&pixel);
1195 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1196 p=PushShortPixel(quantum_info->endian,p,&pixel);
1197 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
1198 p+=quantum_info->pad;
1199 q+=GetPixelChannels(image);
1200 }
1201 break;
1202 }
1203 case 32:
1204 {
1205 if (quantum_info->format == FloatingPointQuantumFormat)
1206 {
1207 float
1208 pixel;
1209
1210 for (x=0; x < (ssize_t) number_pixels; x++)
1211 {
1212 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1213 SetPixelRed(image,ClampToQuantum(pixel),q);
1214 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1215 SetPixelGreen(image,ClampToQuantum(pixel),q);
1216 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1217 SetPixelBlue(image,ClampToQuantum(pixel),q);
1218 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1219 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1220 p+=quantum_info->pad;
1221 q+=GetPixelChannels(image);
1222 }
1223 break;
1224 }
1225 else
1226 {
1227 unsigned int
1228 pixel;
1229
1230 for (x=0; x < (ssize_t) number_pixels; x++)
1231 {
1232 p=PushLongPixel(quantum_info->endian,p,&pixel);
1233 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1234 p=PushLongPixel(quantum_info->endian,p,&pixel);
1235 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1236 p=PushLongPixel(quantum_info->endian,p,&pixel);
1237 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1238 p=PushLongPixel(quantum_info->endian,p,&pixel);
1239 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
1240 p+=quantum_info->pad;
1241 q+=GetPixelChannels(image);
1242 }
1243 }
1244 break;
1245 }
1246 case 24:
1247 {
1248 if (quantum_info->format == FloatingPointQuantumFormat)
1249 {
1250 float
1251 pixel;
1252
1253 for (x=0; x < (ssize_t) number_pixels; x++)
1254 {
1255 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1256 SetPixelRed(image,ClampToQuantum(pixel),q);
1257 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1258 SetPixelGreen(image,ClampToQuantum(pixel),q);
1259 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1260 SetPixelBlue(image,ClampToQuantum(pixel),q);
1261 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1262 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1263 p+=quantum_info->pad;
1264 q+=GetPixelChannels(image);
1265 }
1266 break;
1267 }
1268 magick_fallthrough;
1269 }
1270 case 64:
1271 {
1272 if (quantum_info->format == FloatingPointQuantumFormat)
1273 {
1274 double
1275 pixel;
1276
1277 for (x=0; x < (ssize_t) number_pixels; x++)
1278 {
1279 p=PushDoublePixel(quantum_info,p,&pixel);
1280 SetPixelRed(image,ClampToQuantum(pixel),q);
1281 p=PushDoublePixel(quantum_info,p,&pixel);
1282 SetPixelGreen(image,ClampToQuantum(pixel),q);
1283 p=PushDoublePixel(quantum_info,p,&pixel);
1284 SetPixelBlue(image,ClampToQuantum(pixel),q);
1285 p=PushDoublePixel(quantum_info,p,&pixel);
1286 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1287 p+=quantum_info->pad;
1288 q+=GetPixelChannels(image);
1289 }
1290 break;
1291 }
1292 magick_fallthrough;
1293 }
1294 default:
1295 {
1296 unsigned int
1297 pixel;
1298
1299 range=GetQuantumRange(quantum_info->depth);
1300 for (x=0; x < (ssize_t) number_pixels; x++)
1301 {
1302 p=PushQuantumPixel(quantum_info,p,&pixel);
1303 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1304 p=PushQuantumPixel(quantum_info,p,&pixel);
1305 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1306 p=PushQuantumPixel(quantum_info,p,&pixel);
1307 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1308 p=PushQuantumPixel(quantum_info,p,&pixel);
1309 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
1310 q+=GetPixelChannels(image);
1311 }
1312 break;
1313 }
1314 }
1315}
1316
1317static void ImportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
1318 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1319 Quantum *magick_restrict q,ExceptionInfo *exception)
1320{
1321 QuantumAny
1322 range;
1323
1324 ssize_t
1325 x;
1326
1327 if (image->colorspace != CMYKColorspace)
1328 {
1329 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1330 "ColorSeparatedImageRequired","`%s'",image->filename);
1331 return;
1332 }
1333 switch (quantum_info->depth)
1334 {
1335 case 8:
1336 {
1337 unsigned char
1338 pixel;
1339
1340 for (x=0; x < (ssize_t) number_pixels; x++)
1341 {
1342 p=PushCharPixel(p,&pixel);
1343 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1344 p+=quantum_info->pad;
1345 q+=GetPixelChannels(image);
1346 }
1347 break;
1348 }
1349 case 16:
1350 {
1351 unsigned short
1352 pixel;
1353
1354 if (quantum_info->format == FloatingPointQuantumFormat)
1355 {
1356 for (x=0; x < (ssize_t) number_pixels; x++)
1357 {
1358 p=PushShortPixel(quantum_info->endian,p,&pixel);
1359 SetPixelBlack(image,ClampToQuantum((double) QuantumRange*(double)
1360 HalfToSinglePrecision(pixel)),q);
1361 p+=quantum_info->pad;
1362 q+=GetPixelChannels(image);
1363 }
1364 break;
1365 }
1366 for (x=0; x < (ssize_t) number_pixels; x++)
1367 {
1368 p=PushShortPixel(quantum_info->endian,p,&pixel);
1369 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1370 p+=quantum_info->pad;
1371 q+=GetPixelChannels(image);
1372 }
1373 break;
1374 }
1375 case 32:
1376 {
1377 if (quantum_info->format == FloatingPointQuantumFormat)
1378 {
1379 float
1380 pixel;
1381
1382 for (x=0; x < (ssize_t) number_pixels; x++)
1383 {
1384 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1385 SetPixelBlack(image,ClampToQuantum(pixel),q);
1386 p+=quantum_info->pad;
1387 q+=GetPixelChannels(image);
1388 }
1389 break;
1390 }
1391 else
1392 {
1393 unsigned int
1394 pixel;
1395
1396 for (x=0; x < (ssize_t) number_pixels; x++)
1397 {
1398 p=PushLongPixel(quantum_info->endian,p,&pixel);
1399 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1400 p+=quantum_info->pad;
1401 q+=GetPixelChannels(image);
1402 }
1403 break;
1404 }
1405 }
1406 case 24:
1407 {
1408 if (quantum_info->format == FloatingPointQuantumFormat)
1409 {
1410 float
1411 pixel;
1412
1413 for (x=0; x < (ssize_t) number_pixels; x++)
1414 {
1415 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1416 SetPixelBlack(image,ClampToQuantum(pixel),q);
1417 p+=quantum_info->pad;
1418 q+=GetPixelChannels(image);
1419 }
1420 break;
1421 }
1422 magick_fallthrough;
1423 }
1424 case 64:
1425 {
1426 if (quantum_info->format == FloatingPointQuantumFormat)
1427 {
1428 double
1429 pixel;
1430
1431 for (x=0; x < (ssize_t) number_pixels; x++)
1432 {
1433 p=PushDoublePixel(quantum_info,p,&pixel);
1434 SetPixelBlack(image,ClampToQuantum(pixel),q);
1435 p+=quantum_info->pad;
1436 q+=GetPixelChannels(image);
1437 }
1438 break;
1439 }
1440 magick_fallthrough;
1441 }
1442 default:
1443 {
1444 unsigned int
1445 pixel;
1446
1447 range=GetQuantumRange(quantum_info->depth);
1448 for (x=0; x < (ssize_t) number_pixels; x++)
1449 {
1450 p=PushQuantumPixel(quantum_info,p,&pixel);
1451 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
1452 p+=quantum_info->pad;
1453 q+=GetPixelChannels(image);
1454 }
1455 break;
1456 }
1457 }
1458}
1459
1460static void ImportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
1461 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1462 Quantum *magick_restrict q)
1463{
1464 QuantumAny
1465 range;
1466
1467 ssize_t
1468 x;
1469
1470 assert(image != (Image *) NULL);
1471 assert(image->signature == MagickCoreSignature);
1472 switch (quantum_info->depth)
1473 {
1474 case 8:
1475 {
1476 unsigned char
1477 pixel;
1478
1479 for (x=0; x < (ssize_t) number_pixels; x++)
1480 {
1481 p=PushCharPixel(p,&pixel);
1482 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1483 p+=quantum_info->pad;
1484 q+=GetPixelChannels(image);
1485 }
1486 break;
1487 }
1488 case 16:
1489 {
1490 unsigned short
1491 pixel;
1492
1493 if (quantum_info->format == FloatingPointQuantumFormat)
1494 {
1495 for (x=0; x < (ssize_t) number_pixels; x++)
1496 {
1497 p=PushShortPixel(quantum_info->endian,p,&pixel);
1498 SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)
1499 HalfToSinglePrecision(pixel)),q);
1500 p+=quantum_info->pad;
1501 q+=GetPixelChannels(image);
1502 }
1503 break;
1504 }
1505 for (x=0; x < (ssize_t) number_pixels; x++)
1506 {
1507 p=PushShortPixel(quantum_info->endian,p,&pixel);
1508 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1509 p+=quantum_info->pad;
1510 q+=GetPixelChannels(image);
1511 }
1512 break;
1513 }
1514 case 32:
1515 {
1516 if (quantum_info->format == FloatingPointQuantumFormat)
1517 {
1518 float
1519 pixel;
1520
1521 for (x=0; x < (ssize_t) number_pixels; x++)
1522 {
1523 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1524 SetPixelBlue(image,ClampToQuantum(pixel),q);
1525 p+=quantum_info->pad;
1526 q+=GetPixelChannels(image);
1527 }
1528 break;
1529 }
1530 else
1531 {
1532 unsigned int
1533 pixel;
1534
1535 for (x=0; x < (ssize_t) number_pixels; x++)
1536 {
1537 p=PushLongPixel(quantum_info->endian,p,&pixel);
1538 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1539 p+=quantum_info->pad;
1540 q+=GetPixelChannels(image);
1541 }
1542 break;
1543 }
1544 }
1545 case 24:
1546 {
1547 if (quantum_info->format == FloatingPointQuantumFormat)
1548 {
1549 float
1550 pixel;
1551
1552 for (x=0; x < (ssize_t) number_pixels; x++)
1553 {
1554 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1555 SetPixelBlue(image,ClampToQuantum(pixel),q);
1556 p+=quantum_info->pad;
1557 q+=GetPixelChannels(image);
1558 }
1559 break;
1560 }
1561 magick_fallthrough;
1562 }
1563 case 64:
1564 {
1565 if (quantum_info->format == FloatingPointQuantumFormat)
1566 {
1567 double
1568 pixel;
1569
1570 for (x=0; x < (ssize_t) number_pixels; x++)
1571 {
1572 p=PushDoublePixel(quantum_info,p,&pixel);
1573 SetPixelBlue(image,ClampToQuantum(pixel),q);
1574 p+=quantum_info->pad;
1575 q+=GetPixelChannels(image);
1576 }
1577 break;
1578 }
1579 magick_fallthrough;
1580 }
1581 default:
1582 {
1583 unsigned int
1584 pixel;
1585
1586 range=GetQuantumRange(quantum_info->depth);
1587 for (x=0; x < (ssize_t) number_pixels; x++)
1588 {
1589 p=PushQuantumPixel(quantum_info,p,&pixel);
1590 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1591 p+=quantum_info->pad;
1592 q+=GetPixelChannels(image);
1593 }
1594 break;
1595 }
1596 }
1597}
1598
1599static void ImportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
1600 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1601 Quantum *magick_restrict q)
1602{
1603 QuantumAny
1604 range;
1605
1606 ssize_t
1607 x;
1608
1609 unsigned int
1610 pixel;
1611
1612 assert(image != (Image *) NULL);
1613 assert(image->signature == MagickCoreSignature);
1614 switch (quantum_info->depth)
1615 {
1616 case 10:
1617 {
1618 Quantum
1619 cbcr[4];
1620
1621 pixel=0;
1622 if (quantum_info->pack == MagickFalse)
1623 {
1624 ssize_t
1625 i;
1626
1627 size_t
1628 quantum;
1629
1630 ssize_t
1631 n;
1632
1633 n=0;
1634 quantum=0;
1635 for (x=0; x < (ssize_t) (number_pixels-3); x+=4)
1636 {
1637 for (i=0; i < 4; i++)
1638 {
1639 switch (n % 3)
1640 {
1641 case 0:
1642 {
1643 p=PushLongPixel(quantum_info->endian,p,&pixel);
1644 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1645 (((pixel >> 22) & 0x3ff) << 6)));
1646 break;
1647 }
1648 case 1:
1649 {
1650 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1651 (((pixel >> 12) & 0x3ff) << 6)));
1652 break;
1653 }
1654 case 2:
1655 {
1656 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1657 (((pixel >> 2) & 0x3ff) << 6)));
1658 break;
1659 }
1660 }
1661 cbcr[i]=(Quantum) (quantum);
1662 n++;
1663 }
1664 p+=quantum_info->pad;
1665 SetPixelRed(image,cbcr[1],q);
1666 SetPixelGreen(image,cbcr[0],q);
1667 SetPixelBlue(image,cbcr[2],q);
1668 q+=GetPixelChannels(image);
1669 SetPixelRed(image,cbcr[3],q);
1670 SetPixelGreen(image,cbcr[0],q);
1671 SetPixelBlue(image,cbcr[2],q);
1672 q+=GetPixelChannels(image);
1673 }
1674 break;
1675 }
1676 magick_fallthrough;
1677 }
1678 default:
1679 {
1680 range=GetQuantumRange(quantum_info->depth);
1681 for (x=0; x < (ssize_t) number_pixels; x++)
1682 {
1683 p=PushQuantumPixel(quantum_info,p,&pixel);
1684 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1685 p=PushQuantumPixel(quantum_info,p,&pixel);
1686 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1687 q+=GetPixelChannels(image);
1688 }
1689 break;
1690 }
1691 }
1692}
1693
1694static void ImportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
1695 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1696 Quantum *magick_restrict q,ExceptionInfo *exception)
1697{
1698 QuantumAny
1699 range;
1700
1701 ssize_t
1702 x;
1703
1704 if (image->colorspace != CMYKColorspace)
1705 {
1706 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1707 "ColorSeparatedImageRequired","`%s'",image->filename);
1708 return;
1709 }
1710 switch (quantum_info->depth)
1711 {
1712 case 8:
1713 {
1714 unsigned char
1715 pixel;
1716
1717 for (x=0; x < (ssize_t) number_pixels; x++)
1718 {
1719 p=PushCharPixel(p,&pixel);
1720 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1721 p=PushCharPixel(p,&pixel);
1722 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1723 p=PushCharPixel(p,&pixel);
1724 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1725 p=PushCharPixel(p,&pixel);
1726 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1727 p+=quantum_info->pad;
1728 q+=GetPixelChannels(image);
1729 }
1730 break;
1731 }
1732 case 16:
1733 {
1734 unsigned short
1735 pixel;
1736
1737 if (quantum_info->format == FloatingPointQuantumFormat)
1738 {
1739 for (x=0; x < (ssize_t) number_pixels; x++)
1740 {
1741 p=PushShortPixel(quantum_info->endian,p,&pixel);
1742 SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)
1743 HalfToSinglePrecision(pixel)),q);
1744 p=PushShortPixel(quantum_info->endian,p,&pixel);
1745 SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)
1746 HalfToSinglePrecision(pixel)),q);
1747 p=PushShortPixel(quantum_info->endian,p,&pixel);
1748 SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)
1749 HalfToSinglePrecision(pixel)),q);
1750 p=PushShortPixel(quantum_info->endian,p,&pixel);
1751 SetPixelBlack(image,ClampToQuantum((double) QuantumRange*(double)
1752 HalfToSinglePrecision(pixel)),q);
1753 p+=quantum_info->pad;
1754 q+=GetPixelChannels(image);
1755 }
1756 break;
1757 }
1758 for (x=0; x < (ssize_t) number_pixels; x++)
1759 {
1760 p=PushShortPixel(quantum_info->endian,p,&pixel);
1761 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1762 p=PushShortPixel(quantum_info->endian,p,&pixel);
1763 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1764 p=PushShortPixel(quantum_info->endian,p,&pixel);
1765 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1766 p=PushShortPixel(quantum_info->endian,p,&pixel);
1767 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1768 p+=quantum_info->pad;
1769 q+=GetPixelChannels(image);
1770 }
1771 break;
1772 }
1773 case 32:
1774 {
1775 if (quantum_info->format == FloatingPointQuantumFormat)
1776 {
1777 float
1778 pixel;
1779
1780 for (x=0; x < (ssize_t) number_pixels; x++)
1781 {
1782 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1783 SetPixelRed(image,ClampToQuantum(pixel),q);
1784 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1785 SetPixelGreen(image,ClampToQuantum(pixel),q);
1786 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1787 SetPixelBlue(image,ClampToQuantum(pixel),q);
1788 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1789 SetPixelBlack(image,ClampToQuantum(pixel),q);
1790 p+=quantum_info->pad;
1791 q+=GetPixelChannels(image);
1792 }
1793 break;
1794 }
1795 else
1796 {
1797 unsigned int
1798 pixel;
1799
1800 for (x=0; x < (ssize_t) number_pixels; x++)
1801 {
1802 p=PushLongPixel(quantum_info->endian,p,&pixel);
1803 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1804 p=PushLongPixel(quantum_info->endian,p,&pixel);
1805 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1806 p=PushLongPixel(quantum_info->endian,p,&pixel);
1807 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1808 p=PushLongPixel(quantum_info->endian,p,&pixel);
1809 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1810 p+=quantum_info->pad;
1811 q+=GetPixelChannels(image);
1812 }
1813 break;
1814 }
1815 }
1816 case 24:
1817 {
1818 if (quantum_info->format == FloatingPointQuantumFormat)
1819 {
1820 float
1821 pixel;
1822
1823 for (x=0; x < (ssize_t) number_pixels; x++)
1824 {
1825 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1826 SetPixelRed(image,ClampToQuantum(pixel),q);
1827 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1828 SetPixelGreen(image,ClampToQuantum(pixel),q);
1829 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1830 SetPixelBlue(image,ClampToQuantum(pixel),q);
1831 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1832 SetPixelBlack(image,ClampToQuantum(pixel),q);
1833 p+=quantum_info->pad;
1834 q+=GetPixelChannels(image);
1835 }
1836 break;
1837 }
1838 magick_fallthrough;
1839 }
1840 case 64:
1841 {
1842 if (quantum_info->format == FloatingPointQuantumFormat)
1843 {
1844 double
1845 pixel;
1846
1847 for (x=0; x < (ssize_t) number_pixels; x++)
1848 {
1849 p=PushDoublePixel(quantum_info,p,&pixel);
1850 SetPixelRed(image,ClampToQuantum(pixel),q);
1851 p=PushDoublePixel(quantum_info,p,&pixel);
1852 SetPixelGreen(image,ClampToQuantum(pixel),q);
1853 p=PushDoublePixel(quantum_info,p,&pixel);
1854 SetPixelBlue(image,ClampToQuantum(pixel),q);
1855 p=PushDoublePixel(quantum_info,p,&pixel);
1856 SetPixelBlack(image,ClampToQuantum(pixel),q);
1857 p+=quantum_info->pad;
1858 q+=GetPixelChannels(image);
1859 }
1860 break;
1861 }
1862 magick_fallthrough;
1863 }
1864 default:
1865 {
1866 unsigned int
1867 pixel;
1868
1869 range=GetQuantumRange(quantum_info->depth);
1870 for (x=0; x < (ssize_t) number_pixels; x++)
1871 {
1872 p=PushQuantumPixel(quantum_info,p,&pixel);
1873 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1874 p=PushQuantumPixel(quantum_info,p,&pixel);
1875 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1876 p=PushQuantumPixel(quantum_info,p,&pixel);
1877 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1878 p=PushQuantumPixel(quantum_info,p,&pixel);
1879 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
1880 q+=GetPixelChannels(image);
1881 }
1882 break;
1883 }
1884 }
1885}
1886
1887static void ImportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
1888 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1889 Quantum *magick_restrict q,ExceptionInfo *exception)
1890{
1891 QuantumAny
1892 range;
1893
1894 ssize_t
1895 x;
1896
1897 if (image->colorspace != CMYKColorspace)
1898 {
1899 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1900 "ColorSeparatedImageRequired","`%s'",image->filename);
1901 return;
1902 }
1903 switch (quantum_info->depth)
1904 {
1905 case 8:
1906 {
1907 unsigned char
1908 pixel;
1909
1910 for (x=0; x < (ssize_t) number_pixels; x++)
1911 {
1912 p=PushCharPixel(p,&pixel);
1913 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1914 p=PushCharPixel(p,&pixel);
1915 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1916 p=PushCharPixel(p,&pixel);
1917 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1918 p=PushCharPixel(p,&pixel);
1919 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1920 p=PushCharPixel(p,&pixel);
1921 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
1922 p+=quantum_info->pad;
1923 q+=GetPixelChannels(image);
1924 }
1925 break;
1926 }
1927 case 16:
1928 {
1929 unsigned short
1930 pixel;
1931
1932 if (quantum_info->format == FloatingPointQuantumFormat)
1933 {
1934 for (x=0; x < (ssize_t) number_pixels; x++)
1935 {
1936 p=PushShortPixel(quantum_info->endian,p,&pixel);
1937 SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)
1938 HalfToSinglePrecision(pixel)),q);
1939 p=PushShortPixel(quantum_info->endian,p,&pixel);
1940 SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)
1941 HalfToSinglePrecision(pixel)),q);
1942 p=PushShortPixel(quantum_info->endian,p,&pixel);
1943 SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)
1944 HalfToSinglePrecision(pixel)),q);
1945 p=PushShortPixel(quantum_info->endian,p,&pixel);
1946 SetPixelBlack(image,ClampToQuantum((double) QuantumRange*(double)
1947 HalfToSinglePrecision(pixel)),q);
1948 p=PushShortPixel(quantum_info->endian,p,&pixel);
1949 SetPixelAlpha(image,ClampToQuantum((double) QuantumRange*(double)
1950 HalfToSinglePrecision(pixel)),q);
1951 p+=quantum_info->pad;
1952 q+=GetPixelChannels(image);
1953 }
1954 break;
1955 }
1956 for (x=0; x < (ssize_t) number_pixels; x++)
1957 {
1958 p=PushShortPixel(quantum_info->endian,p,&pixel);
1959 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1960 p=PushShortPixel(quantum_info->endian,p,&pixel);
1961 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1962 p=PushShortPixel(quantum_info->endian,p,&pixel);
1963 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1964 p=PushShortPixel(quantum_info->endian,p,&pixel);
1965 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1966 p=PushShortPixel(quantum_info->endian,p,&pixel);
1967 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
1968 p+=quantum_info->pad;
1969 q+=GetPixelChannels(image);
1970 }
1971 break;
1972 }
1973 case 32:
1974 {
1975 if (quantum_info->format == FloatingPointQuantumFormat)
1976 {
1977 float
1978 pixel;
1979
1980 for (x=0; x < (ssize_t) number_pixels; x++)
1981 {
1982 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1983 SetPixelRed(image,ClampToQuantum(pixel),q);
1984 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1985 SetPixelGreen(image,ClampToQuantum(pixel),q);
1986 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1987 SetPixelBlue(image,ClampToQuantum(pixel),q);
1988 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1989 SetPixelBlack(image,ClampToQuantum(pixel),q);
1990 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1991 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1992 p+=quantum_info->pad;
1993 q+=GetPixelChannels(image);
1994 }
1995 break;
1996 }
1997 else
1998 {
1999 unsigned int
2000 pixel;
2001
2002 for (x=0; x < (ssize_t) number_pixels; x++)
2003 {
2004 p=PushLongPixel(quantum_info->endian,p,&pixel);
2005 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
2006 p=PushLongPixel(quantum_info->endian,p,&pixel);
2007 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2008 p=PushLongPixel(quantum_info->endian,p,&pixel);
2009 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
2010 p=PushLongPixel(quantum_info->endian,p,&pixel);
2011 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
2012 p=PushLongPixel(quantum_info->endian,p,&pixel);
2013 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
2014 p+=quantum_info->pad;
2015 q+=GetPixelChannels(image);
2016 }
2017 break;
2018 }
2019 }
2020 case 24:
2021 {
2022 if (quantum_info->format == FloatingPointQuantumFormat)
2023 {
2024 float
2025 pixel;
2026
2027 for (x=0; x < (ssize_t) number_pixels; x++)
2028 {
2029 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2030 SetPixelRed(image,ClampToQuantum(pixel),q);
2031 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2032 SetPixelGreen(image,ClampToQuantum(pixel),q);
2033 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2034 SetPixelBlue(image,ClampToQuantum(pixel),q);
2035 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2036 SetPixelBlack(image,ClampToQuantum(pixel),q);
2037 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2038 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2039 p+=quantum_info->pad;
2040 q+=GetPixelChannels(image);
2041 }
2042 break;
2043 }
2044 magick_fallthrough;
2045 }
2046 case 64:
2047 {
2048 if (quantum_info->format == FloatingPointQuantumFormat)
2049 {
2050 double
2051 pixel;
2052
2053 for (x=0; x < (ssize_t) number_pixels; x++)
2054 {
2055 p=PushDoublePixel(quantum_info,p,&pixel);
2056 SetPixelRed(image,ClampToQuantum(pixel),q);
2057 p=PushDoublePixel(quantum_info,p,&pixel);
2058 SetPixelGreen(image,ClampToQuantum(pixel),q);
2059 p=PushDoublePixel(quantum_info,p,&pixel);
2060 SetPixelBlue(image,ClampToQuantum(pixel),q);
2061 p=PushDoublePixel(quantum_info,p,&pixel);
2062 SetPixelBlack(image,ClampToQuantum(pixel),q);
2063 p=PushDoublePixel(quantum_info,p,&pixel);
2064 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2065 p+=quantum_info->pad;
2066 q+=GetPixelChannels(image);
2067 }
2068 break;
2069 }
2070 magick_fallthrough;
2071 }
2072 default:
2073 {
2074 unsigned int
2075 pixel;
2076
2077 range=GetQuantumRange(quantum_info->depth);
2078 for (x=0; x < (ssize_t) number_pixels; x++)
2079 {
2080 p=PushQuantumPixel(quantum_info,p,&pixel);
2081 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2082 p=PushQuantumPixel(quantum_info,p,&pixel);
2083 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2084 p=PushQuantumPixel(quantum_info,p,&pixel);
2085 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2086 p=PushQuantumPixel(quantum_info,p,&pixel);
2087 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
2088 p=PushQuantumPixel(quantum_info,p,&pixel);
2089 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2090 q+=GetPixelChannels(image);
2091 }
2092 break;
2093 }
2094 }
2095}
2096
2097static void ImportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
2098 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
2099 Quantum *magick_restrict q,ExceptionInfo *exception)
2100{
2101 QuantumAny
2102 range;
2103
2104 ssize_t
2105 x;
2106
2107 if (image->colorspace != CMYKColorspace)
2108 {
2109 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2110 "ColorSeparatedImageRequired","`%s'",image->filename);
2111 return;
2112 }
2113 switch (quantum_info->depth)
2114 {
2115 case 8:
2116 {
2117 unsigned char
2118 pixel;
2119
2120 for (x=0; x < (ssize_t) number_pixels; x++)
2121 {
2122 p=PushCharPixel(p,&pixel);
2123 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
2124 p=PushCharPixel(p,&pixel);
2125 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
2126 p=PushCharPixel(p,&pixel);
2127 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
2128 p=PushCharPixel(p,&pixel);
2129 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
2130 p=PushCharPixel(p,&pixel);
2131 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
2132 p+=quantum_info->pad;
2133 q+=GetPixelChannels(image);
2134 }
2135 break;
2136 }
2137 case 16:
2138 {
2139 unsigned short
2140 pixel;
2141
2142 if (quantum_info->format == FloatingPointQuantumFormat)
2143 {
2144 for (x=0; x < (ssize_t) number_pixels; x++)
2145 {
2146 p=PushShortPixel(quantum_info->endian,p,&pixel);
2147 SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)
2148 HalfToSinglePrecision(pixel)),q);
2149 p=PushShortPixel(quantum_info->endian,p,&pixel);
2150 SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)
2151 HalfToSinglePrecision(pixel)),q);
2152 p=PushShortPixel(quantum_info->endian,p,&pixel);
2153 SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)
2154 HalfToSinglePrecision(pixel)),q);
2155 p=PushShortPixel(quantum_info->endian,p,&pixel);
2156 SetPixelBlack(image,ClampToQuantum((double) QuantumRange*(double)
2157 HalfToSinglePrecision(pixel)),q);
2158 p=PushShortPixel(quantum_info->endian,p,&pixel);
2159 SetPixelOpacity(image,ClampToQuantum((double) QuantumRange*(double)
2160 HalfToSinglePrecision(pixel)),q);
2161 p+=quantum_info->pad;
2162 q+=GetPixelChannels(image);
2163 }
2164 break;
2165 }
2166 for (x=0; x < (ssize_t) number_pixels; x++)
2167 {
2168 p=PushShortPixel(quantum_info->endian,p,&pixel);
2169 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
2170 p=PushShortPixel(quantum_info->endian,p,&pixel);
2171 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
2172 p=PushShortPixel(quantum_info->endian,p,&pixel);
2173 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
2174 p=PushShortPixel(quantum_info->endian,p,&pixel);
2175 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
2176 p=PushShortPixel(quantum_info->endian,p,&pixel);
2177 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
2178 p+=quantum_info->pad;
2179 q+=GetPixelChannels(image);
2180 }
2181 break;
2182 }
2183 case 32:
2184 {
2185 if (quantum_info->format == FloatingPointQuantumFormat)
2186 {
2187 float
2188 pixel;
2189
2190 for (x=0; x < (ssize_t) number_pixels; x++)
2191 {
2192 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2193 SetPixelRed(image,ClampToQuantum(pixel),q);
2194 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2195 SetPixelGreen(image,ClampToQuantum(pixel),q);
2196 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2197 SetPixelBlue(image,ClampToQuantum(pixel),q);
2198 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2199 SetPixelBlack(image,ClampToQuantum(pixel),q);
2200 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2201 SetPixelOpacity(image,ClampToQuantum(pixel),q);
2202 p+=quantum_info->pad;
2203 q+=GetPixelChannels(image);
2204 }
2205 break;
2206 }
2207 else
2208 {
2209 unsigned int
2210 pixel;
2211
2212 for (x=0; x < (ssize_t) number_pixels; x++)
2213 {
2214 p=PushLongPixel(quantum_info->endian,p,&pixel);
2215 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
2216 p=PushLongPixel(quantum_info->endian,p,&pixel);
2217 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2218 p=PushLongPixel(quantum_info->endian,p,&pixel);
2219 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
2220 p=PushLongPixel(quantum_info->endian,p,&pixel);
2221 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
2222 p=PushLongPixel(quantum_info->endian,p,&pixel);
2223 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
2224 p+=quantum_info->pad;
2225 q+=GetPixelChannels(image);
2226 }
2227 break;
2228 }
2229 }
2230 case 24:
2231 {
2232 if (quantum_info->format == FloatingPointQuantumFormat)
2233 {
2234 float
2235 pixel;
2236
2237 for (x=0; x < (ssize_t) number_pixels; x++)
2238 {
2239 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2240 SetPixelRed(image,ClampToQuantum(pixel),q);
2241 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2242 SetPixelGreen(image,ClampToQuantum(pixel),q);
2243 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2244 SetPixelBlue(image,ClampToQuantum(pixel),q);
2245 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2246 SetPixelBlack(image,ClampToQuantum(pixel),q);
2247 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2248 SetPixelOpacity(image,ClampToQuantum(pixel),q);
2249 p+=quantum_info->pad;
2250 q+=GetPixelChannels(image);
2251 }
2252 break;
2253 }
2254 magick_fallthrough;
2255 }
2256 case 64:
2257 {
2258 if (quantum_info->format == FloatingPointQuantumFormat)
2259 {
2260 double
2261 pixel;
2262
2263 for (x=0; x < (ssize_t) number_pixels; x++)
2264 {
2265 p=PushDoublePixel(quantum_info,p,&pixel);
2266 SetPixelRed(image,ClampToQuantum(pixel),q);
2267 p=PushDoublePixel(quantum_info,p,&pixel);
2268 SetPixelGreen(image,ClampToQuantum(pixel),q);
2269 p=PushDoublePixel(quantum_info,p,&pixel);
2270 SetPixelBlue(image,ClampToQuantum(pixel),q);
2271 p=PushDoublePixel(quantum_info,p,&pixel);
2272 SetPixelBlack(image,ClampToQuantum(pixel),q);
2273 p=PushDoublePixel(quantum_info,p,&pixel);
2274 SetPixelOpacity(image,ClampToQuantum(pixel),q);
2275 p+=quantum_info->pad;
2276 q+=GetPixelChannels(image);
2277 }
2278 break;
2279 }
2280 magick_fallthrough;
2281 }
2282 default:
2283 {
2284 unsigned int
2285 pixel;
2286
2287 range=GetQuantumRange(quantum_info->depth);
2288 for (x=0; x < (ssize_t) number_pixels; x++)
2289 {
2290 p=PushQuantumPixel(quantum_info,p,&pixel);
2291 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2292 p=PushQuantumPixel(quantum_info,p,&pixel);
2293 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2294 p=PushQuantumPixel(quantum_info,p,&pixel);
2295 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2296 p=PushQuantumPixel(quantum_info,p,&pixel);
2297 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
2298 p=PushQuantumPixel(quantum_info,p,&pixel);
2299 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
2300 q+=GetPixelChannels(image);
2301 }
2302 break;
2303 }
2304 }
2305}
2306
2307static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
2308 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
2309 Quantum *magick_restrict q)
2310{
2311 QuantumAny
2312 range;
2313
2314 ssize_t
2315 x;
2316
2317 ssize_t
2318 bit;
2319
2320 assert(image != (Image *) NULL);
2321 assert(image->signature == MagickCoreSignature);
2322 switch (quantum_info->depth)
2323 {
2324 case 1:
2325 {
2326 Quantum
2327 black,
2328 white;
2329
2330 black=(Quantum) 0;
2331 white=QuantumRange;
2332 if (quantum_info->min_is_white != MagickFalse)
2333 {
2334 black=QuantumRange;
2335 white=(Quantum) 0;
2336 }
2337 for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
2338 {
2339 for (bit=0; bit < 8; bit++)
2340 {
2341 SetPixelGray(image,((*p) & (1 << (7-bit))) == 0 ? black : white,q);
2342 q+=GetPixelChannels(image);
2343 }
2344 p++;
2345 }
2346 for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
2347 {
2348 SetPixelGray(image,((*p) & (0x01 << (7-bit))) == 0 ? black : white,q);
2349 q+=GetPixelChannels(image);
2350 }
2351 if (bit != 0)
2352 p++;
2353 break;
2354 }
2355 case 4:
2356 {
2357 unsigned char
2358 pixel;
2359
2360 range=GetQuantumRange(quantum_info->depth);
2361 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
2362 {
2363 pixel=(unsigned char) ((*p >> 4) & 0xf);
2364 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2365 q+=GetPixelChannels(image);
2366 pixel=(unsigned char) ((*p) & 0xf);
2367 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2368 p++;
2369 q+=GetPixelChannels(image);
2370 }
2371 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
2372 {
2373 pixel=(unsigned char) (*p++ >> 4);
2374 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2375 q+=GetPixelChannels(image);
2376 }
2377 break;
2378 }
2379 case 8:
2380 {
2381 unsigned char
2382 pixel;
2383
2384 if (quantum_info->min_is_white != MagickFalse)
2385 {
2386 for (x=0; x < (ssize_t) number_pixels; x++)
2387 {
2388 p=PushCharPixel(p,&pixel);
2389 SetPixelGray(image,QuantumRange-ScaleCharToQuantum(pixel),q);
2390 SetPixelAlpha(image,OpaqueAlpha,q);
2391 p+=quantum_info->pad;
2392 q+=GetPixelChannels(image);
2393 }
2394 break;
2395 }
2396 for (x=0; x < (ssize_t) number_pixels; x++)
2397 {
2398 p=PushCharPixel(p,&pixel);
2399 SetPixelGray(image,ScaleCharToQuantum(pixel),q);
2400 SetPixelAlpha(image,OpaqueAlpha,q);
2401 p+=quantum_info->pad;
2402 q+=GetPixelChannels(image);
2403 }
2404 break;
2405 }
2406 case 10:
2407 {
2408 unsigned int
2409 pixel;
2410
2411 pixel=0;
2412 range=GetQuantumRange(quantum_info->depth);
2413 if (quantum_info->pack == MagickFalse)
2414 {
2415 if (image->endian == LSBEndian)
2416 {
2417 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
2418 {
2419 p=PushLongPixel(quantum_info->endian,p,&pixel);
2420 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
2421 range),q);
2422 q+=GetPixelChannels(image);
2423 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2424 range),q);
2425 q+=GetPixelChannels(image);
2426 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
2427 range),q);
2428 p+=quantum_info->pad;
2429 q+=GetPixelChannels(image);
2430 }
2431 if (x++ < (ssize_t) (number_pixels-1))
2432 {
2433 p=PushLongPixel(quantum_info->endian,p,&pixel);
2434 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
2435 range),q);
2436 q+=GetPixelChannels(image);
2437 }
2438 if (x++ < (ssize_t) number_pixels)
2439 {
2440 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2441 range),q);
2442 q+=GetPixelChannels(image);
2443 }
2444 break;
2445 }
2446 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
2447 {
2448 p=PushLongPixel(quantum_info->endian,p,&pixel);
2449 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),
2450 q);
2451 q+=GetPixelChannels(image);
2452 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
2453 q);
2454 q+=GetPixelChannels(image);
2455 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
2456 q);
2457 p+=quantum_info->pad;
2458 q+=GetPixelChannels(image);
2459 }
2460 if (x++ < (ssize_t) (number_pixels-1))
2461 {
2462 p=PushLongPixel(quantum_info->endian,p,&pixel);
2463 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
2464 range),q);
2465 q+=GetPixelChannels(image);
2466 }
2467 if (x++ < (ssize_t) number_pixels)
2468 {
2469 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2470 range),q);
2471 q+=GetPixelChannels(image);
2472 }
2473 break;
2474 }
2475 for (x=0; x < (ssize_t) number_pixels; x++)
2476 {
2477 p=PushQuantumPixel(quantum_info,p,&pixel);
2478 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2479 p+=quantum_info->pad;
2480 q+=GetPixelChannels(image);
2481 }
2482 break;
2483 }
2484 case 12:
2485 {
2486 range=GetQuantumRange(quantum_info->depth);
2487 if (quantum_info->pack == MagickFalse)
2488 {
2489 unsigned short
2490 pixel;
2491
2492 for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
2493 {
2494 p=PushShortPixel(quantum_info->endian,p,&pixel);
2495 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2496 range),q);
2497 q+=GetPixelChannels(image);
2498 p=PushShortPixel(quantum_info->endian,p,&pixel);
2499 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2500 range),q);
2501 p+=quantum_info->pad;
2502 q+=GetPixelChannels(image);
2503 }
2504 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
2505 {
2506 p=PushShortPixel(quantum_info->endian,p,&pixel);
2507 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2508 range),q);
2509 p+=quantum_info->pad;
2510 q+=GetPixelChannels(image);
2511 }
2512 if (bit != 0)
2513 p++;
2514 break;
2515 }
2516 else
2517 {
2518 unsigned int
2519 pixel;
2520
2521 for (x=0; x < (ssize_t) number_pixels; x++)
2522 {
2523 p=PushQuantumPixel(quantum_info,p,&pixel);
2524 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2525 p+=quantum_info->pad;
2526 q+=GetPixelChannels(image);
2527 }
2528 break;
2529 }
2530 }
2531 case 16:
2532 {
2533 unsigned short
2534 pixel;
2535
2536 if (quantum_info->min_is_white != MagickFalse)
2537 {
2538 for (x=0; x < (ssize_t) number_pixels; x++)
2539 {
2540 p=PushShortPixel(quantum_info->endian,p,&pixel);
2541 SetPixelGray(image,QuantumRange-ScaleShortToQuantum(pixel),q);
2542 p+=quantum_info->pad;
2543 q+=GetPixelChannels(image);
2544 }
2545 break;
2546 }
2547 if (quantum_info->format == FloatingPointQuantumFormat)
2548 {
2549 for (x=0; x < (ssize_t) number_pixels; x++)
2550 {
2551 p=PushShortPixel(quantum_info->endian,p,&pixel);
2552 SetPixelGray(image,ClampToQuantum((double) QuantumRange*(double)
2553 HalfToSinglePrecision(pixel)),q);
2554 p+=quantum_info->pad;
2555 q+=GetPixelChannels(image);
2556 }
2557 break;
2558 }
2559 if (quantum_info->format == SignedQuantumFormat)
2560 {
2561 for (x=0; x < (ssize_t) number_pixels; x++)
2562 {
2563 p=PushShortPixel(quantum_info->endian,p,&pixel);
2564 pixel=(unsigned short) (((unsigned int) pixel+32768) % 65536);
2565 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2566 p+=quantum_info->pad;
2567 q+=GetPixelChannels(image);
2568 }
2569 break;
2570 }
2571 for (x=0; x < (ssize_t) number_pixels; x++)
2572 {
2573 p=PushShortPixel(quantum_info->endian,p,&pixel);
2574 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2575 p+=quantum_info->pad;
2576 q+=GetPixelChannels(image);
2577 }
2578 break;
2579 }
2580 case 32:
2581 {
2582 if (quantum_info->format == FloatingPointQuantumFormat)
2583 {
2584 float
2585 pixel;
2586
2587 for (x=0; x < (ssize_t) number_pixels; x++)
2588 {
2589 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2590 SetPixelGray(image,ClampToQuantum(pixel),q);
2591 p+=quantum_info->pad;
2592 q+=GetPixelChannels(image);
2593 }
2594 break;
2595 }
2596 else
2597 {
2598 unsigned int
2599 pixel;
2600
2601 for (x=0; x < (ssize_t) number_pixels; x++)
2602 {
2603 p=PushLongPixel(quantum_info->endian,p,&pixel);
2604 SetPixelGray(image,ScaleLongToQuantum(pixel),q);
2605 p+=quantum_info->pad;
2606 q+=GetPixelChannels(image);
2607 }
2608 break;
2609 }
2610 }
2611 case 24:
2612 {
2613 if (quantum_info->format == FloatingPointQuantumFormat)
2614 {
2615 float
2616 pixel;
2617
2618 for (x=0; x < (ssize_t) number_pixels; x++)
2619 {
2620 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2621 SetPixelGray(image,ClampToQuantum(pixel),q);
2622 p+=quantum_info->pad;
2623 q+=GetPixelChannels(image);
2624 }
2625 break;
2626 }
2627 magick_fallthrough;
2628 }
2629 case 64:
2630 {
2631 if (quantum_info->format == FloatingPointQuantumFormat)
2632 {
2633 double
2634 pixel;
2635
2636 for (x=0; x < (ssize_t) number_pixels; x++)
2637 {
2638 p=PushDoublePixel(quantum_info,p,&pixel);
2639 SetPixelGray(image,ClampToQuantum(pixel),q);
2640 p+=quantum_info->pad;
2641 q+=GetPixelChannels(image);
2642 }
2643 break;
2644 }
2645 magick_fallthrough;
2646 }
2647 default:
2648 {
2649 unsigned int
2650 pixel;
2651
2652 range=GetQuantumRange(quantum_info->depth);
2653 for (x=0; x < (ssize_t) number_pixels; x++)
2654 {
2655 p=PushQuantumPixel(quantum_info,p,&pixel);
2656 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2657 p+=quantum_info->pad;
2658 q+=GetPixelChannels(image);
2659 }
2660 break;
2661 }
2662 }
2663}
2664
2665static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
2666 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
2667 Quantum *magick_restrict q)
2668{
2669 QuantumAny
2670 range;
2671
2672 ssize_t
2673 x;
2674
2675 ssize_t
2676 bit;
2677
2678 assert(image != (Image *) NULL);
2679 assert(image->signature == MagickCoreSignature);
2680 switch (quantum_info->depth)
2681 {
2682 case 1:
2683 {
2684 unsigned char
2685 pixel;
2686
2687 bit=0;
2688 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2689 {
2690 for (bit=0; bit < 8; bit+=2)
2691 {
2692 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2693 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
2694 SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
2695 TransparentAlpha : OpaqueAlpha,q);
2696 q+=GetPixelChannels(image);
2697 }
2698 p++;
2699 }
2700 if ((number_pixels % 4) != 0)
2701 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2702 {
2703 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2704 SetPixelGray(image,(Quantum) (pixel != 0 ? 0 : QuantumRange),q);
2705 SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
2706 TransparentAlpha : OpaqueAlpha,q);
2707 q+=GetPixelChannels(image);
2708 }
2709 if (bit != 0)
2710 p++;
2711 break;
2712 }
2713 case 4:
2714 {
2715 unsigned char
2716 pixel;
2717
2718 range=GetQuantumRange(quantum_info->depth);
2719 for (x=0; x < (ssize_t) number_pixels; x++)
2720 {
2721 pixel=(unsigned char) ((*p >> 4) & 0xf);
2722 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2723 pixel=(unsigned char) ((*p) & 0xf);
2724 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2725 p++;
2726 q+=GetPixelChannels(image);
2727 }
2728 break;
2729 }
2730 case 8:
2731 {
2732 unsigned char
2733 pixel;
2734
2735 for (x=0; x < (ssize_t) number_pixels; x++)
2736 {
2737 p=PushCharPixel(p,&pixel);
2738 SetPixelGray(image,ScaleCharToQuantum(pixel),q);
2739 p=PushCharPixel(p,&pixel);
2740 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
2741 p+=quantum_info->pad;
2742 q+=GetPixelChannels(image);
2743 }
2744 break;
2745 }
2746 case 10:
2747 {
2748 unsigned int
2749 pixel;
2750
2751 range=GetQuantumRange(quantum_info->depth);
2752 for (x=0; x < (ssize_t) number_pixels; x++)
2753 {
2754 p=PushQuantumPixel(quantum_info,p,&pixel);
2755 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2756 p=PushQuantumPixel(quantum_info,p,&pixel);
2757 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2758 p+=quantum_info->pad;
2759 q+=GetPixelChannels(image);
2760 }
2761 break;
2762 }
2763 case 12:
2764 {
2765 unsigned int
2766 pixel;
2767
2768 range=GetQuantumRange(quantum_info->depth);
2769 for (x=0; x < (ssize_t) number_pixels; x++)
2770 {
2771 p=PushQuantumPixel(quantum_info,p,&pixel);
2772 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2773 p=PushQuantumPixel(quantum_info,p,&pixel);
2774 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2775 p+=quantum_info->pad;
2776 q+=GetPixelChannels(image);
2777 }
2778 break;
2779 }
2780 case 16:
2781 {
2782 unsigned short
2783 pixel;
2784
2785 if (quantum_info->format == FloatingPointQuantumFormat)
2786 {
2787 for (x=0; x < (ssize_t) number_pixels; x++)
2788 {
2789 p=PushShortPixel(quantum_info->endian,p,&pixel);
2790 SetPixelGray(image,ClampToQuantum((double) QuantumRange*(double)
2791 HalfToSinglePrecision(pixel)),q);
2792 p=PushShortPixel(quantum_info->endian,p,&pixel);
2793 SetPixelAlpha(image,ClampToQuantum((double) QuantumRange*(double)
2794 HalfToSinglePrecision(pixel)),q);
2795 p+=quantum_info->pad;
2796 q+=GetPixelChannels(image);
2797 }
2798 break;
2799 }
2800 for (x=0; x < (ssize_t) number_pixels; x++)
2801 {
2802 p=PushShortPixel(quantum_info->endian,p,&pixel);
2803 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2804 p=PushShortPixel(quantum_info->endian,p,&pixel);
2805 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
2806 p+=quantum_info->pad;
2807 q+=GetPixelChannels(image);
2808 }
2809 break;
2810 }
2811 case 32:
2812 {
2813 if (quantum_info->format == FloatingPointQuantumFormat)
2814 {
2815 float
2816 pixel;
2817
2818 for (x=0; x < (ssize_t) number_pixels; x++)
2819 {
2820 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2821 SetPixelGray(image,ClampToQuantum(pixel),q);
2822 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2823 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2824 p+=quantum_info->pad;
2825 q+=GetPixelChannels(image);
2826 }
2827 break;
2828 }
2829 else
2830 {
2831 unsigned int
2832 pixel;
2833
2834 for (x=0; x < (ssize_t) number_pixels; x++)
2835 {
2836 p=PushLongPixel(quantum_info->endian,p,&pixel);
2837 SetPixelGray(image,ScaleLongToQuantum(pixel),q);
2838 p=PushLongPixel(quantum_info->endian,p,&pixel);
2839 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
2840 p+=quantum_info->pad;
2841 q+=GetPixelChannels(image);
2842 }
2843 break;
2844 }
2845 }
2846 case 24:
2847 {
2848 if (quantum_info->format == FloatingPointQuantumFormat)
2849 {
2850 float
2851 pixel;
2852
2853 for (x=0; x < (ssize_t) number_pixels; x++)
2854 {
2855 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2856 SetPixelGray(image,ClampToQuantum(pixel),q);
2857 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2858 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2859 p+=quantum_info->pad;
2860 q+=GetPixelChannels(image);
2861 }
2862 break;
2863 }
2864 magick_fallthrough;
2865 }
2866 case 64:
2867 {
2868 if (quantum_info->format == FloatingPointQuantumFormat)
2869 {
2870 double
2871 pixel;
2872
2873 for (x=0; x < (ssize_t) number_pixels; x++)
2874 {
2875 p=PushDoublePixel(quantum_info,p,&pixel);
2876 SetPixelGray(image,ClampToQuantum(pixel),q);
2877 p=PushDoublePixel(quantum_info,p,&pixel);
2878 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2879 p+=quantum_info->pad;
2880 q+=GetPixelChannels(image);
2881 }
2882 break;
2883 }
2884 magick_fallthrough;
2885 }
2886 default:
2887 {
2888 unsigned int
2889 pixel;
2890
2891 range=GetQuantumRange(quantum_info->depth);
2892 for (x=0; x < (ssize_t) number_pixels; x++)
2893 {
2894 p=PushQuantumPixel(quantum_info,p,&pixel);
2895 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2896 p=PushQuantumPixel(quantum_info,p,&pixel);
2897 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2898 p+=quantum_info->pad;
2899 q+=GetPixelChannels(image);
2900 }
2901 break;
2902 }
2903 }
2904}
2905
2906static void ImportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
2907 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
2908 Quantum *magick_restrict q)
2909{
2910 QuantumAny
2911 range;
2912
2913 ssize_t
2914 x;
2915
2916 assert(image != (Image *) NULL);
2917 assert(image->signature == MagickCoreSignature);
2918 switch (quantum_info->depth)
2919 {
2920 case 8:
2921 {
2922 unsigned char
2923 pixel;
2924
2925 for (x=0; x < (ssize_t) number_pixels; x++)
2926 {
2927 p=PushCharPixel(p,&pixel);
2928 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
2929 p+=quantum_info->pad;
2930 q+=GetPixelChannels(image);
2931 }
2932 break;
2933 }
2934 case 16:
2935 {
2936 unsigned short
2937 pixel;
2938
2939 if (quantum_info->format == FloatingPointQuantumFormat)
2940 {
2941 for (x=0; x < (ssize_t) number_pixels; x++)
2942 {
2943 p=PushShortPixel(quantum_info->endian,p,&pixel);
2944 SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)
2945 HalfToSinglePrecision(pixel)),q);
2946 p+=quantum_info->pad;
2947 q+=GetPixelChannels(image);
2948 }
2949 break;
2950 }
2951 for (x=0; x < (ssize_t) number_pixels; x++)
2952 {
2953 p=PushShortPixel(quantum_info->endian,p,&pixel);
2954 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
2955 p+=quantum_info->pad;
2956 q+=GetPixelChannels(image);
2957 }
2958 break;
2959 }
2960 case 32:
2961 {
2962 if (quantum_info->format == FloatingPointQuantumFormat)
2963 {
2964 float
2965 pixel;
2966
2967 for (x=0; x < (ssize_t) number_pixels; x++)
2968 {
2969 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2970 SetPixelGreen(image,ClampToQuantum(pixel),q);
2971 p+=quantum_info->pad;
2972 q+=GetPixelChannels(image);
2973 }
2974 break;
2975 }
2976 else
2977 {
2978 unsigned int
2979 pixel;
2980
2981 for (x=0; x < (ssize_t) number_pixels; x++)
2982 {
2983 p=PushLongPixel(quantum_info->endian,p,&pixel);
2984 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2985 p+=quantum_info->pad;
2986 q+=GetPixelChannels(image);
2987 }
2988 break;
2989 }
2990 }
2991 case 24:
2992 {
2993 if (quantum_info->format == FloatingPointQuantumFormat)
2994 {
2995 float
2996 pixel;
2997
2998 for (x=0; x < (ssize_t) number_pixels; x++)
2999 {
3000 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3001 SetPixelGreen(image,ClampToQuantum(pixel),q);
3002 p+=quantum_info->pad;
3003 q+=GetPixelChannels(image);
3004 }
3005 break;
3006 }
3007 magick_fallthrough;
3008 }
3009 case 64:
3010 {
3011 if (quantum_info->format == FloatingPointQuantumFormat)
3012 {
3013 double
3014 pixel;
3015
3016 for (x=0; x < (ssize_t) number_pixels; x++)
3017 {
3018 p=PushDoublePixel(quantum_info,p,&pixel);
3019 SetPixelGreen(image,ClampToQuantum(pixel),q);
3020 p+=quantum_info->pad;
3021 q+=GetPixelChannels(image);
3022 }
3023 break;
3024 }
3025 magick_fallthrough;
3026 }
3027 default:
3028 {
3029 unsigned int
3030 pixel;
3031
3032 range=GetQuantumRange(quantum_info->depth);
3033 for (x=0; x < (ssize_t) number_pixels; x++)
3034 {
3035 p=PushQuantumPixel(quantum_info,p,&pixel);
3036 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3037 p+=quantum_info->pad;
3038 q+=GetPixelChannels(image);
3039 }
3040 break;
3041 }
3042 }
3043}
3044
3045static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
3046 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
3047 Quantum *magick_restrict q,ExceptionInfo *exception)
3048{
3049 MagickBooleanType
3050 range_exception;
3051
3052 ssize_t
3053 x;
3054
3055 ssize_t
3056 bit;
3057
3058 if (image->storage_class != PseudoClass)
3059 {
3060 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3061 "ColormappedImageRequired","`%s'",image->filename);
3062 return;
3063 }
3064 range_exception=MagickFalse;
3065 switch (quantum_info->depth)
3066 {
3067 case 1:
3068 {
3069 unsigned char
3070 pixel;
3071
3072 for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
3073 {
3074 for (bit=0; bit < 8; bit++)
3075 {
3076 if (quantum_info->min_is_white == MagickFalse)
3077 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
3078 0x00 : 0x01);
3079 else
3080 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
3081 0x00 : 0x01);
3082 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),
3083 q);
3084 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3085 GetPixelIndex(image,q),q);
3086 q+=GetPixelChannels(image);
3087 }
3088 p++;
3089 }
3090 for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
3091 {
3092 if (quantum_info->min_is_white == MagickFalse)
3093 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
3094 else
3095 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
3096 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3097 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3098 GetPixelIndex(image,q),q);
3099 q+=GetPixelChannels(image);
3100 }
3101 break;
3102 }
3103 case 4:
3104 {
3105 unsigned char
3106 pixel;
3107
3108 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
3109 {
3110 pixel=(unsigned char) ((*p >> 4) & 0xf);
3111 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3112 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3113 GetPixelIndex(image,q),q);
3114 q+=GetPixelChannels(image);
3115 pixel=(unsigned char) ((*p) & 0xf);
3116 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3117 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3118 GetPixelIndex(image,q),q);
3119 p++;
3120 q+=GetPixelChannels(image);
3121 }
3122 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
3123 {
3124 pixel=(unsigned char) ((*p++ >> 4) & 0xf);
3125 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3126 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3127 GetPixelIndex(image,q),q);
3128 q+=GetPixelChannels(image);
3129 }
3130 break;
3131 }
3132 case 8:
3133 {
3134 unsigned char
3135 pixel;
3136
3137 for (x=0; x < (ssize_t) number_pixels; x++)
3138 {
3139 p=PushCharPixel(p,&pixel);
3140 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3141 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3142 GetPixelIndex(image,q),q);
3143 p+=quantum_info->pad;
3144 q+=GetPixelChannels(image);
3145 }
3146 break;
3147 }
3148 case 16:
3149 {
3150 unsigned short
3151 pixel;
3152
3153 if (quantum_info->format == FloatingPointQuantumFormat)
3154 {
3155 for (x=0; x < (ssize_t) number_pixels; x++)
3156 {
3157 p=PushShortPixel(quantum_info->endian,p,&pixel);
3158 SetPixelIndex(image,PushColormapIndex(image,(size_t)
3159 ClampToQuantum((double) QuantumRange*(double)
3160 HalfToSinglePrecision(pixel)),&range_exception),q);
3161 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3162 GetPixelIndex(image,q),q);
3163 p+=quantum_info->pad;
3164 q+=GetPixelChannels(image);
3165 }
3166 break;
3167 }
3168 for (x=0; x < (ssize_t) number_pixels; x++)
3169 {
3170 p=PushShortPixel(quantum_info->endian,p,&pixel);
3171 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3172 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3173 GetPixelIndex(image,q),q);
3174 p+=quantum_info->pad;
3175 q+=GetPixelChannels(image);
3176 }
3177 break;
3178 }
3179 case 32:
3180 {
3181 if (quantum_info->format == FloatingPointQuantumFormat)
3182 {
3183 float
3184 pixel;
3185
3186 for (x=0; x < (ssize_t) number_pixels; x++)
3187 {
3188 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3189 SetPixelIndex(image,PushColormapIndex(image,(size_t)
3190 ClampToQuantum(pixel),&range_exception),q);
3191 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3192 GetPixelIndex(image,q),q);
3193 p+=quantum_info->pad;
3194 q+=GetPixelChannels(image);
3195 }
3196 break;
3197 }
3198 else
3199 {
3200 unsigned int
3201 pixel;
3202
3203 for (x=0; x < (ssize_t) number_pixels; x++)
3204 {
3205 p=PushLongPixel(quantum_info->endian,p,&pixel);
3206 SetPixelIndex(image,PushColormapIndex(image,pixel,
3207 &range_exception),q);
3208 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3209 GetPixelIndex(image,q),q);
3210 p+=quantum_info->pad;
3211 q+=GetPixelChannels(image);
3212 }
3213 break;
3214 }
3215 }
3216 case 24:
3217 {
3218 if (quantum_info->format == FloatingPointQuantumFormat)
3219 {
3220 float
3221 pixel;
3222
3223 for (x=0; x < (ssize_t) number_pixels; x++)
3224 {
3225 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3226 SetPixelIndex(image,PushColormapIndex(image,(size_t)
3227 ClampToQuantum(pixel),&range_exception),q);
3228 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3229 GetPixelIndex(image,q),q);
3230 p+=quantum_info->pad;
3231 q+=GetPixelChannels(image);
3232 }
3233 break;
3234 }
3235 magick_fallthrough;
3236 }
3237 case 64:
3238 {
3239 if (quantum_info->format == FloatingPointQuantumFormat)
3240 {
3241 double
3242 pixel;
3243
3244 for (x=0; x < (ssize_t) number_pixels; x++)
3245 {
3246 p=PushDoublePixel(quantum_info,p,&pixel);
3247 SetPixelIndex(image,PushColormapIndex(image,(size_t)
3248 ClampToQuantum(pixel),&range_exception),q);
3249 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3250 GetPixelIndex(image,q),q);
3251 p+=quantum_info->pad;
3252 q+=GetPixelChannels(image);
3253 }
3254 break;
3255 }
3256 magick_fallthrough;
3257 }
3258 default:
3259 {
3260 unsigned int
3261 pixel;
3262
3263 for (x=0; x < (ssize_t) number_pixels; x++)
3264 {
3265 p=PushQuantumPixel(quantum_info,p,&pixel);
3266 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3267 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3268 GetPixelIndex(image,q),q);
3269 p+=quantum_info->pad;
3270 q+=GetPixelChannels(image);
3271 }
3272 break;
3273 }
3274 }
3275 if (range_exception != MagickFalse)
3276 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
3277 "InvalidColormapIndex","`%s'",image->filename);
3278}
3279
3280static void ImportIndexAlphaQuantum(const Image *image,
3281 QuantumInfo *quantum_info,const MagickSizeType number_pixels,
3282 const unsigned char *magick_restrict p,Quantum *magick_restrict q,
3283 ExceptionInfo *exception)
3284{
3285 MagickBooleanType
3286 range_exception;
3287
3288 QuantumAny
3289 range;
3290
3291 ssize_t
3292 x;
3293
3294 ssize_t
3295 bit;
3296
3297 if (image->storage_class != PseudoClass)
3298 {
3299 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3300 "ColormappedImageRequired","`%s'",image->filename);
3301 return;
3302 }
3303 range_exception=MagickFalse;
3304 switch (quantum_info->depth)
3305 {
3306 case 1:
3307 {
3308 unsigned char
3309 pixel;
3310
3311 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
3312 {
3313 for (bit=0; bit < 8; bit+=2)
3314 {
3315 if (quantum_info->min_is_white == MagickFalse)
3316 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
3317 else
3318 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
3319 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
3320 SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
3321 TransparentAlpha : OpaqueAlpha,q);
3322 SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
3323 q+=GetPixelChannels(image);
3324 }
3325 }
3326 if ((number_pixels % 4) != 0)
3327 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
3328 {
3329 if (quantum_info->min_is_white == MagickFalse)
3330 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
3331 else
3332 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
3333 SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
3334 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
3335 SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
3336 TransparentAlpha : OpaqueAlpha,q);
3337 q+=GetPixelChannels(image);
3338 }
3339 break;
3340 }
3341 case 4:
3342 {
3343 unsigned char
3344 pixel;
3345
3346 range=GetQuantumRange(quantum_info->depth);
3347 for (x=0; x < (ssize_t) number_pixels; x++)
3348 {
3349 pixel=(unsigned char) ((*p >> 4) & 0xf);
3350 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3351 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3352 GetPixelIndex(image,q),q);
3353 pixel=(unsigned char) ((*p) & 0xf);
3354 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
3355 p++;
3356 q+=GetPixelChannels(image);
3357 }
3358 break;
3359 }
3360 case 8:
3361 {
3362 unsigned char
3363 pixel;
3364
3365 for (x=0; x < (ssize_t) number_pixels; x++)
3366 {
3367 p=PushCharPixel(p,&pixel);
3368 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3369 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3370 GetPixelIndex(image,q),q);
3371 p=PushCharPixel(p,&pixel);
3372 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
3373 p+=quantum_info->pad;
3374 q+=GetPixelChannels(image);
3375 }
3376 break;
3377 }
3378 case 16:
3379 {
3380 unsigned short
3381 pixel;
3382
3383 if (quantum_info->format == FloatingPointQuantumFormat)
3384 {
3385 for (x=0; x < (ssize_t) number_pixels; x++)
3386 {
3387 p=PushShortPixel(quantum_info->endian,p,&pixel);
3388 SetPixelIndex(image,PushColormapIndex(image,(size_t)
3389 ClampToQuantum((double) QuantumRange*(double)
3390 HalfToSinglePrecision(pixel)),&range_exception),q);
3391 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3392 GetPixelIndex(image,q),q);
3393 p=PushShortPixel(quantum_info->endian,p,&pixel);
3394 SetPixelAlpha(image,ClampToQuantum((double) QuantumRange*(double)
3395 HalfToSinglePrecision(pixel)),q);
3396 p+=quantum_info->pad;
3397 q+=GetPixelChannels(image);
3398 }
3399 break;
3400 }
3401 for (x=0; x < (ssize_t) number_pixels; x++)
3402 {
3403 p=PushShortPixel(quantum_info->endian,p,&pixel);
3404 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3405 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3406 GetPixelIndex(image,q),q);
3407 p=PushShortPixel(quantum_info->endian,p,&pixel);
3408 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
3409 p+=quantum_info->pad;
3410 q+=GetPixelChannels(image);
3411 }
3412 break;
3413 }
3414 case 32:
3415 {
3416 if (quantum_info->format == FloatingPointQuantumFormat)
3417 {
3418 float
3419 pixel;
3420
3421 for (x=0; x < (ssize_t) number_pixels; x++)
3422 {
3423 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3424 SetPixelIndex(image,PushColormapIndex(image,(size_t)
3425 ClampToQuantum(pixel),&range_exception),q);
3426 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3427 GetPixelIndex(image,q),q);
3428 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3429 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3430 p+=quantum_info->pad;
3431 q+=GetPixelChannels(image);
3432 }
3433 break;
3434 }
3435 else
3436 {
3437 unsigned int
3438 pixel;
3439
3440 for (x=0; x < (ssize_t) number_pixels; x++)
3441 {
3442 p=PushLongPixel(quantum_info->endian,p,&pixel);
3443 SetPixelIndex(image,PushColormapIndex(image,pixel,
3444 &range_exception),q);
3445 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3446 GetPixelIndex(image,q),q);
3447 p=PushLongPixel(quantum_info->endian,p,&pixel);
3448 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
3449 p+=quantum_info->pad;
3450 q+=GetPixelChannels(image);
3451 }
3452 break;
3453 }
3454 }
3455 case 24:
3456 {
3457 if (quantum_info->format == FloatingPointQuantumFormat)
3458 {
3459 float
3460 pixel;
3461
3462 for (x=0; x < (ssize_t) number_pixels; x++)
3463 {
3464 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3465 SetPixelIndex(image,PushColormapIndex(image,(size_t)
3466 ClampToQuantum(pixel),&range_exception),q);
3467 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3468 GetPixelIndex(image,q),q);
3469 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3470 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3471 p+=quantum_info->pad;
3472 q+=GetPixelChannels(image);
3473 }
3474 break;
3475 }
3476 magick_fallthrough;
3477 }
3478 case 64:
3479 {
3480 if (quantum_info->format == FloatingPointQuantumFormat)
3481 {
3482 double
3483 pixel;
3484
3485 for (x=0; x < (ssize_t) number_pixels; x++)
3486 {
3487 p=PushDoublePixel(quantum_info,p,&pixel);
3488 SetPixelIndex(image,PushColormapIndex(image,(size_t)
3489 ClampToQuantum(pixel),&range_exception),q);
3490 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3491 GetPixelIndex(image,q),q);
3492 p=PushDoublePixel(quantum_info,p,&pixel);
3493 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3494 p+=quantum_info->pad;
3495 q+=GetPixelChannels(image);
3496 }
3497 break;
3498 }
3499 magick_fallthrough;
3500 }
3501 default:
3502 {
3503 unsigned int
3504 pixel;
3505
3506 range=GetQuantumRange(quantum_info->depth);
3507 for (x=0; x < (ssize_t) number_pixels; x++)
3508 {
3509 p=PushQuantumPixel(quantum_info,p,&pixel);
3510 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3511 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3512 GetPixelIndex(image,q),q);
3513 p=PushQuantumPixel(quantum_info,p,&pixel);
3514 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
3515 p+=quantum_info->pad;
3516 q+=GetPixelChannels(image);
3517 }
3518 break;
3519 }
3520 }
3521 if (range_exception != MagickFalse)
3522 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
3523 "InvalidColormapIndex","`%s'",image->filename);
3524}
3525
3526static void ImportMultispectralQuantum(const Image *image,
3527 QuantumInfo *quantum_info,const MagickSizeType number_pixels,
3528 const unsigned char *magick_restrict p,Quantum *magick_restrict q,
3529 ExceptionInfo *exception)
3530{
3531 QuantumAny
3532 range;
3533
3534 ssize_t
3535 i,
3536 x;
3537
3538 if (image->number_meta_channels == 0)
3539 {
3540 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3541 "MultispectralImageRequired","`%s'",image->filename);
3542 return;
3543 }
3544 switch (quantum_info->depth)
3545 {
3546 case 8:
3547 {
3548 unsigned char
3549 pixel;
3550
3551 for (x=0; x < (ssize_t) number_pixels; x++)
3552 {
3553 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3554 {
3555 p=PushCharPixel(p,&pixel);
3556 q[i]=ScaleCharToQuantum(pixel);
3557 }
3558 p+=quantum_info->pad;
3559 q+=GetPixelChannels(image);
3560 }
3561 break;
3562 }
3563 case 16:
3564 {
3565 unsigned short
3566 pixel;
3567
3568 if (quantum_info->format == FloatingPointQuantumFormat)
3569 {
3570 for (x=0; x < (ssize_t) number_pixels; x++)
3571 {
3572 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3573 {
3574 p=PushShortPixel(quantum_info->endian,p,&pixel);
3575 q[i]=ClampToQuantum((double) QuantumRange*(double)HalfToSinglePrecision(pixel));
3576 }
3577 p+=quantum_info->pad;
3578 q+=GetPixelChannels(image);
3579 }
3580 break;
3581 }
3582 for (x=0; x < (ssize_t) number_pixels; x++)
3583 {
3584 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3585 {
3586 p=PushShortPixel(quantum_info->endian,p,&pixel);
3587 q[i]=ScaleShortToQuantum(pixel);
3588 }
3589 p+=quantum_info->pad;
3590 q+=GetPixelChannels(image);
3591 }
3592 break;
3593 }
3594 case 32:
3595 {
3596 if (quantum_info->format == FloatingPointQuantumFormat)
3597 {
3598 float
3599 pixel;
3600
3601 for (x=0; x < (ssize_t) number_pixels; x++)
3602 {
3603 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3604 {
3605 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3606 q[i]=ClampToQuantum(pixel);
3607 }
3608 p+=quantum_info->pad;
3609 q+=GetPixelChannels(image);
3610 }
3611 break;
3612 }
3613 else
3614 {
3615 unsigned int
3616 pixel;
3617
3618 for (x=0; x < (ssize_t) number_pixels; x++)
3619 {
3620 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3621 {
3622 p=PushLongPixel(quantum_info->endian,p,&pixel);
3623 q[i]=ScaleLongToQuantum(pixel);
3624 }
3625 p+=quantum_info->pad;
3626 q+=GetPixelChannels(image);
3627 }
3628 break;
3629 }
3630 }
3631 case 24:
3632 {
3633 if (quantum_info->format == FloatingPointQuantumFormat)
3634 {
3635 float
3636 pixel;
3637
3638 for (x=0; x < (ssize_t) number_pixels; x++)
3639 {
3640 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3641 {
3642 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3643 q[i]=ClampToQuantum(pixel);
3644 }
3645 p+=quantum_info->pad;
3646 q+=GetPixelChannels(image);
3647 }
3648 break;
3649 }
3650 magick_fallthrough;
3651 }
3652 case 64:
3653 {
3654 if (quantum_info->format == FloatingPointQuantumFormat)
3655 {
3656 double
3657 pixel;
3658
3659 for (x=0; x < (ssize_t) number_pixels; x++)
3660 {
3661 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3662 {
3663 p=PushDoublePixel(quantum_info,p,&pixel);
3664 q[i]=ClampToQuantum(pixel);
3665 }
3666 p+=quantum_info->pad;
3667 q+=GetPixelChannels(image);
3668 }
3669 break;
3670 }
3671 magick_fallthrough;
3672 }
3673 default:
3674 {
3675 unsigned int
3676 pixel = 0;
3677
3678 range=GetQuantumRange(quantum_info->depth);
3679 for (x=0; x < (ssize_t) number_pixels; x++)
3680 {
3681 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3682 {
3683 p=PushQuantumPixel(quantum_info,p,&pixel);
3684 q[i]=ScaleAnyToQuantum(pixel,range);
3685 }
3686 q+=GetPixelChannels(image);
3687 }
3688 break;
3689 }
3690 }
3691}
3692
3693static void ImportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
3694 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
3695 Quantum *magick_restrict q)
3696{
3697 QuantumAny
3698 range;
3699
3700 ssize_t
3701 x;
3702
3703 assert(image != (Image *) NULL);
3704 assert(image->signature == MagickCoreSignature);
3705 switch (quantum_info->depth)
3706 {
3707 case 8:
3708 {
3709 unsigned char
3710 pixel;
3711
3712 for (x=0; x < (ssize_t) number_pixels; x++)
3713 {
3714 p=PushCharPixel(p,&pixel);
3715 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
3716 p+=quantum_info->pad;
3717 q+=GetPixelChannels(image);
3718 }
3719 break;
3720 }
3721 case 16:
3722 {
3723 unsigned short
3724 pixel;
3725
3726 if (quantum_info->format == FloatingPointQuantumFormat)
3727 {
3728 for (x=0; x < (ssize_t) number_pixels; x++)
3729 {
3730 p=PushShortPixel(quantum_info->endian,p,&pixel);
3731 SetPixelOpacity(image,ClampToQuantum((double) QuantumRange*(double)
3732 HalfToSinglePrecision(pixel)),q);
3733 p+=quantum_info->pad;
3734 q+=GetPixelChannels(image);
3735 }
3736 break;
3737 }
3738 for (x=0; x < (ssize_t) number_pixels; x++)
3739 {
3740 p=PushShortPixel(quantum_info->endian,p,&pixel);
3741 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
3742 p+=quantum_info->pad;
3743 q+=GetPixelChannels(image);
3744 }
3745 break;
3746 }
3747 case 32:
3748 {
3749 if (quantum_info->format == FloatingPointQuantumFormat)
3750 {
3751 float
3752 pixel;
3753
3754 for (x=0; x < (ssize_t) number_pixels; x++)
3755 {
3756 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3757 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3758 p+=quantum_info->pad;
3759 q+=GetPixelChannels(image);
3760 }
3761 break;
3762 }
3763 else
3764 {
3765 unsigned int
3766 pixel;
3767
3768 for (x=0; x < (ssize_t) number_pixels; x++)
3769 {
3770 p=PushLongPixel(quantum_info->endian,p,&pixel);
3771 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
3772 p+=quantum_info->pad;
3773 q+=GetPixelChannels(image);
3774 }
3775 break;
3776 }
3777 }
3778 case 24:
3779 {
3780 if (quantum_info->format == FloatingPointQuantumFormat)
3781 {
3782 float
3783 pixel;
3784
3785 for (x=0; x < (ssize_t) number_pixels; x++)
3786 {
3787 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3788 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3789 p+=quantum_info->pad;
3790 q+=GetPixelChannels(image);
3791 }
3792 break;
3793 }
3794 magick_fallthrough;
3795 }
3796 case 64:
3797 {
3798 if (quantum_info->format == FloatingPointQuantumFormat)
3799 {
3800 double
3801 pixel;
3802
3803 for (x=0; x < (ssize_t) number_pixels; x++)
3804 {
3805 p=PushDoublePixel(quantum_info,p,&pixel);
3806 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3807 p+=quantum_info->pad;
3808 q+=GetPixelChannels(image);
3809 }
3810 break;
3811 }
3812 magick_fallthrough;
3813 }
3814 default:
3815 {
3816 unsigned int
3817 pixel;
3818
3819 range=GetQuantumRange(quantum_info->depth);
3820 for (x=0; x < (ssize_t) number_pixels; x++)
3821 {
3822 p=PushQuantumPixel(quantum_info,p,&pixel);
3823 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
3824 p+=quantum_info->pad;
3825 q+=GetPixelChannels(image);
3826 }
3827 break;
3828 }
3829 }
3830}
3831
3832static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
3833 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
3834 Quantum *magick_restrict q)
3835{
3836 QuantumAny
3837 range;
3838
3839 ssize_t
3840 x;
3841
3842 assert(image != (Image *) NULL);
3843 assert(image->signature == MagickCoreSignature);
3844 switch (quantum_info->depth)
3845 {
3846 case 8:
3847 {
3848 unsigned char
3849 pixel;
3850
3851 for (x=0; x < (ssize_t) number_pixels; x++)
3852 {
3853 p=PushCharPixel(p,&pixel);
3854 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3855 p+=quantum_info->pad;
3856 q+=GetPixelChannels(image);
3857 }
3858 break;
3859 }
3860 case 16:
3861 {
3862 unsigned short
3863 pixel;
3864
3865 if (quantum_info->format == FloatingPointQuantumFormat)
3866 {
3867 for (x=0; x < (ssize_t) number_pixels; x++)
3868 {
3869 p=PushShortPixel(quantum_info->endian,p,&pixel);
3870 SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)
3871 HalfToSinglePrecision(pixel)),q);
3872 p+=quantum_info->pad;
3873 q+=GetPixelChannels(image);
3874 }
3875 break;
3876 }
3877 for (x=0; x < (ssize_t) number_pixels; x++)
3878 {
3879 p=PushShortPixel(quantum_info->endian,p,&pixel);
3880 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
3881 p+=quantum_info->pad;
3882 q+=GetPixelChannels(image);
3883 }
3884 break;
3885 }
3886 case 32:
3887 {
3888 if (quantum_info->format == FloatingPointQuantumFormat)
3889 {
3890 float
3891 pixel;
3892
3893 for (x=0; x < (ssize_t) number_pixels; x++)
3894 {
3895 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3896 SetPixelRed(image,ClampToQuantum(pixel),q);
3897 p+=quantum_info->pad;
3898 q+=GetPixelChannels(image);
3899 }
3900 break;
3901 }
3902 else
3903 {
3904 unsigned int
3905 pixel;
3906
3907 for (x=0; x < (ssize_t) number_pixels; x++)
3908 {
3909 p=PushLongPixel(quantum_info->endian,p,&pixel);
3910 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
3911 p+=quantum_info->pad;
3912 q+=GetPixelChannels(image);
3913 }
3914 break;
3915 }
3916 }
3917 case 24:
3918 {
3919 if (quantum_info->format == FloatingPointQuantumFormat)
3920 {
3921 float
3922 pixel;
3923
3924 for (x=0; x < (ssize_t) number_pixels; x++)
3925 {
3926 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3927 SetPixelRed(image,ClampToQuantum(pixel),q);
3928 p+=quantum_info->pad;
3929 q+=GetPixelChannels(image);
3930 }
3931 break;
3932 }
3933 magick_fallthrough;
3934 }
3935 case 64:
3936 {
3937 if (quantum_info->format == FloatingPointQuantumFormat)
3938 {
3939 double
3940 pixel;
3941
3942 for (x=0; x < (ssize_t) number_pixels; x++)
3943 {
3944 p=PushDoublePixel(quantum_info,p,&pixel);
3945 SetPixelRed(image,ClampToQuantum(pixel),q);
3946 p+=quantum_info->pad;
3947 q+=GetPixelChannels(image);
3948 }
3949 break;
3950 }
3951 magick_fallthrough;
3952 }
3953 default:
3954 {
3955 unsigned int
3956 pixel;
3957
3958 range=GetQuantumRange(quantum_info->depth);
3959 for (x=0; x < (ssize_t) number_pixels; x++)
3960 {
3961 p=PushQuantumPixel(quantum_info,p,&pixel);
3962 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3963 p+=quantum_info->pad;
3964 q+=GetPixelChannels(image);
3965 }
3966 break;
3967 }
3968 }
3969}
3970
3971static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
3972 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
3973 Quantum *magick_restrict q)
3974{
3975 QuantumAny
3976 range;
3977
3978 ssize_t
3979 x;
3980
3981 ssize_t
3982 bit;
3983
3984 assert(image != (Image *) NULL);
3985 assert(image->signature == MagickCoreSignature);
3986 switch (quantum_info->depth)
3987 {
3988 case 8:
3989 {
3990 unsigned char
3991 pixel;
3992
3993 for (x=0; x < (ssize_t) number_pixels; x++)
3994 {
3995 p=PushCharPixel(p,&pixel);
3996 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3997 p=PushCharPixel(p,&pixel);
3998 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
3999 p=PushCharPixel(p,&pixel);
4000 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
4001 SetPixelAlpha(image,OpaqueAlpha,q);
4002 p+=quantum_info->pad;
4003 q+=GetPixelChannels(image);
4004 }
4005 break;
4006 }
4007 case 10:
4008 {
4009 unsigned int
4010 pixel;
4011
4012 range=GetQuantumRange(quantum_info->depth);
4013 if (quantum_info->pack == MagickFalse)
4014 {
4015 for (x=0; x < (ssize_t) number_pixels; x++)
4016 {
4017 p=PushLongPixel(quantum_info->endian,p,&pixel);
4018 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
4019 SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
4020 q);
4021 SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
4022 p+=quantum_info->pad;
4023 q+=GetPixelChannels(image);
4024 }
4025 break;
4026 }
4027 if (quantum_info->quantum == 32U)
4028 {
4029 for (x=0; x < (ssize_t) number_pixels; x++)
4030 {
4031 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4032 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4033 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4034 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4035 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4036 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4037 q+=GetPixelChannels(image);
4038 }
4039 break;
4040 }
4041 for (x=0; x < (ssize_t) number_pixels; x++)
4042 {
4043 p=PushQuantumPixel(quantum_info,p,&pixel);
4044 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4045 p=PushQuantumPixel(quantum_info,p,&pixel);
4046 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4047 p=PushQuantumPixel(quantum_info,p,&pixel);
4048 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4049 q+=GetPixelChannels(image);
4050 }
4051 break;
4052 }
4053 case 12:
4054 {
4055 range=GetQuantumRange(quantum_info->depth);
4056 if (quantum_info->pack == MagickFalse)
4057 {
4058 unsigned short
4059 pixel;
4060
4061 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
4062 {
4063 p=PushShortPixel(quantum_info->endian,p,&pixel);
4064 switch (x % 3)
4065 {
4066 default:
4067 case 0:
4068 {
4069 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4070 range),q);
4071 break;
4072 }
4073 case 1:
4074 {
4075 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4076 range),q);
4077 break;
4078 }
4079 case 2:
4080 {
4081 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4082 range),q);
4083 q+=GetPixelChannels(image);
4084 break;
4085 }
4086 }
4087 p=PushShortPixel(quantum_info->endian,p,&pixel);
4088 switch ((x+1) % 3)
4089 {
4090 default:
4091 case 0:
4092 {
4093 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4094 range),q);
4095 break;
4096 }
4097 case 1:
4098 {
4099 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4100 range),q);
4101 break;
4102 }
4103 case 2:
4104 {
4105 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4106 range),q);
4107 q+=GetPixelChannels(image);
4108 break;
4109 }
4110 }
4111 p+=quantum_info->pad;
4112 }
4113 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
4114 {
4115 p=PushShortPixel(quantum_info->endian,p,&pixel);
4116 switch ((x+bit) % 3)
4117 {
4118 default:
4119 case 0:
4120 {
4121 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4122 range),q);
4123 break;
4124 }
4125 case 1:
4126 {
4127 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4128 range),q);
4129 break;
4130 }
4131 case 2:
4132 {
4133 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4134 range),q);
4135 q+=GetPixelChannels(image);
4136 break;
4137 }
4138 }
4139 p+=quantum_info->pad;
4140 }
4141 if (bit != 0)
4142 p++;
4143 break;
4144 }
4145 else
4146 {
4147 unsigned int
4148 pixel;
4149
4150 if (quantum_info->quantum == 32U)
4151 {
4152 for (x=0; x < (ssize_t) number_pixels; x++)
4153 {
4154 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4155 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4156 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4157 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4158 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4159 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4160 q+=GetPixelChannels(image);
4161 }
4162 break;
4163 }
4164 for (x=0; x < (ssize_t) number_pixels; x++)
4165 {
4166 p=PushQuantumPixel(quantum_info,p,&pixel);
4167 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4168 p=PushQuantumPixel(quantum_info,p,&pixel);
4169 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4170 p=PushQuantumPixel(quantum_info,p,&pixel);
4171 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4172 q+=GetPixelChannels(image);
4173 }
4174 break;
4175 }
4176 }
4177 case 16:
4178 {
4179 unsigned short
4180 pixel;
4181
4182 if (quantum_info->format == FloatingPointQuantumFormat)
4183 {
4184 for (x=0; x < (ssize_t) number_pixels; x++)
4185 {
4186 p=PushShortPixel(quantum_info->endian,p,&pixel);
4187 SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)
4188 HalfToSinglePrecision(pixel)),q);
4189 p=PushShortPixel(quantum_info->endian,p,&pixel);
4190 SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)
4191 HalfToSinglePrecision(pixel)),q);
4192 p=PushShortPixel(quantum_info->endian,p,&pixel);
4193 SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)
4194 HalfToSinglePrecision(pixel)),q);
4195 p+=quantum_info->pad;
4196 q+=GetPixelChannels(image);
4197 }
4198 break;
4199 }
4200 for (x=0; x < (ssize_t) number_pixels; x++)
4201 {
4202 p=PushShortPixel(quantum_info->endian,p,&pixel);
4203 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
4204 p=PushShortPixel(quantum_info->endian,p,&pixel);
4205 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
4206 p=PushShortPixel(quantum_info->endian,p,&pixel);
4207 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
4208 p+=quantum_info->pad;
4209 q+=GetPixelChannels(image);
4210 }
4211 break;
4212 }
4213 case 32:
4214 {
4215 if (quantum_info->format == FloatingPointQuantumFormat)
4216 {
4217 float
4218 pixel;
4219
4220 for (x=0; x < (ssize_t) number_pixels; x++)
4221 {
4222 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4223 SetPixelRed(image,ClampToQuantum(pixel),q);
4224 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4225 SetPixelGreen(image,ClampToQuantum(pixel),q);
4226 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4227 SetPixelBlue(image,ClampToQuantum(pixel),q);
4228 p+=quantum_info->pad;
4229 q+=GetPixelChannels(image);
4230 }
4231 break;
4232 }
4233 else
4234 {
4235 unsigned int
4236 pixel;
4237
4238 for (x=0; x < (ssize_t) number_pixels; x++)
4239 {
4240 p=PushLongPixel(quantum_info->endian,p,&pixel);
4241 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
4242 p=PushLongPixel(quantum_info->endian,p,&pixel);
4243 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
4244 p=PushLongPixel(quantum_info->endian,p,&pixel);
4245 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
4246 p+=quantum_info->pad;
4247 q+=GetPixelChannels(image);
4248 }
4249 break;
4250 }
4251 }
4252 case 24:
4253 {
4254 if (quantum_info->format == FloatingPointQuantumFormat)
4255 {
4256 float
4257 pixel;
4258
4259 for (x=0; x < (ssize_t) number_pixels; x++)
4260 {
4261 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4262 SetPixelRed(image,ClampToQuantum(pixel),q);
4263 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4264 SetPixelGreen(image,ClampToQuantum(pixel),q);
4265 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4266 SetPixelBlue(image,ClampToQuantum(pixel),q);
4267 p+=quantum_info->pad;
4268 q+=GetPixelChannels(image);
4269 }
4270 break;
4271 }
4272 magick_fallthrough;
4273 }
4274 case 64:
4275 {
4276 if (quantum_info->format == FloatingPointQuantumFormat)
4277 {
4278 double
4279 pixel;
4280
4281 for (x=0; x < (ssize_t) number_pixels; x++)
4282 {
4283 p=PushDoublePixel(quantum_info,p,&pixel);
4284 SetPixelRed(image,ClampToQuantum(pixel),q);
4285 p=PushDoublePixel(quantum_info,p,&pixel);
4286 SetPixelGreen(image,ClampToQuantum(pixel),q);
4287 p=PushDoublePixel(quantum_info,p,&pixel);
4288 SetPixelBlue(image,ClampToQuantum(pixel),q);
4289 p+=quantum_info->pad;
4290 q+=GetPixelChannels(image);
4291 }
4292 break;
4293 }
4294 magick_fallthrough;
4295 }
4296 default:
4297 {
4298 unsigned int
4299 pixel;
4300
4301 range=GetQuantumRange(quantum_info->depth);
4302 for (x=0; x < (ssize_t) number_pixels; x++)
4303 {
4304 p=PushQuantumPixel(quantum_info,p,&pixel);
4305 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4306 p=PushQuantumPixel(quantum_info,p,&pixel);
4307 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4308 p=PushQuantumPixel(quantum_info,p,&pixel);
4309 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4310 q+=GetPixelChannels(image);
4311 }
4312 break;
4313 }
4314 }
4315}
4316
4317static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
4318 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
4319 Quantum *magick_restrict q)
4320{
4321 QuantumAny
4322 range;
4323
4324 ssize_t
4325 x;
4326
4327 assert(image != (Image *) NULL);
4328 assert(image->signature == MagickCoreSignature);
4329 switch (quantum_info->depth)
4330 {
4331 case 8:
4332 {
4333 unsigned char
4334 pixel;
4335
4336 for (x=0; x < (ssize_t) number_pixels; x++)
4337 {
4338 p=PushCharPixel(p,&pixel);
4339 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
4340 p=PushCharPixel(p,&pixel);
4341 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
4342 p=PushCharPixel(p,&pixel);
4343 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
4344 p=PushCharPixel(p,&pixel);
4345 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
4346 p+=quantum_info->pad;
4347 q+=GetPixelChannels(image);
4348 }
4349 break;
4350 }
4351 case 10:
4352 {
4353 unsigned int
4354 pixel;
4355
4356 pixel=0;
4357 if (quantum_info->pack == MagickFalse)
4358 {
4359 ssize_t
4360 i;
4361
4362 size_t
4363 quantum;
4364
4365 ssize_t
4366 n;
4367
4368 n=0;
4369 quantum=0;
4370 for (x=0; x < (ssize_t) number_pixels; x++)
4371 {
4372 for (i=0; i < 4; i++)
4373 {
4374 switch (n % 3)
4375 {
4376 case 0:
4377 {
4378 p=PushLongPixel(quantum_info->endian,p,&pixel);
4379 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
4380 (((pixel >> 22) & 0x3ff) << 6)));
4381 break;
4382 }
4383 case 1:
4384 {
4385 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
4386 (((pixel >> 12) & 0x3ff) << 6)));
4387 break;
4388 }
4389 case 2:
4390 {
4391 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
4392 (((pixel >> 2) & 0x3ff) << 6)));
4393 break;
4394 }
4395 }
4396 switch (i)
4397 {
4398 case 0: SetPixelRed(image,(Quantum) quantum,q); break;
4399 case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
4400 case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
4401 case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
4402 }
4403 n++;
4404 }
4405 p+=quantum_info->pad;
4406 q+=GetPixelChannels(image);
4407 }
4408 break;
4409 }
4410 for (x=0; x < (ssize_t) number_pixels; x++)
4411 {
4412 p=PushQuantumPixel(quantum_info,p,&pixel);
4413 SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
4414 p=PushQuantumPixel(quantum_info,p,&pixel);
4415 SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
4416 q);
4417 p=PushQuantumPixel(quantum_info,p,&pixel);
4418 SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
4419 q);
4420 p=PushQuantumPixel(quantum_info,p,&pixel);
4421 SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
4422 q);
4423 q+=GetPixelChannels(image);
4424 }
4425 break;
4426 }
4427 case 16:
4428 {
4429 unsigned short
4430 pixel;
4431
4432 if (quantum_info->format == FloatingPointQuantumFormat)
4433 {
4434 for (x=0; x < (ssize_t) number_pixels; x++)
4435 {
4436 p=PushShortPixel(quantum_info->endian,p,&pixel);
4437 SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)
4438 HalfToSinglePrecision(pixel)),q);
4439 p=PushShortPixel(quantum_info->endian,p,&pixel);
4440 SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)
4441 HalfToSinglePrecision(pixel)),q);
4442 p=PushShortPixel(quantum_info->endian,p,&pixel);
4443 SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)
4444 HalfToSinglePrecision(pixel)),q);
4445 p=PushShortPixel(quantum_info->endian,p,&pixel);
4446 SetPixelAlpha(image,ClampToQuantum((double) QuantumRange*(double)
4447 HalfToSinglePrecision(pixel)),q);
4448 p+=quantum_info->pad;
4449 q+=GetPixelChannels(image);
4450 }
4451 break;
4452 }
4453 for (x=0; x < (ssize_t) number_pixels; x++)
4454 {
4455 p=PushShortPixel(quantum_info->endian,p,&pixel);
4456 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
4457 p=PushShortPixel(quantum_info->endian,p,&pixel);
4458 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
4459 p=PushShortPixel(quantum_info->endian,p,&pixel);
4460 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
4461 p=PushShortPixel(quantum_info->endian,p,&pixel);
4462 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
4463 p+=quantum_info->pad;
4464 q+=GetPixelChannels(image);
4465 }
4466 break;
4467 }
4468 case 32:
4469 {
4470 if (quantum_info->format == FloatingPointQuantumFormat)
4471 {
4472 float
4473 pixel;
4474
4475 for (x=0; x < (ssize_t) number_pixels; x++)
4476 {
4477 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4478 SetPixelRed(image,ClampToQuantum(pixel),q);
4479 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4480 SetPixelGreen(image,ClampToQuantum(pixel),q);
4481 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4482 SetPixelBlue(image,ClampToQuantum(pixel),q);
4483 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4484 SetPixelAlpha(image,ClampToQuantum(pixel),q);
4485 p+=quantum_info->pad;
4486 q+=GetPixelChannels(image);
4487 }
4488 break;
4489 }
4490 else
4491 {
4492 unsigned int
4493 pixel;
4494
4495 for (x=0; x < (ssize_t) number_pixels; x++)
4496 {
4497 p=PushLongPixel(quantum_info->endian,p,&pixel);
4498 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
4499 p=PushLongPixel(quantum_info->endian,p,&pixel);
4500 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
4501 p=PushLongPixel(quantum_info->endian,p,&pixel);
4502 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
4503 p=PushLongPixel(quantum_info->endian,p,&pixel);
4504 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
4505 p+=quantum_info->pad;
4506 q+=GetPixelChannels(image);
4507 }
4508 break;
4509 }
4510 }
4511 case 24:
4512 {
4513 if (quantum_info->format == FloatingPointQuantumFormat)
4514 {
4515 float
4516 pixel;
4517
4518 for (x=0; x < (ssize_t) number_pixels; x++)
4519 {
4520 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4521 SetPixelRed(image,ClampToQuantum(pixel),q);
4522 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4523 SetPixelGreen(image,ClampToQuantum(pixel),q);
4524 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4525 SetPixelBlue(image,ClampToQuantum(pixel),q);
4526 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4527 SetPixelAlpha(image,ClampToQuantum(pixel),q);
4528 p+=quantum_info->pad;
4529 q+=GetPixelChannels(image);
4530 }
4531 break;
4532 }
4533 magick_fallthrough;
4534 }
4535 case 64:
4536 {
4537 if (quantum_info->format == FloatingPointQuantumFormat)
4538 {
4539 double
4540 pixel;
4541
4542 for (x=0; x < (ssize_t) number_pixels; x++)
4543 {
4544 p=PushDoublePixel(quantum_info,p,&pixel);
4545 SetPixelRed(image,ClampToQuantum(pixel),q);
4546 p=PushDoublePixel(quantum_info,p,&pixel);
4547 SetPixelGreen(image,ClampToQuantum(pixel),q);
4548 p=PushDoublePixel(quantum_info,p,&pixel);
4549 SetPixelBlue(image,ClampToQuantum(pixel),q);
4550 p=PushDoublePixel(quantum_info,p,&pixel);
4551 SetPixelAlpha(image,ClampToQuantum(pixel),q);
4552 p+=quantum_info->pad;
4553 q+=GetPixelChannels(image);
4554 }
4555 break;
4556 }
4557 magick_fallthrough;
4558 }
4559 default:
4560 {
4561 unsigned int
4562 pixel;
4563
4564 range=GetQuantumRange(quantum_info->depth);
4565 for (x=0; x < (ssize_t) number_pixels; x++)
4566 {
4567 p=PushQuantumPixel(quantum_info,p,&pixel);
4568 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4569 p=PushQuantumPixel(quantum_info,p,&pixel);
4570 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4571 p=PushQuantumPixel(quantum_info,p,&pixel);
4572 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4573 p=PushQuantumPixel(quantum_info,p,&pixel);
4574 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
4575 q+=GetPixelChannels(image);
4576 }
4577 break;
4578 }
4579 }
4580}
4581
4582static void ImportRGBOQuantum(const Image *image,QuantumInfo *quantum_info,
4583 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
4584 Quantum *magick_restrict q)
4585{
4586 QuantumAny
4587 range;
4588
4589 ssize_t
4590 x;
4591
4592 assert(image != (Image *) NULL);
4593 assert(image->signature == MagickCoreSignature);
4594 switch (quantum_info->depth)
4595 {
4596 case 8:
4597 {
4598 unsigned char
4599 pixel;
4600
4601 for (x=0; x < (ssize_t) number_pixels; x++)
4602 {
4603 p=PushCharPixel(p,&pixel);
4604 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
4605 p=PushCharPixel(p,&pixel);
4606 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
4607 p=PushCharPixel(p,&pixel);
4608 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
4609 p=PushCharPixel(p,&pixel);
4610 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
4611 p+=quantum_info->pad;
4612 q+=GetPixelChannels(image);
4613 }
4614 break;
4615 }
4616 case 10:
4617 {
4618 unsigned int
4619 pixel;
4620
4621 pixel=0;
4622 if (quantum_info->pack == MagickFalse)
4623 {
4624 ssize_t
4625 i;
4626
4627 size_t
4628 quantum;
4629
4630 ssize_t
4631 n;
4632
4633 n=0;
4634 quantum=0;
4635 for (x=0; x < (ssize_t) number_pixels; x++)
4636 {
4637 for (i=0; i < 4; i++)
4638 {
4639 switch (n % 3)
4640 {
4641 case 0:
4642 {
4643 p=PushLongPixel(quantum_info->endian,p,&pixel);
4644 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
4645 (((pixel >> 22) & 0x3ff) << 6)));
4646 break;
4647 }
4648 case 1:
4649 {
4650 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
4651 (((pixel >> 12) & 0x3ff) << 6)));
4652 break;
4653 }
4654 case 2:
4655 {
4656 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
4657 (((pixel >> 2) & 0x3ff) << 6)));
4658 break;
4659 }
4660 }
4661 switch (i)
4662 {
4663 case 0: SetPixelRed(image,(Quantum) quantum,q); break;
4664 case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
4665 case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
4666 case 3: SetPixelOpacity(image,(Quantum) quantum,q); break;
4667 }
4668 n++;
4669 }
4670 p+=quantum_info->pad;
4671 q+=GetPixelChannels(image);
4672 }
4673 break;
4674 }
4675 for (x=0; x < (ssize_t) number_pixels; x++)
4676 {
4677 p=PushQuantumPixel(quantum_info,p,&pixel);
4678 SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
4679 p=PushQuantumPixel(quantum_info,p,&pixel);
4680 SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
4681 q);
4682 p=PushQuantumPixel(quantum_info,p,&pixel);
4683 SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
4684 q);
4685 p=PushQuantumPixel(quantum_info,p,&pixel);
4686 SetPixelOpacity(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
4687 q);
4688 q+=GetPixelChannels(image);
4689 }
4690 break;
4691 }
4692 case 16:
4693 {
4694 unsigned short
4695 pixel;
4696
4697 if (quantum_info->format == FloatingPointQuantumFormat)
4698 {
4699 for (x=0; x < (ssize_t) number_pixels; x++)
4700 {
4701 p=PushShortPixel(quantum_info->endian,p,&pixel);
4702 SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)
4703 HalfToSinglePrecision(pixel)),q);
4704 p=PushShortPixel(quantum_info->endian,p,&pixel);
4705 SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)
4706 HalfToSinglePrecision(pixel)),q);
4707 p=PushShortPixel(quantum_info->endian,p,&pixel);
4708 SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)
4709 HalfToSinglePrecision(pixel)),q);
4710 p=PushShortPixel(quantum_info->endian,p,&pixel);
4711 SetPixelOpacity(image,ClampToQuantum((double) QuantumRange*(double)
4712 HalfToSinglePrecision(pixel)),q);
4713 p+=quantum_info->pad;
4714 q+=GetPixelChannels(image);
4715 }
4716 break;
4717 }
4718 for (x=0; x < (ssize_t) number_pixels; x++)
4719 {
4720 p=PushShortPixel(quantum_info->endian,p,&pixel);
4721 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
4722 p=PushShortPixel(quantum_info->endian,p,&pixel);
4723 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
4724 p=PushShortPixel(quantum_info->endian,p,&pixel);
4725 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
4726 p=PushShortPixel(quantum_info->endian,p,&pixel);
4727 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
4728 p+=quantum_info->pad;
4729 q+=GetPixelChannels(image);
4730 }
4731 break;
4732 }
4733 case 32:
4734 {
4735 if (quantum_info->format == FloatingPointQuantumFormat)
4736 {
4737 float
4738 pixel;
4739
4740 for (x=0; x < (ssize_t) number_pixels; x++)
4741 {
4742 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4743 SetPixelRed(image,ClampToQuantum(pixel),q);
4744 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4745 SetPixelGreen(image,ClampToQuantum(pixel),q);
4746 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4747 SetPixelBlue(image,ClampToQuantum(pixel),q);
4748 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4749 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4750 p+=quantum_info->pad;
4751 q+=GetPixelChannels(image);
4752 }
4753 break;
4754 }
4755 else
4756 {
4757 unsigned int
4758 pixel;
4759
4760 for (x=0; x < (ssize_t) number_pixels; x++)
4761 {
4762 p=PushLongPixel(quantum_info->endian,p,&pixel);
4763 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
4764 p=PushLongPixel(quantum_info->endian,p,&pixel);
4765 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
4766 p=PushLongPixel(quantum_info->endian,p,&pixel);
4767 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
4768 p=PushLongPixel(quantum_info->endian,p,&pixel);
4769 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
4770 p+=quantum_info->pad;
4771 q+=GetPixelChannels(image);
4772 }
4773 break;
4774 }
4775 }
4776 case 24:
4777 {
4778 if (quantum_info->format == FloatingPointQuantumFormat)
4779 {
4780 float
4781 pixel;
4782
4783 for (x=0; x < (ssize_t) number_pixels; x++)
4784 {
4785 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4786 SetPixelRed(image,ClampToQuantum(pixel),q);
4787 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4788 SetPixelGreen(image,ClampToQuantum(pixel),q);
4789 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4790 SetPixelBlue(image,ClampToQuantum(pixel),q);
4791 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4792 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4793 p+=quantum_info->pad;
4794 q+=GetPixelChannels(image);
4795 }
4796 break;
4797 }
4798 magick_fallthrough;
4799 }
4800 case 64:
4801 {
4802 if (quantum_info->format == FloatingPointQuantumFormat)
4803 {
4804 double
4805 pixel;
4806
4807 for (x=0; x < (ssize_t) number_pixels; x++)
4808 {
4809 p=PushDoublePixel(quantum_info,p,&pixel);
4810 SetPixelRed(image,ClampToQuantum(pixel),q);
4811 p=PushDoublePixel(quantum_info,p,&pixel);
4812 SetPixelGreen(image,ClampToQuantum(pixel),q);
4813 p=PushDoublePixel(quantum_info,p,&pixel);
4814 SetPixelBlue(image,ClampToQuantum(pixel),q);
4815 p=PushDoublePixel(quantum_info,p,&pixel);
4816 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4817 p+=quantum_info->pad;
4818 q+=GetPixelChannels(image);
4819 }
4820 break;
4821 }
4822 magick_fallthrough;
4823 }
4824 default:
4825 {
4826 unsigned int
4827 pixel;
4828
4829 range=GetQuantumRange(quantum_info->depth);
4830 for (x=0; x < (ssize_t) number_pixels; x++)
4831 {
4832 p=PushQuantumPixel(quantum_info,p,&pixel);
4833 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4834 p=PushQuantumPixel(quantum_info,p,&pixel);
4835 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4836 p=PushQuantumPixel(quantum_info,p,&pixel);
4837 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4838 p=PushQuantumPixel(quantum_info,p,&pixel);
4839 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
4840 q+=GetPixelChannels(image);
4841 }
4842 break;
4843 }
4844 }
4845}
4846
4847MagickExport size_t ImportQuantumPixels(const Image *image,
4848 CacheView *image_view,QuantumInfo *quantum_info,
4849 const QuantumType quantum_type,const unsigned char *magick_restrict pixels,
4850 ExceptionInfo *exception)
4851{
4852 MagickSizeType
4853 number_pixels;
4854
4855 const unsigned char
4856 *magick_restrict p;
4857
4858 ssize_t
4859 x;
4860
4861 Quantum
4862 *magick_restrict q;
4863
4864 size_t
4865 extent;
4866
4867 assert(image != (Image *) NULL);
4868 assert(image->signature == MagickCoreSignature);
4869 assert(quantum_info != (QuantumInfo *) NULL);
4870 assert(quantum_info->signature == MagickCoreSignature);
4871 if (IsEventLogging() != MagickFalse)
4872 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4873 if (pixels == (const unsigned char *) NULL)
4874 pixels=(const unsigned char *) GetQuantumPixels(quantum_info);
4875 x=0;
4876 p=pixels;
4877 if (image_view == (CacheView *) NULL)
4878 {
4879 number_pixels=GetImageExtent(image);
4880 q=GetAuthenticPixelQueue(image);
4881 }
4882 else
4883 {
4884 number_pixels=GetCacheViewExtent(image_view);
4885 q=GetCacheViewAuthenticPixelQueue(image_view);
4886 }
4887 ResetQuantumState(quantum_info);
4888 extent=GetQuantumExtent(image,quantum_info,quantum_type);
4889 switch (quantum_type)
4890 {
4891 case AlphaQuantum:
4892 {
4893 ImportAlphaQuantum(image,quantum_info,number_pixels,p,q);
4894 break;
4895 }
4896 case BGRQuantum:
4897 {
4898 ImportBGRQuantum(image,quantum_info,number_pixels,p,q);
4899 break;
4900 }
4901 case BGRAQuantum:
4902 {
4903 ImportBGRAQuantum(image,quantum_info,number_pixels,p,q);
4904 break;
4905 }
4906 case BGROQuantum:
4907 {
4908 ImportBGROQuantum(image,quantum_info,number_pixels,p,q);
4909 break;
4910 }
4911 case BlackQuantum:
4912 {
4913 ImportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
4914 break;
4915 }
4916 case BlueQuantum:
4917 case YellowQuantum:
4918 {
4919 ImportBlueQuantum(image,quantum_info,number_pixels,p,q);
4920 break;
4921 }
4922 case CMYKQuantum:
4923 {
4924 ImportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
4925 break;
4926 }
4927 case CMYKAQuantum:
4928 {
4929 ImportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
4930 break;
4931 }
4932 case MultispectralQuantum:
4933 {
4934 ImportMultispectralQuantum(image,quantum_info,number_pixels,p,q,exception);
4935 break;
4936 }
4937 case CMYKOQuantum:
4938 {
4939 ImportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
4940 break;
4941 }
4942 case CbYCrYQuantum:
4943 {
4944 ImportCbYCrYQuantum(image,quantum_info,number_pixels,p,q);
4945 break;
4946 }
4947 case GrayQuantum:
4948 {
4949 ImportGrayQuantum(image,quantum_info,number_pixels,p,q);
4950 break;
4951 }
4952 case GrayAlphaQuantum:
4953 {
4954 ImportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q);
4955 break;
4956 }
4957 case GreenQuantum:
4958 case MagentaQuantum:
4959 {
4960 ImportGreenQuantum(image,quantum_info,number_pixels,p,q);
4961 break;
4962 }
4963 case IndexQuantum:
4964 {
4965 ImportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
4966 break;
4967 }
4968 case IndexAlphaQuantum:
4969 {
4970 ImportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
4971 break;
4972 }
4973 case OpacityQuantum:
4974 {
4975 ImportOpacityQuantum(image,quantum_info,number_pixels,p,q);
4976 break;
4977 }
4978 case RedQuantum:
4979 case CyanQuantum:
4980 {
4981 ImportRedQuantum(image,quantum_info,number_pixels,p,q);
4982 break;
4983 }
4984 case RGBQuantum:
4985 case CbYCrQuantum:
4986 {
4987 ImportRGBQuantum(image,quantum_info,number_pixels,p,q);
4988 break;
4989 }
4990 case RGBAQuantum:
4991 case CbYCrAQuantum:
4992 {
4993 ImportRGBAQuantum(image,quantum_info,number_pixels,p,q);
4994 break;
4995 }
4996 case RGBOQuantum:
4997 {
4998 ImportRGBOQuantum(image,quantum_info,number_pixels,p,q);
4999 break;
5000 }
5001 default:
5002 break;
5003 }
5004 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
5005 {
5006 Quantum
5007 quantum;
5008
5009 q=GetAuthenticPixelQueue(image);
5010 if (image_view != (CacheView *) NULL)
5011 q=GetCacheViewAuthenticPixelQueue(image_view);
5012 for (x=0; x < (ssize_t) number_pixels; x++)
5013 {
5014 quantum=GetPixelRed(image,q);
5015 SetPixelRed(image,GetPixelGreen(image,q),q);
5016 SetPixelGreen(image,quantum,q);
5017 q+=GetPixelChannels(image);
5018 }
5019 }
5020 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
5021 {
5022 double
5023 gamma,
5024 Sa;
5025
5026 /*
5027 Disassociate alpha.
5028 */
5029 q=GetAuthenticPixelQueue(image);
5030 if (image_view != (CacheView *) NULL)
5031 q=GetCacheViewAuthenticPixelQueue(image_view);
5032 for (x=0; x < (ssize_t) number_pixels; x++)
5033 {
5034 ssize_t
5035 i;
5036
5037 Sa=QuantumScale*(double) GetPixelAlpha(image,q);
5038 gamma=PerceptibleReciprocal(Sa);
5039 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
5040 {
5041 PixelChannel channel = GetPixelChannelChannel(image,i);
5042 PixelTrait traits = GetPixelChannelTraits(image,channel);
5043 if ((channel == AlphaPixelChannel) ||
5044 ((traits & UpdatePixelTrait) == 0))
5045 continue;
5046 q[i]=ClampToQuantum(gamma*(double) q[i]);
5047 }
5048 q+=GetPixelChannels(image);
5049 }
5050 }
5051 return(extent);
5052}