1 files changed, 31 insertions, 31 deletions

diff --git a/rhimport/wave_generator.go b/rhimport/wave_generator.go
index f4c3261..7816bc0 100644
--- a/rhimport/wave_generator.go
+++ b/rhimport/wave_generator.go
@@ -34,11 +34,11 @@ import (
 )
 
 const (
-	RIFF_TAG   = "RIFF"
-	WAVE_TAG   = "WAVE"
-	FMT_TAG    = "fmt "
-	FMT_ID_PCM = 0x0001
-	DATA_TAG   = "data"
+	_RIFF_TAG   = "RIFF"
+	_WAVE_TAG   = "WAVE"
+	_FMT_TAG    = "fmt "
+	_FMT_ID_PCM = 0x0001
+	_DATA_TAG   = "data"
 )
 
 type wavHeader struct {
@@ -60,31 +60,31 @@ type wavHeader struct {
 }
 
 func (h *wavHeader) Bytes() []byte {
-	buf := new(bytes.Buffer)
+	buf := &bytes.Buffer{}
 	binary.Write(buf, binary.LittleEndian, h)
 	return buf.Bytes()
 }
 
-type SampleGenerator interface {
+type sampleGenerator interface {
 	Reset(samplePeriod float64)
 	GetSamples(nSamples uint32, channels uint16) []float64 // this needs to be normalized, aka -1 <= value <= 1
 }
 
-type WavFile struct {
+type wavFile struct {
 	header         wavHeader
 	headerSize     uint32
 	pcmSampleMax   float64
 	pcmSampleBytes uint32
 	samplePeriod   float64
-	Generator      SampleGenerator
+	generator      sampleGenerator
 	readOffset     uint32
 }
 
-func (wav *WavFile) GetFileSize() (size uint32) {
+func (wav *wavFile) GetFileSize() (size uint32) {
 	return wav.headerSize + wav.header.dataLength
 }
 
-func (wav *WavFile) Read(p []byte) (n int, err error) {
+func (wav *wavFile) Read(p []byte) (n int, err error) {
 	n = 0
 	if wav.readOffset >= (wav.header.riffLength + 8) {
 		return n, io.EOF
@@ -93,16 +93,16 @@ func (wav *WavFile) Read(p []byte) (n int, err error) {
 	if wav.readOffset < wav.headerSize {
 		n = copy(p, wav.header.Bytes()[wav.readOffset:])
 		wav.readOffset += uint32(n)
-		wav.Generator.Reset(wav.samplePeriod)
+		wav.generator.Reset(wav.samplePeriod)
 	}
 	if n >= len(p) {
 		return
 	}
 	nsamples := uint32(len(p)-n) / uint32(wav.header.blockAlign)
-	data := wav.Generator.GetSamples(nsamples, wav.header.nChannels)
+	data := wav.generator.GetSamples(nsamples, wav.header.nChannels)
 
 	switch wav.header.fmtID {
-	case FMT_ID_PCM:
+	case _FMT_ID_PCM:
 		idx := 0
 		for _, normalized := range data {
 			scaled := wav.pcmSampleMax * normalized
@@ -123,8 +123,8 @@ func (wav *WavFile) Read(p []byte) (n int, err error) {
 	return
 }
 
-func NewPCMWavFile(sampleRate uint32, sampleDepth uint16, channels uint16, length time.Duration) (wav *WavFile, err error) {
-	wav = &WavFile{}
+func newPCMWavFile(sampleRate uint32, sampleDepth uint16, channels uint16, length time.Duration) (wav *wavFile, err error) {
+	wav = &wavFile{}
 	wav.headerSize = 8 + 4 + 8 + 16 + 8
 	if length <= 0 {
 		return nil, errors.New("invalid length: must be > 0")
@@ -154,61 +154,61 @@ func NewPCMWavFile(sampleRate uint32, sampleDepth uint16, channels uint16, lengt
 	}
 	dataLen := nFrames * uint32(frameSize)
 
-	copy(wav.header.riffTag[:], RIFF_TAG)
+	copy(wav.header.riffTag[:], _RIFF_TAG)
 	wav.header.riffLength = wav.headerSize - 8 + dataLen
-	copy(wav.header.waveTag[:], WAVE_TAG)
+	copy(wav.header.waveTag[:], _WAVE_TAG)
 
-	copy(wav.header.fmtTag[:], FMT_TAG)
+	copy(wav.header.fmtTag[:], _FMT_TAG)
 	wav.header.fmtLength = 16
-	wav.header.fmtID = FMT_ID_PCM
+	wav.header.fmtID = _FMT_ID_PCM
 	wav.header.nChannels = channels
 	wav.header.sampleRate = sampleRate
 	wav.header.byteRate = sampleRate * uint32(frameSize)
 	wav.header.blockAlign = frameSize
 	wav.header.sampleDepth = sampleDepth
 
-	copy(wav.header.dataTag[:], DATA_TAG)
+	copy(wav.header.dataTag[:], _DATA_TAG)
 	wav.header.dataLength = dataLen
 
 	return
 }
 
-type SilenceGenerator struct {
+type silenceGenerator struct {
 }
 
-func NewSilenceGenerator() *SilenceGenerator {
-	return &SilenceGenerator{}
+func NewSilenceGenerator() *silenceGenerator {
+	return &silenceGenerator{}
 }
 
-func (s *SilenceGenerator) Reset(samplePeriod float64) {
+func (s *silenceGenerator) Reset(samplePeriod float64) {
 	// nothing here
 }
 
-func (s *SilenceGenerator) GetSamples(nSamples uint32, nChannels uint16) (data []float64) {
+func (s *silenceGenerator) GetSamples(nSamples uint32, nChannels uint16) (data []float64) {
 	data = make([]float64, int(nSamples)*int(nChannels))
 	return
 }
 
-type SinusGenerator struct {
+type sinusGenerator struct {
 	amp  float64
 	freq float64
 	sp   float64
 	t    float64
 }
 
-func NewSinusGenerator(ampDB, freq float64) (sin *SinusGenerator) {
-	sin = &SinusGenerator{}
+func newSinusGenerator(ampDB, freq float64) (sin *sinusGenerator) {
+	sin = &sinusGenerator{}
 	sin.amp = math.Pow(10.0, (ampDB / 20.0))
 	sin.freq = freq
 	return
 }
 
-func (sin *SinusGenerator) Reset(samplePeriod float64) {
+func (sin *sinusGenerator) Reset(samplePeriod float64) {
 	sin.sp = samplePeriod
 	sin.t = 0
 }
 
-func (sin *SinusGenerator) GetSamples(nSamples uint32, nChannels uint16) (data []float64) {
+func (sin *sinusGenerator) GetSamples(nSamples uint32, nChannels uint16) (data []float64) {
 	data = make([]float64, int(nSamples)*int(nChannels))
 	for i := 0; i < int(nSamples); i++ {
 		val := sin.amp * math.Sin(2*math.Pi*sin.freq*sin.t)