/*
NAME
  pcm.go

DESCRIPTION
  pcm.go contains functions for processing pcm.

AUTHOR
  Trek Hopton <trek@ausocean.org>

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

// Package pcm provides functions for processing and converting pcm audio.
package pcm

import (
	"encoding/binary"
	"fmt"

	"github.com/yobert/alsa"
)

// Resample takes alsa.Buffer b and resamples the pcm audio data to 'rate' Hz and returns an alsa.Buffer with the resampled data.
// Notes:
// 	- Currently only downsampling is implemented and b's rate must be divisible by 'rate' or an error will occur.
// 	- If the number of bytes in b.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(b alsa.Buffer, rate int) (alsa.Buffer, error) {
	if b.Format.Rate == rate {
		return b, nil
	}
	if b.Format.Rate < 0 {
		return alsa.Buffer{}, fmt.Errorf("Unable to convert from: %v Hz", b.Format.Rate)
	}
	if rate < 0 {
		return alsa.Buffer{}, fmt.Errorf("Unable to convert to: %v Hz", rate)
	}

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

	// Calculate sample rate ratio ratioFrom:ratioTo.
	rateGcd := gcd(rate, b.Format.Rate)
	ratioFrom := b.Format.Rate / rateGcd
	ratioTo := rate / rateGcd

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

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

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

	// Return a new alsa.Buffer with resampled data.
	return alsa.Buffer{
		Format: alsa.BufferFormat{
			Channels:     b.Format.Channels,
			SampleFormat: b.Format.SampleFormat,
			Rate:         rate,
		},
		Data: resampled,
	}, nil
}

// StereoToMono returns raw mono audio data generated from only the left channel from
// the given stereo recording (ALSA buffer)
func StereoToMono(b alsa.Buffer) (alsa.Buffer, error) {
	if b.Format.Channels == 1 {
		return b, nil
	}
	if b.Format.Channels != 2 {
		return alsa.Buffer{}, fmt.Errorf("Audio is not stereo or mono, it has %v channels", b.Format.Channels)
	}

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

	recLength := len(b.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] = b.Data[i]
			inc++
		}
	}

	// Return a new alsa.Buffer with resampled data.
	return alsa.Buffer{
		Format: alsa.BufferFormat{
			Channels:     1,
			SampleFormat: b.Format.SampleFormat,
			Rate:         b.Format.Rate,
		},
		Data: 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 {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}