| 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.
|
|
This documents the `bear` call required to produce a proper
`compile_commands.json` here.
The JSON file is not committed since it contains absolute paths. It is
used for language servers like `clangd`.
|
|
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.
|
|
|
|
|
|
This keeps track of the changes to this repository.
|
|
|
|
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`.
|
|
This example is completely based on the StreamURLContext() function.
Thus it should go to the respective test file.
|
|
|
|
This should be the primary public API of the library to stream web radio
to soundbox devices.
|
|
This data structure only contained a net.HardwareAddr and did not
provide much more useful functionality. Thus the net.HardwareAddr type
should be used directly.
|
|
It is planned to provide a function for streaming. Thus the streaming
port is not required to be exposed. If there is a use case the streaming
port can be exposed again.
|
|
This is required as a temporary solution to guess the correct interface.
|
|
It is expected that further ports (maybe for information via HTTP) are
added in the future.
To keep the public API stable this should be taken into account before
the first release.
|
|
|
|
Since the module name is `soundbox` naming the primary type of the
module also `Soundbox` is redundant. Following similar code from the Go
standard library this struct is renamed to `Client`.
|
|
The file did not work properly if used via Git commit hook symlink.
|
|
This script should be usable as a Git pre-commit hook to make sure every
commit has a running test suite and is well formatted.
This commit starts with running the test suite for the module.
|
|
This gives a brief introduction how the library should be used.
Furthermore it has an output string comment making sure with the test
suite that it actually works.
|
|
This splits the soundbox.NewSoundbox() function into two smaller
functions.
|
|
Using testing.Errorf() does not stop the test. This was never wanted.
|
|
To communicate with soundbox devices it is required to convert the known
device MAC address (printed on the case) to an IPv6 link-local address.
|
|
|
|
This gives a better overview of the existing repositories.
|
|
Go modules should be named with a single word if possible (see the
[standard libraray][1] as a reference example). Furthermore the module
name will be present in the code very often and thus length is a
critical point.
The repository and project should still be named `soundbox-go` to
distinguish it from the device repository [soundbox][2] and the
application repository [soundbox-app][3].
[1]: https://pkg.go.dev/std
[2]: https://cgit.xengineering.eu/soundbox
[3]: https://cgit.xengineering.eu/soundbox-app
|
|
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 makes this repository a Go module.
|
|
This only adds the `Soundbox` struct type which has a `net.HardwareAddr`
to identify it together with a constructor and a unit test.
|
|
|
