MagickCore  6.8.9
quantum-private.h
Go to the documentation of this file.
1 /*
2  Copyright 1999-2014 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=(unsigned int) (quantum & 0xffffffff);
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=(unsigned int) (quantum & 0xffffffff);
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 !defined(MAGICKCORE_HDRI_SUPPORT)
275  return((Quantum) (((MagickRealType) QuantumRange*quantum)/range+0.5));
276 #else
277  return((Quantum) (((MagickRealType) QuantumRange*quantum)/range));
278 #endif
279 }
280 
281 static inline QuantumAny ScaleQuantumToAny(const Quantum quantum,
282  const QuantumAny range)
283 {
284  return((QuantumAny) (((MagickRealType) range*quantum)/QuantumRange+0.5));
285 }
286 
287 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
288 static inline Quantum ScaleCharToQuantum(const unsigned char value)
289 {
290  return((Quantum) value);
291 }
292 
293 static inline Quantum ScaleLongToQuantum(const unsigned int value)
294 {
295 #if !defined(MAGICKCORE_HDRI_SUPPORT)
296  return((Quantum) ((value+8421504UL)/16843009UL));
297 #else
298  return((Quantum) (value/16843009.0));
299 #endif
300 }
301 
302 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
303 {
304  if (value <= 0.0)
305  return((Quantum) 0);
306  if (value >= MaxMap)
307  return(QuantumRange);
308 #if !defined(MAGICKCORE_HDRI_SUPPORT)
309  return((Quantum) (value+0.5));
310 #else
311  return((Quantum) value);
312 #endif
313 }
314 
315 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
316 {
317 #if !defined(MAGICKCORE_HDRI_SUPPORT)
318  return((unsigned int) (16843009UL*quantum));
319 #else
320  if (quantum <= 0.0)
321  return(0UL);
322  if ((16843009.0*quantum) >= 4294967295.0)
323  return(4294967295UL);
324  return((unsigned int) (16843009.0*quantum+0.5));
325 #endif
326 }
327 
328 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
329 {
330  if (quantum >= (Quantum) MaxMap)
331  return((unsigned int) MaxMap);
332 #if !defined(MAGICKCORE_HDRI_SUPPORT)
333  return((unsigned int) quantum);
334 #else
335  if (quantum < 0.0)
336  return(0UL);
337  return((unsigned int) (quantum+0.5));
338 #endif
339 }
340 
341 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
342 {
343 #if !defined(MAGICKCORE_HDRI_SUPPORT)
344  return((unsigned short) (257UL*quantum));
345 #else
346  if (quantum <= 0.0)
347  return(0);
348  if ((257.0*quantum) >= 65535.0)
349  return(65535);
350  return((unsigned short) (257.0*quantum+0.5));
351 #endif
352 }
353 
354 static inline Quantum ScaleShortToQuantum(const unsigned short value)
355 {
356 #if !defined(MAGICKCORE_HDRI_SUPPORT)
357  return((Quantum) ((value+128U)/257U));
358 #else
359  return((Quantum) (value/257.0));
360 #endif
361 }
362 #elif (MAGICKCORE_QUANTUM_DEPTH == 16)
363 static inline Quantum ScaleCharToQuantum(const unsigned char value)
364 {
365 #if !defined(MAGICKCORE_HDRI_SUPPORT)
366  return((Quantum) (257U*value));
367 #else
368  return((Quantum) (257.0*value));
369 #endif
370 }
371 
372 static inline Quantum ScaleLongToQuantum(const unsigned int value)
373 {
374 #if !defined(MAGICKCORE_HDRI_SUPPORT)
375  return((Quantum) ((value+MagickULLConstant(32768))/
376  MagickULLConstant(65537)));
377 #else
378  return((Quantum) (value/65537.0));
379 #endif
380 }
381 
382 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
383 {
384  if (value <= 0.0)
385  return((Quantum) 0);
386  if (value >= MaxMap)
387  return(QuantumRange);
388 #if !defined(MAGICKCORE_HDRI_SUPPORT)
389  return((Quantum) (value+0.5));
390 #else
391  return((Quantum) value);
392 #endif
393 }
394 
395 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
396 {
397 #if !defined(MAGICKCORE_HDRI_SUPPORT)
398  return((unsigned int) (65537UL*quantum));
399 #else
400  if (quantum <= 0.0)
401  return(0UL);
402  if ((65537.0*quantum) >= 4294967295.0)
403  return(4294967295U);
404  return((unsigned int) (65537.0*quantum+0.5));
405 #endif
406 }
407 
408 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
409 {
410  if (quantum >= (Quantum) MaxMap)
411  return((unsigned int) MaxMap);
412 #if !defined(MAGICKCORE_HDRI_SUPPORT)
413  return((unsigned int) quantum);
414 #else
415  if (quantum < 0.0)
416  return(0UL);
417  return((unsigned int) (quantum+0.5));
418 #endif
419 }
420 
421 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
422 {
423 #if !defined(MAGICKCORE_HDRI_SUPPORT)
424  return((unsigned short) quantum);
425 #else
426  if (quantum <= 0.0)
427  return(0);
428  if (quantum >= 65535.0)
429  return(65535);
430  return((unsigned short) (quantum+0.5));
431 #endif
432 }
433 
434 static inline Quantum ScaleShortToQuantum(const unsigned short value)
435 {
436  return((Quantum) value);
437 }
438 #elif (MAGICKCORE_QUANTUM_DEPTH == 32)
439 static inline Quantum ScaleCharToQuantum(const unsigned char value)
440 {
441 #if !defined(MAGICKCORE_HDRI_SUPPORT)
442  return((Quantum) (16843009UL*value));
443 #else
444  return((Quantum) (16843009.0*value));
445 #endif
446 }
447 
448 static inline Quantum ScaleLongToQuantum(const unsigned int value)
449 {
450  return((Quantum) value);
451 }
452 
453 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
454 {
455  if (value <= 0.0)
456  return((Quantum) 0);
457  if (value >= (Quantum) MaxMap)
458  return(QuantumRange);
459 #if !defined(MAGICKCORE_HDRI_SUPPORT)
460  return((Quantum) (65537.0*value+0.5));
461 #else
462  return((Quantum) (65537.0*value));
463 #endif
464 }
465 
466 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
467 {
468 #if !defined(MAGICKCORE_HDRI_SUPPORT)
469  return((unsigned int) quantum);
470 #else
471  if (quantum <= 0.0)
472  return(0);
473  if ((quantum) >= 4294967295.0)
474  return(4294967295);
475  return((unsigned int) (quantum+0.5));
476 #endif
477 }
478 
479 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
480 {
481  if (quantum < 0.0)
482  return(0UL);
483  if ((quantum/65537) >= (Quantum) MaxMap)
484  return((unsigned int) MaxMap);
485 #if !defined(MAGICKCORE_HDRI_SUPPORT)
486  return((unsigned int) ((quantum+MagickULLConstant(32768))/
487  MagickULLConstant(65537)));
488 #else
489  return((unsigned int) (quantum/65537.0+0.5));
490 #endif
491 }
492 
493 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
494 {
495 #if !defined(MAGICKCORE_HDRI_SUPPORT)
496  return((unsigned short) ((quantum+MagickULLConstant(32768))/
497  MagickULLConstant(65537)));
498 #else
499  if (quantum <= 0.0)
500  return(0);
501  if ((quantum/65537.0) >= 65535.0)
502  return(65535);
503  return((unsigned short) (quantum/65537.0+0.5));
504 #endif
505 }
506 
507 static inline Quantum ScaleShortToQuantum(const unsigned short value)
508 {
509 #if !defined(MAGICKCORE_HDRI_SUPPORT)
510  return((Quantum) (65537UL*value));
511 #else
512  return((Quantum) (65537.0*value));
513 #endif
514 }
515 #elif (MAGICKCORE_QUANTUM_DEPTH == 64)
516 static inline Quantum ScaleCharToQuantum(const unsigned char value)
517 {
518  return((Quantum) (72340172838076673.0*value));
519 }
520 
521 static inline Quantum ScaleLongToQuantum(const unsigned int value)
522 {
523  return((Quantum) (4294967297.0*value));
524 }
525 
526 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
527 {
528  if (value <= 0.0)
529  return((Quantum) 0);
530  if (value >= MaxMap)
531  return(QuantumRange);
532  return((Quantum) (281479271743489.0*value));
533 }
534 
535 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
536 {
537  return((unsigned int) (quantum/4294967297.0+0.5));
538 }
539 
540 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
541 {
542  if (quantum <= 0.0)
543  return(0UL);
544  if ((quantum/281479271743489.0) >= MaxMap)
545  return((unsigned int) MaxMap);
546  return((unsigned int) (quantum/281479271743489.0+0.5));
547 }
548 
549 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
550 {
551  if (quantum <= 0.0)
552  return(0);
553  if ((quantum/281479271743489.0) >= 65535.0)
554  return(65535);
555  return((unsigned short) (quantum/281479271743489.0+0.5));
556 }
557 
558 static inline Quantum ScaleShortToQuantum(const unsigned short value)
559 {
560  return((Quantum) (281479271743489.0*value));
561 }
562 #endif
563 
564 static inline unsigned short SinglePrecisionToHalf(const float value)
565 {
566  typedef union _SinglePrecision
567  {
568  unsigned int
569  fixed_point;
570 
571  float
572  single_precision;
573  } SinglePrecision;
574 
575  register int
576  exponent;
577 
578  register unsigned int
579  significand,
580  sign_bit;
581 
582  SinglePrecision
583  map;
584 
585  unsigned short
586  half;
587 
588  /*
589  The IEEE 754 standard specifies half precision as having:
590 
591  Sign bit: 1 bit
592  Exponent width: 5 bits
593  Significand precision: 11 (10 explicitly stored)
594  */
595  map.single_precision=value;
596  sign_bit=(map.fixed_point >> 16) & 0x00008000;
597  exponent=(int) ((map.fixed_point >> ExponentShift) & 0x000000ff)-ExponentBias;
598  significand=map.fixed_point & 0x007fffff;
599  if (exponent <= 0)
600  {
601  int
602  shift;
603 
604  if (exponent < -10)
605  return((unsigned short) sign_bit);
606  significand=significand | 0x00800000;
607  shift=(int) (14-exponent);
608  significand=(unsigned int) ((significand+((1 << (shift-1))-1)+
609  ((significand >> shift) & 0x01)) >> shift);
610  return((unsigned short) (sign_bit | significand));
611  }
612  else
613  if (exponent == (0xff-ExponentBias))
614  {
615  if (significand == 0)
616  return((unsigned short) (sign_bit | ExponentMask));
617  else
618  {
619  significand>>=SignificandShift;
620  half=(unsigned short) (sign_bit | significand |
621  (significand == 0) | ExponentMask);
622  return(half);
623  }
624  }
625  significand=significand+((significand >> SignificandShift) & 0x01)+0x00000fff;
626  if ((significand & 0x00800000) != 0)
627  {
628  significand=0;
629  exponent++;
630  }
631  if (exponent > 30)
632  {
633  float
634  alpha;
635 
636  register int
637  i;
638 
639  /*
640  Float overflow.
641  */
642  alpha=1.0e10;
643  for (i=0; i < 10; i++)
644  alpha*=alpha;
645  return((unsigned short) (sign_bit | ExponentMask));
646  }
647  half=(unsigned short) (sign_bit | (exponent << 10) |
648  (significand >> SignificandShift));
649  return(half);
650 }
651 
652 #if defined(__cplusplus) || defined(c_plusplus)
653 }
654 #endif
655 
656 #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:578
#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:564
#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:281
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