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