148 lines
3.3 KiB
Go
148 lines
3.3 KiB
Go
package audio
|
|
|
|
import "math"
|
|
|
|
func IntMaxSignedValue(b int) int {
|
|
switch b {
|
|
case 8:
|
|
return 255 / 2
|
|
case 16:
|
|
return 65535 / 2
|
|
case 24:
|
|
return 16777215 / 2
|
|
case 32:
|
|
return 4294967295 / 2
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func IEEEFloatToInt(b [10]byte) int {
|
|
var i uint32
|
|
if (b[0] & 0x80) == 1 {
|
|
return 0
|
|
}
|
|
if b[0] <= 0x3F {
|
|
return 1
|
|
}
|
|
if b[0] > 0x40 {
|
|
return 67108864
|
|
}
|
|
if b[0] == 0x40 && b[1] > 0x1C {
|
|
return 800000000
|
|
}
|
|
i = (uint32(b[2]) << 23) | (uint32(b[3]) << 15) | (uint32(b[4]) << 7) | (uint32(b[5]) >> 1)
|
|
i >>= (29 - uint32(b[1]))
|
|
return int(i)
|
|
}
|
|
|
|
func IntToIEEEFloat(i int) [10]byte {
|
|
b := [10]byte{}
|
|
num := float64(i)
|
|
var sign int
|
|
var expon int
|
|
var fMant, fsMant float64
|
|
var hiMant, loMant uint
|
|
if num < 0 {
|
|
sign = 0x8000
|
|
} else {
|
|
sign = 0
|
|
}
|
|
if num == 0 {
|
|
expon = 0
|
|
hiMant = 0
|
|
loMant = 0
|
|
} else {
|
|
fMant, expon = math.Frexp(num)
|
|
if (expon > 16384) || !(fMant < 1) { /* Infinity or NaN */
|
|
expon = sign | 0x7FFF
|
|
hiMant = 0
|
|
loMant = 0 /* infinity */
|
|
} else { /* Finite */
|
|
expon += 16382
|
|
if expon < 0 { /* denormalized */
|
|
fMant = math.Ldexp(fMant, expon)
|
|
expon = 0
|
|
}
|
|
expon |= sign
|
|
fMant = math.Ldexp(fMant, 32)
|
|
fsMant = math.Floor(fMant)
|
|
hiMant = uint(fsMant)
|
|
fMant = math.Ldexp(fMant-fsMant, 32)
|
|
fsMant = math.Floor(fMant)
|
|
loMant = uint(fsMant)
|
|
}
|
|
}
|
|
b[0] = byte(expon >> 8)
|
|
b[1] = byte(expon)
|
|
b[2] = byte(hiMant >> 24)
|
|
b[3] = byte(hiMant >> 16)
|
|
b[4] = byte(hiMant >> 8)
|
|
b[5] = byte(hiMant)
|
|
b[6] = byte(loMant >> 24)
|
|
b[7] = byte(loMant >> 16)
|
|
b[8] = byte(loMant >> 8)
|
|
b[9] = byte(loMant)
|
|
return b
|
|
}
|
|
|
|
func Uint24to32(bytes []byte) uint32 {
|
|
var output uint32
|
|
output |= uint32(bytes[2]) << 0
|
|
output |= uint32(bytes[1]) << 8
|
|
output |= uint32(bytes[0]) << 16
|
|
return output
|
|
}
|
|
|
|
func Int24BETo32(bytes []byte) int32 {
|
|
if len(bytes) < 3 {
|
|
return 0
|
|
}
|
|
ss := int32(0xFF&bytes[0])<<16 | int32(0xFF&bytes[1])<<8 | int32(0xFF&bytes[2])
|
|
if (ss & 0x800000) > 0 {
|
|
ss |= ^0xffffff
|
|
}
|
|
return ss
|
|
}
|
|
|
|
func Int24LETo32(bytes []byte) int32 {
|
|
if len(bytes) < 3 {
|
|
return 0
|
|
}
|
|
ss := int32(bytes[0]) | int32(bytes[1])<<8 | int32(bytes[2])<<16
|
|
if (ss & 0x800000) > 0 {
|
|
ss |= ^0xffffff
|
|
}
|
|
return ss
|
|
}
|
|
|
|
func Uint32toUint24Bytes(n uint32) []byte {
|
|
bytes := make([]byte, 3)
|
|
bytes[0] = byte(n >> 16)
|
|
bytes[1] = byte(n >> 8)
|
|
bytes[2] = byte(n >> 0)
|
|
return bytes
|
|
}
|
|
|
|
func Int32toInt24LEBytes(n int32) []byte {
|
|
bytes := make([]byte, 3)
|
|
if (n & 0x800000) > 0 {
|
|
n |= ^0xffffff
|
|
}
|
|
bytes[2] = byte(n >> 16)
|
|
bytes[1] = byte(n >> 8)
|
|
bytes[0] = byte(n >> 0)
|
|
return bytes
|
|
}
|
|
|
|
func Int32toInt24BEBytes(n int32) []byte {
|
|
bytes := make([]byte, 3)
|
|
if (n & 0x800000) > 0 {
|
|
n |= ^0xffffff
|
|
}
|
|
bytes[0] = byte(n >> 16)
|
|
bytes[1] = byte(n >> 8)
|
|
bytes[2] = byte(n >> 0)
|
|
return bytes
|
|
}
|