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