diff --git a/cmd/adpcm/adpcm.go b/cmd/adpcm/adpcm.go deleted file mode 100644 index 27be2aa7..00000000 --- a/cmd/adpcm/adpcm.go +++ /dev/null @@ -1,216 +0,0 @@ -package adpcm - -import ( - "encoding/binary" - "fmt" - "math" -) - -// table of index changes -var indexTable = []int16{ - -1, -1, -1, -1, 2, 4, 6, 8, - -1, -1, -1, -1, 2, 4, 6, 8, -} - -// quantize step size table -var stepTable = []int16{ - 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 int16 - encIndex int16 - decPred int16 - decIndex int16 - decStep int16 = 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 int16) byte { - - // find difference from predicted sample - delta := sample - encPred - - // set sign bit and find absolute value of difference - var nibble byte - if delta < 0 { - nibble = 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 { - nibble |= mask - delta -= step - diff += step - } - mask >>= 1 - step >>= 1 - } - - // adjust predicted sample based on calculated difference - if nibble&8 != 0 { - encPred -= diff - } else { - encPred += diff - } - - // check for underflow and overflow - if encPred < math.MinInt16 { - encPred = math.MinInt16 - } else if encPred > math.MaxInt16 { - encPred = math.MaxInt16 - } - - encIndex += indexTable[nibble&7] - - // check for underflow and overflow - if encIndex < 0 { - encIndex = 0 - } else if encIndex > int16(len(stepTable)-1) { - encIndex = int16(len(stepTable) - 1) - } - - return nibble -} - -// decodeSample takes a byte, the last 4 bits of which contain a single -// 4 bit ADPCM nibble, and returns a 16 bit decoded PCM sample -func decodeSample(nibble byte) int16 { - - // compute predicted sample estimate (decPred): - - // calculate difference - var diff int16 - if nibble&4 != 0 { - diff += decStep - } - if nibble&2 != 0 { - diff += decStep >> 1 - } - if nibble&1 != 0 { - diff += decStep >> 2 - } - diff += decStep >> 3 - // account for sign bit - if nibble&8 != 0 { - diff = -diff - } - // adjust predicted sample based on calculated difference - decPred += diff - - // check for overflow and underflow - if decPred > math.MaxInt16 { - decPred = math.MaxInt16 - } else if decPred < math.MinInt16 { - decPred = math.MinInt16 - } - - // compute new step size: - - // adjust index into step size lookup table using nibble - decIndex += indexTable[nibble] - // check for overflow and underflow - if decIndex < 0 { - decIndex = 0 - } else if decIndex > int16(len(stepTable)-1) { - decIndex = int16(len(stepTable) - 1) - } - // find new quantizer step size - decStep = stepTable[decIndex] - - return decPred -} - -func calcHead(sample []byte) ([]byte, error) { - if len(sample) != 2 { - return nil, fmt.Errorf("length of given byte array is: %v, expected: 2", len(sample)) - } - - intSample := int16(binary.LittleEndian.Uint16(sample)) - - encodeSample(intSample) - - head := make([]byte, 2) - - head[0] = sample[0] - head[1] = sample[1] - - head = append(head, byte(uint16(encIndex))) - head = append(head, byte(0x00)) - return head, nil -} - -// EncodeBlock takes a slice of 1010 bytes (505 16-bit PCM samples). -// It returns a byte slice containing encoded (compressed) ADPCM nibbles (each byte contains two nibbles). -func EncodeBlock(block []byte) ([]byte, error) { - - if len(block) != 1010 { - return nil, fmt.Errorf("unsupported block size. Given: %v, expected: 1010, ie. 505 16-bit PCM samples", len(block)) - } - - result, err := calcHead(block[0:2]) - if err != nil { - return nil, err - } - - for i := 2; i < len(block); i++ { - if (i+1)%4 == 0 { - sample2 := encodeSample(int16(binary.LittleEndian.Uint16(block[i-1 : i+1]))) - sample := encodeSample(int16(binary.LittleEndian.Uint16(block[i+1 : i+3]))) - result = append(result, byte((sample<<4)|sample2)) - - } - } - - return result, nil -} - -// DecodeBlock takes a slice of 256 bytes, each byte should contain two ADPCM encoded nibbles. -// It returns a byte slice containing the resulting decoded (uncompressed) 16-bit PCM samples. -func DecodeBlock(block []byte) ([]byte, error) { - - if len(block) != 256 { - return nil, fmt.Errorf("unsupported block size. Given: %v, expected: 256", len(block)) - } - - var result []byte - decPred = int16(binary.LittleEndian.Uint16(block[0:2])) - decIndex = int16(block[2]) - decStep = stepTable[decIndex] - result = append(result, block[0:2]...) - - for i := 4; i < len(block); i++ { - originalSample := block[i] - secondSample := byte(originalSample >> 4) - firstSample := byte((secondSample << 4) ^ originalSample) - - firstBytes := make([]byte, 2) - binary.LittleEndian.PutUint16(firstBytes, uint16(decodeSample(firstSample))) - result = append(result, firstBytes...) - - secondBytes := make([]byte, 2) - binary.LittleEndian.PutUint16(secondBytes, uint16(decodeSample(secondSample))) - result = append(result, secondBytes...) - - } - - return result, nil -} diff --git a/stream/adpcm/adpcm.go b/stream/adpcm/adpcm.go index 27be2aa7..61259de0 100644 --- a/stream/adpcm/adpcm.go +++ b/stream/adpcm/adpcm.go @@ -40,11 +40,11 @@ var ( // returns a byte of which the last 4 bits are an encoded ADPCM nibble func encodeSample(sample int16) byte { - // find difference from predicted sample delta := sample - encPred - // set sign bit and find absolute value of difference var nibble byte + + // set sign bit and find absolute value of difference if delta < 0 { nibble = 8 delta = -delta @@ -54,7 +54,6 @@ func encodeSample(sample int16) byte { diff := step >> 3 var mask byte = 4 - // quantize delta down to four bits for i := 0; i < 3; i++ { if delta > step { nibble |= mask @@ -140,16 +139,17 @@ func decodeSample(nibble byte) int16 { } func calcHead(sample []byte) ([]byte, error) { - if len(sample) != 2 { - return nil, fmt.Errorf("length of given byte array is: %v, expected: 2", len(sample)) + + // check that we are given 1 16-bit sample (2 bytes) + sampSize := 2 + if len(sample) != sampSize { + return nil, fmt.Errorf("length of given byte array is: %v, expected: %v", len(sample), sampSize) } intSample := int16(binary.LittleEndian.Uint16(sample)) - encodeSample(intSample) head := make([]byte, 2) - head[0] = sample[0] head[1] = sample[1] @@ -162,8 +162,9 @@ func calcHead(sample []byte) ([]byte, error) { // It returns a byte slice containing encoded (compressed) ADPCM nibbles (each byte contains two nibbles). func EncodeBlock(block []byte) ([]byte, error) { - if len(block) != 1010 { - return nil, fmt.Errorf("unsupported block size. Given: %v, expected: 1010, ie. 505 16-bit PCM samples", len(block)) + bSize := 1010 + if len(block) != bSize { + return nil, fmt.Errorf("unsupported block size. Given: %v, expected: %v, ie. 505 16-bit PCM samples", len(block), bSize) } result, err := calcHead(block[0:2]) @@ -187,8 +188,9 @@ func EncodeBlock(block []byte) ([]byte, error) { // It returns a byte slice containing the resulting decoded (uncompressed) 16-bit PCM samples. func DecodeBlock(block []byte) ([]byte, error) { - if len(block) != 256 { - return nil, fmt.Errorf("unsupported block size. Given: %v, expected: 256", len(block)) + bSize := 256 + if len(block) != bSize { + return nil, fmt.Errorf("unsupported block size. Given: %v, expected: %v", len(block), bSize) } var result []byte diff --git a/stream/adpcm/adpcm_test.go b/stream/adpcm/adpcm_test.go index 96c4a556..c83732c3 100644 --- a/stream/adpcm/adpcm_test.go +++ b/stream/adpcm/adpcm_test.go @@ -6,13 +6,14 @@ import ( "testing" ) +// TestEncodeBlock will read PCM data, encode it in blocks and generate ADPCM +// then compare the result with expected ADPCM. func TestEncodeBlock(t *testing.T) { //read input pcm pcm, err := ioutil.ReadFile("../../../test/test-data/av/input/raw-voice.pcm") if err != nil { t.Errorf("Unable to read input PCM file: %v", err) } - //encode adpcm var comp []byte start := 0 @@ -29,7 +30,6 @@ func TestEncodeBlock(t *testing.T) { start = i + 1 } } - //read expected adpcm file exp, err := ioutil.ReadFile("../../../test/test-data/av/output/encoded-voice.adpcm") if err != nil { @@ -40,3 +40,36 @@ func TestEncodeBlock(t *testing.T) { t.Error("ADPCM generated does not match expected ADPCM") } } + +// TestDecodeBlock will read encoded ADPCM, decode it in blocks and then compare the +// resulting PCM with the expected decoded PCM. +func TestDecodeBlock(t *testing.T) { + //read adpcm + comp, err := ioutil.ReadFile("../../../test/test-data/av/input/encoded-voice.adpcm") + if err != nil { + t.Errorf("Unable to read input ADPCM file: %v", err) + } + //decode adpcm + var decoded []byte + start := 0 + for i := 0; i < len(comp); i++ { + if i%256 == 255 { + block := comp[start : i+1] + decBlock, err := DecodeBlock(block) + if err != nil { + t.Errorf("Unable to decode block: %v", err) + } + decoded = append(decoded, decBlock...) + start = i + 1 + } + } + //read expected pcm file + exp, err := ioutil.ReadFile("../../../test/test-data/av/output/decoded-voice.pcm") + if err != nil { + t.Errorf("Unable to read expected PCM file: %v", err) + } + + if !bytes.Equal(decoded, exp) { + t.Error("PCM generated does not match expected PCM") + } +}