av/audio/pcm/pcm.go

/*
NAME
  pcm.go

DESCRIPTION
  pcm.go contains functions for processing pcm.

AUTHOR
  Trek Hopton <trek@ausocean.org>

LICENSE
  pcm.go is Copyright (C) 2018 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 in gpl.txt.
  If not, see [GNU licenses](http://www.gnu.org/licenses).
*/
package pcm

import (
	"encoding/binary"
	"fmt"

	"github.com/yobert/alsa"
)

// Resample takes an alsa.Buffer (fromBuf) and resamples the pcm audio data to 'toRate' Hz and returns the resulting pcm.
// If an error occurs, an error will be returned along with the original fromBuf's data.
// Notes:
// 	- Currently only downsampling is implemented and fromBuf's rate must be divisible by toRate or an error will occur.
// 	- If the number of bytes in fromBuf.Data is not divisible by the decimation factor (ratioFrom), the remaining bytes will
// 	  not be included in the result. Eg. input of length 480002 downsampling 6:1 will result in output length 80000.
func Resample(fromBuf alsa.Buffer, toRate int) ([]byte, error) {
	fromRate := fromBuf.Format.Rate
	if fromRate == toRate {
		return fromBuf.Data, nil
	} else if fromRate < 0 {
		return fromBuf.Data, fmt.Errorf("Unable to convert from: %v Hz", fromRate)
	} else if toRate < 0 {
		return fromBuf.Data, fmt.Errorf("Unable to convert to: %v Hz", toRate)
	}

	// The number of bytes in a sample.
	var sampleLen int
	switch fromBuf.Format.SampleFormat {
	case alsa.S32_LE:
		sampleLen = 4 * fromBuf.Format.Channels
	case alsa.S16_LE:
		sampleLen = 2 * fromBuf.Format.Channels
	default:
		return fromBuf.Data, fmt.Errorf("Unhandled ALSA format: %v", fromBuf.Format.SampleFormat)
	}
	inPcmLen := len(fromBuf.Data)

	// Calculate sample rate ratio ratioFrom:ratioTo.
	rateGcd := gcd(toRate, fromRate)
	ratioFrom := fromRate / rateGcd
	ratioTo := toRate / rateGcd

	// ratioTo = 1 is the only number that will result in an even sampling.
	if ratioTo != 1 {
		return fromBuf.Data, fmt.Errorf("%v:%v is an unhandled from:to rate ratio. must be n:1 for some rate n", ratioFrom, ratioTo)
	}

	newLen := inPcmLen / ratioFrom
	result := make([]byte, 0, newLen)

	// For each new sample to be generated, loop through the respective 'ratioFrom' samples in 'fromBuf.Data' to add them
	// up and average them. The result is the new sample.
	for i := 0; i < newLen/sampleLen; i++ {
		var sum int
		for j := 0; j < ratioFrom; j++ {
			switch fromBuf.Format.SampleFormat {
			case alsa.S32_LE:
				sum += int(int32(binary.LittleEndian.Uint32(fromBuf.Data[(i*ratioFrom*sampleLen)+(j*sampleLen) : (i*ratioFrom*sampleLen)+((j+1)*sampleLen)])))
			case alsa.S16_LE:
				sum += int(int16(binary.LittleEndian.Uint16(fromBuf.Data[(i*ratioFrom*sampleLen)+(j*sampleLen) : (i*ratioFrom*sampleLen)+((j+1)*sampleLen)])))
			}
		}
		avg := sum / ratioFrom
		bAvg := make([]byte, sampleLen)
		switch fromBuf.Format.SampleFormat {
		case alsa.S32_LE:
			binary.LittleEndian.PutUint32(bAvg, uint32(avg))
		case alsa.S16_LE:
			binary.LittleEndian.PutUint16(bAvg, uint16(avg))
		}
		result = append(result, bAvg...)
	}
	return result, nil
}

// StereoToMono returns raw mono audio data generated from only the left channel from
// the given stereo recording (ALSA buffer)
// if an error occurs, an error will be returned along with the original stereo data.
func StereoToMono(stereoBuf alsa.Buffer) ([]byte, error) {
	if stereoBuf.Format.Channels == 1 {
		return stereoBuf.Data, nil
	} else if stereoBuf.Format.Channels != 2 {
		return stereoBuf.Data, fmt.Errorf("Audio is not stereo or mono, it has %v channels", stereoBuf.Format.Channels)
	}

	var stereoSampleBytes int
	switch stereoBuf.Format.SampleFormat {
	case alsa.S32_LE:
		stereoSampleBytes = 8
	case alsa.S16_LE:
		stereoSampleBytes = 4
	default:
		return stereoBuf.Data, fmt.Errorf("Unhandled ALSA format %v", stereoBuf.Format.SampleFormat)
	}

	recLength := len(stereoBuf.Data)
	mono := make([]byte, recLength/2)

	// Convert to mono: for each byte in the stereo recording, if it's in the first half of a stereo sample
	// (left channel), add it to the new mono audio data.
	var inc int
	for i := 0; i < recLength; i++ {
		if i%stereoSampleBytes < stereoSampleBytes/2 {
			mono[inc] = stereoBuf.Data[i]
			inc++
		}
	}

	return mono, nil
}

// gcd is used for calculating the greatest common divisor of two positive integers, a and b.
// assumes given a and b are positive.
func gcd(a, b int) int {
	if b != 0 {
		return gcd(b, a%b)
	}
	return a
}