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