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