MagickCore  6.9.10
Convert, Edit, Or Compose Bitmap Images
quantum-private.h
Go to the documentation of this file.
1 /*
2  Copyright 1999-2019 ImageMagick Studio LLC, a non-profit organization
3  dedicated to making software imaging solutions freely available.
4 
5  You may not use this file except in compliance with the License. You may
6  obtain a copy of the License at
7 
8  https://imagemagick.org/script/license.php
9 
10  Unless required by applicable law or agreed to in writing, software
11  distributed under the License is distributed on an "AS IS" BASIS,
12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  See the License for the specific language governing permissions and
14  limitations under the License.
15 
16  MagickCore quantum inline methods.
17 */
18 #ifndef MAGICKCORE_QUANTUM_PRIVATE_H
19 #define MAGICKCORE_QUANTUM_PRIVATE_H
20 
21 #include "magick/memory_.h"
22 #include "magick/cache.h"
23 #include "magick/image-private.h"
24 #include "magick/pixel-accessor.h"
25 
26 #if defined(__cplusplus) || defined(c_plusplus)
27 extern "C" {
28 #endif
29 
30 typedef struct _QuantumState
31 {
32  double
34 
35  unsigned int
37 
38  size_t
40 
41  const unsigned int
42  *mask;
43 } QuantumState;
44 
46 {
47  size_t
49  quantum;
50 
53 
54  double
56  maximum,
57  scale;
58 
59  size_t
60  pad;
61 
64  pack;
65 
68 
69  size_t
71 
73  **pixels;
74 
75  size_t
77 
80 
83 
86 
87  size_t
89 };
90 
91 extern MagickPrivate void
93 
94 static inline MagickSizeType GetQuantumRange(const size_t depth)
95 {
97  one;
98 
99  size_t
100  max_depth;
101 
102  if (depth == 0)
103  return(0);
104  one=1;
105  max_depth=8*sizeof(MagickSizeType);
106  return((MagickSizeType) ((one << (MagickMin(depth,max_depth)-1))+
107  ((one << (MagickMin(depth,max_depth)-1))-1)));
108 }
109 
110 static inline float HalfToSinglePrecision(const unsigned short half)
111 {
112 #define ExponentBias (127-15)
113 #define ExponentMask 0x7c00
114 #define ExponentShift 23
115 #define SignBitShift 31
116 #define SignificandShift 13
117 #define SignificandMask 0x00000400
118 
119  typedef union _SinglePrecision
120  {
121  unsigned int
122  fixed_point;
123 
124  float
125  single_precision;
126  } SinglePrecision;
127 
128  register unsigned int
129  exponent,
130  significand,
131  sign_bit;
132 
133  SinglePrecision
134  map;
135 
136  unsigned int
137  value;
138 
139  /*
140  The IEEE 754 standard specifies half precision as having:
141 
142  Sign bit: 1 bit
143  Exponent width: 5 bits
144  Significand precision: 11 (10 explicitly stored)
145  */
146  sign_bit=(unsigned int) ((half >> 15) & 0x00000001);
147  exponent=(unsigned int) ((half >> 10) & 0x0000001f);
148  significand=(unsigned int) (half & 0x000003ff);
149  if (exponent == 0)
150  {
151  if (significand == 0)
152  value=sign_bit << SignBitShift;
153  else
154  {
155  while ((significand & SignificandMask) == 0)
156  {
157  significand<<=1;
158  exponent--;
159  }
160  exponent++;
161  significand&=(~SignificandMask);
162  exponent+=ExponentBias;
163  value=(sign_bit << SignBitShift) | (exponent << ExponentShift) |
164  (significand << SignificandShift);
165  }
166  }
167  else
168  if (exponent == SignBitShift)
169  {
170  value=(sign_bit << SignBitShift) | 0x7f800000;
171  if (significand != 0)
172  value|=(significand << SignificandShift);
173  }
174  else
175  {
176  exponent+=ExponentBias;
177  significand<<=SignificandShift;
178  value=(sign_bit << SignBitShift) | (exponent << ExponentShift) |
179  significand;
180  }
181  map.fixed_point=value;
182  return(map.single_precision);
183 }
184 
185 static inline unsigned char *PopCharPixel(const unsigned char pixel,
186  unsigned char *pixels)
187 {
188  *pixels++=pixel;
189  return(pixels);
190 }
191 
192 static inline unsigned char *PopLongPixel(const EndianType endian,
193  const unsigned int pixel,unsigned char *pixels)
194 {
195  register unsigned int
196  quantum;
197 
198  quantum=(unsigned int) pixel;
199  if (endian == LSBEndian)
200  {
201  *pixels++=(unsigned char) (quantum);
202  *pixels++=(unsigned char) (quantum >> 8);
203  *pixels++=(unsigned char) (quantum >> 16);
204  *pixels++=(unsigned char) (quantum >> 24);
205  return(pixels);
206  }
207  *pixels++=(unsigned char) (quantum >> 24);
208  *pixels++=(unsigned char) (quantum >> 16);
209  *pixels++=(unsigned char) (quantum >> 8);
210  *pixels++=(unsigned char) (quantum);
211  return(pixels);
212 }
213 
214 static inline unsigned char *PopShortPixel(const EndianType endian,
215  const unsigned short pixel,unsigned char *pixels)
216 {
217  register unsigned int
218  quantum;
219 
220  quantum=pixel;
221  if (endian == LSBEndian)
222  {
223  *pixels++=(unsigned char) (quantum);
224  *pixels++=(unsigned char) (quantum >> 8);
225  return(pixels);
226  }
227  *pixels++=(unsigned char) (quantum >> 8);
228  *pixels++=(unsigned char) (quantum);
229  return(pixels);
230 }
231 
232 static inline const unsigned char *PushCharPixel(const unsigned char *pixels,
233  unsigned char *pixel)
234 {
235  *pixel=(*pixels++);
236  return(pixels);
237 }
238 
239 static inline const unsigned char *PushLongPixel(const EndianType endian,
240  const unsigned char *pixels,unsigned int *pixel)
241 {
242  register unsigned int
243  quantum;
244 
245  if (endian == LSBEndian)
246  {
247  quantum=((unsigned int) *pixels++);
248  quantum|=((unsigned int) *pixels++ << 8);
249  quantum|=((unsigned int) *pixels++ << 16);
250  quantum|=((unsigned int) *pixels++ << 24);
251  *pixel=quantum;
252  return(pixels);
253  }
254  quantum=((unsigned int) *pixels++ << 24);
255  quantum|=((unsigned int) *pixels++ << 16);
256  quantum|=((unsigned int) *pixels++ << 8);
257  quantum|=((unsigned int) *pixels++);
258  *pixel=quantum;
259  return(pixels);
260 }
261 
262 static inline const unsigned char *PushShortPixel(const EndianType endian,
263  const unsigned char *pixels,unsigned short *pixel)
264 {
265  register unsigned int
266  quantum;
267 
268  if (endian == LSBEndian)
269  {
270  quantum=(unsigned int) *pixels++;
271  quantum|=(unsigned int) (*pixels++ << 8);
272  *pixel=(unsigned short) (quantum & 0xffff);
273  return(pixels);
274  }
275  quantum=(unsigned int) (*pixels++ << 8);
276  quantum|=(unsigned int) *pixels++;
277  *pixel=(unsigned short) (quantum & 0xffff);
278  return(pixels);
279 }
280 
281 static inline const unsigned char *PushFloatPixel(const EndianType endian,
282  const unsigned char *pixels,MagickFloatType *pixel)
283 {
284  union
285  {
286  unsigned int
287  unsigned_value;
288 
290  float_value;
291  } quantum;
292 
293  if (endian == LSBEndian)
294  {
295  quantum.unsigned_value=((unsigned int) *pixels++);
296  quantum.unsigned_value|=((unsigned int) *pixels++ << 8);
297  quantum.unsigned_value|=((unsigned int) *pixels++ << 16);
298  quantum.unsigned_value|=((unsigned int) *pixels++ << 24);
299  *pixel=quantum.float_value;
300  return(pixels);
301  }
302  quantum.unsigned_value=((unsigned int) *pixels++ << 24);
303  quantum.unsigned_value|=((unsigned int) *pixels++ << 16);
304  quantum.unsigned_value|=((unsigned int) *pixels++ << 8);
305  quantum.unsigned_value|=((unsigned int) *pixels++);
306  *pixel=quantum.float_value;
307  return(pixels);
308 }
309 
310 static inline Quantum ScaleAnyToQuantum(const QuantumAny quantum,
311  const QuantumAny range)
312 {
313  if (quantum > range)
314  return(QuantumRange);
315 #if !defined(MAGICKCORE_HDRI_SUPPORT)
316  return((Quantum) (((MagickRealType) QuantumRange*quantum)*
317  PerceptibleReciprocal((double) range)+0.5));
318 #else
319  return((Quantum) (((MagickRealType) QuantumRange*quantum)*
320  PerceptibleReciprocal((double) range)));
321 #endif
322 }
323 
324 static inline QuantumAny ScaleQuantumToAny(const Quantum quantum,
325  const QuantumAny range)
326 {
327 #if !defined(MAGICKCORE_HDRI_SUPPORT)
328  return((QuantumAny) ((MagickRealType) range*quantum/QuantumRange));
329 #else
330  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
331  return((QuantumAny) 0UL);
332  if (((MagickRealType) range*quantum/QuantumRange) >= 18446744073709551615.0)
333  return((QuantumAny) MagickULLConstant(18446744073709551615));
334  return((QuantumAny) ((MagickRealType) range*quantum/QuantumRange+0.5));
335 #endif
336 }
337 
338 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
339 static inline Quantum ScaleCharToQuantum(const unsigned char value)
340 {
341  return((Quantum) value);
342 }
343 
344 static inline Quantum ScaleLongToQuantum(const unsigned int value)
345 {
346 #if !defined(MAGICKCORE_HDRI_SUPPORT)
347  return((Quantum) ((value)/16843009UL));
348 #else
349  return((Quantum) (value/16843009.0));
350 #endif
351 }
352 
353 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
354 {
355  if (value <= 0.0)
356  return((Quantum) 0);
357  if (value >= MaxMap)
358  return(QuantumRange);
359 #if !defined(MAGICKCORE_HDRI_SUPPORT)
360  return((Quantum) (value+0.5));
361 #else
362  return((Quantum) value);
363 #endif
364 }
365 
366 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
367 {
368 #if !defined(MAGICKCORE_HDRI_SUPPORT)
369  return((unsigned int) (16843009UL*quantum));
370 #else
371  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
372  return(0U);
373  if ((16843009.0*quantum) >= 4294967295.0)
374  return(4294967295UL);
375  return((unsigned int) (16843009.0*quantum+0.5));
376 #endif
377 }
378 
379 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
380 {
381  if (quantum >= (Quantum) MaxMap)
382  return((unsigned int) MaxMap);
383 #if !defined(MAGICKCORE_HDRI_SUPPORT)
384  return((unsigned int) quantum);
385 #else
386  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
387  return(0U);
388  return((unsigned int) (quantum+0.5));
389 #endif
390 }
391 
392 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
393 {
394 #if !defined(MAGICKCORE_HDRI_SUPPORT)
395  return((unsigned short) (257UL*quantum));
396 #else
397  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
398  return(0);
399  if ((257.0*quantum) >= 65535.0)
400  return(65535);
401  return((unsigned short) (257.0*quantum+0.5));
402 #endif
403 }
404 
405 static inline Quantum ScaleShortToQuantum(const unsigned short value)
406 {
407 #if !defined(MAGICKCORE_HDRI_SUPPORT)
408  return((Quantum) ((value+128U)/257U));
409 #else
410  return((Quantum) (value/257.0));
411 #endif
412 }
413 #elif (MAGICKCORE_QUANTUM_DEPTH == 16)
414 static inline Quantum ScaleCharToQuantum(const unsigned char value)
415 {
416 #if !defined(MAGICKCORE_HDRI_SUPPORT)
417  return((Quantum) (257U*value));
418 #else
419  return((Quantum) (257.0*value));
420 #endif
421 }
422 
423 static inline Quantum ScaleLongToQuantum(const unsigned int value)
424 {
425 #if !defined(MAGICKCORE_HDRI_SUPPORT)
426  return((Quantum) ((value)/MagickULLConstant(65537)));
427 #else
428  return((Quantum) (value/65537.0));
429 #endif
430 }
431 
432 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
433 {
434  if (value <= 0.0)
435  return((Quantum) 0);
436  if (value >= MaxMap)
437  return(QuantumRange);
438 #if !defined(MAGICKCORE_HDRI_SUPPORT)
439  return((Quantum) (value+0.5));
440 #else
441  return((Quantum) value);
442 #endif
443 }
444 
445 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
446 {
447 #if !defined(MAGICKCORE_HDRI_SUPPORT)
448  return((unsigned int) (65537UL*quantum));
449 #else
450  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
451  return(0U);
452  if ((65537.0*quantum) >= 4294967295.0)
453  return(4294967295U);
454  return((unsigned int) (65537.0*quantum+0.5));
455 #endif
456 }
457 
458 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
459 {
460  if (quantum >= (Quantum) MaxMap)
461  return((unsigned int) MaxMap);
462 #if !defined(MAGICKCORE_HDRI_SUPPORT)
463  return((unsigned int) quantum);
464 #else
465  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
466  return(0U);
467  return((unsigned int) (quantum+0.5));
468 #endif
469 }
470 
471 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
472 {
473 #if !defined(MAGICKCORE_HDRI_SUPPORT)
474  return((unsigned short) quantum);
475 #else
476  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
477  return(0);
478  if (quantum >= 65535.0)
479  return(65535);
480  return((unsigned short) (quantum+0.5));
481 #endif
482 }
483 
484 static inline Quantum ScaleShortToQuantum(const unsigned short value)
485 {
486  return((Quantum) value);
487 }
488 #elif (MAGICKCORE_QUANTUM_DEPTH == 32)
489 static inline Quantum ScaleCharToQuantum(const unsigned char value)
490 {
491 #if !defined(MAGICKCORE_HDRI_SUPPORT)
492  return((Quantum) (16843009UL*value));
493 #else
494  return((Quantum) (16843009.0*value));
495 #endif
496 }
497 
498 static inline Quantum ScaleLongToQuantum(const unsigned int value)
499 {
500  return((Quantum) value);
501 }
502 
503 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
504 {
505  if (value <= 0.0)
506  return((Quantum) 0);
507  if (value >= (Quantum) MaxMap)
508  return(QuantumRange);
509 #if !defined(MAGICKCORE_HDRI_SUPPORT)
510  return((Quantum) (65537.0*value+0.5));
511 #else
512  return((Quantum) (65537.0*value));
513 #endif
514 }
515 
516 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
517 {
518 #if !defined(MAGICKCORE_HDRI_SUPPORT)
519  return((unsigned int) quantum);
520 #else
521  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
522  return(0U);
523  if ((quantum) >= 4294967295.0)
524  return(4294967295);
525  return((unsigned int) (quantum+0.5));
526 #endif
527 }
528 
529 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
530 {
531  if ((quantum/65537) >= (Quantum) MaxMap)
532  return((unsigned int) MaxMap);
533 #if !defined(MAGICKCORE_HDRI_SUPPORT)
534  return((unsigned int) ((quantum+MagickULLConstant(32768))/
535  MagickULLConstant(65537)));
536 #else
537  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
538  return(0U);
539  return((unsigned int) (quantum/65537.0+0.5));
540 #endif
541 }
542 
543 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
544 {
545 #if !defined(MAGICKCORE_HDRI_SUPPORT)
546  return((unsigned short) ((quantum+MagickULLConstant(32768))/
547  MagickULLConstant(65537)));
548 #else
549  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
550  return(0);
551  if ((quantum/65537.0) >= 65535.0)
552  return(65535);
553  return((unsigned short) (quantum/65537.0+0.5));
554 #endif
555 }
556 
557 static inline Quantum ScaleShortToQuantum(const unsigned short value)
558 {
559 #if !defined(MAGICKCORE_HDRI_SUPPORT)
560  return((Quantum) (65537UL*value));
561 #else
562  return((Quantum) (65537.0*value));
563 #endif
564 }
565 #elif (MAGICKCORE_QUANTUM_DEPTH == 64)
566 static inline Quantum ScaleCharToQuantum(const unsigned char value)
567 {
568  return((Quantum) (72340172838076673.0*value));
569 }
570 
571 static inline Quantum ScaleLongToQuantum(const unsigned int value)
572 {
573  return((Quantum) (4294967297.0*value));
574 }
575 
576 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
577 {
578  if (value <= 0.0)
579  return((Quantum) 0);
580  if (value >= MaxMap)
581  return(QuantumRange);
582  return((Quantum) (281479271743489.0*value));
583 }
584 
585 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
586 {
587  return((unsigned int) (quantum/4294967297.0+0.5));
588 }
589 
590 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
591 {
592  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
593  return(0U);
594  if ((quantum/281479271743489.0) >= MaxMap)
595  return((unsigned int) MaxMap);
596  return((unsigned int) (quantum/281479271743489.0+0.5));
597 }
598 
599 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
600 {
601  if ((IsNaN(quantum) != MagickFalse) || (quantum <= 0.0))
602  return(0);
603  if ((quantum/281479271743489.0) >= 65535.0)
604  return(65535);
605  return((unsigned short) (quantum/281479271743489.0+0.5));
606 }
607 
608 static inline Quantum ScaleShortToQuantum(const unsigned short value)
609 {
610  return((Quantum) (281479271743489.0*value));
611 }
612 #endif
613 
614 static inline unsigned short SinglePrecisionToHalf(const float value)
615 {
616  typedef union _SinglePrecision
617  {
618  unsigned int
619  fixed_point;
620 
621  float
622  single_precision;
623  } SinglePrecision;
624 
625  register int
626  exponent;
627 
628  register unsigned int
629  significand,
630  sign_bit;
631 
632  SinglePrecision
633  map;
634 
635  unsigned short
636  half;
637 
638  /*
639  The IEEE 754 standard specifies half precision as having:
640 
641  Sign bit: 1 bit
642  Exponent width: 5 bits
643  Significand precision: 11 (10 explicitly stored)
644  */
645  map.single_precision=value;
646  sign_bit=(map.fixed_point >> 16) & 0x00008000;
647  exponent=(int) ((map.fixed_point >> ExponentShift) & 0x000000ff)-ExponentBias;
648  significand=map.fixed_point & 0x007fffff;
649  if (exponent <= 0)
650  {
651  int
652  shift;
653 
654  if (exponent < -10)
655  return((unsigned short) sign_bit);
656  significand=significand | 0x00800000;
657  shift=(int) (14-exponent);
658  significand=(unsigned int) ((significand+((1 << (shift-1))-1)+
659  ((significand >> shift) & 0x01)) >> shift);
660  return((unsigned short) (sign_bit | significand));
661  }
662  else
663  if (exponent == (0xff-ExponentBias))
664  {
665  if (significand == 0)
666  return((unsigned short) (sign_bit | ExponentMask));
667  else
668  {
669  significand>>=SignificandShift;
670  half=(unsigned short) (sign_bit | significand |
671  (significand == 0) | ExponentMask);
672  return(half);
673  }
674  }
675  significand=significand+((significand >> SignificandShift) & 0x01)+0x00000fff;
676  if ((significand & 0x00800000) != 0)
677  {
678  significand=0;
679  exponent++;
680  }
681  if (exponent > 30)
682  {
683  float
684  alpha;
685 
686  register int
687  i;
688 
689  /*
690  Float overflow.
691  */
692  alpha=1.0e10;
693  for (i=0; i < 10; i++)
694  alpha*=alpha;
695  return((unsigned short) (sign_bit | ExponentMask));
696  }
697  half=(unsigned short) (sign_bit | (exponent << 10) |
698  (significand >> SignificandShift));
699  return(half);
700 }
701 
702 #if defined(__cplusplus) || defined(c_plusplus)
703 }
704 #endif
705 
706 #endif
MagickDoubleType MagickRealType
Definition: magick-type.h:125
QuantumFormatType
Definition: quantum.h:45
QuantumFormatType format
Definition: quantum-private.h:52
static MagickSizeType GetQuantumRange(const size_t depth)
Definition: quantum-private.h:94
MemoryInfo ** pixels
Definition: quantum-private.h:73
#define ExponentMask
QuantumAlphaType alpha_type
Definition: quantum-private.h:67
size_t signature
Definition: quantum-private.h:88
#define MagickULLConstant(c)
Definition: magick-type.h:39
Definition: quantum.h:34
MagickPrivate void ResetQuantumState(QuantumInfo *)
Definition: quantum.c:578
#define SignBitShift
#define SignificandMask
QuantumState state
Definition: quantum-private.h:82
size_t depth
Definition: quantum-private.h:48
float MagickFloatType
Definition: magick-type.h:43
double minimum
Definition: quantum-private.h:55
Definition: memory.c:131
EndianType
Definition: quantum.h:31
size_t quantum
Definition: quantum-private.h:48
EndianType endian
Definition: quantum-private.h:79
static const unsigned char * PushShortPixel(const EndianType endian, const unsigned char *pixels, unsigned short *pixel)
Definition: quantum-private.h:262
MagickBooleanType pack
Definition: quantum-private.h:63
static const unsigned char * PushCharPixel(const unsigned char *pixels, unsigned char *pixel)
Definition: quantum-private.h:232
MagickBooleanType
Definition: magick-type.h:191
static double PerceptibleReciprocal(const double x)
Definition: pixel-accessor.h:124
static Quantum ScaleAnyToQuantum(const QuantumAny quantum, const QuantumAny range)
Definition: quantum-private.h:310
static unsigned char * PopLongPixel(const EndianType endian, const unsigned int pixel, unsigned char *pixels)
Definition: quantum-private.h:192
unsigned int pixel
Definition: quantum-private.h:36
size_t MagickSizeType
Definition: magick-type.h:136
static const unsigned char * PushLongPixel(const EndianType endian, const unsigned char *pixels, unsigned int *pixel)
Definition: quantum-private.h:239
SemaphoreInfo * semaphore
Definition: quantum-private.h:85
#define SignificandShift
#define ExponentShift
#define MaxMap
Definition: magick-type.h:78
Definition: quantum-private.h:45
size_t pad
Definition: quantum-private.h:60
#define IsNaN(a)
Definition: magick-type.h:214
static float HalfToSinglePrecision(const unsigned short half)
Definition: quantum-private.h:110
size_t number_threads
Definition: quantum-private.h:70
double scale
Definition: quantum-private.h:55
Definition: magick-type.h:193
const unsigned int * mask
Definition: quantum-private.h:42
unsigned short Quantum
Definition: magick-type.h:85
#define ExponentBias
size_t bits
Definition: quantum-private.h:39
size_t extent
Definition: quantum-private.h:76
static unsigned char * PopCharPixel(const unsigned char pixel, unsigned char *pixels)
Definition: quantum-private.h:185
static unsigned char * PopShortPixel(const EndianType endian, const unsigned short pixel, unsigned char *pixels)
Definition: quantum-private.h:214
#define MagickMin(x, y)
Definition: image-private.h:27
double inverse_scale
Definition: quantum-private.h:33
static unsigned short SinglePrecisionToHalf(const float value)
Definition: quantum-private.h:614
#define MagickPrivate
Definition: method-attribute.h:81
struct _QuantumState QuantumState
double maximum
Definition: quantum-private.h:55
static QuantumAny ScaleQuantumToAny(const Quantum quantum, const QuantumAny range)
Definition: quantum-private.h:324
MagickBooleanType min_is_white
Definition: quantum-private.h:63
Definition: quantum-private.h:30
MagickSizeType QuantumAny
Definition: magick-type.h:150
QuantumAlphaType
Definition: quantum.h:38
Definition: semaphore.c:59
#define QuantumRange
Definition: magick-type.h:86
static const unsigned char * PushFloatPixel(const EndianType endian, const unsigned char *pixels, MagickFloatType *pixel)
Definition: quantum-private.h:281