mirror
/
av
mirror of https://bitbucket.org/ausocean/av.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

adpcm: removed adpcm.go changes from this branch

This commit is contained in:
Trek H 2019-08-21 16:23:27 +09:30
parent 6bef4aeefc
commit 4ac968654f
1 changed files with 43 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
codec/adpcm/adpcm.go
View File

@ -40,11 +40,10 @@ import (
const ( const (
byteDepth = 2 // We are working with 16-bit samples. TODO(Trek): make configurable. byteDepth = 2 // We are working with 16-bit samples. TODO(Trek): make configurable.
initSamps = 2 // Number of samples used to initialise the encoder. initSamps = 2 // Number of samples used to initialise the encoder.
initSize = initSamps * byteDepth initBytes = initSamps * byteDepth
headSize = 8 // Number of bytes in the header of ADPCM. headBytes = 4 // Number of bytes in the header of ADPCM.
samplesPerEnc = 2 // Number of sample encoded at a time eg. 2 16-bit samples get encoded into 1 byte. samplesPerEnc = 2 // Number of sample encoded at a time eg. 2 16-bit samples get encoded into 1 byte.
bytesPerEnc = samplesPerEnc * byteDepth bytesPerEnc = samplesPerEnc * byteDepth
chunkLenSize = 4 // Size of the chunk length in bytes, chunk length is a 32 bit number.
compFact = 4 // In general ADPCM compresses by a factor of 4. compFact = 4 // In general ADPCM compresses by a factor of 4.
) )
@ -177,7 +176,7 @@ func (e *Encoder) calcHead(sample []byte, pad bool) (int, error) {
// The suitable step size is the closest step size in the stepTable to half the absolute difference of the first two samples. // The suitable step size is the closest step size in the stepTable to half the absolute difference of the first two samples.
func (e *Encoder) init(samples []byte) { func (e *Encoder) init(samples []byte) {
int1 := int16(binary.LittleEndian.Uint16(samples[:byteDepth])) int1 := int16(binary.LittleEndian.Uint16(samples[:byteDepth]))
int2 := int16(binary.LittleEndian.Uint16(samples[byteDepth:initSize])) int2 := int16(binary.LittleEndian.Uint16(samples[byteDepth:initBytes]))
e.est = int1 e.est = int1
halfDiff := math.Abs(math.Abs(float64(int1)) - math.Abs(float64(int2))/2) halfDiff := math.Abs(math.Abs(float64(int1)) - math.Abs(float64(int2))/2)
@ -198,8 +197,8 @@ func (e *Encoder) init(samples []byte) {
func (e *Encoder) Write(b []byte) (int, error) { func (e *Encoder) Write(b []byte) (int, error) {
// Check that pcm has enough data to initialize Decoder. // Check that pcm has enough data to initialize Decoder.
pcmLen := len(b) pcmLen := len(b)
if pcmLen < initSize { if pcmLen < initBytes {
return 0, fmt.Errorf("length of given byte array must be >= %v", initSize) return 0, fmt.Errorf("length of given byte array must be >= %v", initBytes)
} }
// Determine if there will be a byte that won't contain two full nibbles and will need padding. // Determine if there will be a byte that won't contain two full nibbles and will need padding.
@ -208,18 +207,8 @@ func (e *Encoder) Write(b []byte) (int, error) {
pad = true pad = true
} }
// Write the first 4 bytes of the adpcm chunk, which represent its length, ie. the number of bytes following the chunk length. e.init(b[:initBytes])
chunkLen := EncBytes(pcmLen) n, err := e.calcHead(b[:byteDepth], pad)
chunkLenBytes := make([]byte, chunkLenSize)
binary.LittleEndian.PutUint32(chunkLenBytes, uint32(chunkLen))
n, err := e.dst.Write(chunkLenBytes)
if err != nil {
return n, err
}
e.init(b[:initSize])
_n, err := e.calcHead(b[:byteDepth], pad)
n += _n
if err != nil { if err != nil {
return n, err return n, err
} }
@ -295,59 +284,47 @@ func (d *Decoder) decodeSample(nibble byte) int16 {
// It writes its output to the Decoder's dst. // It writes its output to the Decoder's dst.
// The number of bytes written out is returned along with any error that occured. // The number of bytes written out is returned along with any error that occured.
func (d *Decoder) Write(b []byte) (int, error) { func (d *Decoder) Write(b []byte) (int, error) {
// Iterate over each chunk and decode it. // Initialize Decoder with first 4 bytes of b.
var n int d.est = int16(binary.LittleEndian.Uint16(b[:byteDepth]))
var chunkLen int d.idx = int16(b[byteDepth])
for off := 0; off+headSize <= len(b); off += chunkLen { d.step = stepTable[d.idx]
// Read length of chunk and check if whole chunk exists. n, err := d.dst.Write(b[:byteDepth])
chunkLen = int(binary.LittleEndian.Uint32(b[off : off+chunkLenSize])) if err != nil {
if off+chunkLen > len(b) { return n, err
break }
}
// Initialize Decoder with header of b. // For each byte, seperate it into two nibbles (each nibble is a compressed sample),
d.est = int16(binary.LittleEndian.Uint16(b[off+chunkLenSize : off+chunkLenSize+byteDepth])) // then decode each nibble and output the resulting 16-bit samples.
d.idx = int16(b[off+chunkLenSize+byteDepth]) // If padding flag is true (Adpcm[3]), only decode up until the last byte, then decode that separately.
d.step = stepTable[d.idx] for i := headBytes; i < len(b)-int(b[3]); i++ {
_n, err := d.dst.Write(b[off+chunkLenSize : off+chunkLenSize+byteDepth]) twoNibs := b[i]
nib2 := byte(twoNibs >> 4)
nib1 := byte((nib2 << 4) ^ twoNibs)
firstBytes := make([]byte, byteDepth)
binary.LittleEndian.PutUint16(firstBytes, uint16(d.decodeSample(nib1)))
_n, err := d.dst.Write(firstBytes)
n += _n n += _n
if err != nil { if err != nil {
return n, err return n, err
} }
// For each byte, seperate it into two nibbles (each nibble is a compressed sample), secondBytes := make([]byte, byteDepth)
// then decode each nibble and output the resulting 16-bit samples. binary.LittleEndian.PutUint16(secondBytes, uint16(d.decodeSample(nib2)))
// If padding flag is true only decode up until the last byte, then decode that separately. _n, err = d.dst.Write(secondBytes)
for i := off + headSize; i < off+chunkLen-int(b[off+chunkLenSize+3]); i++ { n += _n
twoNibs := b[i] if err != nil {
nib2 := byte(twoNibs >> 4) return n, err
nib1 := byte((nib2 << 4) ^ twoNibs)
firstBytes := make([]byte, byteDepth)
binary.LittleEndian.PutUint16(firstBytes, uint16(d.decodeSample(nib1)))
_n, err := d.dst.Write(firstBytes)
n += _n
if err != nil {
return n, err
}
secondBytes := make([]byte, byteDepth)
binary.LittleEndian.PutUint16(secondBytes, uint16(d.decodeSample(nib2)))
_n, err = d.dst.Write(secondBytes)
n += _n
if err != nil {
return n, err
}
} }
if b[off+chunkLenSize+3] == 0x01 { }
padNib := b[off+chunkLen-1] if b[3] == 0x01 {
samp := make([]byte, byteDepth) padNib := b[len(b)-1]
binary.LittleEndian.PutUint16(samp, uint16(d.decodeSample(padNib))) samp := make([]byte, byteDepth)
_n, err := d.dst.Write(samp) binary.LittleEndian.PutUint16(samp, uint16(d.decodeSample(padNib)))
n += _n _n, err := d.dst.Write(samp)
if err != nil { n += _n
return n, err if err != nil {
} return n, err
} }
} }
return n, nil return n, nil
@ -372,7 +349,7 @@ func EncBytes(n int) int {
// and a start index and padding-flag byte are added. // and a start index and padding-flag byte are added.
// Also if there are an even number of samples, there will be half a byte of padding added to the last byte. // Also if there are an even number of samples, there will be half a byte of padding added to the last byte.
if n%bytesPerEnc == 0 { if n%bytesPerEnc == 0 {
return (n-byteDepth)/compFact + headSize + 1 return (n-byteDepth)/compFact + headBytes + 1
} }
return (n-byteDepth)/compFact + headSize return (n-byteDepth)/compFact + headBytes
} }