Merge branch 'devgianlu:master' into metadata-pipe

Author: iVolt1

README.md

@@ -26,6 +26,15 @@ on the [GitHub Container Registry](https://github.com/devgianlu/go-librespot/pkg
 
 An example Docker Compose configuration for PulseAudio is available [here](/docker-compose.pulse.yml).
 
+### Using Brew
+
+You can also install go-librespot [using Brew](https://formulae.brew.sh/formula/go-librespot) 
+on macOS and Linux (thanks @kriive):
+
+```shell
+brew install go-librespot
+```
+
 ### Building from source
 
 To build from source the following prerequisites are necessary:
@@ -51,7 +60,8 @@ Details about cross-compiling go-librespot are described [here](/CROSS_COMPILE.m
 
 ## Configuration
 
-The default directory for configuration files is `~/.config/go-librespot`. On macOS devices, this is `~/Library/Application Support/go-librespot`. You can change this directory with the
+The default directory for configuration files is `~/.config/go-librespot`. On macOS devices, this is
+`~/Library/Application Support/go-librespot`. You can change this directory with the
 `-config_dir` flag. The configuration directory contains:
 
 - `config.yml`: The main configuration (does not exist by default)
@@ -79,7 +89,9 @@ credentials:
 If `persist_credentials` is `true`, after connecting to the device for the first time credentials will be stored locally
 and you can switch to interactive mode without having to authenticate manually.
 
-If `zeroconf_interfaces_to_advertise` is provided, you can limit interfaces that will be advertised. For example, if you have Docker installed on your host, you may want to disable advertising to its bridge interface, or you may want to disable interfaces that will not be reachable.
+If `zeroconf_interfaces_to_advertise` is provided, you can limit interfaces that will be advertised. For example, if you
+have Docker installed on your host, you may want to disable advertising to its bridge interface, or you may want to
+disable interfaces that will not be reachable.
 
 ### Interactive mode
 
@@ -155,6 +167,7 @@ audio_output_pipe_format: s16le # Audio output pipe format (s16le, s32le, f32le)
 bitrate: 160 # Playback bitrate (96, 160, 320)
 volume_steps: 100 # Volume steps count
 initial_volume: 100 # Initial volume in steps (not applied to the mixer device)
+ignore_last_volume: false # Whether to ignore the last saved volume and always use initial_volume
 external_volume: false # Whether volume is controlled externally 
 disable_autoplay: false # Whether autoplay of more songs should be disabled
 ```

cmd/daemon/controls.go

@@ -769,6 +769,12 @@ func (p *AppPlayer) updateVolume(newVal uint32) {
 	p.app.log.Debugf("update volume requested to %d/%d", newVal, player.MaxStateVolume)
 	p.player.SetVolume(newVal)
 
+	// Save the volume to the state
+	p.app.state.LastVolume = &newVal
+	if err := p.app.state.Write(); err != nil {
+		p.app.log.WithError(err).Error("failed writing state after volume change")
+	}
+
 	// If there is a value in the channel buffer, remove it.
 	select {
 	case <-p.volumeUpdate:

cmd/daemon/main.go

@@ -396,6 +396,7 @@ type Config struct {
 	Bitrate                       int       `koanf:"bitrate"`
 	VolumeSteps                   uint32    `koanf:"volume_steps"`
 	InitialVolume                 uint32    `koanf:"initial_volume"`
+	IgnoreLastVolume              bool      `koanf:"ignore_last_volume"`
 	NormalisationDisabled         bool      `koanf:"normalisation_disabled"`
 	NormalisationUseAlbumGain     bool      `koanf:"normalisation_use_album_gain"`
 	NormalisationPregain          float32   `koanf:"normalisation_pregain"`

cmd/daemon/player.go

@@ -86,7 +86,11 @@ func (p *AppPlayer) handleDealerMessage(ctx context.Context, msg dealer.Message)
 		if !p.app.cfg.ExternalVolume && len(p.app.cfg.MixerDevice) == 0 {
 			// update initial volume
 			p.initialVolumeOnce.Do(func() {
-				p.updateVolume(p.app.cfg.InitialVolume * player.MaxStateVolume / p.app.cfg.VolumeSteps)
+				if lastVolume := p.app.state.LastVolume; !p.app.cfg.IgnoreLastVolume && lastVolume != nil {
+					p.updateVolume(*lastVolume)
+				} else {
+					p.updateVolume(p.app.cfg.InitialVolume * player.MaxStateVolume / p.app.cfg.VolumeSteps)
+				}
 			})
 		}
 	} else if strings.HasPrefix(msg.Uri, "hm://connect-state/v1/connect/volume") {

config_schema.json

@@ -232,6 +232,11 @@
           "min": 0,
           "default": 100
         },
+        "ignore_last_volume": {
+          "type": "boolean",
+          "description": "Whether the last saved volume should be ignored",
+          "default": false
+        },
         "normalisation_disabled": {
           "type": "boolean",
           "description": "Whether track/album normalisation should be disabled",

output/driver-alsa.go

@@ -38,6 +38,7 @@ type alsaOutput struct {
 	periodCount int
 	periodSize  int
 	bufferSize  int
+	pcmFormat   C.snd_pcm_format_t
 
 	externalVolume bool
 
@@ -100,6 +101,15 @@ func (out *alsaOutput) alsaError(name string, err C.int) error {
 	return fmt.Errorf("ALSA error at %s: %s", name, C.GoString(C.snd_strerror(err)))
 }
 
+func (out *alsaOutput) isFormatSupported(hwparams *C.snd_pcm_hw_params_t, format C.snd_pcm_format_t) bool {
+	errCode := C.snd_pcm_hw_params_test_format(out.pcmHandle, hwparams, format)
+	if errCode < 0 {
+		return false
+	}
+
+	return true
+}
+
 func (out *alsaOutput) setupPcm() error {
 	cdevice := C.CString(out.device)
 	defer C.free(unsafe.Pointer(cdevice))
@@ -119,8 +129,24 @@ func (out *alsaOutput) setupPcm() error {
 		return out.alsaError("snd_pcm_hw_params_set_access", err)
 	}
 
-	if err := C.snd_pcm_hw_params_set_format(out.pcmHandle, hwparams, C.SND_PCM_FORMAT_FLOAT_LE); err < 0 {
-		return out.alsaError("snd_pcm_hw_params_set_format", err)
+	var formatFound bool
+	for _, format := range []C.snd_pcm_format_t{
+		C.SND_PCM_FORMAT_FLOAT_LE, // 32-bit floating point, little-endian
+		C.SND_PCM_FORMAT_S32_LE,   // 32-bit signed integer, little-endian
+		C.SND_PCM_FORMAT_S16_LE,   // 16-bit signed integer, little-endian
+	} {
+		if !out.isFormatSupported(hwparams, format) {
+			continue
+		}
+
+		if err := C.snd_pcm_hw_params_set_format(out.pcmHandle, hwparams, format); err < 0 {
+			return out.alsaError("snd_pcm_hw_params_set_format", err)
+		}
+		formatFound = true
+	}
+
+	if !formatFound {
+		return fmt.Errorf("could not find a supported PCM format")
 	}
 
 	if err := C.snd_pcm_hw_params_set_channels(out.pcmHandle, hwparams, C.unsigned(out.channels)); err < 0 {
@@ -173,6 +199,13 @@ func (out *alsaOutput) setupPcm() error {
 		out.bufferSize = int(frames)
 	}
 
+	var pcmFormat C.snd_pcm_format_t
+	if err := C.snd_pcm_hw_params_get_format(hwparams, &pcmFormat); err < 0 {
+		return out.alsaError("snd_pcm_hw_params_get_format", err)
+	} else {
+		out.pcmFormat = pcmFormat
+	}
+
 	var swparams *C.snd_pcm_sw_params_t
 	C.snd_pcm_sw_params_malloc(&swparams)
 	defer C.free(unsafe.Pointer(swparams))
@@ -202,6 +235,45 @@ func (out *alsaOutput) setupPcm() error {
 	return nil
 }
 
+func pcmFormatName(format C.snd_pcm_format_t) string {
+	switch format {
+	case C.SND_PCM_FORMAT_S8:
+		return "S8"
+	case C.SND_PCM_FORMAT_U8:
+		return "U8"
+	case C.SND_PCM_FORMAT_S16_LE:
+		return "S16_LE"
+	case C.SND_PCM_FORMAT_S16_BE:
+		return "S16_BE"
+	case C.SND_PCM_FORMAT_U16_LE:
+		return "U16_LE"
+	case C.SND_PCM_FORMAT_U16_BE:
+		return "U16_BE"
+	case C.SND_PCM_FORMAT_S24_LE:
+		return "S24_LE"
+	case C.SND_PCM_FORMAT_S24_BE:
+		return "S24_BE"
+	case C.SND_PCM_FORMAT_U24_LE:
+		return "U24_LE"
+	case C.SND_PCM_FORMAT_U24_BE:
+		return "U24_BE"
+	case C.SND_PCM_FORMAT_S32_LE:
+		return "S32_LE"
+	case C.SND_PCM_FORMAT_S32_BE:
+		return "S32_BE"
+	case C.SND_PCM_FORMAT_U32_LE:
+		return "U32_LE"
+	case C.SND_PCM_FORMAT_U32_BE:
+		return "U32_BE"
+	case C.SND_PCM_FORMAT_FLOAT_LE:
+		return "FLOAT_LE"
+	case C.SND_PCM_FORMAT_FLOAT_BE:
+		return "FLOAT_BE"
+	default:
+		return "unknown"
+	}
+}
+
 func (out *alsaOutput) logParams(params *C.snd_pcm_hw_params_t) error {
 	var dir C.int
 
@@ -235,12 +307,51 @@ func (out *alsaOutput) logParams(params *C.snd_pcm_hw_params_t) error {
 		return out.alsaError("snd_pcm_hw_params_get_periods", err)
 	}
 
-	out.log.Debugf("alsa driver configured, rate = %d bps, period time = %d us, period size = %d frames, buffer time = %d us, buffer size = %d frames, periods per buffer = %d frames",
-		rate, periodTime, frames, bufferTime, bufferSize, periods)
+	var format C.snd_pcm_format_t
+	if err := C.snd_pcm_hw_params_get_format(params, &format); err < 0 {
+		return out.alsaError("snd_pcm_hw_params_get_format", err)
+	}
+
+	out.log.Debugf("alsa driver configured, rate = %d bps, period time = %d us, period size = %d frames, buffer time = %d us, buffer size = %d frames, periods per buffer = %d frames, PCM format = %s",
+		rate, periodTime, frames, bufferTime, bufferSize, periods, pcmFormatName(format))
 
 	return nil
 }
 
+func floatLeToS16Le(floats []float32) []C.int16_t {
+	shorts := make([]C.int16_t, len(floats))
+	for i, f := range floats {
+		// Clip the float to the range [-1.0, 1.0]
+		if f < -1.0 {
+			f = -1.0
+		}
+		if f > 1.0 {
+			f = 1.0
+		}
+
+		// Convert to int16 (short) in the range [-32768, 32767]
+		shorts[i] = C.int16_t(f * 32767)
+	}
+	return shorts
+}
+
+func floatLeToS32Le(floats []float32) []C.int32_t {
+	ints := make([]C.int32_t, len(floats))
+	for i, f := range floats {
+		// Clip the float to the range [-1.0, 1.0]
+		if f < -1.0 {
+			f = -1.0
+		}
+		if f > 1.0 {
+			f = 1.0
+		}
+
+		// Convert to int32 in the range [-2147483648, 2147483647]
+		ints[i] = C.int32_t(f * 2147483647)
+	}
+	return ints
+}
+
 func (out *alsaOutput) outputLoop(pcmHandle *C.snd_pcm_t) {
 	floats := make([]float32, out.channels*out.periodSize)
 
@@ -296,7 +407,24 @@ func (out *alsaOutput) outputLoop(pcmHandle *C.snd_pcm_t) {
 		// be very fast. It might be delayed a bit however if the sleep above
 		// didn't sleep long enough to wait for room in the buffer.
 		if n > 0 {
-			if nn := C.snd_pcm_writei(pcmHandle, unsafe.Pointer(&floats[0]), C.snd_pcm_uframes_t(n/out.channels)); nn < 0 {
+			var data unsafe.Pointer
+			switch out.pcmFormat {
+			case C.SND_PCM_FORMAT_FLOAT_LE:
+				data = unsafe.Pointer(&floats[0])
+			case C.SND_PCM_FORMAT_S32_LE:
+				ints := floatLeToS32Le(floats)
+				data = unsafe.Pointer(&ints[0])
+			case C.SND_PCM_FORMAT_S16_LE:
+				shorts := floatLeToS16Le(floats)
+				data = unsafe.Pointer(&shorts[0])
+			default:
+				out.err <- fmt.Errorf("unsupported PCM format: %s", pcmFormatName(out.pcmFormat))
+				out.closed = true
+				out.lock.Unlock()
+				return
+			}
+
+			if nn := C.snd_pcm_writei(pcmHandle, data, C.snd_pcm_uframes_t(n/out.channels)); nn < 0 {
 				// Got an error, so must recover (even for an underrun).
 				errCode := C.snd_pcm_recover(pcmHandle, C.int(nn), 1)
 				if errCode < 0 {

state.go

@@ -20,6 +20,7 @@ type AppState struct {
 		Username string `json:"username"`
 		Data     []byte `json:"data"`
 	} `json:"credentials"`
+	LastVolume *uint32 `json:"last_volume"`
 }
 
 func (s *AppState) SetLogger(log Logger) {