From 56422a366e7b4961780777f845c56631648ae0c6 Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Mon, 21 Jan 2019 14:57:40 +1030
Subject: [PATCH 01/13] av/stream/flac: added decode.go and flac_test.go

---
 stream/flac/decode.go    | 0
 stream/flac/flac_test.go | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 stream/flac/decode.go
 create mode 100644 stream/flac/flac_test.go

diff --git a/stream/flac/decode.go b/stream/flac/decode.go
new file mode 100644
index 00000000..e69de29b
diff --git a/stream/flac/flac_test.go b/stream/flac/flac_test.go
new file mode 100644
index 00000000..e69de29b

From 44c79e225673f3f7fd74a420273d23f94227ec91 Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Mon, 21 Jan 2019 15:41:49 +1030
Subject: [PATCH 02/13] av/stream/flac: wrote decode function and test to see
 if we can get wav.

---
 stream/flac/decode.go    | 108 +++++++++++++++++++++++++++++++++++++++
 stream/flac/flac_test.go |  31 +++++++++++
 2 files changed, 139 insertions(+)

diff --git a/stream/flac/decode.go b/stream/flac/decode.go
index e69de29b..2ecfb737 100644
--- a/stream/flac/decode.go
+++ b/stream/flac/decode.go
@@ -0,0 +1,108 @@
+package flac
+
+import (
+	"bytes"
+	"errors"
+	"io"
+
+	"github.com/go-audio/audio"
+	"github.com/go-audio/wav"
+	"github.com/mewkiz/flac"
+)
+
+const wavAudioFormat = 1
+
+type buffer struct {
+	Buffer bytes.Buffer
+	Index  int64
+}
+
+func (b *buffer) Bytes() []byte {
+	return b.Buffer.Bytes()
+}
+
+func (b *buffer) Read(p []byte) (int, error) {
+	n, err := bytes.NewBuffer(b.Buffer.Bytes()[b.Index:]).Read(p)
+
+	if err == nil {
+		if b.Index+int64(len(p)) < int64(b.Buffer.Len()) {
+			b.Index += int64(len(p))
+		} else {
+			b.Index = int64(b.Buffer.Len())
+		}
+	}
+
+	return n, err
+}
+
+func (b *buffer) Write(p []byte) (int, error) {
+	n, err := b.Buffer.Write(p)
+
+	if err == nil {
+		b.Index = int64(b.Buffer.Len())
+	}
+
+	return n, err
+}
+
+func (b *buffer) Seek(offset int64, whence int) (int64, error) {
+	var err error
+	var Index int64 = 0
+
+	switch whence {
+	case 0:
+		if offset >= int64(b.Buffer.Len()) || offset < 0 {
+			err = errors.New("Invalid Offset.")
+		} else {
+			b.Index = offset
+			Index = offset
+		}
+	default:
+		err = errors.New("Unsupported Seek Method.")
+	}
+
+	return Index, err
+}
+
+// Decode takes a slice of flac and decodes to wav
+func Decode(buf []byte) ([]byte, error) {
+	r := bytes.NewReader(buf)
+	stream, err := flac.Parse(r)
+	if err != nil {
+		return nil, errors.New("Could not parse FLAC")
+	}
+	fb := &buffer{}
+	enc := wav.NewEncoder(fb, int(stream.Info.SampleRate), int(stream.Info.BitsPerSample), int(stream.Info.NChannels), wavAudioFormat)
+	defer enc.Close()
+	var data []int
+	for {
+		// Decode FLAC audio samples.
+		frame, err := stream.ParseNext()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return nil, err
+		}
+
+		// Encode WAV audio samples.
+		data = data[:0]
+		for i := 0; i < frame.Subframes[0].NSamples; i++ {
+			for _, subframe := range frame.Subframes {
+				data = append(data, int(subframe.Samples[i]))
+			}
+		}
+		buf := &audio.IntBuffer{
+			Format: &audio.Format{
+				NumChannels: int(stream.Info.NChannels),
+				SampleRate:  int(stream.Info.SampleRate),
+			},
+			Data:           data,
+			SourceBitDepth: int(stream.Info.BitsPerSample),
+		}
+		if err := enc.Write(buf); err != nil {
+			return nil, err
+		}
+	}
+	return fb.Bytes(), nil
+}
diff --git a/stream/flac/flac_test.go b/stream/flac/flac_test.go
index e69de29b..763731d4 100644
--- a/stream/flac/flac_test.go
+++ b/stream/flac/flac_test.go
@@ -0,0 +1,31 @@
+package flac
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+const (
+	testFile = "/home/saxon/Desktop/robot.flac"
+	outFile  = "out.wav"
+)
+
+func TestDecodeFlac(t *testing.T) {
+	b, err := ioutil.ReadFile(testFile)
+	if err != nil {
+		t.Fatalf("Could not read test file, failed with err: %v", err.Error())
+	}
+	out, err := Decode(b)
+	if err != nil {
+		t.Errorf("Could not decode, failed with err: %v", err.Error())
+	}
+	f, err := os.Create(outFile)
+	if err != nil {
+		t.Fatalf("Could not create output file, failed with err: %v", err.Error())
+	}
+	_, err = f.Write(out)
+	if err != nil {
+		t.Fatalf("Could not write to output file, failed with err: %v", err.Error())
+	}
+}

