MagickCore  7.1.2-29
Convert, Edit, Or Compose Bitmap Images
quantum-private.h
1 /*
2  Copyright @ 1999 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/license/
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 "MagickCore/memory_.h"
22 #include "MagickCore/cache.h"
23 #include "MagickCore/image-private.h"
24 #include "MagickCore/pixel-accessor.h"
25 #include "MagickCore/statistic-private.h"
26 
27 #if defined(__cplusplus) || defined(c_plusplus)
28 extern "C" {
29 #endif
30 
31 typedef struct _QuantumState
32 {
33  double
34  inverse_scale;
35 
36  unsigned int
37  pixel;
38 
39  size_t
40  bits;
41 
42  const unsigned int
43  *mask;
44 } QuantumState;
45 
46 struct _QuantumInfo
47 {
48  size_t
49  depth,
50  quantum;
51 
52  QuantumFormatType
53  format;
54 
55  double
56  minimum,
57  maximum,
58  scale;
59 
60  size_t
61  pad;
62 
63  MagickBooleanType
64  min_is_white,
65  pack;
66 
67  QuantumAlphaType
68  alpha_type;
69 
70  size_t
71  number_threads;
72 
73  MemoryInfo
74  **pixels;
75 
76  size_t
77  extent;
78 
79  EndianType
80  endian;
81 
82  QuantumState
83  state;
84 
85  SemaphoreInfo
86  *semaphore;
87 
88  size_t
89  signature;
90 
91  size_t
92  meta_channel;
93 };
94 
95 extern MagickExport MagickBooleanType
96  SetQuantumExtent(const Image *,QuantumInfo *);
97 
98 extern MagickPrivate void
99  ResetQuantumState(QuantumInfo *);
100 
101 static inline MagickSizeType GetQuantumRange(const size_t depth)
102 {
103  MagickSizeType
104  one;
105 
106  size_t
107  max_depth;
108 
109  if (depth == 0)
110  return(0);
111  one=1;
112  max_depth=8*sizeof(MagickSizeType);
113  return((MagickSizeType) ((one << (MagickMin(depth,max_depth)-1))+
114  ((one << (MagickMin(depth,max_depth)-1))-1)));
115 }
116 
117 static inline EndianType GetHostEndian(void)
118 {
119  unsigned long
120  lsb_first;
121 
122  lsb_first=1;
123  return((*(char *) &lsb_first) == 1 ? LSBEndian : MSBEndian);
124 }
125 
126 static inline float HalfToSinglePrecision(const unsigned short half)
127 {
128 #define ExponentBias (127-15)
129 #define ExponentMask (0x7c00U)
130 #define ExponentShift 23
131 #define SignBitShift 31
132 #define SignificandShift 13
133 #define SignificandMask (0x00000400U)
134 
135  typedef union _SinglePrecision
136  {
137  unsigned int
138  fixed_point;
139 
140  float
141  single_precision;
142  } SinglePrecision;
143 
144  SinglePrecision
145  map;
146 
147  unsigned int
148  exponent,
149  significand,
150  sign_bit,
151  value;
152 
153  /*
154  The IEEE 754 standard specifies half precision as having:
155 
156  Sign bit: 1 bit
157  Exponent width: 5 bits
158  Significand precision: 11 (10 explicitly stored)
159  */
160  sign_bit=(unsigned int) ((half >> 15) & 0x00000001);
161  exponent=(unsigned int) ((half >> 10) & 0x0000001f);
162  significand=(unsigned int) (half & 0x000003ff);
163  if (exponent == 0)
164  {
165  if (significand == 0)
166  value=sign_bit << SignBitShift;
167  else
168  {
169  while ((significand & SignificandMask) == 0)
170  {
171  significand<<=1;
172  exponent--;
173  }
174  exponent++;
175  significand&=(~SignificandMask);
176  exponent+=ExponentBias;
177  value=(sign_bit << SignBitShift) | (exponent << ExponentShift) |
178  (significand << SignificandShift);
179  }
180  }
181  else
182  if (exponent == SignBitShift)
183  {
184  value=(sign_bit << SignBitShift) | 0x7f800000;
185  if (significand != 0)
186  value|=(significand << SignificandShift);
187  }
188  else
189  {
190  exponent+=ExponentBias;
191  significand<<=SignificandShift;
192  value=(sign_bit << SignBitShift) | (exponent << ExponentShift) |
193  significand;
194  }
195  map.fixed_point=value;
196  return(map.single_precision);
197 }
198 
199 static inline unsigned char *PopCharPixel(const unsigned char pixel,
200  unsigned char *magick_restrict pixels)
201 {
202  *pixels++=pixel;
203  return(pixels);
204 }
205 
206 static inline unsigned char *PopLongPixel(const EndianType endian,
207  const unsigned int pixel,unsigned char *magick_restrict pixels)
208 {
209  unsigned int
210  quantum;
211 
212  quantum=(unsigned int) pixel;
213  if (endian == LSBEndian)
214  {
215  *pixels++=(unsigned char) (quantum);
216  *pixels++=(unsigned char) (quantum >> 8);
217  *pixels++=(unsigned char) (quantum >> 16);
218  *pixels++=(unsigned char) (quantum >> 24);
219  return(pixels);
220  }
221  *pixels++=(unsigned char) (quantum >> 24);
222  *pixels++=(unsigned char) (quantum >> 16);
223  *pixels++=(unsigned char) (quantum >> 8);
224  *pixels++=(unsigned char) (quantum);
225  return(pixels);
226 }
227 
228 static inline unsigned char *PopShortPixel(const EndianType endian,
229  const unsigned short pixel,unsigned char *magick_restrict pixels)
230 {
231  unsigned int
232  quantum;
233 
234  quantum=pixel;
235  if (endian == LSBEndian)
236  {
237  *pixels++=(unsigned char) (quantum);
238  *pixels++=(unsigned char) (quantum >> 8);
239  return(pixels);
240  }
241  *pixels++=(unsigned char) (quantum >> 8);
242  *pixels++=(unsigned char) (quantum);
243  return(pixels);
244 }
245 
246 static inline const unsigned char *PushCharPixel(
247  const unsigned char *magick_restrict pixels,
248  unsigned char *magick_restrict pixel)
249 {
250  *pixel=(*pixels++);
251  return(pixels);
252 }
253 
254 static inline const unsigned char *PushLongPixel(const EndianType endian,
255  const unsigned char *magick_restrict pixels,
256  unsigned int *magick_restrict pixel)
257 {
258  unsigned int
259  quantum;
260 
261  if (endian == LSBEndian)
262  {
263  quantum=((unsigned int) *pixels++);
264  quantum|=((unsigned int) *pixels++ << 8);
265  quantum|=((unsigned int) *pixels++ << 16);
266  quantum|=((unsigned int) *pixels++ << 24);
267  *pixel=quantum;
268  return(pixels);
269  }
270  quantum=((unsigned int) *pixels++ << 24);
271  quantum|=((unsigned int) *pixels++ << 16);
272  quantum|=((unsigned int) *pixels++ << 8);
273  quantum|=((unsigned int) *pixels++);
274  *pixel=quantum;
275  return(pixels);
276 }
277 
278 static inline const unsigned char *PushShortPixel(const EndianType endian,
279  const unsigned char *magick_restrict pixels,
280  unsigned short *magick_restrict pixel)
281 {
282  unsigned int
283  quantum;
284 
285  if (endian == LSBEndian)
286  {
287  quantum=(unsigned int) *pixels++;
288  quantum|=(unsigned int) (*pixels++ << 8);
289  *pixel=(unsigned short) (quantum & 0xffff);
290  return(pixels);
291  }
292  quantum=(unsigned int) (*pixels++ << 8);
293  quantum|=(unsigned int) *pixels++;
294  *pixel=(unsigned short) (quantum & 0xffff);
295  return(pixels);
296 }
297 
298 static inline const unsigned char *PushFloatPixel(const EndianType endian,
299  const unsigned char *magick_restrict pixels,
300  MagickFloatType *magick_restrict pixel)
301 {
302  union
303  {
304  unsigned int
305  unsigned_value;
306 
307  MagickFloatType
308  float_value;
309  } quantum;
310 
311  if (endian == LSBEndian)
312  {
313  quantum.unsigned_value=((unsigned int) *pixels++);
314  quantum.unsigned_value|=((unsigned int) *pixels++ << 8);
315  quantum.unsigned_value|=((unsigned int) *pixels++ << 16);
316  quantum.unsigned_value|=((unsigned int) *pixels++ << 24);
317  *pixel=quantum.float_value;
318  return(pixels);
319  }
320  quantum.unsigned_value=((unsigned int) *pixels++ << 24);
321  quantum.unsigned_value|=((unsigned int) *pixels++ << 16);
322  quantum.unsigned_value|=((unsigned int) *pixels++ << 8);
323  quantum.unsigned_value|=((unsigned int) *pixels++);
324  *pixel=quantum.float_value;
325  return(pixels);
326 }
327 
328 static inline Quantum ScaleAnyToQuantum(const QuantumAny quantum,
329  const QuantumAny range)
330 {
331  if (quantum > range)
332  return(QuantumRange);
333 #if !defined(MAGICKCORE_HDRI_SUPPORT)
334  return((Quantum) ((double) QuantumRange*(quantum*
335  MagickSafeReciprocal((double) range))+0.5));
336 #else
337  return((Quantum) ((double) QuantumRange*(quantum*
338  MagickSafeReciprocal((double) range))));
339 #endif
340 }
341 
342 static inline QuantumAny ScaleQuantumToAny(const Quantum quantum,
343  const QuantumAny range)
344 {
345 #if !defined(MAGICKCORE_HDRI_SUPPORT)
346  return((QuantumAny) ((double) range*quantum/QuantumRange));
347 #else
348  if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
349  return((QuantumAny) 0UL);
350  if (((double) range*quantum/(double) QuantumRange) >= 18446744073709551615.0)
351  return((QuantumAny) MagickULLConstant(18446744073709551615));
352  return((QuantumAny) (range*(double) quantum/(double) QuantumRange+0.5));
353 #endif
354 }
355 
356 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
357 static inline Quantum ScaleCharToQuantum(const unsigned char value)
358 {
359  return((Quantum) value);
360 }
361 
362 static inline Quantum ScaleLongToQuantum(const unsigned int value)
363 {
364 #if !defined(MAGICKCORE_HDRI_SUPPORT)
365  return((Quantum) ((value)/16843009UL));
366 #else
367  return((Quantum) (value/16843009.0));
368 #endif
369 }
370 
371 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
372 {
373 #if !defined(MAGICKCORE_HDRI_SUPPORT)
374  return((Quantum) (value/MagickULLConstant(72340172838076673)));
375 #else
376  return((Quantum) (value/72340172838076673.0));
377 #endif
378 }
379 
380 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
381 {
382  if (value <= 0.0)
383  return((Quantum) 0);
384  if (value >= MaxMap)
385  return(QuantumRange);
386 #if !defined(MAGICKCORE_HDRI_SUPPORT)
387  return((Quantum) (value+0.5));
388 #else
389  return((Quantum) value);
390 #endif
391 }
392 
393 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
394 {
395 #if !defined(MAGICKCORE_HDRI_SUPPORT)
396  return((unsigned int) (16843009UL*quantum));
397 #else
398  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
399  return(0U);
400  if ((16843009.0*quantum) >= 4294967295.0)
401  return(4294967295UL);
402  return((unsigned int) (16843009.0*quantum+0.5));
403 #endif
404 }
405 
406 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
407 {
408 #if !defined(MAGICKCORE_HDRI_SUPPORT)
409  return((MagickSizeType) (MagickULLConstant(72340172838076673)*quantum));
410 #else
411  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
412  return(0UL);
413  if ((72340172838076673.0*quantum) >= 18446744073709551615.0)
414  return(MagickULLConstant(18446744073709551615));
415  return((MagickSizeType) (72340172838076673.0*quantum+0.5));
416 #endif
417 }
418 
419 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
420 {
421  if (quantum >= (Quantum) MaxMap)
422  return((unsigned int) MaxMap);
423 #if !defined(MAGICKCORE_HDRI_SUPPORT)
424  return((unsigned int) quantum);
425 #else
426  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
427  return(0U);
428  return((unsigned int) (quantum+0.5));
429 #endif
430 }
431 
432 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
433 {
434 #if !defined(MAGICKCORE_HDRI_SUPPORT)
435  return((unsigned short) (257UL*quantum));
436 #else
437  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
438  return(0);
439  if ((257.0*quantum) >= 65535.0)
440  return(65535);
441  return((unsigned short) (257.0*quantum+0.5));
442 #endif
443 }
444 
445 static inline Quantum ScaleShortToQuantum(const unsigned short value)
446 {
447 #if !defined(MAGICKCORE_HDRI_SUPPORT)
448  return((Quantum) ((value+128U)/257U));
449 #else
450  return((Quantum) (value/257.0));
451 #endif
452 }
453 #elif (MAGICKCORE_QUANTUM_DEPTH == 16)
454 static inline Quantum ScaleCharToQuantum(const unsigned char value)
455 {
456 #if !defined(MAGICKCORE_HDRI_SUPPORT)
457  return((Quantum) (257U*value));
458 #else
459  return((Quantum) (257.0*value));
460 #endif
461 }
462 
463 static inline Quantum ScaleLongToQuantum(const unsigned int value)
464 {
465 #if !defined(MAGICKCORE_HDRI_SUPPORT)
466  return((Quantum) ((value)/MagickULLConstant(65537)));
467 #else
468  return((Quantum) (value/65537.0));
469 #endif
470 }
471 
472 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
473 {
474 #if !defined(MAGICKCORE_HDRI_SUPPORT)
475  return((Quantum) ((value)/MagickULLConstant(281479271743489)));
476 #else
477  return((Quantum) (value/281479271743489.0));
478 #endif
479 }
480 
481 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
482 {
483  if (value <= 0.0)
484  return((Quantum) 0);
485  if (value >= MaxMap)
486  return(QuantumRange);
487 #if !defined(MAGICKCORE_HDRI_SUPPORT)
488  return((Quantum) (value+0.5));
489 #else
490  return((Quantum) value);
491 #endif
492 }
493 
494 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
495 {
496 #if !defined(MAGICKCORE_HDRI_SUPPORT)
497  return((unsigned int) (65537UL*quantum));
498 #else
499  if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
500  return(0U);
501  if ((65537.0*(double) quantum) >= 4294967295.0)
502  return(4294967295U);
503  return((unsigned int) (65537.0*(double) quantum+0.5));
504 #endif
505 }
506 
507 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
508 {
509 #if !defined(MAGICKCORE_HDRI_SUPPORT)
510  return((MagickSizeType) (MagickULLConstant(281479271743489)*quantum));
511 #else
512  if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
513  return(0UL);
514  if ((281479271743489.0*(double) quantum) >= 18446744073709551615.0)
515  return(MagickULLConstant(18446744073709551615));
516  return((MagickSizeType) (281479271743489.0*(double) quantum+0.5));
517 #endif
518 }
519 
520 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
521 {
522  if (quantum >= (Quantum) MaxMap)
523  return((unsigned int) MaxMap);
524 #if !defined(MAGICKCORE_HDRI_SUPPORT)
525  return((unsigned int) quantum);
526 #else
527  if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
528  return(0U);
529  return((unsigned int) (quantum+0.5f));
530 #endif
531 }
532 
533 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
534 {
535 #if !defined(MAGICKCORE_HDRI_SUPPORT)
536  return((unsigned short) quantum);
537 #else
538  if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
539  return(0);
540  if (quantum >= 65535.0f)
541  return(65535);
542  return((unsigned short) (quantum+0.5f));
543 #endif
544 }
545 
546 static inline Quantum ScaleShortToQuantum(const unsigned short value)
547 {
548  return((Quantum) value);
549 }
550 #elif (MAGICKCORE_QUANTUM_DEPTH == 32)
551 static inline Quantum ScaleCharToQuantum(const unsigned char value)
552 {
553 #if !defined(MAGICKCORE_HDRI_SUPPORT)
554  return((Quantum) (16843009UL*value));
555 #else
556  return((Quantum) (16843009.0*value));
557 #endif
558 }
559 
560 static inline Quantum ScaleLongToQuantum(const unsigned int value)
561 {
562  return((Quantum) value);
563 }
564 
565 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
566 {
567 #if !defined(MAGICKCORE_HDRI_SUPPORT)
568  return((Quantum) ((value)/MagickULLConstant(4294967297)));
569 #else
570  return((Quantum) (value/4294967297.0));
571 #endif
572 }
573 
574 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
575 {
576  if (value <= 0.0)
577  return((Quantum) 0);
578  if (value >= (Quantum) MaxMap)
579  return(QuantumRange);
580 #if !defined(MAGICKCORE_HDRI_SUPPORT)
581  return((Quantum) (65537.0*value+0.5));
582 #else
583  return((Quantum) (65537.0*value));
584 #endif
585 }
586 
587 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
588 {
589 #if !defined(MAGICKCORE_HDRI_SUPPORT)
590  return((unsigned int) quantum);
591 #else
592  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
593  return(0U);
594  if ((quantum) >= 4294967295.0)
595  return(4294967295);
596  return((unsigned int) (quantum+0.5));
597 #endif
598 }
599 
600 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
601 {
602 #if !defined(MAGICKCORE_HDRI_SUPPORT)
603  return((MagickSizeType) (MagickULLConstant(4294967297)*quantum));
604 #else
605  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
606  return(0UL);
607  if ((4294967297.0*quantum) >= 18446744073709551615.0)
608  return(MagickULLConstant(18446744073709551615));
609  return((MagickSizeType) (4294967297.0*quantum+0.5));
610 #endif
611 }
612 
613 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
614 {
615  if ((quantum/65537) >= (Quantum) MaxMap)
616  return((unsigned int) MaxMap);
617 #if !defined(MAGICKCORE_HDRI_SUPPORT)
618  return((unsigned int) ((quantum+MagickULLConstant(32768))/
619  MagickULLConstant(65537)));
620 #else
621  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
622  return(0U);
623  return((unsigned int) (quantum/65537.0+0.5));
624 #endif
625 }
626 
627 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
628 {
629 #if !defined(MAGICKCORE_HDRI_SUPPORT)
630  return((unsigned short) ((quantum+MagickULLConstant(32768))/
631  MagickULLConstant(65537)));
632 #else
633  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
634  return(0);
635  if ((quantum/65537.0) >= 65535.0)
636  return(65535);
637  return((unsigned short) (quantum/65537.0+0.5));
638 #endif
639 }
640 
641 static inline Quantum ScaleShortToQuantum(const unsigned short value)
642 {
643 #if !defined(MAGICKCORE_HDRI_SUPPORT)
644  return((Quantum) (65537UL*value));
645 #else
646  return((Quantum) (65537.0*value));
647 #endif
648 }
649 #elif (MAGICKCORE_QUANTUM_DEPTH == 64)
650 static inline Quantum ScaleCharToQuantum(const unsigned char value)
651 {
652  return((Quantum) (72340172838076673.0*value));
653 }
654 
655 static inline Quantum ScaleLongToQuantum(const unsigned int value)
656 {
657  return((Quantum) (4294967297.0*value));
658 }
659 
660 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
661 {
662  return((Quantum) (value));
663 }
664 
665 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
666 {
667  if (value <= 0.0)
668  return((Quantum) 0);
669  if (value >= MaxMap)
670  return(QuantumRange);
671  return((Quantum) (281479271743489.0*value));
672 }
673 
674 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
675 {
676  return((unsigned int) (quantum/4294967297.0+0.5));
677 }
678 
679 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
680 {
681 #if !defined(MAGICKCORE_HDRI_SUPPORT)
682  return((MagickSizeType) quantum);
683 #else
684  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
685  return(0UL);
686  if (quantum >= 18446744073709551615.0)
687  return(MagickULLConstant(18446744073709551615));
688  return((MagickSizeType) (quantum+0.5));
689 #endif
690 }
691 
692 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
693 {
694  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
695  return(0U);
696  if ((quantum/281479271743489.0) >= MaxMap)
697  return((unsigned int) MaxMap);
698  return((unsigned int) (quantum/281479271743489.0+0.5));
699 }
700 
701 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
702 {
703  if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
704  return(0);
705  if ((quantum/281479271743489.0) >= 65535.0)
706  return(65535);
707  return((unsigned short) (quantum/281479271743489.0+0.5));
708 }
709 
710 static inline Quantum ScaleShortToQuantum(const unsigned short value)
711 {
712  return((Quantum) (281479271743489.0*value));
713 }
714 #endif
715 
716 static inline unsigned short SinglePrecisionToHalf(const double value)
717 {
718  typedef union _SinglePrecision
719  {
720  unsigned int
721  fixed_point;
722 
723  float
724  single_precision;
725  } SinglePrecision;
726 
727  int
728  exponent;
729 
730  SinglePrecision
731  map;
732 
733  unsigned int
734  significand,
735  sign_bit;
736 
737  unsigned short
738  half;
739 
740  /*
741  The IEEE 754 standard specifies half precision as having:
742 
743  Sign bit: 1 bit
744  Exponent width: 5 bits
745  Significand precision: 11 (10 explicitly stored)
746  */
747  map.single_precision=(float) value;
748  sign_bit=(map.fixed_point >> 16) & 0x00008000;
749  exponent=(int) ((map.fixed_point >> ExponentShift) & 0x000000ff)-ExponentBias;
750  significand=map.fixed_point & 0x007fffff;
751  if (exponent <= 0)
752  {
753  int
754  shift;
755 
756  if (exponent < -10)
757  return((unsigned short) sign_bit);
758  significand=significand | 0x00800000;
759  shift=(int) (14-exponent);
760  significand=(unsigned int) ((significand+((1U << (shift-1))-1)+
761  ((significand >> shift) & 0x01)) >> shift);
762  return((unsigned short) (sign_bit | significand));
763  }
764  else
765  if (exponent == (0xff-ExponentBias))
766  {
767  if (significand == 0)
768  return((unsigned short) (sign_bit | ExponentMask));
769  else
770  {
771  significand>>=SignificandShift;
772  half=(unsigned short) (sign_bit | significand |
773  (significand == 0) | ExponentMask);
774  return(half);
775  }
776  }
777  significand=significand+((significand >> SignificandShift) & 0x01)+0x00000fff;
778  if ((significand & 0x00800000) != 0)
779  {
780  significand=0;
781  exponent++;
782  }
783  if (exponent > 30)
784  {
785  float
786  alpha;
787 
788  int
789  i;
790 
791  /*
792  Float overflow.
793  */
794  alpha=1.0e10;
795  for (i=0; i < 10; i++)
796  alpha*=alpha;
797  return((unsigned short) (sign_bit | ExponentMask));
798  }
799  half=(unsigned short) (sign_bit | ((unsigned int) exponent << 10) |
800  (significand >> SignificandShift));
801  return(half);
802 }
803 
804 #if defined(__cplusplus) || defined(c_plusplus)
805 }
806 #endif
807 
808 #endif
_Image
Definition: image.h:132
_MemoryInfo
Definition: memory.c:164
_QuantumInfo
Definition: quantum-private.h:47
_QuantumState
Definition: quantum-private.h:32