| Age | Commit message (Collapse) | Author |
|---|
|
PipeWire is a Linux-specific sound system. This commit adds a proper
error if the operating is not matching.
|
|
The init / deinit of the PipeWire C library is not well handled for
multiple instances. Furthermore the PipeWire audio streaming relies on a
channel which is a global variable.
Both issues have to be fixed before multiple PipeWire capture instances
are allowed.
|
|
It used to drop silence per channel, not silence per sample. In the
unlikely case of perfect silence on one channel and sound on the other
this would switch effectively the channels.
|
|
This closes the PipeWire process properly to not leak memory and remove
the PipeWire capture node of soundbox as soon as the context passed to
StreamPipewireContext() is closed.
|
|
This used to connect the soundbox capture device directly to the default
input (usually system microphone). This is not wanted since the main
purpose of soundbox is not streaming the microphone but output of media
players.
Furthermore depending on the sound setup it could lead to a feedback
loop with a very loud noise.
|
|
This makes the code less readable.
|
|
|
|
This makes it easier for readers to find them.
|
|
The current architecture uses the following processing:
- capture raw audio from PipeWire as unsigned 16 bit integers
- convert with a `ffmpeg` process to OGG / FLAC
- stream the `ffmpeg` output to multiple soundboxes via TCP
Only the first part is different for URL sources. Since using PipeWire
significant latency (up to 15 seconds) were measured.
It turned out that this happens exactly when zero bytes (silence) are
fed into the `ffmpeg` process. This commit avoids this by dropping those
empty samples.
It has to be made sure that only samples are dropped where both channels
are zero. Otherwise audible noise is the result.
|
|
This implements a PipeWire capture device which can be used as an input
source instead of the already available URL input.
Known issues with the current PipeWire support are:
- user has to connect the monitor of the default audio sink to the
capture device manually
- correct shutdown has to be tested
- multiple instances do not work
- medium code quality requires refactoring
Since this is nevertheless usable and possible unknown bugs should be
figured out in practise soon this implementation is already added.
Bugfixes and refactoring might follow.
|
|
This avoids an unnecessary additional for loop.
|
|
|
|
The switch to `io.Copy()` to pump the data to the soundbox devices
removed the control over the buffer size of this copy action.
While for generic copy actions it is even an advantage when a big buffer
is used this is a problem for the soundbox use case. A big buffer used
during copy means that the first soundbox device gets audio data
significantly earlier than the later ones since `io.MultiWriter()` works
sequentially.
Thus this commit switches to `io.CopyBuffer()` where a buffer has to
provided. For that purpose the same buffer size is used as before the
refactoring to use `io.Copy()`.
|
|
This makes use of two functions from this package:
- io.Copy()
- io.MultiWriter()
`io.Copy()` is used to move the data from whatever reader is provided.
`io.Multiwriter()` solves the issue that we need to stream to multiple
network connections at the same time (one for each soundbox).
|
|
This is recommended by the Go standard library. One reason is that a
Reader might deliver the last couple of bytes together with the EOF
error. This is only handled correctly if the returned bytes are
processed first and the error is handled later.
[1]: https://pkg.go.dev/io#Reader
|
|
This prepares the switch to adding more sources than web URLs.
Everything providing an io.Reader can then simply use this internal
function in the background to avoid code duplication.
|
|
|
|
|
|
Calling the external program `ffmpeg` should be avoided completely in
the future to make soundbox-go a pure Go code base. `ffmpeg` provides
the following functionality to soundbox-go:
- web radio input stream transport
- re-encoding of the audio stream
- output stream transport to soundbox devices
The last part should be replaced with this commit as a first step.
|
|
This variable only contains the arguments for the called program. Thus
it should be named like this.
|
|
The repository names for soundbox are named as below:
- app: soundbox-app
- Go library module: soundbox-go
- Device: soundbox
The Go module names were:
- app: xengineering.eu/soundbox/app
- Go library module: xengineering.eu/soundbox
This does not make clear which module is related to which repository
since the names are different. Thus it should be changed to:
- app: xengineering.eu/soundbox-app
- Go library module: xengineering.eu/soundbox-go
The import statement for the library is then:
import "xengineering.eu/soundbox-go/soundbox"
This is a bit longer but it keeps the property that the library is
referenced inside the code by the simple name `soundbox`.
|
|
It is not expected that this library will be so big that multiple
packages make sense. Thus it should start only with the main package.
|
|
This only adds the `Soundbox` struct type which has a `net.HardwareAddr`
to identify it together with a constructor and a unit test.
|
