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