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