vendor/github.com/ugorji/go/codec/helper_internal.go

   1 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
   2 // Use of this source code is governed by a MIT license found in the LICENSE file.
   3
   4 package codec
   5
   6 // All non-std package dependencies live in this file,
   7 // so porting to different environment is easy (just update functions).
   8
   9 func pruneSignExt(v []byte, pos bool) (n int) {
  10         if len(v) < 2 {
  11         } else if pos && v[0] == 0 {
  12                 for ; v[n] == 0 && n+1 < len(v) && (v[n+1]&(1<<7) == 0); n++ {
  13                 }
  14         } else if !pos && v[0] == 0xff {
  15                 for ; v[n] == 0xff && n+1 < len(v) && (v[n+1]&(1<<7) != 0); n++ {
  16                 }
  17         }
  18         return
  19 }
  20
  21 // validate that this function is correct ...
  22 // culled from OGRE (Object-Oriented Graphics Rendering Engine)
  23 // function: halfToFloatI (http://stderr.org/doc/ogre-doc/api/OgreBitwise_8h-source.html)
  24 func halfFloatToFloatBits(yy uint16) (d uint32) {
  25         y := uint32(yy)
  26         s := (y >> 15) & 0x01
  27         e := (y >> 10) & 0x1f
  28         m := y & 0x03ff
  29
  30         if e == 0 {
  31                 if m == 0 { // plu or minus 0
  32                         return s << 31
  33                 }
  34                 // Denormalized number -- renormalize it
  35                 for (m & 0x00000400) == 0 {
  36                         m <<= 1
  37                         e -= 1
  38                 }
  39                 e += 1
  40                 const zz uint32 = 0x0400
  41                 m &= ^zz
  42         } else if e == 31 {
  43                 if m == 0 { // Inf
  44                         return (s << 31) | 0x7f800000
  45                 }
  46                 return (s << 31) | 0x7f800000 | (m << 13) // NaN
  47         }
  48         e = e + (127 - 15)
  49         m = m << 13
  50         return (s << 31) | (e << 23) | m
  51 }
  52
  53 // GrowCap will return a new capacity for a slice, given the following:
  54 //   - oldCap: current capacity
  55 //   - unit: in-memory size of an element
  56 //   - num: number of elements to add
  57 func growCap(oldCap, unit, num int) (newCap int) {
  58         // appendslice logic (if cap < 1024, *2, else *1.25):
  59         //   leads to many copy calls, especially when copying bytes.
  60         //   bytes.Buffer model (2*cap + n): much better for bytes.
  61         // smarter way is to take the byte-size of the appended element(type) into account
  62
  63         // maintain 3 thresholds:
  64         // t1: if cap <= t1, newcap = 2x
  65         // t2: if cap <= t2, newcap = 1.75x
  66         // t3: if cap <= t3, newcap = 1.5x
  67         //     else          newcap = 1.25x
  68         //
  69         // t1, t2, t3 >= 1024 always.
  70         // i.e. if unit size >= 16, then always do 2x or 1.25x (ie t1, t2, t3 are all same)
  71         //
  72         // With this, appending for bytes increase by:
  73         //    100% up to 4K
  74         //     75% up to 8K
  75         //     50% up to 16K
  76         //     25% beyond that
  77
  78         // unit can be 0 e.g. for struct{}{}; handle that appropriately
  79         var t1, t2, t3 int // thresholds
  80         if unit <= 1 {
  81                 t1, t2, t3 = 4*1024, 8*1024, 16*1024
  82         } else if unit < 16 {
  83                 t3 = 16 / unit * 1024
  84                 t1 = t3 * 1 / 4
  85                 t2 = t3 * 2 / 4
  86         } else {
  87                 t1, t2, t3 = 1024, 1024, 1024
  88         }
  89
  90         var x int // temporary variable
  91
  92         // x is multiplier here: one of 5, 6, 7 or 8; incr of 25%, 50%, 75% or 100% respectively
  93         if oldCap <= t1 { // [0,t1]
  94                 x = 8
  95         } else if oldCap > t3 { // (t3,infinity]
  96                 x = 5
  97         } else if oldCap <= t2 { // (t1,t2]
  98                 x = 7
  99         } else { // (t2,t3]
 100                 x = 6
 101         }
 102         newCap = x * oldCap / 4
 103
 104         if num > 0 {
 105                 newCap += num
 106         }
 107
 108         // ensure newCap is a multiple of 64 (if it is > 64) or 16.
 109         if newCap > 64 {
 110                 if x = newCap % 64; x != 0 {
 111                         x = newCap / 64
 112                         newCap = 64 * (x + 1)
 113                 }
 114         } else {
 115                 if x = newCap % 16; x != 0 {
 116                         x = newCap / 16
 117                         newCap = 16 * (x + 1)
 118                 }
 119         }
 120         return
 121 }