av/stream/flac/decode.go

/*
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 (
	"bytes"
	"errors"
	"io"

	"github.com/go-audio/audio"
	"github.com/go-audio/wav"
	"github.com/mewkiz/flac"
)

const wavFormat = 1

// writeSeeker implements a memory based io.WriteSeeker.
type writeSeeker struct {
	buf []byte
	pos int
}

// Bytes returns the bytes contained in the writeSeekers buffer.
func (ws *writeSeeker) Bytes() []byte {
	return ws.buf
}

// 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(ws.buf) {
		ws.buf = ws.buf[:minCap]
	}
	copy(ws.buf[ws.pos:], p)
	ws.pos += len(p)
	return len(p), nil
}

// 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 = ws.pos + offs
	case io.SeekEnd:
		newPos = len(ws.buf) + offs
	}
	if newPos < 0 {
		return 0, errors.New("negative result pos")
	}
	ws.pos = newPos
	return int64(newPos), nil
}

// 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 the FLAC into a stream to hold audio and it's properties.
	r := bytes.NewReader(buf)
	stream, err := flac.Parse(r)
	if err != nil {
		return nil, errors.New("Could not parse FLAC")
	}

	// Create WAV encoder and pass writeSeeker that will store output WAV.
	ws := &writeSeeker{}
	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 {
		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
		}

		// 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]))
			}
		}
		intBuf.Data = data
		if err := e.Write(intBuf); err != nil {
			return nil, err
		}
	}
}