git.sesse.net Git - ffmpeg/blob - libavutil/softfloat.h

   1 /*
   2  * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #ifndef AVUTIL_SOFTFLOAT_H
  22 #define AVUTIL_SOFTFLOAT_H
  23
  24 #include <stdint.h>
  25 #include "common.h"
  26
  27 #include "avassert.h"
  28 #include "softfloat_tables.h"
  29
  30 #define MIN_EXP -126
  31 #define MAX_EXP  126
  32 #define ONE_BITS 29
  33
  34 typedef struct SoftFloat{
  35     int32_t mant;
  36     int32_t  exp;
  37 }SoftFloat;
  38
  39 static inline av_const double av_sf2double(SoftFloat v) {
  40     v.exp -= ONE_BITS +1;
  41     if(v.exp > 0) return (double)v.mant * (double)(1 << v.exp);
  42     else          return (double)v.mant / (double)(1 << (-v.exp));
  43 }
  44
  45 static av_const SoftFloat av_normalize_sf(SoftFloat a){
  46     if(a.mant){
  47 #if 1
  48         while((a.mant + 0x1FFFFFFFU)<0x3FFFFFFFU){
  49             a.mant += a.mant;
  50             a.exp  -= 1;
  51         }
  52 #else
  53         int s=ONE_BITS - av_log2(FFABS(a.mant));
  54         a.exp   -= s;
  55         a.mant <<= s;
  56 #endif
  57         if(a.exp < MIN_EXP){
  58             a.exp = MIN_EXP;
  59             a.mant= 0;
  60         }
  61     }else{
  62         a.exp= MIN_EXP;
  63     }
  64     return a;
  65 }
  66
  67 static inline av_const SoftFloat av_normalize1_sf(SoftFloat a){
  68 #if 1
  69     if((int32_t)(a.mant + 0x40000000U) <= 0){
  70         a.exp++;
  71         a.mant>>=1;
  72     }
  73     av_assert2(a.mant < 0x40000000 && a.mant > -0x40000000);
  74     return a;
  75 #elif 1
  76     int t= a.mant + 0x40000000 < 0;
  77     return (SoftFloat){ a.mant>>t, a.exp+t};
  78 #else
  79     int t= (a.mant + 0x3FFFFFFFU)>>31;
  80     return (SoftFloat){a.mant>>t, a.exp+t};
  81 #endif
  82 }
  83
  84 /**
  85  * @return Will not be more denormalized than a+b. So if either input is
  86  *         normalized, then the output will not be worse then the other input.
  87  *         If both are normalized, then the output will be normalized.
  88  */
  89 static inline av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b){
  90     a.exp += b.exp;
  91     av_assert2((int32_t)((a.mant * (int64_t)b.mant) >> ONE_BITS) == (a.mant * (int64_t)b.mant) >> ONE_BITS);
  92     a.mant = (a.mant * (int64_t)b.mant) >> ONE_BITS;
  93     return av_normalize1_sf((SoftFloat){a.mant, a.exp - 1});
  94 }
  95
  96 /**
  97  * b has to be normalized and not zero.
  98  * @return Will not be more denormalized than a.
  99  */
 100 static inline av_const SoftFloat av_div_sf(SoftFloat a, SoftFloat b){
 101     a.exp -= b.exp;
 102     a.mant = ((int64_t)a.mant<<(ONE_BITS+1)) / b.mant;
 103     return av_normalize1_sf(a);
 104 }
 105
 106 static inline av_const int av_cmp_sf(SoftFloat a, SoftFloat b){
 107     int t= a.exp - b.exp;
 108     if(t<0) return (a.mant >> (-t)) -  b.mant      ;
 109     else    return  a.mant          - (b.mant >> t);
 110 }
 111
 112 static inline av_const int av_gt_sf(SoftFloat a, SoftFloat b)
 113 {
 114     int t= a.exp - b.exp;
 115     if(t<0) return (a.mant >> (-t)) >  b.mant      ;
 116     else    return  a.mant          > (b.mant >> t);
 117 }
 118
 119 static inline av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b){
 120     int t= a.exp - b.exp;
 121     if      (t <-31) return b;
 122     else if (t <  0) return av_normalize_sf(av_normalize1_sf((SoftFloat){ b.mant + (a.mant >> (-t)), b.exp}));
 123     else if (t < 32) return av_normalize_sf(av_normalize1_sf((SoftFloat){ a.mant + (b.mant >>   t ), a.exp}));
 124     else             return a;
 125 }
 126
 127 static inline av_const SoftFloat av_sub_sf(SoftFloat a, SoftFloat b){
 128     return av_add_sf(a, (SoftFloat){ -b.mant, b.exp});
 129 }
 130
 131 //FIXME log, exp, pow
 132
 133 /**
 134  * Converts a mantisse and exponent to a SoftFloat
 135  * @returns a SoftFloat with value v * 2^frac_bits
 136  */
 137 static inline av_const SoftFloat av_int2sf(int v, int frac_bits){
 138     return av_normalize_sf((SoftFloat){v, ONE_BITS + 1 - frac_bits});
 139 }
 140
 141 /**
 142  * Rounding is to -inf.
 143  */
 144 static inline av_const int av_sf2int(SoftFloat v, int frac_bits){
 145     v.exp += frac_bits - (ONE_BITS + 1);
 146     if(v.exp >= 0) return v.mant <<  v.exp ;
 147     else           return v.mant >>(-v.exp);
 148 }
 149
 150 /**
 151  * Rounding-to-nearest used.
 152  */
 153 static av_always_inline SoftFloat av_sqrt_sf(SoftFloat val)
 154 {
 155     int tabIndex, rem;
 156
 157     if (val.mant == 0)
 158         val.exp = 0;
 159     else
 160     {
 161         tabIndex = (val.mant - 0x20000000) >> 20;
 162
 163         rem = val.mant & 0xFFFFF;
 164         val.mant  = (int)(((int64_t)av_sqrttbl_sf[tabIndex] * (0x100000 - rem) +
 165                            (int64_t)av_sqrttbl_sf[tabIndex + 1] * rem +
 166                            0x80000) >> 20);
 167         val.mant = (int)(((int64_t)av_sqr_exp_multbl_sf[val.exp & 1] * val.mant +
 168                           0x10000000) >> 29);
 169
 170         if (val.mant < 0x40000000)
 171             val.exp -= 2;
 172         else
 173             val.mant >>= 1;
 174
 175         val.exp = (val.exp >> 1) + 1;
 176     }
 177
 178     return val;
 179 }
 180
 181 /**
 182  * Rounding-to-nearest used.
 183  */
 184 void av_sincos_sf(int a, int *s, int *c);
 185
 186 #endif /* AVUTIL_SOFTFLOAT_H */