From 4b8864ff207580492c48e4aa6d12ae01485ce1f2 Mon Sep 17 00:00:00 2001 From: Trek H Date: Wed, 21 Aug 2019 15:39:58 +0930 Subject: [PATCH] adpcm: better decoding of chunks added chunk length to chunk header added to decoder the ability to decode consecutive chunks of variable length. --- codec/adpcm/adpcm.go | 109 ++++++++++++++++++++++++++----------------- 1 file changed, 66 insertions(+), 43 deletions(-) diff --git a/codec/adpcm/adpcm.go b/codec/adpcm/adpcm.go index ce8ae9f7..479f6261 100644 --- a/codec/adpcm/adpcm.go +++ b/codec/adpcm/adpcm.go @@ -40,10 +40,11 @@ import ( const ( byteDepth = 2 // We are working with 16-bit samples. TODO(Trek): make configurable. initSamps = 2 // Number of samples used to initialise the encoder. - initBytes = initSamps * byteDepth - headBytes = 4 // Number of bytes in the header of ADPCM. + initSize = initSamps * byteDepth + headSize = 8 // 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. 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. ) @@ -176,7 +177,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. func (e *Encoder) init(samples []byte) { int1 := int16(binary.LittleEndian.Uint16(samples[:byteDepth])) - int2 := int16(binary.LittleEndian.Uint16(samples[byteDepth:initBytes])) + int2 := int16(binary.LittleEndian.Uint16(samples[byteDepth:initSize])) e.est = int1 halfDiff := math.Abs(math.Abs(float64(int1)) - math.Abs(float64(int2))/2) @@ -197,8 +198,8 @@ func (e *Encoder) init(samples []byte) { func (e *Encoder) Write(b []byte) (int, error) { // Check that pcm has enough data to initialize Decoder. pcmLen := len(b) - if pcmLen < initBytes { - return 0, fmt.Errorf("length of given byte array must be >= %v", initBytes) + if pcmLen < initSize { + return 0, fmt.Errorf("length of given byte array must be >= %v", initSize) } // Determine if there will be a byte that won't contain two full nibbles and will need padding. @@ -207,8 +208,18 @@ func (e *Encoder) Write(b []byte) (int, error) { pad = true } - e.init(b[:initBytes]) - n, err := e.calcHead(b[:byteDepth], pad) + // Write the first 4 bytes of the adpcm chunk, which represent its length, ie. the number of bytes following the chunk length. + chunkLen := EncBytes(pcmLen) + 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 { return n, err } @@ -284,47 +295,59 @@ func (d *Decoder) decodeSample(nibble byte) int16 { // It writes its output to the Decoder's dst. // The number of bytes written out is returned along with any error that occured. func (d *Decoder) Write(b []byte) (int, error) { - // Initialize Decoder with first 4 bytes of b. - d.est = int16(binary.LittleEndian.Uint16(b[:byteDepth])) - d.idx = int16(b[byteDepth]) - d.step = stepTable[d.idx] - n, err := d.dst.Write(b[:byteDepth]) - if err != nil { - return n, err - } + // Iterate over each chunk and decode it. + var n int + var chunkLen int + for off := 0; off+headSize <= len(b); off += chunkLen { + // Read length of chunk and check if whole chunk exists. + chunkLen = int(binary.LittleEndian.Uint32(b[off : off+chunkLenSize])) + if off+chunkLen > len(b) { + break + } - // For each byte, seperate it into two nibbles (each nibble is a compressed sample), - // then decode each nibble and output the resulting 16-bit samples. - // If padding flag is true (Adpcm[3]), only decode up until the last byte, then decode that separately. - for i := headBytes; i < len(b)-int(b[3]); i++ { - 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) + // Initialize Decoder with header of b. + d.est = int16(binary.LittleEndian.Uint16(b[off+chunkLenSize : off+chunkLenSize+byteDepth])) + d.idx = int16(b[off+chunkLenSize+byteDepth]) + d.step = stepTable[d.idx] + _n, err := d.dst.Write(b[off+chunkLenSize : off+chunkLenSize+byteDepth]) 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 + // For each byte, seperate it into two nibbles (each nibble is a compressed sample), + // then decode each nibble and output the resulting 16-bit samples. + // If padding flag is true only decode up until the last byte, then decode that separately. + for i := off + headSize; i < off+chunkLen-int(b[off+chunkLenSize+3]); i++ { + 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 + 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[3] == 0x01 { - padNib := b[len(b)-1] - samp := make([]byte, byteDepth) - binary.LittleEndian.PutUint16(samp, uint16(d.decodeSample(padNib))) - _n, err := d.dst.Write(samp) - n += _n - if err != nil { - return n, err + if b[off+chunkLenSize+3] == 0x01 { + padNib := b[off+chunkLen-1] + samp := make([]byte, byteDepth) + binary.LittleEndian.PutUint16(samp, uint16(d.decodeSample(padNib))) + _n, err := d.dst.Write(samp) + n += _n + if err != nil { + return n, err + } } } return n, nil @@ -349,7 +372,7 @@ func EncBytes(n int) int { // 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. if n%bytesPerEnc == 0 { - return (n-byteDepth)/compFact + headBytes + 1 + return (n-byteDepth)/compFact + headSize + 1 } - return (n-byteDepth)/compFact + headBytes + return (n-byteDepth)/compFact + headSize }