mirror of https://bitbucket.org/ausocean/av.git
138 lines
2.6 KiB
Go
138 lines
2.6 KiB
Go
package adpcmgo
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
)
|
|
|
|
// table of index changes
|
|
var indexTable = []int{
|
|
-1, -1, -1, -1, 2, 4, 6, 8,
|
|
-1, -1, -1, -1, 2, 4, 6, 8,
|
|
}
|
|
|
|
// quantize step size table
|
|
var stepTable = []int{
|
|
7, 8, 9, 10, 11, 12, 13, 14,
|
|
16, 17, 19, 21, 23, 25, 28, 31,
|
|
34, 37, 41, 45, 50, 55, 60, 66,
|
|
73, 80, 88, 97, 107, 118, 130, 143,
|
|
157, 173, 190, 209, 230, 253, 279, 307,
|
|
337, 371, 408, 449, 494, 544, 598, 658,
|
|
724, 796, 876, 963, 1060, 1166, 1282, 1411,
|
|
1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
|
|
3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484,
|
|
7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
|
|
15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
|
|
32767,
|
|
}
|
|
|
|
var (
|
|
encPred = 0
|
|
encIndex = 0
|
|
encStep = 7
|
|
decPred = 0
|
|
decIndex = 0
|
|
decStep = 7
|
|
)
|
|
|
|
// EncodeSample takes a single 16 bit PCM sample and
|
|
// returns a byte of which the last 4 bits are an encoded ADPCM nibble
|
|
func EncodeSample(sample int) byte {
|
|
|
|
// find difference from predicted sample
|
|
delta := sample - encPred
|
|
|
|
// set sign bit and find absolute value of difference
|
|
var newSample byte
|
|
if delta < 0 {
|
|
newSample = 8
|
|
delta = -delta
|
|
}
|
|
|
|
step := stepTable[encIndex]
|
|
diff := step >> 3
|
|
var mask byte = 4
|
|
|
|
// quantize delta down to four bits
|
|
for i := 0; i < 3; i++ {
|
|
if delta > step {
|
|
newSample |= mask
|
|
delta -= step
|
|
diff += step
|
|
}
|
|
mask >>= 1
|
|
step >>= 1
|
|
}
|
|
|
|
// adjust predicted sample based on calculated difference
|
|
if newSample&8 != 0 {
|
|
encPred -= diff
|
|
} else {
|
|
encPred += diff
|
|
}
|
|
|
|
// check for underflow and overflow
|
|
fmt.Print("max, min: ", math.MaxInt16)
|
|
fmt.Println(math.MinInt16)
|
|
if encPred < math.MinInt16 {
|
|
encPred = math.MinInt16
|
|
} else if encPred > math.MaxInt16 {
|
|
encPred = math.MaxInt16
|
|
}
|
|
|
|
encIndex += indexTable[newSample&7]
|
|
|
|
// check for underflow and overflow
|
|
if encIndex < 0 {
|
|
encIndex = 0
|
|
} else if encIndex > len(stepTable)-1 {
|
|
encIndex = len(stepTable) - 1
|
|
}
|
|
|
|
return newSample
|
|
}
|
|
|
|
// DecodeSample takes a byte, the last 4 bits of which contain a single
|
|
// 4 bit ADPCM value/sample, and returns a 16 bit decoded PCM sample
|
|
func DecodeSample(nibble byte) int {
|
|
|
|
diff := 0
|
|
|
|
if nibble&4 != 0 {
|
|
diff += decStep
|
|
}
|
|
|
|
if nibble&2 != 0 {
|
|
diff += decStep >> 1
|
|
}
|
|
|
|
if nibble&1 != 0 {
|
|
diff += decStep >> 2
|
|
}
|
|
|
|
diff += decStep >> 3
|
|
|
|
if nibble&8 != 0 {
|
|
diff = -diff
|
|
}
|
|
|
|
decPred += diff
|
|
|
|
if decPred > math.MaxInt16 {
|
|
decPred = math.MaxInt16
|
|
} else if decPred < math.MinInt16 {
|
|
decPred = math.MinInt16
|
|
}
|
|
|
|
decIndex += indexTable[nibble]
|
|
if decIndex < 0 {
|
|
decIndex = 0
|
|
} else if decIndex > len(stepTable)-1 {
|
|
decIndex = len(stepTable) - 1
|
|
}
|
|
decStep = stepTable[decIndex]
|
|
|
|
return decPred
|
|
}
|