When there are no nodes, we can't make links. This avoids getting into
an infinite loop when trying to find ports.

First collect all the graph objects and then parse them in the
right order. Otherwise, we might try to parse links before the nodes if
they are first in the JSON string.

Fixes #1950

Barnabás Pőcze authored May 07, 2022 and Wim Taymans committed May 07, 2022

When the client destroys the protocol-native module, the server
and the client are destroyed but the client is still reffed (not freed).
It will be unreffed after its messages are processed, after which point
it will be freed and removed from the server client_list that is already
destroyed.

Fix this by removing the client from the server list when it is
destroyed.

See #565

Guess the expected latency with the stream info we have and use that as
the node.latency. This way, the graph can attempt to start with some
sort of latency setting.

After we know the exact format, we can calculate the real latency and we
will update the node latency accordingly.

Support a global node.name and prefix it with input. and output.
if no per-stream node.name is given.
This might be less confusing.

Try 8 times to make progress, if nothing after that, xrun.

A stream that keeps sending 0 sized buffers would otherwise get into
an endless loop.

See #2359

Add a refcount to resource and client so that we can keep them alive
while the native protocol is using them.

One problem might be that the protocol destroys the client or resource
while handling it and that would cause errors.

Fixes #565

Listen for factory destroy and clean up the module.

See #565

Destroy the module when the factory is destroyed.

When the factory is destroyed, clean up and destroy the module as well.

When the global is destroyed, we remove our listeners and set the global
to NULL.  We then destroy the module but because the global is NULL, we
don't remove ourselves from the list of modules, causing a crash later.

Fix this by always adding ourself to the list of modules and always
removing ourselves on destroy.

See #565

Or else PIPEWIRE_PROPS will not have any effect.

Don't just always forward node results but use port_enum_param_sync.

Avoids duplicate param results in pw-dump for ports.

The file name "lc3.h" in the ETSI LC3plus package may conflict with the
actual LC3 codec, so try to find a file "lc3plus.h" instead.  Also try
to find a pkg-config dependency for it first (in which case use lc3.h,
assuming it's in different directory).  This can be fine tuned, if
something starts to package that library.

Use the new requested buffer field to only queue the amount of samples
required by the resampler for the current quantum. This avoid spikes
when the maxsize block of samples is processed.

Fixes #2353

The lc3plus codec isn't packaged, so don't try to check if it builds.

Implement codec plugin for the LC3plus codec, supporting the LC3plus
encoder/decoder from Fraunhofer.

From the specification
https://www.iis.fraunhofer.de/en/ff/amm/communication/lc3.html

LC3plus expands 509 bytes input -> 7680 bytes output, which is bigger
than current decode buffer.

Make the decode buffer bigger, and put it on heap, not stack.

A2DP source should continue trying to decode, even if garbled data is
received.

Codecs may need to fragment a single encoder frame across multiple
packets that are sent consecutively.

Allow codec->encode() to set need_flush=NEED_FLUSH_FRAGMENT, so that
sink should immediately call start_encode + encode with NULL input data,
to produce the next packet.

Previously, other return values than need_flush=1 were unused, so no
need to bump codec ABI for this.

Make the default allowed samplerates be 44.1KHz and 48KHz to see
what happens..

Make the alsa buffer a little larger when we scaled the samplerate,
like for DSD. This allows us to go all the way up to the quantum
limit.

Make the DSD buffers a little bigger because we scale down the rate.
Read an interleaved number of samples to fill one quantum.

Fixes #1159

Add some more context to the match rules and return how many properties
changed. If something changed, send all the properties as updates
instead of just the original changed ones.

Make sure we free the old pointer, clear it and set the array size to 0.
Use reallocarray where possible.