From 6fda0b3c3fe91515c792cac3e29124090f7dcf18 Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Mon, 21 Jan 2019 17:34:15 +1030
Subject: [PATCH 03/13] av/stream/flac: using writerseeker to pass to
 wav.NewEncoder because I don't want to give it a file, but it's not working

---
 stream/flac/decode.go    | 68 ++++++++--------------------------------
 stream/flac/flac_test.go |  2 +-
 2 files changed, 14 insertions(+), 56 deletions(-)

diff --git a/stream/flac/decode.go b/stream/flac/decode.go
index 2ecfb737..941610e2 100644
--- a/stream/flac/decode.go
+++ b/stream/flac/decode.go
@@ -4,66 +4,16 @@ import (
 	"bytes"
 	"errors"
 	"io"
+	"io/ioutil"
 
 	"github.com/go-audio/audio"
 	"github.com/go-audio/wav"
 	"github.com/mewkiz/flac"
+	"github.com/orcaman/writerseeker"
 )
 
 const wavAudioFormat = 1
 
-type buffer struct {
-	Buffer bytes.Buffer
-	Index  int64
-}
-
-func (b *buffer) Bytes() []byte {
-	return b.Buffer.Bytes()
-}
-
-func (b *buffer) Read(p []byte) (int, error) {
-	n, err := bytes.NewBuffer(b.Buffer.Bytes()[b.Index:]).Read(p)
-
-	if err == nil {
-		if b.Index+int64(len(p)) < int64(b.Buffer.Len()) {
-			b.Index += int64(len(p))
-		} else {
-			b.Index = int64(b.Buffer.Len())
-		}
-	}
-
-	return n, err
-}
-
-func (b *buffer) Write(p []byte) (int, error) {
-	n, err := b.Buffer.Write(p)
-
-	if err == nil {
-		b.Index = int64(b.Buffer.Len())
-	}
-
-	return n, err
-}
-
-func (b *buffer) Seek(offset int64, whence int) (int64, error) {
-	var err error
-	var Index int64 = 0
-
-	switch whence {
-	case 0:
-		if offset >= int64(b.Buffer.Len()) || offset < 0 {
-			err = errors.New("Invalid Offset.")
-		} else {
-			b.Index = offset
-			Index = offset
-		}
-	default:
-		err = errors.New("Unsupported Seek Method.")
-	}
-
-	return Index, err
-}
-
 // Decode takes a slice of flac and decodes to wav
 func Decode(buf []byte) ([]byte, error) {
 	r := bytes.NewReader(buf)
@@ -71,10 +21,12 @@ func Decode(buf []byte) ([]byte, error) {
 	if err != nil {
 		return nil, errors.New("Could not parse FLAC")
 	}
-	fb := &buffer{}
-	enc := wav.NewEncoder(fb, int(stream.Info.SampleRate), int(stream.Info.BitsPerSample), int(stream.Info.NChannels), wavAudioFormat)
+	ws := &writerseeker.WriterSeeker{}
+	enc := wav.NewEncoder(ws, int(stream.Info.SampleRate), int(stream.Info.BitsPerSample), int(stream.Info.NChannels), wavAudioFormat)
 	defer enc.Close()
 	var data []int
+	var out []byte
+	var d []byte
 	for {
 		// Decode FLAC audio samples.
 		frame, err := stream.ParseNext()
@@ -103,6 +55,12 @@ func Decode(buf []byte) ([]byte, error) {
 		if err := enc.Write(buf); err != nil {
 			return nil, err
 		}
+		d, err = ioutil.ReadAll(ws.Reader())
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, d...)
 	}
-	return fb.Bytes(), nil
+
+	return d, nil
 }
diff --git a/stream/flac/flac_test.go b/stream/flac/flac_test.go
index 763731d4..13bef836 100644
--- a/stream/flac/flac_test.go
+++ b/stream/flac/flac_test.go
@@ -8,7 +8,7 @@ import (
 
 const (
 	testFile = "/home/saxon/Desktop/robot.flac"
-	outFile  = "out.wav"
+	outFile  = "testOut.wav"
 )
 
 func TestDecodeFlac(t *testing.T) {

From 155134eeed1bd79ddc52c2bdd27c92fb9f527cef Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Mon, 21 Jan 2019 17:37:16 +1030
Subject: [PATCH 04/13] av/stream/flac: moved readAll to after loop

---
 stream/flac/decode.go | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/stream/flac/decode.go b/stream/flac/decode.go
index 941610e2..6c8445e4 100644
--- a/stream/flac/decode.go
+++ b/stream/flac/decode.go
@@ -25,8 +25,6 @@ func Decode(buf []byte) ([]byte, error) {
 	enc := wav.NewEncoder(ws, int(stream.Info.SampleRate), int(stream.Info.BitsPerSample), int(stream.Info.NChannels), wavAudioFormat)
 	defer enc.Close()
 	var data []int
-	var out []byte
-	var d []byte
 	for {
 		// Decode FLAC audio samples.
 		frame, err := stream.ParseNext()
@@ -55,12 +53,10 @@ func Decode(buf []byte) ([]byte, error) {
 		if err := enc.Write(buf); err != nil {
 			return nil, err
 		}
-		d, err = ioutil.ReadAll(ws.Reader())
-		if err != nil {
-			return nil, err
-		}
-		out = append(out, d...)
 	}
-
+	d, err := ioutil.ReadAll(ws.Reader())
+	if err != nil {
+		return nil, err
+	}
 	return d, nil
 }

From 28e26cd151cc9866cf9e1072c2936528c2ed4554 Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Mon, 21 Jan 2019 17:50:09 +1030
Subject: [PATCH 05/13] av/stream/flc: using my own writeSeeker implementation
 - working

---
 stream/flac/decode.go | 52 ++++++++++++++++++++++++++++++++++++-------
 1 file changed, 44 insertions(+), 8 deletions(-)

diff --git a/stream/flac/decode.go b/stream/flac/decode.go
index 6c8445e4..667fcf9c 100644
--- a/stream/flac/decode.go
+++ b/stream/flac/decode.go
@@ -4,16 +4,55 @@ import (
 	"bytes"
 	"errors"
 	"io"
-	"io/ioutil"
 
 	"github.com/go-audio/audio"
 	"github.com/go-audio/wav"
 	"github.com/mewkiz/flac"
-	"github.com/orcaman/writerseeker"
 )
 
 const wavAudioFormat = 1
 
+type WriterSeeker struct {
+	buf []byte
+	pos int
+}
+
+func (ws *WriterSeeker) Bytes() []byte {
+	return ws.buf
+}
+
+func (m *WriterSeeker) Write(p []byte) (n int, err error) {
+	minCap := m.pos + len(p)
+	if minCap > cap(m.buf) { // Make sure buf has enough capacity:
+		buf2 := make([]byte, len(m.buf), minCap+len(p)) // add some extra
+		copy(buf2, m.buf)
+		m.buf = buf2
+	}
+	if minCap > len(m.buf) {
+		m.buf = m.buf[:minCap]
+	}
+	copy(m.buf[m.pos:], p)
+	m.pos += len(p)
+	return len(p), nil
+}
+
+func (m *WriterSeeker) Seek(offset int64, whence int) (int64, error) {
+	newPos, offs := 0, int(offset)
+	switch whence {
+	case io.SeekStart:
+		newPos = offs
+	case io.SeekCurrent:
+		newPos = m.pos + offs
+	case io.SeekEnd:
+		newPos = len(m.buf) + offs
+	}
+	if newPos < 0 {
+		return 0, errors.New("negative result pos")
+	}
+	m.pos = newPos
+	return int64(newPos), nil
+}
+
 // Decode takes a slice of flac and decodes to wav
 func Decode(buf []byte) ([]byte, error) {
 	r := bytes.NewReader(buf)
@@ -21,7 +60,7 @@ func Decode(buf []byte) ([]byte, error) {
 	if err != nil {
 		return nil, errors.New("Could not parse FLAC")
 	}
-	ws := &writerseeker.WriterSeeker{}
+	ws := &WriterSeeker{}
 	enc := wav.NewEncoder(ws, int(stream.Info.SampleRate), int(stream.Info.BitsPerSample), int(stream.Info.NChannels), wavAudioFormat)
 	defer enc.Close()
 	var data []int
@@ -54,9 +93,6 @@ func Decode(buf []byte) ([]byte, error) {
 			return nil, err
 		}
 	}
-	d, err := ioutil.ReadAll(ws.Reader())
-	if err != nil {
-		return nil, err
-	}
-	return d, nil
+
+	return ws.Bytes(), nil
 }

From 5f3bf33213926fee73fd1c2a8fee55735e93a12b Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Mon, 21 Jan 2019 22:52:17 +1030
Subject: [PATCH 06/13] av/stream/flac/decode.go: wrote func headers

---
 stream/flac/decode.go    | 79 ++++++++++++++++++++++++++++++----------
 stream/flac/flac_test.go | 26 +++++++++++++
 2 files changed, 85 insertions(+), 20 deletions(-)

diff --git a/stream/flac/decode.go b/stream/flac/decode.go
index 667fcf9c..42c4dace 100644
--- a/stream/flac/decode.go
+++ b/stream/flac/decode.go
@@ -1,3 +1,29 @@
+/*
+NAME
+	decode.go
+
+DESCRIPTION
+  decode.go provides functionality for the decoding of FLAC compressed audio
+
+AUTHOR
+  Saxon Nelson-Milton <saxon@ausocean.org>
+
+LICENSE
+  decode.go is Copyright (C) 2017-2019 the Australian Ocean Lab (AusOcean)
+
+  It is free software: you can redistribute it and/or modify them
+  under the terms of the GNU General Public License as published by the
+  Free Software Foundation, either version 3 of the License, or (at your
+  option) any later version.
+
+  It is distributed in the hope that it will be useful, but WITHOUT
+  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with revid in gpl.txt.  If not, see http://www.gnu.org/licenses.
+*/
 package flac
 
 import (
@@ -10,59 +36,72 @@ import (
 	"github.com/mewkiz/flac"
 )
 
-const wavAudioFormat = 1
+const wavFormat = 1
 
-type WriterSeeker struct {
+// writeSeeker implements a memory based io.WriteSeeker.
+type writeSeeker struct {
 	buf []byte
 	pos int
 }
 
-func (ws *WriterSeeker) Bytes() []byte {
+// Bytes returns the bytes contained in the writeSeekers buffer.
+func (ws *writeSeeker) Bytes() []byte {
 	return ws.buf
 }
 
-func (m *WriterSeeker) Write(p []byte) (n int, err error) {
-	minCap := m.pos + len(p)
-	if minCap > cap(m.buf) { // Make sure buf has enough capacity:
-		buf2 := make([]byte, len(m.buf), minCap+len(p)) // add some extra
-		copy(buf2, m.buf)
-		m.buf = buf2
+// Write writes len(p) bytes from p to the writeSeeker's buf and returns the number
+// of bytes written. If less than len(p) bytes are written, an error is returned.
+func (ws *writeSeeker) Write(p []byte) (n int, err error) {
+	minCap := ws.pos + len(p)
+	if minCap > cap(ws.buf) { // Make sure buf has enough capacity:
+		buf2 := make([]byte, len(ws.buf), minCap+len(p)) // add some extra
+		copy(buf2, ws.buf)
+		ws.buf = buf2
 	}
-	if minCap > len(m.buf) {
-		m.buf = m.buf[:minCap]
+	if minCap > len(ws.buf) {
+		ws.buf = ws.buf[:minCap]
 	}
-	copy(m.buf[m.pos:], p)
-	m.pos += len(p)
+	copy(ws.buf[ws.pos:], p)
+	ws.pos += len(p)
 	return len(p), nil
 }
 
-func (m *WriterSeeker) Seek(offset int64, whence int) (int64, error) {
+// Seek sets the offset for the next Read or Write to offset, interpreted according
+// to whence: SeekStart means relative to the start of the file, SeekCurrent means
+// relative to the current offset, and SeekEnd means relative to the end. Seek returns
+// the new offset relative to the start of the file and an error, if any.
+func (ws *writeSeeker) Seek(offset int64, whence int) (int64, error) {
 	newPos, offs := 0, int(offset)
 	switch whence {
 	case io.SeekStart:
 		newPos = offs
 	case io.SeekCurrent:
-		newPos = m.pos + offs
+		newPos = ws.pos + offs
 	case io.SeekEnd:
-		newPos = len(m.buf) + offs
+		newPos = len(ws.buf) + offs
 	}
 	if newPos < 0 {
 		return 0, errors.New("negative result pos")
 	}
-	m.pos = newPos
+	ws.pos = newPos
 	return int64(newPos), nil
 }
 
-// Decode takes a slice of flac and decodes to wav
+// Decode takes buf, a slice of FLAC, and decodes to WAV. If complete decoding
+// fails, an error is returned.
 func Decode(buf []byte) ([]byte, error) {
+	// Lex and decode the FLAC into a stream to hold audio and properties.
 	r := bytes.NewReader(buf)
 	stream, err := flac.Parse(r)
 	if err != nil {
 		return nil, errors.New("Could not parse FLAC")
 	}
-	ws := &WriterSeeker{}
-	enc := wav.NewEncoder(ws, int(stream.Info.SampleRate), int(stream.Info.BitsPerSample), int(stream.Info.NChannels), wavAudioFormat)
+
+	// Create WAV encoder and pass writeSeeker that will store output WAV.
+	ws := &writeSeeker{}
+	enc := wav.NewEncoder(ws, int(stream.Info.SampleRate), int(stream.Info.BitsPerSample), int(stream.Info.NChannels), wavFormat)
 	defer enc.Close()
+
 	var data []int
 	for {
 		// Decode FLAC audio samples.
diff --git a/stream/flac/flac_test.go b/stream/flac/flac_test.go
index 13bef836..d69c0494 100644
--- a/stream/flac/flac_test.go
+++ b/stream/flac/flac_test.go
@@ -1,3 +1,29 @@
+/*
+NAME
+	flac_test.go
+
+DESCRIPTION
+  flac_test.go provides utilities to test FLAC audio decoding
+
+AUTHOR
+  Saxon Nelson-Milton <saxon@ausocean.org>
+
+LICENSE
+  flac_test.go is Copyright (C) 2017-2019 the Australian Ocean Lab (AusOcean)
+
+  It is free software: you can redistribute it and/or modify them
+  under the terms of the GNU General Public License as published by the
+  Free Software Foundation, either version 3 of the License, or (at your
+  option) any later version.
+
+  It is distributed in the hope that it will be useful, but WITHOUT
+  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with revid in gpl.txt.  If not, see http://www.gnu.org/licenses.
+*/
 package flac
 
 import (

From 7628efdbc298a1e1527375fd4416c35f52349feb Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Tue, 22 Jan 2019 10:26:22 +1030
Subject: [PATCH 07/13] av/stream/flac: working on cleaning up decode code

---
 stream/flac/decode.go | 43 ++++++++++++++++++++++++-------------------
 1 file changed, 24 insertions(+), 19 deletions(-)

diff --git a/stream/flac/decode.go b/stream/flac/decode.go
index 42c4dace..5a470370 100644
--- a/stream/flac/decode.go
+++ b/stream/flac/decode.go
@@ -90,7 +90,8 @@ func (ws *writeSeeker) Seek(offset int64, whence int) (int64, error) {
 // Decode takes buf, a slice of FLAC, and decodes to WAV. If complete decoding
 // fails, an error is returned.
 func Decode(buf []byte) ([]byte, error) {
-	// Lex and decode the FLAC into a stream to hold audio and properties.
+
+	// Lex the FLAC into a stream to hold audio and it's properties.
 	r := bytes.NewReader(buf)
 	stream, err := flac.Parse(r)
 	if err != nil {
@@ -99,17 +100,30 @@ func Decode(buf []byte) ([]byte, error) {
 
 	// Create WAV encoder and pass writeSeeker that will store output WAV.
 	ws := &writeSeeker{}
-	enc := wav.NewEncoder(ws, int(stream.Info.SampleRate), int(stream.Info.BitsPerSample), int(stream.Info.NChannels), wavFormat)
+	sr := int(stream.Info.SampleRate)
+	bps := int(stream.Info.BitsPerSample)
+	nc := int(stream.Info.NChannels)
+	enc := wav.NewEncoder(ws, sr, bps, nc, wavFormat)
 	defer enc.Close()
 
+	// Decode FLAC into frames of samples
+	intBuf := &audio.IntBuffer{
+		Format:         &audio.Format{NumChannels: nc, SampleRate: sr},
+		SourceBitDepth: bps,
+	}
+	return decodeFrames(stream, intBuf, enc, ws)
+}
+
+//
+func decodeFrames(s *flac.Stream, intBuf *audio.IntBuffer, e *wav.Encoder, ws *writeSeeker) ([]byte, error) {
 	var data []int
 	for {
-		// Decode FLAC audio samples.
-		frame, err := stream.ParseNext()
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
+		frame, err := s.ParseNext()
+
+		// If we've reached the end of the stream then we can output the writeSeeker's buffer.
+		if err == io.EOF {
+			return ws.Bytes(), nil
+		} else if err != nil {
 			return nil, err
 		}
 
@@ -120,18 +134,9 @@ func Decode(buf []byte) ([]byte, error) {
 				data = append(data, int(subframe.Samples[i]))
 			}
 		}
-		buf := &audio.IntBuffer{
-			Format: &audio.Format{
-				NumChannels: int(stream.Info.NChannels),
-				SampleRate:  int(stream.Info.SampleRate),
-			},
-			Data:           data,
-			SourceBitDepth: int(stream.Info.BitsPerSample),
-		}
-		if err := enc.Write(buf); err != nil {
+		intBuf.Data = data
+		if err := e.Write(intBuf); err != nil {
 			return nil, err
 		}
 	}
-
-	return ws.Bytes(), nil
 }

From 6f1767d152d98ca5128f4c91f56449fc6854b322 Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Tue, 22 Jan 2019 10:40:40 +1030
Subject: [PATCH 08/13] av/stream/flac: finished cleaning up decode

---
 stream/flac/decode.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/stream/flac/decode.go b/stream/flac/decode.go
index 5a470370..34d42057 100644
--- a/stream/flac/decode.go
+++ b/stream/flac/decode.go
@@ -114,7 +114,9 @@ func Decode(buf []byte) ([]byte, error) {
 	return decodeFrames(stream, intBuf, enc, ws)
 }
 
-//
+// decodeFrames parses frames from the stream and encodes them into WAV until
+// the end of the stream is reached. The bytes from writeSeeker buffer are then
+// returned. If any errors occur during encodeing, nil bytes and the error is returned.
 func decodeFrames(s *flac.Stream, intBuf *audio.IntBuffer, e *wav.Encoder, ws *writeSeeker) ([]byte, error) {
 	var data []int
 	for {

From b5611bb2b42f8145dc364c1a6fbba0d96fc15757 Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Tue, 22 Jan 2019 10:45:36 +1030
Subject: [PATCH 09/13] av/stream/flac: added writeseeker tests

---
 stream/flac/flac_test.go | 44 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/stream/flac/flac_test.go b/stream/flac/flac_test.go
index d69c0494..9537d682 100644
--- a/stream/flac/flac_test.go
+++ b/stream/flac/flac_test.go
@@ -27,6 +27,7 @@ LICENSE
 package flac
 
 import (
+	"io"
 	"io/ioutil"
 	"os"
 	"testing"
@@ -37,6 +38,49 @@ const (
 	outFile  = "testOut.wav"
 )
 
+func TestWriteSeekerWrite(t *testing.T) {
+	writerSeeker := &writeSeeker{}
+	var ws io.WriteSeeker = writerSeeker
+
+	ws.Write([]byte("hello"))
+	if string(writerSeeker.buf) != "hello" {
+		t.Fail()
+	}
+
+	ws.Write([]byte(" world"))
+	if string(writerSeeker.buf) != "hello world" {
+		t.Fail()
+	}
+
+}
+
+func TestWriteSeekerSeek(t *testing.T) {
+	writerSeeker := &writeSeeker{}
+	var ws io.WriteSeeker = writerSeeker
+
+	ws.Write([]byte("hello"))
+	if string(writerSeeker.buf) != "hello" {
+		t.Fail()
+	}
+
+	ws.Write([]byte(" world"))
+	if string(writerSeeker.buf) != "hello world" {
+		t.Fail()
+	}
+
+	ws.Seek(-2, io.SeekEnd)
+	ws.Write([]byte("k!"))
+	if string(writerSeeker.buf) != "hello work!" {
+		t.Fail()
+	}
+
+	ws.Seek(6, io.SeekStart)
+	ws.Write([]byte("gopher"))
+	if string(writerSeeker.buf) != "hello gopher" {
+		t.Fail()
+	}
+}
+
 func TestDecodeFlac(t *testing.T) {
 	b, err := ioutil.ReadFile(testFile)
 	if err != nil {

From 99b7f4a44bae180cd3f3cf288da5bca4d619581f Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Tue, 22 Jan 2019 11:15:39 +1030
Subject: [PATCH 10/13] av/stream/flac: saving progress

---
 stream/flac/flac_test.go | 36 +++++++++++++++++++++---------------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/stream/flac/flac_test.go b/stream/flac/flac_test.go
index 9537d682..79274819 100644
--- a/stream/flac/flac_test.go
+++ b/stream/flac/flac_test.go
@@ -38,45 +38,51 @@ const (
 	outFile  = "testOut.wav"
 )
 
+// TestWriteSeekerWrite checks that basic writing to the ws works as expected.
 func TestWriteSeekerWrite(t *testing.T) {
-	writerSeeker := &writeSeeker{}
-	var ws io.WriteSeeker = writerSeeker
+	ws := &writeSeeker{}
 
-	ws.Write([]byte("hello"))
-	if string(writerSeeker.buf) != "hello" {
-		t.Fail()
+	const tstStr1 = "hello"
+	ws.Write([]byte(tstStr1))
+	got := string(ws.buf)
+	if got != tstStr1 {
+		t.Errorf("Write failed, got: %v, want: %v", got, tstStr1)
 	}
 
-	ws.Write([]byte(" world"))
-	if string(writerSeeker.buf) != "hello world" {
-		t.Fail()
+	const tstStr2 = " world"
+	const want = "hello world"
+	ws.Write([]byte(tstStr2))
+	got = string(ws.buf)
+	if got != want {
+		t.Errorf("Second write failed, got: %v, want: %v", got, want)
 	}
-
 }
 
+// TestWriteSeekerSeek checks that writing and seeking works as expected, i.e. we
+// can write, then seek to a knew place in the buf, and write again, either replacing
+// bytes, or appending bytes.
 func TestWriteSeekerSeek(t *testing.T) {
-	writerSeeker := &writeSeeker{}
-	var ws io.WriteSeeker = writerSeeker
+	ws := &writeSeeker{}
 
 	ws.Write([]byte("hello"))
-	if string(writerSeeker.buf) != "hello" {
+	if string(ws.buf) != "hello" {
 		t.Fail()
 	}
 
 	ws.Write([]byte(" world"))
-	if string(writerSeeker.buf) != "hello world" {
+	if string(ws.buf) != "hello world" {
 		t.Fail()
 	}
 
 	ws.Seek(-2, io.SeekEnd)
 	ws.Write([]byte("k!"))
-	if string(writerSeeker.buf) != "hello work!" {
+	if string(ws.buf) != "hello work!" {
 		t.Fail()
 	}
 
 	ws.Seek(6, io.SeekStart)
 	ws.Write([]byte("gopher"))
-	if string(writerSeeker.buf) != "hello gopher" {
+	if string(ws.buf) != "hello gopher" {
 		t.Fail()
 	}
 }

From 9ffc5367cb01297c8aa696e24e440977353595ff Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Tue, 22 Jan 2019 12:14:40 +1030
Subject: [PATCH 11/13] av/stream/flac: cleaned up testing file

---
 stream/flac/flac_test.go | 38 ++++++++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 12 deletions(-)

diff --git a/stream/flac/flac_test.go b/stream/flac/flac_test.go
index 79274819..0d8079f7 100644
--- a/stream/flac/flac_test.go
+++ b/stream/flac/flac_test.go
@@ -64,29 +64,43 @@ func TestWriteSeekerWrite(t *testing.T) {
 func TestWriteSeekerSeek(t *testing.T) {
 	ws := &writeSeeker{}
 
-	ws.Write([]byte("hello"))
-	if string(ws.buf) != "hello" {
-		t.Fail()
+	const tstStr1 = "hello"
+	want1 := tstStr1
+	ws.Write([]byte(tstStr1))
+	got := string(ws.buf)
+	if got != tstStr1 {
+		t.Errorf("Unexpected output, got: %v, want: %v", got, want1)
 	}
 
-	ws.Write([]byte(" world"))
-	if string(ws.buf) != "hello world" {
-		t.Fail()
+	const tstStr2 = " world"
+	const want2 = tstStr1 + tstStr2
+	ws.Write([]byte(tstStr2))
+	got = string(ws.buf)
+	if got != want2 {
+		t.Errorf("Unexpected output, got: %v, want: %v", got, want2)
 	}
 
+	const tstStr3 = "k!"
+	const want3 = "hello work!"
 	ws.Seek(-2, io.SeekEnd)
-	ws.Write([]byte("k!"))
-	if string(ws.buf) != "hello work!" {
-		t.Fail()
+	ws.Write([]byte(tstStr3))
+	got = string(ws.buf)
+	if got != want3 {
+		t.Errorf("Unexpected output, got: %v, want: %v", got, want3)
 	}
 
+	const tstStr4 = "gopher"
+	const want4 = "hello gopher"
 	ws.Seek(6, io.SeekStart)
-	ws.Write([]byte("gopher"))
-	if string(ws.buf) != "hello gopher" {
-		t.Fail()
+	ws.Write([]byte(tstStr4))
+	got = string(ws.buf)
+	if got != want4 {
+		t.Errorf("Unexpected output, got: %v, want: %v", got, want4)
 	}
 }
 
+// TestDecodeFlac checks that we can load a flac file and decode to wav, writing
+// to a wav file.
 func TestDecodeFlac(t *testing.T) {
 	b, err := ioutil.ReadFile(testFile)
 	if err != nil {

From 4602a555d5d098471ad9ee6885a44786f2e36619 Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Tue, 22 Jan 2019 12:27:52 +1030
Subject: [PATCH 12/13] av/stream/flac: updated test file directory

---
 stream/flac/flac_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stream/flac/flac_test.go b/stream/flac/flac_test.go
index 0d8079f7..1f8019e5 100644
--- a/stream/flac/flac_test.go
+++ b/stream/flac/flac_test.go
@@ -34,7 +34,7 @@ import (
 )
 
 const (
-	testFile = "/home/saxon/Desktop/robot.flac"
+	testFile = "../../../test/test-data/av/input/robot.flac"
 	outFile  = "testOut.wav"
 )
 

From 9ef5886d669c59b4a0dc69caa82a7867b6828af0 Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Thu, 7 Feb 2019 19:58:08 +1030
Subject: [PATCH 13/13] created experimentation dir under av, and moved flac
 package here.

created experimentation dir under av, and moved flac pkg here.

experimentation/flac: removed wav file
---
 {stream => experimentation}/flac/decode.go    | 0
 {stream => experimentation}/flac/flac_test.go | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename {stream => experimentation}/flac/decode.go (100%)
 rename {stream => experimentation}/flac/flac_test.go (100%)

diff --git a/stream/flac/decode.go b/experimentation/flac/decode.go
similarity index 100%
rename from stream/flac/decode.go
rename to experimentation/flac/decode.go
diff --git a/stream/flac/flac_test.go b/experimentation/flac/flac_test.go
similarity index 100%
rename from stream/flac/flac_test.go
rename to experimentation/flac/flac_test.go