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   if (quantum < 0)
00328     return((QuantumAny) 0);
00329   return((QuantumAny) (((double) range*quantum)/QuantumRange+0.5));
00330 }
00331 
00332 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
00333 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00334 {
00335   return((Quantum) value);
00336 }
00337 
00338 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00339 {
00340 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00341   return((Quantum) ((value)/16843009UL));
00342 #else
00343   return((Quantum) (value/16843009.0));
00344 #endif
00345 }
00346 
00347 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00348 {
00349 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00350   return((Quantum) (value/MagickULLConstant(72340172838076673)));
00351 #else
00352   return((Quantum) (value/72340172838076673.0));
00353 #endif
00354 }
00355 
00356 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00357 {
00358   if (value <= 0.0)
00359     return((Quantum) 0);
00360   if (value >= MaxMap)
00361     return(QuantumRange);
00362 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00363   return((Quantum) (value+0.5));
00364 #else
00365   return((Quantum) value);
00366 #endif
00367 }
00368 
00369 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00370 {
00371 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00372   return((unsigned int) (16843009UL*quantum));
00373 #else
00374   if (quantum <= 0.0)
00375     return(0UL);
00376   if ((16843009.0*quantum) >= 4294967295.0)
00377     return(4294967295UL);
00378   return((unsigned int) (16843009.0*quantum+0.5));
00379 #endif
00380 }
00381 
00382 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00383 {
00384 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00385   return((MagickSizeType) (MagickULLConstant(72340172838076673)*quantum));
00386 #else
00387   if (quantum <= 0.0)
00388     return(0UL);
00389   if ((72340172838076673.0*quantum) >= 18446744073709551615.0)
00390     return(MagickULLConstant(18446744073709551615));
00391   return((MagickSizeType) (72340172838076673*quantum+0.5));
00392 #endif
00393 }
00394 
00395 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00396 {
00397   if (quantum >= (Quantum) MaxMap)
00398     return((unsigned int) MaxMap);
00399 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00400   return((unsigned int) quantum);
00401 #else
00402   if (quantum < 0.0)
00403     return(0UL);
00404   return((unsigned int) (quantum+0.5));
00405 #endif
00406 }
00407 
00408 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00409 {
00410 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00411   return((unsigned short) (257UL*quantum));
00412 #else
00413   if (quantum <= 0.0)
00414     return(0);
00415   if ((257.0*quantum) >= 65535.0)
00416     return(65535);
00417   return((unsigned short) (257.0*quantum+0.5));
00418 #endif
00419 }
00420 
00421 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00422 {
00423 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00424   return((Quantum) ((value+128U)/257U));
00425 #else
00426   return((Quantum) (value/257.0));
00427 #endif
00428 }
00429 #elif (MAGICKCORE_QUANTUM_DEPTH == 16)
00430 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00431 {
00432 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00433   return((Quantum) (257U*value));
00434 #else
00435   return((Quantum) (257.0*value));
00436 #endif
00437 }
00438 
00439 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00440 {
00441 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00442   return((Quantum) ((value)/MagickULLConstant(65537)));
00443 #else
00444   return((Quantum) (value/65537.0));
00445 #endif
00446 }
00447 
00448 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00449 {
00450 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00451   return((Quantum) ((value)/MagickULLConstant(281479271743489)));
00452 #else
00453   return((Quantum) (value/281479271743489.0));
00454 #endif
00455 }
00456 
00457 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00458 {
00459   if (value <= 0.0)
00460     return((Quantum) 0);
00461   if (value >= MaxMap)
00462     return(QuantumRange);
00463 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00464   return((Quantum) (value+0.5));
00465 #else
00466   return((Quantum) value);
00467 #endif
00468 }
00469 
00470 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00471 {
00472 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00473   return((unsigned int) (65537UL*quantum));
00474 #else
00475   if (quantum <= 0.0)
00476     return(0UL);
00477   if ((65537.0*quantum) >= 4294967295.0)
00478     return(4294967295U);
00479   return((unsigned int) (65537.0*quantum+0.5));
00480 #endif
00481 }
00482 
00483 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00484 {
00485 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00486   return((MagickSizeType) (MagickULLConstant(281479271743489)*quantum));
00487 #else
00488   if (quantum <= 0.0)
00489     return(0UL);
00490   if ((281479271743489.0*quantum) >= 18446744073709551615.0)
00491     return(MagickULLConstant(18446744073709551615));
00492   return((MagickSizeType) (281479271743489.0*quantum+0.5));
00493 #endif
00494 }
00495 
00496 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00497 {
00498   if (quantum >= (Quantum) MaxMap)
00499     return((unsigned int) MaxMap);
00500 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00501   return((unsigned int) quantum);
00502 #else
00503   if (quantum < 0.0)
00504     return(0UL);
00505   return((unsigned int) (quantum+0.5));
00506 #endif
00507 }
00508 
00509 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00510 {
00511 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00512   return((unsigned short) quantum);
00513 #else
00514   if (quantum <= 0.0)
00515     return(0);
00516   if (quantum >= 65535.0)
00517     return(65535);
00518   return((unsigned short) (quantum+0.5));
00519 #endif
00520 }
00521 
00522 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00523 {
00524   return((Quantum) value);
00525 }
00526 #elif (MAGICKCORE_QUANTUM_DEPTH == 32)
00527 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00528 {
00529 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00530   return((Quantum) (16843009UL*value));
00531 #else
00532   return((Quantum) (16843009.0*value));
00533 #endif
00534 }
00535 
00536 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00537 {
00538   return((Quantum) value);
00539 }
00540 
00541 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00542 {
00543 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00544   return((Quantum) ((value)/MagickULLConstant(4294967297)));
00545 #else
00546   return((Quantum) (value/4294967297.0));
00547 #endif
00548 }
00549 
00550 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00551 {
00552   if (value <= 0.0)
00553     return((Quantum) 0);
00554   if (value >= (Quantum) MaxMap)
00555     return(QuantumRange);
00556 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00557   return((Quantum) (65537.0*value+0.5));
00558 #else
00559   return((Quantum) (65537.0*value));
00560 #endif
00561 }
00562 
00563 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00564 {
00565 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00566   return((unsigned int) quantum);
00567 #else
00568   if (quantum <= 0.0)
00569     return(0);
00570   if ((quantum) >= 4294967295.0)
00571     return(4294967295);
00572   return((unsigned int) (quantum+0.5));
00573 #endif
00574 }
00575 
00576 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00577 {
00578 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00579   return((MagickSizeType) (MagickULLConstant(4294967297)*quantum));
00580 #else
00581   if (quantum <= 0.0)
00582     return(0UL);
00583   if ((4294967297.0*quantum) >= 18446744073709551615.0)
00584     return(MagickULLConstant(18446744073709551615));
00585   return((MagickSizeType) (4294967297.0*quantum+0.5));
00586 #endif
00587 }
00588 
00589 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00590 {
00591   if (quantum < 0.0)
00592     return(0UL);
00593   if ((quantum/65537) >= (Quantum) MaxMap)
00594     return((unsigned int) MaxMap);
00595 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00596   return((unsigned int) ((quantum+MagickULLConstant(32768))/
00597     MagickULLConstant(65537)));
00598 #else
00599   return((unsigned int) (quantum/65537.0+0.5));
00600 #endif
00601 }
00602 
00603 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00604 {
00605 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00606   return((unsigned short) ((quantum+MagickULLConstant(32768))/
00607     MagickULLConstant(65537)));
00608 #else
00609   if (quantum <= 0.0)
00610     return(0);
00611   if ((quantum/65537.0) >= 65535.0)
00612     return(65535);
00613   return((unsigned short) (quantum/65537.0+0.5));
00614 #endif
00615 }
00616 
00617 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00618 {
00619 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00620   return((Quantum) (65537UL*value));
00621 #else
00622   return((Quantum) (65537.0*value));
00623 #endif
00624 }
00625 #elif (MAGICKCORE_QUANTUM_DEPTH == 64)
00626 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00627 {
00628   return((Quantum) (72340172838076673.0*value));
00629 }
00630 
00631 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00632 {
00633   return((Quantum) (4294967297.0*value));
00634 }
00635 
00636 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00637 {
00638   return((Quantum) (value));
00639 }
00640 
00641 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00642 {
00643   if (value <= 0.0)
00644     return((Quantum) 0);
00645   if (value >= MaxMap)
00646     return(QuantumRange);
00647   return((Quantum) (281479271743489.0*value));
00648 }
00649 
00650 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00651 {
00652   return((unsigned int) (quantum/4294967297.0+0.5));
00653 }
00654 
00655 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00656 {
00657 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00658   return((MagickSizeType) quantum);
00659 #else
00660   if (quantum <= 0.0)
00661     return(0);
00662   if (quantum >= 18446744073709551615.0)
00663     return(MagickULLConstant(18446744073709551615));
00664   return((MagickSizeType) (quantum+0.5));
00665 #endif
00666 }
00667 
00668 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00669 {
00670   if (quantum <= 0.0)
00671     return(0UL);
00672   if ((quantum/281479271743489.0) >= MaxMap)
00673     return((unsigned int) MaxMap);
00674   return((unsigned int) (quantum/281479271743489.0+0.5));
00675 }
00676 
00677 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00678 {
00679   if (quantum <= 0.0)
00680     return(0);
00681   if ((quantum/281479271743489.0) >= 65535.0)
00682     return(65535);
00683   return((unsigned short) (quantum/281479271743489.0+0.5));
00684 }
00685 
00686 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00687 {
00688   return((Quantum) (281479271743489.0*value));
00689 }
00690 #endif
00691 
00692 static inline unsigned short SinglePrecisionToHalf(const float value)
00693 {
00694   typedef union _SinglePrecision
00695   {
00696     unsigned int
00697       fixed_point;
00698 
00699     float
00700       single_precision;
00701   } SinglePrecision;
00702 
00703   register int
00704     exponent;
00705 
00706   register unsigned int
00707     significand,
00708     sign_bit;
00709 
00710   SinglePrecision
00711     map;
00712 
00713   unsigned short
00714     half;
00715 
00716   /*
00717     The IEEE 754 standard specifies half precision as having:
00718 
00719       Sign bit: 1 bit
00720       Exponent width: 5 bits
00721       Significand precision: 11 (10 explicitly stored)
00722   */
00723   map.single_precision=value;
00724   sign_bit=(map.fixed_point >> 16) & 0x00008000;
00725   exponent=(int) ((map.fixed_point >> ExponentShift) & 0x000000ff)-ExponentBias;
00726   significand=map.fixed_point & 0x007fffff;
00727   if (exponent <= 0)
00728     {
00729       int
00730         shift;
00731 
00732       if (exponent < -10)
00733         return((unsigned short) sign_bit);
00734       significand=significand | 0x00800000;
00735       shift=(int) (14-exponent);
00736       significand=(unsigned int) ((significand+((1 << (shift-1))-1)+
00737         ((significand >> shift) & 0x01)) >> shift);
00738       return((unsigned short) (sign_bit | significand));
00739     }
00740   else
00741     if (exponent == (0xff-ExponentBias))
00742       {
00743         if (significand == 0)
00744           return((unsigned short) (sign_bit | ExponentMask));
00745         else
00746           {
00747             significand>>=SignificandShift;
00748             half=(unsigned short) (sign_bit | significand |
00749               (significand == 0) | ExponentMask);
00750             return(half);
00751           }
00752       }
00753   significand=significand+((significand >> SignificandShift) & 0x01)+0x00000fff;
00754   if ((significand & 0x00800000) != 0)
00755     {
00756       significand=0;
00757       exponent++;
00758     }
00759   if (exponent > 30)
00760     {
00761       float
00762         alpha;
00763 
00764       register int
00765         i;
00766 
00767       /*
00768         Float overflow.
00769       */
00770       alpha=1.0e10;
00771       for (i=0; i < 10; i++)
00772         alpha*=alpha;
00773       return((unsigned short) (sign_bit | ExponentMask));
00774     }
00775   half=(unsigned short) (sign_bit | (exponent << 10) |
00776     (significand >> SignificandShift));
00777   return(half);
00778 }
00779 
00780 #if defined(__cplusplus) || defined(c_plusplus)
00781 }
00782 #endif
00783 
00784 #endif

Generated on 7 Oct 2019 for MagickCore by  doxygen 1.6.1