quantum-private.h

Go to the documentation of this file.
00001 /*
00002   Copyright 1999-2019 ImageMagick Studio LLC, a non-profit organization
00003   dedicated to making software imaging solutions freely available.
00004 
00005   You may not use this file except in compliance with the License.  You may
00006   obtain a copy of the License at
00007 
00008     https://imagemagick.org/script/license.php
00009 
00010   Unless required by applicable law or agreed to in writing, software
00011   distributed under the License is distributed on an "AS IS" BASIS,
00012   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013   See the License for the specific language governing permissions and
00014   limitations under the License.
00015 
00016   MagickCore quantum inline methods.
00017 */
00018 #ifndef MAGICKCORE_QUANTUM_PRIVATE_H
00019 #define MAGICKCORE_QUANTUM_PRIVATE_H
00020 
00021 #include "MagickCore/memory_.h"
00022 #include "MagickCore/cache.h"
00023 #include "MagickCore/image-private.h"
00024 #include "MagickCore/pixel-accessor.h"
00025 
00026 #if defined(__cplusplus) || defined(c_plusplus)
00027 extern "C" {
00028 #endif
00029 
00030 typedef struct _QuantumState
00031 {
00032   double
00033     inverse_scale;
00034 
00035   unsigned int
00036     pixel;
00037 
00038   size_t
00039     bits;
00040 
00041   const unsigned int
00042     *mask;
00043 } QuantumState;
00044 
00045 struct _QuantumInfo
00046 {
00047   size_t
00048     depth,
00049     quantum;
00050 
00051   QuantumFormatType
00052     format;
00053 
00054   double
00055     minimum,
00056     maximum,
00057     scale;
00058 
00059   size_t
00060     pad;
00061 
00062   MagickBooleanType
00063     min_is_white,
00064     pack;
00065 
00066   QuantumAlphaType
00067     alpha_type;
00068 
00069   size_t
00070     number_threads;
00071 
00072   MemoryInfo
00073     **pixels;
00074 
00075   size_t
00076     extent;
00077 
00078   EndianType
00079     endian;
00080 
00081   QuantumState
00082     state;
00083 
00084   SemaphoreInfo
00085     *semaphore;
00086 
00087   size_t
00088     signature;
00089 };
00090 
00091 extern MagickPrivate void
00092   ResetQuantumState(QuantumInfo *);
00093 
00094 static inline MagickSizeType GetQuantumRange(const size_t depth)
00095 {
00096   MagickSizeType
00097     one;
00098 
00099   size_t
00100     max_depth;
00101 
00102   if (depth == 0)
00103     return(0);
00104   one=1;
00105   max_depth=8*sizeof(MagickSizeType);
00106   return((MagickSizeType) ((one << (MagickMin(depth,max_depth)-1))+
00107     ((one << (MagickMin(depth,max_depth)-1))-1)));
00108 }
00109 
00110 static inline float HalfToSinglePrecision(const unsigned short half)
00111 {
00112 #define ExponentBias  (127-15)
00113 #define ExponentMask  0x7c00
00114 #define ExponentShift  23
00115 #define SignBitShift  31
00116 #define SignificandShift  13
00117 #define SignificandMask  0x00000400
00118 
00119   typedef union _SinglePrecision
00120   {
00121     unsigned int
00122       fixed_point;
00123 
00124     float
00125       single_precision;
00126   } SinglePrecision;
00127 
00128   register unsigned int
00129     exponent,
00130     significand,
00131     sign_bit;
00132 
00133   SinglePrecision
00134     map;
00135 
00136   unsigned int
00137     value;
00138 
00139   /*
00140     The IEEE 754 standard specifies half precision as having:
00141 
00142       Sign bit: 1 bit
00143       Exponent width: 5 bits
00144       Significand precision: 11 (10 explicitly stored)
00145   */
00146   sign_bit=(unsigned int) ((half >> 15) & 0x00000001);
00147   exponent=(unsigned int) ((half >> 10) & 0x0000001f);
00148   significand=(unsigned int) (half & 0x000003ff);
00149   if (exponent == 0)
00150     {
00151       if (significand == 0)
00152         value=sign_bit << SignBitShift;
00153       else
00154         {
00155           while ((significand & SignificandMask) == 0)
00156           {
00157             significand<<=1;
00158             exponent--;
00159           }
00160           exponent++;
00161           significand&=(~SignificandMask);
00162           exponent+=ExponentBias;
00163           value=(sign_bit << SignBitShift) | (exponent << ExponentShift) |
00164             (significand << SignificandShift);
00165         }
00166     }
00167   else
00168     if (exponent == SignBitShift)
00169       {
00170         value=(sign_bit << SignBitShift) | 0x7f800000;
00171         if (significand != 0)
00172           value|=(significand << SignificandShift);
00173       }
00174     else
00175       {
00176         exponent+=ExponentBias;
00177         significand<<=SignificandShift;
00178         value=(sign_bit << SignBitShift) | (exponent << ExponentShift) |
00179           significand;
00180       }
00181   map.fixed_point=value;
00182   return(map.single_precision);
00183 }
00184 
00185 static inline unsigned char *PopCharPixel(const unsigned char pixel,
00186   unsigned char *pixels)
00187 {
00188   *pixels++=pixel;
00189   return(pixels);
00190 }
00191 
00192 static inline unsigned char *PopLongPixel(const EndianType endian,
00193   const unsigned int pixel,unsigned char *pixels)
00194 {
00195   register unsigned int
00196     quantum;
00197 
00198   quantum=(unsigned int) pixel;
00199   if (endian == LSBEndian)
00200     {
00201       *pixels++=(unsigned char) (quantum);
00202       *pixels++=(unsigned char) (quantum >> 8);
00203       *pixels++=(unsigned char) (quantum >> 16);
00204       *pixels++=(unsigned char) (quantum >> 24);
00205       return(pixels);
00206     }
00207   *pixels++=(unsigned char) (quantum >> 24);
00208   *pixels++=(unsigned char) (quantum >> 16);
00209   *pixels++=(unsigned char) (quantum >> 8);
00210   *pixels++=(unsigned char) (quantum);
00211   return(pixels);
00212 }
00213 
00214 static inline unsigned char *PopShortPixel(const EndianType endian,
00215   const unsigned short pixel,unsigned char *pixels)
00216 {
00217   register unsigned int
00218     quantum;
00219 
00220   quantum=pixel;
00221   if (endian == LSBEndian)
00222     {
00223       *pixels++=(unsigned char) (quantum);
00224       *pixels++=(unsigned char) (quantum >> 8);
00225       return(pixels);
00226     }
00227   *pixels++=(unsigned char) (quantum >> 8);
00228   *pixels++=(unsigned char) (quantum);
00229   return(pixels);
00230 }
00231 
00232 static inline const unsigned char *PushCharPixel(const unsigned char *pixels,
00233   unsigned char *pixel)
00234 {
00235   *pixel=(*pixels++);
00236   return(pixels);
00237 }
00238 
00239 static inline const unsigned char *PushLongPixel(const EndianType endian,
00240   const unsigned char *pixels,unsigned int *pixel)
00241 {
00242   register unsigned int
00243     quantum;
00244 
00245   if (endian == LSBEndian)
00246     {
00247       quantum=((unsigned int) *pixels++);
00248       quantum|=((unsigned int) *pixels++ << 8);
00249       quantum|=((unsigned int) *pixels++ << 16);
00250       quantum|=((unsigned int) *pixels++ << 24);
00251       *pixel=quantum;
00252       return(pixels);
00253     }
00254   quantum=((unsigned int) *pixels++ << 24);
00255   quantum|=((unsigned int) *pixels++ << 16);
00256   quantum|=((unsigned int) *pixels++ << 8);
00257   quantum|=((unsigned int) *pixels++);
00258   *pixel=quantum;
00259   return(pixels);
00260 }
00261 
00262 static inline const unsigned char *PushShortPixel(const EndianType endian,
00263   const unsigned char *pixels,unsigned short *pixel)
00264 {
00265   register unsigned int
00266     quantum;
00267 
00268   if (endian == LSBEndian)
00269     {
00270       quantum=(unsigned int) *pixels++;
00271       quantum|=(unsigned int) (*pixels++ << 8);
00272       *pixel=(unsigned short) (quantum & 0xffff);
00273       return(pixels);
00274     }
00275   quantum=(unsigned int) (*pixels++ << 8);
00276   quantum|=(unsigned int) *pixels++;
00277   *pixel=(unsigned short) (quantum & 0xffff);
00278   return(pixels);
00279 }
00280 
00281 static inline const unsigned char *PushFloatPixel(const EndianType endian,
00282   const unsigned char *pixels,MagickFloatType *pixel)
00283 {
00284   union
00285   {
00286     unsigned int
00287       unsigned_value;
00288 
00289     MagickFloatType
00290       float_value;
00291   } quantum;
00292 
00293   if (endian == LSBEndian)
00294     {
00295       quantum.unsigned_value=((unsigned int) *pixels++);
00296       quantum.unsigned_value|=((unsigned int) *pixels++ << 8);
00297       quantum.unsigned_value|=((unsigned int) *pixels++ << 16);
00298       quantum.unsigned_value|=((unsigned int) *pixels++ << 24);
00299       *pixel=quantum.float_value;
00300       return(pixels);
00301     }
00302   quantum.unsigned_value=((unsigned int) *pixels++ << 24);
00303   quantum.unsigned_value|=((unsigned int) *pixels++ << 16);
00304   quantum.unsigned_value|=((unsigned int) *pixels++ << 8);
00305   quantum.unsigned_value|=((unsigned int) *pixels++);
00306   *pixel=quantum.float_value;
00307   return(pixels);
00308 }
00309 
00310 static inline Quantum ScaleAnyToQuantum(const QuantumAny quantum,
00311   const QuantumAny range)
00312 {
00313   if (quantum > range)
00314     return(QuantumRange);
00315 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00316   return((Quantum) (((double) QuantumRange*quantum)*
00317     PerceptibleReciprocal((double) range)+0.5));
00318 #else
00319   return((Quantum) (((double) QuantumRange*quantum)*
00320     PerceptibleReciprocal((double) range)));
00321 #endif
00322 }
00323 
00324 static inline QuantumAny ScaleQuantumToAny(const Quantum quantum,
00325   const QuantumAny range)
00326 {
00327   return((QuantumAny) (((double) range*quantum)/QuantumRange+0.5));
00328 }
00329 
00330 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
00331 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00332 {
00333   return((Quantum) value);
00334 }
00335 
00336 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00337 {
00338 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00339   return((Quantum) ((value)/16843009UL));
00340 #else
00341   return((Quantum) (value/16843009.0));
00342 #endif
00343 }
00344 
00345 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00346 {
00347 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00348   return((Quantum) (value/MagickULLConstant(72340172838076673)));
00349 #else
00350   return((Quantum) (value/72340172838076673.0));
00351 #endif
00352 }
00353 
00354 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00355 {
00356   if (value <= 0.0)
00357     return((Quantum) 0);
00358   if (value >= MaxMap)
00359     return(QuantumRange);
00360 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00361   return((Quantum) (value+0.5));
00362 #else
00363   return((Quantum) value);
00364 #endif
00365 }
00366 
00367 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00368 {
00369 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00370   return((unsigned int) (16843009UL*quantum));
00371 #else
00372   if (quantum <= 0.0)
00373     return(0UL);
00374   if ((16843009.0*quantum) >= 4294967295.0)
00375     return(4294967295UL);
00376   return((unsigned int) (16843009.0*quantum+0.5));
00377 #endif
00378 }
00379 
00380 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00381 {
00382 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00383   return((MagickSizeType) (MagickULLConstant(72340172838076673)*quantum));
00384 #else
00385   if (quantum <= 0.0)
00386     return(0UL);
00387   if ((72340172838076673.0*quantum) >= 18446744073709551615.0)
00388     return(MagickULLConstant(18446744073709551615));
00389   return((MagickSizeType) (72340172838076673*quantum+0.5));
00390 #endif
00391 }
00392 
00393 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00394 {
00395   if (quantum >= (Quantum) MaxMap)
00396     return((unsigned int) MaxMap);
00397 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00398   return((unsigned int) quantum);
00399 #else
00400   if (quantum < 0.0)
00401     return(0UL);
00402   return((unsigned int) (quantum+0.5));
00403 #endif
00404 }
00405 
00406 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00407 {
00408 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00409   return((unsigned short) (257UL*quantum));
00410 #else
00411   if (quantum <= 0.0)
00412     return(0);
00413   if ((257.0*quantum) >= 65535.0)
00414     return(65535);
00415   return((unsigned short) (257.0*quantum+0.5));
00416 #endif
00417 }
00418 
00419 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00420 {
00421 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00422   return((Quantum) ((value+128U)/257U));
00423 #else
00424   return((Quantum) (value/257.0));
00425 #endif
00426 }
00427 #elif (MAGICKCORE_QUANTUM_DEPTH == 16)
00428 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00429 {
00430 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00431   return((Quantum) (257U*value));
00432 #else
00433   return((Quantum) (257.0*value));
00434 #endif
00435 }
00436 
00437 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00438 {
00439 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00440   return((Quantum) ((value)/MagickULLConstant(65537)));
00441 #else
00442   return((Quantum) (value/65537.0));
00443 #endif
00444 }
00445 
00446 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00447 {
00448 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00449   return((Quantum) ((value)/MagickULLConstant(281479271743489)));
00450 #else
00451   return((Quantum) (value/281479271743489.0));
00452 #endif
00453 }
00454 
00455 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00456 {
00457   if (value <= 0.0)
00458     return((Quantum) 0);
00459   if (value >= MaxMap)
00460     return(QuantumRange);
00461 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00462   return((Quantum) (value+0.5));
00463 #else
00464   return((Quantum) value);
00465 #endif
00466 }
00467 
00468 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00469 {
00470 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00471   return((unsigned int) (65537UL*quantum));
00472 #else
00473   if (quantum <= 0.0)
00474     return(0UL);
00475   if ((65537.0*quantum) >= 4294967295.0)
00476     return(4294967295U);
00477   return((unsigned int) (65537.0*quantum+0.5));
00478 #endif
00479 }
00480 
00481 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00482 {
00483 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00484   return((MagickSizeType) (MagickULLConstant(281479271743489)*quantum));
00485 #else
00486   if (quantum <= 0.0)
00487     return(0UL);
00488   if ((281479271743489.0*quantum) >= 18446744073709551615.0)
00489     return(MagickULLConstant(18446744073709551615));
00490   return((MagickSizeType) (281479271743489.0*quantum+0.5));
00491 #endif
00492 }
00493 
00494 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00495 {
00496   if (quantum >= (Quantum) MaxMap)
00497     return((unsigned int) MaxMap);
00498 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00499   return((unsigned int) quantum);
00500 #else
00501   if (quantum < 0.0)
00502     return(0UL);
00503   return((unsigned int) (quantum+0.5));
00504 #endif
00505 }
00506 
00507 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00508 {
00509 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00510   return((unsigned short) quantum);
00511 #else
00512   if (quantum <= 0.0)
00513     return(0);
00514   if (quantum >= 65535.0)
00515     return(65535);
00516   return((unsigned short) (quantum+0.5));
00517 #endif
00518 }
00519 
00520 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00521 {
00522   return((Quantum) value);
00523 }
00524 #elif (MAGICKCORE_QUANTUM_DEPTH == 32)
00525 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00526 {
00527 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00528   return((Quantum) (16843009UL*value));
00529 #else
00530   return((Quantum) (16843009.0*value));
00531 #endif
00532 }
00533 
00534 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00535 {
00536   return((Quantum) value);
00537 }
00538 
00539 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00540 {
00541 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00542   return((Quantum) ((value)/MagickULLConstant(4294967297)));
00543 #else
00544   return((Quantum) (value/4294967297.0));
00545 #endif
00546 }
00547 
00548 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00549 {
00550   if (value <= 0.0)
00551     return((Quantum) 0);
00552   if (value >= (Quantum) MaxMap)
00553     return(QuantumRange);
00554 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00555   return((Quantum) (65537.0*value+0.5));
00556 #else
00557   return((Quantum) (65537.0*value));
00558 #endif
00559 }
00560 
00561 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00562 {
00563 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00564   return((unsigned int) quantum);
00565 #else
00566   if (quantum <= 0.0)
00567     return(0);
00568   if ((quantum) >= 4294967295.0)
00569     return(4294967295);
00570   return((unsigned int) (quantum+0.5));
00571 #endif
00572 }
00573 
00574 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00575 {
00576 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00577   return((MagickSizeType) (MagickULLConstant(4294967297)*quantum));
00578 #else
00579   if (quantum <= 0.0)
00580     return(0UL);
00581   if ((4294967297.0*quantum) >= 18446744073709551615.0)
00582     return(MagickULLConstant(18446744073709551615));
00583   return((MagickSizeType) (4294967297.0*quantum+0.5));
00584 #endif
00585 }
00586 
00587 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00588 {
00589   if (quantum < 0.0)
00590     return(0UL);
00591   if ((quantum/65537) >= (Quantum) MaxMap)
00592     return((unsigned int) MaxMap);
00593 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00594   return((unsigned int) ((quantum+MagickULLConstant(32768))/
00595     MagickULLConstant(65537)));
00596 #else
00597   return((unsigned int) (quantum/65537.0+0.5));
00598 #endif
00599 }
00600 
00601 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00602 {
00603 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00604   return((unsigned short) ((quantum+MagickULLConstant(32768))/
00605     MagickULLConstant(65537)));
00606 #else
00607   if (quantum <= 0.0)
00608     return(0);
00609   if ((quantum/65537.0) >= 65535.0)
00610     return(65535);
00611   return((unsigned short) (quantum/65537.0+0.5));
00612 #endif
00613 }
00614 
00615 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00616 {
00617 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00618   return((Quantum) (65537UL*value));
00619 #else
00620   return((Quantum) (65537.0*value));
00621 #endif
00622 }
00623 #elif (MAGICKCORE_QUANTUM_DEPTH == 64)
00624 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00625 {
00626   return((Quantum) (72340172838076673.0*value));
00627 }
00628 
00629 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00630 {
00631   return((Quantum) (4294967297.0*value));
00632 }
00633 
00634 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00635 {
00636   return((Quantum) (value));
00637 }
00638 
00639 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00640 {
00641   if (value <= 0.0)
00642     return((Quantum) 0);
00643   if (value >= MaxMap)
00644     return(QuantumRange);
00645   return((Quantum) (281479271743489.0*value));
00646 }
00647 
00648 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00649 {
00650   return((unsigned int) (quantum/4294967297.0+0.5));
00651 }
00652 
00653 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00654 {
00655 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00656   return((MagickSizeType) quantum);
00657 #else
00658   if (quantum <= 0.0)
00659     return(0);
00660   if (quantum >= 18446744073709551615.0)
00661     return(MagickULLConstant(18446744073709551615));
00662   return((MagickSizeType) (quantum+0.5));
00663 #endif
00664 }
00665 
00666 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00667 {
00668   if (quantum <= 0.0)
00669     return(0UL);
00670   if ((quantum/281479271743489.0) >= MaxMap)
00671     return((unsigned int) MaxMap);
00672   return((unsigned int) (quantum/281479271743489.0+0.5));
00673 }
00674 
00675 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00676 {
00677   if (quantum <= 0.0)
00678     return(0);
00679   if ((quantum/281479271743489.0) >= 65535.0)
00680     return(65535);
00681   return((unsigned short) (quantum/281479271743489.0+0.5));
00682 }
00683 
00684 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00685 {
00686   return((Quantum) (281479271743489.0*value));
00687 }
00688 #endif
00689 
00690 static inline unsigned short SinglePrecisionToHalf(const float value)
00691 {
00692   typedef union _SinglePrecision
00693   {
00694     unsigned int
00695       fixed_point;
00696 
00697     float
00698       single_precision;
00699   } SinglePrecision;
00700 
00701   register int
00702     exponent;
00703 
00704   register unsigned int
00705     significand,
00706     sign_bit;
00707 
00708   SinglePrecision
00709     map;
00710 
00711   unsigned short
00712     half;
00713 
00714   /*
00715     The IEEE 754 standard specifies half precision as having:
00716 
00717       Sign bit: 1 bit
00718       Exponent width: 5 bits
00719       Significand precision: 11 (10 explicitly stored)
00720   */
00721   map.single_precision=value;
00722   sign_bit=(map.fixed_point >> 16) & 0x00008000;
00723   exponent=(int) ((map.fixed_point >> ExponentShift) & 0x000000ff)-ExponentBias;
00724   significand=map.fixed_point & 0x007fffff;
00725   if (exponent <= 0)
00726     {
00727       int
00728         shift;
00729 
00730       if (exponent < -10)
00731         return((unsigned short) sign_bit);
00732       significand=significand | 0x00800000;
00733       shift=(int) (14-exponent);
00734       significand=(unsigned int) ((significand+((1 << (shift-1))-1)+
00735         ((significand >> shift) & 0x01)) >> shift);
00736       return((unsigned short) (sign_bit | significand));
00737     }
00738   else
00739     if (exponent == (0xff-ExponentBias))
00740       {
00741         if (significand == 0)
00742           return((unsigned short) (sign_bit | ExponentMask));
00743         else
00744           {
00745             significand>>=SignificandShift;
00746             half=(unsigned short) (sign_bit | significand |
00747               (significand == 0) | ExponentMask);
00748             return(half);
00749           }
00750       }
00751   significand=significand+((significand >> SignificandShift) & 0x01)+0x00000fff;
00752   if ((significand & 0x00800000) != 0)
00753     {
00754       significand=0;
00755       exponent++;
00756     }
00757   if (exponent > 30)
00758     {
00759       float
00760         alpha;
00761 
00762       register int
00763         i;
00764 
00765       /*
00766         Float overflow.
00767       */
00768       alpha=1.0e10;
00769       for (i=0; i < 10; i++)
00770         alpha*=alpha;
00771       return((unsigned short) (sign_bit | ExponentMask));
00772     }
00773   half=(unsigned short) (sign_bit | (exponent << 10) |
00774     (significand >> SignificandShift));
00775   return(half);
00776 }
00777 
00778 #if defined(__cplusplus) || defined(c_plusplus)
00779 }
00780 #endif
00781 
00782 #endif

Generated on 19 Aug 2019 for MagickCore by  doxygen 1.6.1