LCOV - app.info - gfx/skia/include/core/SkFixed.h

LCOV - code coverage report
| Current view: | directory - gfx/skia/include/core - SkFixed.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 14 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 3 | 0 | 0.0 %

           1                 :
           2                 : /*
           3                 :  * Copyright 2006 The Android Open Source Project
           4                 :  *
           5                 :  * Use of this source code is governed by a BSD-style license that can be
           6                 :  * found in the LICENSE file.
           7                 :  */
           8                 :
           9                 :
          10                 : #ifndef SkFixed_DEFINED
          11                 : #define SkFixed_DEFINED
          12                 :
          13                 : #include "SkTypes.h"
          14                 :
          15                 : /** \file SkFixed.h
          16                 :
          17                 :     Types and macros for 16.16 fixed point
          18                 : */
          19                 :
          20                 : /** 32 bit signed integer used to represent fractions values with 16 bits to the right of the decimal point
          21                 : */
          22                 : typedef int32_t             SkFixed;
          23                 : #define SK_Fixed1           (1 << 16)
          24                 : #define SK_FixedHalf        (1 << 15)
          25                 : #define SK_FixedMax         (0x7FFFFFFF)
          26                 : #define SK_FixedMin         (-SK_FixedMax)
          27                 : #define SK_FixedNaN         ((int) 0x80000000)
          28                 : #define SK_FixedPI          (0x3243F)
          29                 : #define SK_FixedSqrt2       (92682)
          30                 : #define SK_FixedTanPIOver8  (0x6A0A)
          31                 : #define SK_FixedRoot2Over2  (0xB505)
          32                 :
          33                 : #ifdef SK_CAN_USE_FLOAT
          34                 :     #define SkFixedToFloat(x)   ((x) * 1.5258789e-5f)
          35                 : #if 1
          36                 :     #define SkFloatToFixed(x)   ((SkFixed)((x) * SK_Fixed1))
          37                 : #else
          38                 :     // pins over/under flows to max/min int32 (slower than just a cast)
          39                 :     static inline SkFixed SkFloatToFixed(float x) {
          40                 :         int64_t n = x * SK_Fixed1;
          41                 :         return (SkFixed)n;
          42                 :     }
          43                 : #endif
          44                 :
          45                 :     #define SkFixedToDouble(x)  ((x) * 1.5258789e-5)
          46                 :     #define SkDoubleToFixed(x)  ((SkFixed)((x) * SK_Fixed1))
          47                 : #endif
          48                 :
          49                 : /** 32 bit signed integer used to represent fractions values with 30 bits to the right of the decimal point
          50                 : */
          51                 : typedef int32_t             SkFract;
          52                 : #define SK_Fract1           (1 << 30)
          53                 : #define Sk_FracHalf         (1 << 29)
          54                 : #define SK_FractPIOver180   (0x11DF46A)
          55                 :
          56                 : #ifdef SK_CAN_USE_FLOAT
          57                 :     #define SkFractToFloat(x)   ((float)(x) * 0.00000000093132257f)
          58                 :     #define SkFloatToFract(x)   ((SkFract)((x) * SK_Fract1))
          59                 : #endif
          60                 :
          61                 : /** Converts an integer to a SkFixed, asserting that the result does not overflow
          62                 :     a 32 bit signed integer
          63                 : */
          64                 : #ifdef SK_DEBUG
          65               0 :     inline SkFixed SkIntToFixed(int n)
          66                 :     {
          67               0 :         SkASSERT(n >= -32768 && n <= 32767);
          68               0 :         return n << 16;
          69                 :     }
          70                 : #else
          71                 :     //  force the cast to SkFixed to ensure that the answer is signed (like the debug version)
          72                 :     #define SkIntToFixed(n)     (SkFixed)((n) << 16)
          73                 : #endif
          74                 :
          75                 : /** Converts a SkFixed to a SkFract, asserting that the result does not overflow
          76                 :     a 32 bit signed integer
          77                 : */
          78                 : #ifdef SK_DEBUG
          79                 :     inline SkFract SkFixedToFract(SkFixed x)
          80                 :     {
          81                 :         SkASSERT(x >= (-2 << 16) && x <= (2 << 16) - 1);
          82                 :         return x << 14;
          83                 :     }
          84                 : #else
          85                 :     #define SkFixedToFract(x)   ((x) << 14)
          86                 : #endif
          87                 :
          88                 : /** Returns the signed fraction of a SkFixed
          89                 : */
          90                 : inline SkFixed SkFixedFraction(SkFixed x)
          91                 : {
          92                 :     SkFixed mask = x >> 31 << 16;
          93                 :     return (x & 0xFFFF) | mask;
          94                 : }
          95                 :
          96                 : /** Converts a SkFract to a SkFixed
          97                 : */
          98                 : #define SkFractToFixed(x)   ((x) >> 14)
          99                 :
         100                 : #define SkFixedRoundToInt(x)    (((x) + SK_FixedHalf) >> 16)
         101                 : #define SkFixedCeilToInt(x)     (((x) + SK_Fixed1 - 1) >> 16)
         102                 : #define SkFixedFloorToInt(x)    ((x) >> 16)
         103                 :
         104                 : #define SkFixedRoundToFixed(x)  (((x) + SK_FixedHalf) & 0xFFFF0000)
         105                 : #define SkFixedCeilToFixed(x)   (((x) + SK_Fixed1 - 1) & 0xFFFF0000)
         106                 : #define SkFixedFloorToFixed(x)  ((x) & 0xFFFF0000)
         107                 :
         108                 : // DEPRECATED
         109                 : #define SkFixedFloor(x)     SkFixedFloorToInt(x)
         110                 : #define SkFixedCeil(x)      SkFixedCeilToInt(x)
         111                 : #define SkFixedRound(x)     SkFixedRoundToInt(x)
         112                 :
         113                 : #define SkFixedAbs(x)       SkAbs32(x)
         114                 : #define SkFixedAve(a, b)    (((a) + (b)) >> 1)
         115                 :
         116                 : SkFixed SkFixedMul_portable(SkFixed, SkFixed);
         117                 : SkFract SkFractMul_portable(SkFract, SkFract);
         118               0 : inline SkFixed SkFixedSquare_portable(SkFixed value)
         119                 : {
         120               0 :     uint32_t a = SkAbs32(value);
         121               0 :     uint32_t ah = a >> 16;
         122               0 :     uint32_t al = a & 0xFFFF;
         123               0 :     SkFixed result = ah * a + al * ah + (al * al >> 16);
         124               0 :     if (result >= 0)
         125               0 :         return result;
         126                 :     else // Overflow.
         127               0 :         return SK_FixedMax;
         128                 : }
         129                 :
         130                 : #define SkFixedDiv(numer, denom)    SkDivBits(numer, denom, 16)
         131                 : SkFixed SkFixedDivInt(int32_t numer, int32_t denom);
         132                 : SkFixed SkFixedMod(SkFixed numer, SkFixed denom);
         133                 : #define SkFixedInvert(n)            SkDivBits(SK_Fixed1, n, 16)
         134                 : SkFixed SkFixedFastInvert(SkFixed n);
         135                 : #define SkFixedSqrt(n)              SkSqrtBits(n, 23)
         136                 : SkFixed SkFixedMean(SkFixed a, SkFixed b);  //*< returns sqrt(x*y)
         137                 : int SkFixedMulCommon(SkFixed, int , int bias);  // internal used by SkFixedMulFloor, SkFixedMulCeil, SkFixedMulRound
         138                 :
         139                 : #define SkFractDiv(numer, denom)    SkDivBits(numer, denom, 30)
         140                 : #define SkFractSqrt(n)              SkSqrtBits(n, 30)
         141                 :
         142                 : SkFixed SkFixedSinCos(SkFixed radians, SkFixed* cosValueOrNull);
         143                 : #define SkFixedSin(radians)         SkFixedSinCos(radians, NULL)
         144                 : inline SkFixed SkFixedCos(SkFixed radians)
         145                 : {
         146                 :     SkFixed cosValue;
         147                 :     (void)SkFixedSinCos(radians, &cosValue);
         148                 :     return cosValue;
         149                 : }
         150                 : SkFixed SkFixedTan(SkFixed radians);
         151                 : SkFixed SkFixedASin(SkFixed);
         152                 : SkFixed SkFixedACos(SkFixed);
         153                 : SkFixed SkFixedATan2(SkFixed y, SkFixed x);
         154                 : SkFixed SkFixedExp(SkFixed);
         155                 : SkFixed SkFixedLog(SkFixed);
         156                 :
         157                 : #define SK_FixedNearlyZero          (SK_Fixed1 >> 12)
         158                 :
         159               0 : inline bool SkFixedNearlyZero(SkFixed x, SkFixed tolerance = SK_FixedNearlyZero)
         160                 : {
         161               0 :     SkASSERT(tolerance > 0);
         162               0 :     return SkAbs32(x) < tolerance;
         163                 : }
         164                 :
         165                 : //////////////////////////////////////////////////////////////////////////////////////////////////////
         166                 : // Now look for ASM overrides for our portable versions (should consider putting this in its own file)
         167                 :
         168                 : #ifdef SkLONGLONG
         169                 :     inline SkFixed SkFixedMul_longlong(SkFixed a, SkFixed b)
         170                 :     {
         171                 :         return (SkFixed)((SkLONGLONG)a * b >> 16);
         172                 :     }
         173                 :     inline SkFract SkFractMul_longlong(SkFract a, SkFract b)
         174                 :     {
         175                 :         return (SkFixed)((SkLONGLONG)a * b >> 30);
         176                 :     }
         177                 :     inline SkFixed SkFixedSquare_longlong(SkFixed value)
         178                 :     {
         179                 :         return (SkFixed)((SkLONGLONG)value * value >> 16);
         180                 :     }
         181                 :     #define SkFixedMul(a,b)     SkFixedMul_longlong(a,b)
         182                 :     #define SkFractMul(a,b)     SkFractMul_longlong(a,b)
         183                 :     #define SkFixedSquare(a)    SkFixedSquare_longlong(a)
         184                 : #endif
         185                 :
         186                 : #if defined(__arm__) && !defined(__thumb__)
         187                 :     /* This guy does not handle NaN or other obscurities, but is faster than
         188                 :        than (int)(x*65536) when we only have software floats
         189                 :     */
         190                 :     inline SkFixed SkFloatToFixed_arm(float x)
         191                 :     {
         192                 :         register int32_t y, z;
         193                 :         asm("movs    %1, %3, lsl #1         \n"
         194                 :             "mov     %2, #0x8E              \n"
         195                 :             "sub     %1, %2, %1, lsr #24    \n"
         196                 :             "mov     %2, %3, lsl #8         \n"
         197                 :             "orr     %2, %2, #0x80000000    \n"
         198                 :             "mov     %1, %2, lsr %1         \n"
         199                 :             "rsbcs   %1, %1, #0             \n"
         200                 :             : "=r"(x), "=&r"(y), "=&r"(z)
         201                 :             : "r"(x)
         202                 :             : "cc"
         203                 :             );
         204                 :         return y;
         205                 :     }
         206                 :     inline SkFixed SkFixedMul_arm(SkFixed x, SkFixed y)
         207                 :     {
         208                 :         register int32_t t;
         209                 :         asm("smull  %0, %2, %1, %3          \n"
         210                 :             "mov    %0, %0, lsr #16         \n"
         211                 :             "orr    %0, %0, %2, lsl #16     \n"
         212                 :             : "=r"(x), "=&r"(y), "=r"(t)
         213                 :             : "r"(x), "1"(y)
         214                 :             :
         215                 :             );
         216                 :         return x;
         217                 :     }
         218                 :     inline SkFixed SkFixedMulAdd_arm(SkFixed x, SkFixed y, SkFixed a)
         219                 :     {
         220                 :         register int32_t t;
         221                 :         asm("smull  %0, %3, %1, %4          \n"
         222                 :             "add    %0, %2, %0, lsr #16     \n"
         223                 :             "add    %0, %0, %3, lsl #16     \n"
         224                 :             : "=r"(x), "=&r"(y), "=&r"(a), "=r"(t)
         225                 :             : "%r"(x), "1"(y), "2"(a)
         226                 :             :
         227                 :             );
         228                 :         return x;
         229                 :     }
         230                 :     inline SkFixed SkFractMul_arm(SkFixed x, SkFixed y)
         231                 :     {
         232                 :         register int32_t t;
         233                 :         asm("smull  %0, %2, %1, %3          \n"
         234                 :             "mov    %0, %0, lsr #30         \n"
         235                 :             "orr    %0, %0, %2, lsl #2      \n"
         236                 :             : "=r"(x), "=&r"(y), "=r"(t)
         237                 :             : "r"(x), "1"(y)
         238                 :             :
         239                 :             );
         240                 :         return x;
         241                 :     }
         242                 :     #undef SkFixedMul
         243                 :     #undef SkFractMul
         244                 :     #define SkFixedMul(x, y)        SkFixedMul_arm(x, y)
         245                 :     #define SkFractMul(x, y)        SkFractMul_arm(x, y)
         246                 :     #define SkFixedMulAdd(x, y, a)  SkFixedMulAdd_arm(x, y, a)
         247                 :
         248                 :     #undef SkFloatToFixed
         249                 :     #define SkFloatToFixed(x)  SkFloatToFixed_arm(x)
         250                 : #endif
         251                 :
         252                 : /////////////////////// Now define our macros to the portable versions if they weren't overridden
         253                 :
         254                 : #ifndef SkFixedSquare
         255                 :     #define SkFixedSquare(x)    SkFixedSquare_portable(x)
         256                 : #endif
         257                 : #ifndef SkFixedMul
         258                 :     #define SkFixedMul(x, y)    SkFixedMul_portable(x, y)
         259                 : #endif
         260                 : #ifndef SkFractMul
         261                 :     #define SkFractMul(x, y)    SkFractMul_portable(x, y)
         262                 : #endif
         263                 : #ifndef SkFixedMulAdd
         264                 :     #define SkFixedMulAdd(x, y, a)  (SkFixedMul(x, y) + (a))
         265                 : #endif
         266                 :
         267                 : #endif

Generated by: LCOV version 1.7