MagickCore 7.1.2-27
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
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)
28extern "C" {
29#endif
30
31typedef 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
46struct _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
95extern MagickExport MagickBooleanType
96 SetQuantumExtent(const Image *,QuantumInfo *);
97
98extern MagickPrivate void
99 ResetQuantumState(QuantumInfo *);
100
101static 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
117static 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
126static 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
199static inline unsigned char *PopCharPixel(const unsigned char pixel,
200 unsigned char *magick_restrict pixels)
201{
202 *pixels++=pixel;
203 return(pixels);
204}
205
206static 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
228static 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
246static 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
254static 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
278static 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
298static 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
328static 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
342static 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)
357static inline Quantum ScaleCharToQuantum(const unsigned char value)
358{
359 return((Quantum) value);
360}
361
362static 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
371static 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
380static 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
393static 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
406static 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
419static 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
432static 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
445static 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)
454static 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
463static 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
472static 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
481static 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
494static 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
507static 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
520static 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
533static 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
546static inline Quantum ScaleShortToQuantum(const unsigned short value)
547{
548 return((Quantum) value);
549}
550#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
551static 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
560static inline Quantum ScaleLongToQuantum(const unsigned int value)
561{
562 return((Quantum) value);
563}
564
565static 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
574static 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
587static 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
600static 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
613static 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
627static 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
641static 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)
650static inline Quantum ScaleCharToQuantum(const unsigned char value)
651{
652 return((Quantum) (72340172838076673.0*value));
653}
654
655static inline Quantum ScaleLongToQuantum(const unsigned int value)
656{
657 return((Quantum) (4294967297.0*value));
658}
659
660static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
661{
662 return((Quantum) (value));
663}
664
665static 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
674static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
675{
676 return((unsigned int) (quantum/4294967297.0+0.5));
677}
678
679static 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
692static 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
701static 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
710static inline Quantum ScaleShortToQuantum(const unsigned short value)
711{
712 return((Quantum) (281479271743489.0*value));
713}
714#endif
715
716static 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