| array.h |
\defgroup pw_array Array
\brief An array object
The array is a dynamically resizable data structure that can
hold items of the same size.
|
5015 |
| buffers.h |
\defgroup pw_buffers Buffers
Buffer handling
|
2315 |
| client.h |
\defgroup pw_client Client
Client interface
|
5717 |
| conf.h |
\defgroup pw_conf Configuration
Loading/saving properties from/to configuration files.
|
1622 |
| context.h |
\defgroup pw_context Context
\brief The PipeWire context object manages all locally available
resources. It is used by both clients and servers.
The context is used to:
- Load modules and extend the functionality. This includes
extending the protocol with new object types or creating
any of the available objects.
- Create implementations of various objects like nodes,
devices, factories, modules, etc.. This will usually also
create pw_global objects that can then be shared with
clients.
- Connect to another PipeWire instance (the main daemon, for
example) and interact with it (See \ref page_core_api).
- Export a local implementation of an object to another
instance.
|
7324 |
| control.h |
\defgroup pw_control Control
\brief A control can be used to control a port property.
|
2357 |
| core.h |
\defgroup pw_core Core
\brief The core global object.
This is a special singleton object. It is used for internal PipeWire
protocol features. Connecting to a PipeWire instance returns one core
object, the caller should then register event listeners
using \ref pw_core_add_listener.
Updates to the core object are then provided through the \ref
pw_core_events interface. See \ref page_tutorial2 for an example.
|
19661 |
| data-loop.h |
\defgroup pw_data_loop Data Loop
\brief PipeWire rt-loop object
This loop starts a new real-time thread that
is designed to run the processing graph.
|
3611 |
| device.h |
\defgroup pw_device Device
Device interface
|
5501 |
| factory.h |
\defgroup pw_factory Factory
Factory interface
|
3521 |
| filter.h |
\defgroup pw_filter Filter
\brief PipeWire filter object class
The filter object provides a convenient way to implement
processing filters.
See also \ref api_pw_core
|
9467 |
| global.h |
\defgroup pw_global Global
\brief A global object visible to remote clients
A global object is visible to remote clients and represents a resource
that can be used or inspected.
Global objects represent resources that are available on the PipeWire
context and are accessible to remote clients.
Globals come and go when devices or other resources become available for
clients.
Remote clients receives a list of globals when it binds to the registry
object. See \ref pw_registry.
A client can bind to a global to send methods or receive events from
the global.
See \ref page_proxy
|
5667 |
| i18n.h |
\defgroup pw_gettext Internationalization
Gettext interface
|
1717 |
| impl-client.h |
\page page_client_impl Client Implementation
\section sec_page_client_impl_overview Overview
The \ref pw_impl_client object is created by a protocol implementation when
a new client connects.
The client is used to keep track of all resources belonging to one
connection with the PipeWire server.
\section sec_page_client_impl_credentials Credentials
The client object will have its credentials filled in by the protocol.
This information is used to check if a resource or action is available
for this client.
\section sec_page_client_impl_types Types
The client and server maintain a mapping between the client and server
types. All type ids that are in messages exchanged between the client
and server will automatically be remapped.
\section sec_page_client_impl_resources Resources
When a client binds to context global object, a resource is made for this
binding and a unique id is assigned to the resources. The client and
server will use this id as the destination when exchanging messages.
See also \ref pw_resource
|
6596 |
| impl-core.h |
\defgroup pw_impl_core Core Impl
\brief PipeWire core interface.
The core is used to make objects on demand.
|
3151 |
| impl-device.h |
\defgroup pw_impl_device Device Impl
The device is an object that manages nodes. It typically
corresponds to a physical hardware device but it does not
have to be.
The purpose of the device is to provide an interface to
dynamically create/remove/configure the nodes it manages.
|
3836 |
| impl-factory.h |
\defgroup pw_impl_factory Factory Impl
The factory is used to make objects on demand.
|
4158 |
| impl-link.h |
\defgroup pw_impl_link Link Impl
\brief PipeWire link object.
|
4049 |
| impl-metadata.h |
\defgroup pw_impl_metadata Metadata Impl
The metadata is used to store key/type/value pairs per object id.
|
3618 |
| impl-module.h |
\defgroup pw_impl_module Module Impl
A dynamically loadable module
|
3734 |
| impl-node.h |
\defgroup pw_impl_node Node Impl
The node object processes data. The node has a list of
input and output ports (\ref pw_impl_port) on which it
will receive and send out buffers respectively.
|
6812 |
| impl-port.h |
\defgroup pw_impl_port Port Impl
\brief A port can be used to link two nodes.
|
4492 |
| impl.h |
\addtogroup api_pw_impl
|
1924 |
| keys.h |
\defgroup pw_keys Key Names
A collection of keys that are used to add extra information on objects.
Keys that start with "pipewire." are in general set-once and then
read-only. They are usually used for security sensitive information that
needs to be fixed.
Properties from other objects can also appear. This usually suggests some
sort of parent/child or owner/owned relationship.
\addtogroup pw_keys
\{
|
18998 |
| link.h |
\defgroup pw_link Link
A link is the connection between 2 nodes (\ref pw_node). Nodes are
linked together on ports.
The link is responsible for negotiating the format and buffers for
the nodes.
|
4469 |
| log.h |
\defgroup pw_log Logging
\brief Logging functions of PipeWire
Logging is performed to stdout and stderr. Trace logging is performed
in a lockfree ringbuffer and written out from the main thread as to not
block the realtime threads.
|
5688 |
| loop.h |
\defgroup pw_loop Loop
PipeWire loop object provides an implementation of
the spa loop interfaces. It can be used to implement various
event loops.
|
3439 |
| main-loop.h |
\defgroup pw_main_loop Main Loop
A main loop object
|
2409 |
| map.h |
\defgroup pw_map Map
\brief A map that holds pointers to objects indexed by id
The map is a sparse version of the \ref pw_array "pw_array" that manages the
indices of elements for the caller. Adding items with
pw_map_insert_new() returns the assigned index for that item; if items
are removed the map re-uses indices to keep the array at the minimum
required size.
\code{.c}
struct pw_map map = PW_MAP_INIT(4);
idx1 = pw_map_insert_new(&map, ptr1);
idx2 = pw_map_insert_new(&map, ptr2);
// the map is now [ptr1, ptr2], size 2
pw_map_remove(&map, idx1);
// the map is now [<unused>, ptr2], size 2
pw_map_insert_new(&map, ptr3);
// the map is now [ptr3, ptr2], size 2
\endcode
|
8284 |
| mem.h |
\defgroup pw_memblock Memory Blocks
Memory allocation and pools.
|
6967 |
| module.h |
\defgroup pw_module Module
Module interface
|
3580 |
| node.h |
\defgroup pw_node Node
Node interface
|
6678 |
| permission.h |
\defgroup pw_permission Permission
Permissions are kept for a client and describe what the client is
allowed to do with an object.
See \ref page_core_api
|
2846 |
| pipewire.h |
\defgroup pw_pipewire Initialization
Initializing PipeWire and loading SPA modules.
|
3147 |
| port.h |
\defgroup pw_port Port
Port interface
|
5180 |
| private.h |
for pthread_t |
49677 |
| properties.h |
\defgroup pw_properties Properties
Properties are used to pass around arbitrary key/value pairs.
Both keys and values are strings which keeps things simple.
Encoding of arbitrary values should be done by using a string
serialization such as base64 for binary blobs.
|
5998 |
| protocol.h |
\defgroup pw_protocol Protocol
\brief Manages protocols and their implementation
|
5499 |
| proxy.h |
\page page_proxy Proxy
\section sec_page_proxy_overview Overview
The proxy object is a client side representation of a resource
that lives on a remote PipeWire instance.
It is used to communicate with the remote object.
\section sec_page_proxy_core Core proxy
A proxy for a remote core object can be obtained by making
a remote connection with \ref pw_context_connect.
See \ref pw_proxy
Some methods on proxy object allow creation of more proxy objects or
create a binding between a local proxy and global resource.
\section sec_page_proxy_create Create
A client first creates a new proxy object with pw_proxy_new(). A
type must be provided for this object.
The protocol of the context will usually install an interface to
translate method calls and events to the wire format.
The creator of the proxy will usually also install an event
implementation of the particular object type.
\section sec_page_proxy_bind Bind
To actually use the proxy object, one needs to create a server
side resource for it. This can be done by, for example, binding
to a global object or by calling a method that creates and binds
to a new remote object. In all cases, the local id is passed to
the server and is used to create a resource with the same id.
\section sec_page_proxy_methods Methods
To call a method on the proxy use the interface methods. Calling
any interface method will result in a request to the server to
perform the requested action on the corresponding resource.
\section sec_page_proxy_events Events
Events send from the server to the proxy will be demarshalled by
the protocol and will then result in a call to the installed
implementation of the proxy.
\section sec_page_proxy_destroy Destroy
Use pw_proxy_destroy() to destroy the client side object. This
is usually done automatically when the server removes the resource
associated to the proxy.
|
7553 |
| resource.h |
\defgroup pw_resource Resource
\brief Client owned objects
Resources represent objects owned by a \ref pw_impl_client. They are
the result of binding to a global resource or by calling API that
creates client owned objects.
The client usually has a proxy object associated with the resource
that it can use to communicate with the resource. See \ref page_proxy.
Resources are destroyed when the client or the bound object is
destroyed.
|
6071 |
| stream.h |
|
21303 |
| thread-loop.h |
\page page_thread_loop Thread Loop
\section sec_thread_loop_overview Overview
The threaded loop implementation is a special wrapper around the
regular \ref pw_loop implementation.
The added feature in the threaded loop is that it spawns a new thread
that runs the wrapped loop. This allows a synchronous application to use
the asynchronous API without risking to stall the PipeWire library.
\section sec_thread_loop_create Creation
A \ref pw_thread_loop object is created using pw_thread_loop_new().
The \ref pw_loop to wrap must be given as an argument along with the name
for the thread that will be spawned.
After allocating the object, the thread must be started with
pw_thread_loop_start()
\section sec_thread_loop_destruction Destruction
When the PipeWire connection has been terminated, the thread must be
stopped and the resources freed. Stopping the thread is done using
pw_thread_loop_stop(), which must be called without the lock (see
below) held. When that function returns, the thread is stopped and the
\ref pw_thread_loop object can be freed using pw_thread_loop_destroy().
\section sec_thread_loop_locking Locking
Since the PipeWire API doesn't allow concurrent accesses to objects,
a locking scheme must be used to guarantee safe usage. The threaded
loop API provides such a scheme through the functions
pw_thread_loop_lock() and pw_thread_loop_unlock().
The lock is recursive, so it's safe to use it multiple times from the same
thread. Just make sure you call pw_thread_loop_unlock() the same
number of times you called pw_thread_loop_lock().
The lock needs to be held whenever you call any PipeWire function that
uses an object associated with this loop. Make sure you do not hold
on to the lock more than necessary though, as the threaded loop stops
while the lock is held.
\section sec_thread_loop_events Events and Callbacks
All events and callbacks are called with the thread lock held.
|
6367 |
| thread.h |
\defgroup pw_thread Thread
\brief functions to manipulate threads
|
2181 |
| type.h |
\defgroup pw_type Type info
Type information
|
1833 |
| utils.h |
\defgroup pw_utils Utilities
Various utility functions
|
2745 |
| version.h |
WARNING: Make sure to edit the real source file version.h.in! |
2525 |
| work-queue.h |
\defgroup pw_work_queue Work Queue
Queued processing of work items.
|
2010 |