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
48  depth,
49  quantum;
50 
53 
54  double
55  minimum,
56  maximum,
57  scale;
58 
59  size_t
60  pad;
61 
63  min_is_white,
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  return((QuantumAny) (((MagickRealType) range*quantum)/QuantumRange+0.5));
328 }
329 
330 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
331 static inline Quantum ScaleCharToQuantum(const unsigned char value)
332 {
333  return((Quantum) value);
334 }
335 
336 static inline Quantum ScaleLongToQuantum(const unsigned int value)
337 {
338 #if !defined(MAGICKCORE_HDRI_SUPPORT)
339  return((Quantum) ((value)/16843009UL));
340 #else
341  return((Quantum) (value/16843009.0));
342 #endif
343 }
344 
345 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
346 {
347  if (value <= 0.0)
348  return((Quantum) 0);
349  if (value >= MaxMap)
350  return(QuantumRange);
351 #if !defined(MAGICKCORE_HDRI_SUPPORT)
352  return((Quantum) (value+0.5));
353 #else
354  return((Quantum) value);
355 #endif
356 }
357 
358 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
359 {
360 #if !defined(MAGICKCORE_HDRI_SUPPORT)
361  return((unsigned int) (16843009UL*quantum));
362 #else
363  if (quantum <= 0.0)
364  return(0UL);
365  if ((16843009.0*quantum) >= 4294967295.0)
366  return(4294967295UL);
367  return((unsigned int) (16843009.0*quantum+0.5));
368 #endif
369 }
370 
371 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
372 {
373  if (quantum >= (Quantum) MaxMap)
374  return((unsigned int) MaxMap);
375 #if !defined(MAGICKCORE_HDRI_SUPPORT)
376  return((unsigned int) quantum);
377 #else
378  if (quantum < 0.0)
379  return(0UL);
380  return((unsigned int) (quantum+0.5));
381 #endif
382 }
383 
384 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
385 {
386 #if !defined(MAGICKCORE_HDRI_SUPPORT)
387  return((unsigned short) (257UL*quantum));
388 #else
389  if (quantum <= 0.0)
390  return(0);
391  if ((257.0*quantum) >= 65535.0)
392  return(65535);
393  return((unsigned short) (257.0*quantum+0.5));
394 #endif
395 }
396 
397 static inline Quantum ScaleShortToQuantum(const unsigned short value)
398 {
399 #if !defined(MAGICKCORE_HDRI_SUPPORT)
400  return((Quantum) ((value+128U)/257U));
401 #else
402  return((Quantum) (value/257.0));
403 #endif
404 }
405 #elif (MAGICKCORE_QUANTUM_DEPTH == 16)
406 static inline Quantum ScaleCharToQuantum(const unsigned char value)
407 {
408 #if !defined(MAGICKCORE_HDRI_SUPPORT)
409  return((Quantum) (257U*value));
410 #else
411  return((Quantum) (257.0*value));
412 #endif
413 }
414 
415 static inline Quantum ScaleLongToQuantum(const unsigned int value)
416 {
417 #if !defined(MAGICKCORE_HDRI_SUPPORT)
418  return((Quantum) ((value)/MagickULLConstant(65537)));
419 #else
420  return((Quantum) (value/65537.0));
421 #endif
422 }
423 
424 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
425 {
426  if (value <= 0.0)
427  return((Quantum) 0);
428  if (value >= MaxMap)
429  return(QuantumRange);
430 #if !defined(MAGICKCORE_HDRI_SUPPORT)
431  return((Quantum) (value+0.5));
432 #else
433  return((Quantum) value);
434 #endif
435 }
436 
437 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
438 {
439 #if !defined(MAGICKCORE_HDRI_SUPPORT)
440  return((unsigned int) (65537UL*quantum));
441 #else
442  if (quantum <= 0.0)
443  return(0UL);
444  if ((65537.0*quantum) >= 4294967295.0)
445  return(4294967295U);
446  return((unsigned int) (65537.0*quantum+0.5));
447 #endif
448 }
449 
450 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
451 {
452  if (quantum >= (Quantum) MaxMap)
453  return((unsigned int) MaxMap);
454 #if !defined(MAGICKCORE_HDRI_SUPPORT)
455  return((unsigned int) quantum);
456 #else
457  if (quantum < 0.0)
458  return(0UL);
459  return((unsigned int) (quantum+0.5));
460 #endif
461 }
462 
463 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
464 {
465 #if !defined(MAGICKCORE_HDRI_SUPPORT)
466  return((unsigned short) quantum);
467 #else
468  if (quantum <= 0.0)
469  return(0);
470  if (quantum >= 65535.0)
471  return(65535);
472  return((unsigned short) (quantum+0.5));
473 #endif
474 }
475 
476 static inline Quantum ScaleShortToQuantum(const unsigned short value)
477 {
478  return((Quantum) value);
479 }
480 #elif (MAGICKCORE_QUANTUM_DEPTH == 32)
481 static inline Quantum ScaleCharToQuantum(const unsigned char value)
482 {
483 #if !defined(MAGICKCORE_HDRI_SUPPORT)
484  return((Quantum) (16843009UL*value));
485 #else
486  return((Quantum) (16843009.0*value));
487 #endif
488 }
489 
490 static inline Quantum ScaleLongToQuantum(const unsigned int value)
491 {
492  return((Quantum) value);
493 }
494 
495 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
496 {
497  if (value <= 0.0)
498  return((Quantum) 0);
499  if (value >= (Quantum) MaxMap)
500  return(QuantumRange);
501 #if !defined(MAGICKCORE_HDRI_SUPPORT)
502  return((Quantum) (65537.0*value+0.5));
503 #else
504  return((Quantum) (65537.0*value));
505 #endif
506 }
507 
508 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
509 {
510 #if !defined(MAGICKCORE_HDRI_SUPPORT)
511  return((unsigned int) quantum);
512 #else
513  if (quantum <= 0.0)
514  return(0);
515  if ((quantum) >= 4294967295.0)
516  return(4294967295);
517  return((unsigned int) (quantum+0.5));
518 #endif
519 }
520 
521 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
522 {
523  if (quantum < 0.0)
524  return(0UL);
525  if ((quantum/65537) >= (Quantum) MaxMap)
526  return((unsigned int) MaxMap);
527 #if !defined(MAGICKCORE_HDRI_SUPPORT)
528  return((unsigned int) ((quantum+MagickULLConstant(32768))/
529  MagickULLConstant(65537)));
530 #else
531  return((unsigned int) (quantum/65537.0+0.5));
532 #endif
533 }
534 
535 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
536 {
537 #if !defined(MAGICKCORE_HDRI_SUPPORT)
538  return((unsigned short) ((quantum+MagickULLConstant(32768))/
539  MagickULLConstant(65537)));
540 #else
541  if (quantum <= 0.0)
542  return(0);
543  if ((quantum/65537.0) >= 65535.0)
544  return(65535);
545  return((unsigned short) (quantum/65537.0+0.5));
546 #endif
547 }
548 
549 static inline Quantum ScaleShortToQuantum(const unsigned short value)
550 {
551 #if !defined(MAGICKCORE_HDRI_SUPPORT)
552  return((Quantum) (65537UL*value));
553 #else
554  return((Quantum) (65537.0*value));
555 #endif
556 }
557 #elif (MAGICKCORE_QUANTUM_DEPTH == 64)
558 static inline Quantum ScaleCharToQuantum(const unsigned char value)
559 {
560  return((Quantum) (72340172838076673.0*value));
561 }
562 
563 static inline Quantum ScaleLongToQuantum(const unsigned int value)
564 {
565  return((Quantum) (4294967297.0*value));
566 }
567 
568 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
569 {
570  if (value <= 0.0)
571  return((Quantum) 0);
572  if (value >= MaxMap)
573  return(QuantumRange);
574  return((Quantum) (281479271743489.0*value));
575 }
576 
577 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
578 {
579  return((unsigned int) (quantum/4294967297.0+0.5));
580 }
581 
582 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
583 {
584  if (quantum <= 0.0)
585  return(0UL);
586  if ((quantum/281479271743489.0) >= MaxMap)
587  return((unsigned int) MaxMap);
588  return((unsigned int) (quantum/281479271743489.0+0.5));
589 }
590 
591 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
592 {
593  if (quantum <= 0.0)
594  return(0);
595  if ((quantum/281479271743489.0) >= 65535.0)
596  return(65535);
597  return((unsigned short) (quantum/281479271743489.0+0.5));
598 }
599 
600 static inline Quantum ScaleShortToQuantum(const unsigned short value)
601 {
602  return((Quantum) (281479271743489.0*value));
603 }
604 #endif
605 
606 static inline unsigned short SinglePrecisionToHalf(const float value)
607 {
608  typedef union _SinglePrecision
609  {
610  unsigned int
611  fixed_point;
612 
613  float
614  single_precision;
615  } SinglePrecision;
616 
617  register int
618  exponent;
619 
620  register unsigned int
621  significand,
622  sign_bit;
623 
624  SinglePrecision
625  map;
626 
627  unsigned short
628  half;
629 
630  /*
631  The IEEE 754 standard specifies half precision as having:
632 
633  Sign bit: 1 bit
634  Exponent width: 5 bits
635  Significand precision: 11 (10 explicitly stored)
636  */
637  map.single_precision=value;
638  sign_bit=(map.fixed_point >> 16) & 0x00008000;
639  exponent=(int) ((map.fixed_point >> ExponentShift) & 0x000000ff)-ExponentBias;
640  significand=map.fixed_point & 0x007fffff;
641  if (exponent <= 0)
642  {
643  int
644  shift;
645 
646  if (exponent < -10)
647  return((unsigned short) sign_bit);
648  significand=significand | 0x00800000;
649  shift=(int) (14-exponent);
650  significand=(unsigned int) ((significand+((1 << (shift-1))-1)+
651  ((significand >> shift) & 0x01)) >> shift);
652  return((unsigned short) (sign_bit | significand));
653  }
654  else
655  if (exponent == (0xff-ExponentBias))
656  {
657  if (significand == 0)
658  return((unsigned short) (sign_bit | ExponentMask));
659  else
660  {
661  significand>>=SignificandShift;
662  half=(unsigned short) (sign_bit | significand |
663  (significand == 0) | ExponentMask);
664  return(half);
665  }
666  }
667  significand=significand+((significand >> SignificandShift) & 0x01)+0x00000fff;
668  if ((significand & 0x00800000) != 0)
669  {
670  significand=0;
671  exponent++;
672  }
673  if (exponent > 30)
674  {
675  float
676  alpha;
677 
678  register int
679  i;
680 
681  /*
682  Float overflow.
683  */
684  alpha=1.0e10;
685  for (i=0; i < 10; i++)
686  alpha*=alpha;
687  return((unsigned short) (sign_bit | ExponentMask));
688  }
689  half=(unsigned short) (sign_bit | (exponent << 10) |
690  (significand >> SignificandShift));
691  return(half);
692 }
693 
694 #if defined(__cplusplus) || defined(c_plusplus)
695 }
696 #endif
697 
698 #endif
MagickDoubleType MagickRealType
Definition: magick-type.h:125
QuantumFormatType
Definition: quantum.h:44
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:33
MagickPrivate void ResetQuantumState(QuantumInfo *)
Definition: quantum.c:578
#define SignBitShift
#define SignificandMask
QuantumState state
Definition: quantum-private.h:82
float MagickFloatType
Definition: magick-type.h:43
Definition: memory.c:131
EndianType
Definition: quantum.h:30
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
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
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:606
#define MagickPrivate
Definition: method-attribute.h:81
struct _QuantumState QuantumState
static QuantumAny ScaleQuantumToAny(const Quantum quantum, const QuantumAny range)
Definition: quantum-private.h:324
Definition: quantum-private.h:30
MagickSizeType QuantumAny
Definition: magick-type.h:150
QuantumAlphaType
Definition: quantum.h:37
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