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