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

@@ -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
 }