PipeWire 1.0.0

Loading...
Searching...
No Matches
Tutorial - Part 6: Binding Objects

Tutorial - Part 5: Capturing Video Frames | Index

In this tutorial we show how to bind to an object so that we can receive events and call methods on the object.

Let take a look at the following application to start.

#include <pipewire/pipewire.h>
struct data {
struct pw_main_loop *loop;
struct pw_context *context;
struct pw_core *core;
struct pw_registry *registry;
struct spa_hook registry_listener;
struct pw_client *client;
struct spa_hook client_listener;
};
/* [client_info] */
static void client_info(void *object, const struct pw_client_info *info)
{
struct data *data = object;
const struct spa_dict_item *item;
printf("client: id:%u\n", info->id);
printf("\tprops:\n");
spa_dict_for_each(item, info->props)
printf("\t\t%s: \"%s\"\n", item->key, item->value);
pw_main_loop_quit(data->loop);
}
static const struct pw_client_events client_events = {
PW_VERSION_CLIENT_EVENTS,
.info = client_info,
};
/* [client_info] */
/* [registry_event_global] */
static void registry_event_global(void *_data, uint32_t id,
uint32_t permissions, const char *type,
uint32_t version, const struct spa_dict *props)
{
struct data *data = _data;
if (data->client != NULL)
return;
if (strcmp(type, PW_TYPE_INTERFACE_Client) == 0) {
data->client = pw_registry_bind(data->registry,
id, type, PW_VERSION_CLIENT, 0);
pw_client_add_listener(data->client,
&data->client_listener,
&client_events, data);
}
}
/* [registry_event_global] */
static const struct pw_registry_events registry_events = {
PW_VERSION_REGISTRY_EVENTS,
.global = registry_event_global,
};
int main(int argc, char *argv[])
{
struct data data;
spa_zero(data);
pw_init(&argc, &argv);
data.loop = pw_main_loop_new(NULL /* properties */ );
data.context = pw_context_new(pw_main_loop_get_loop(data.loop),
NULL /* properties */ ,
0 /* user_data size */ );
data.core = pw_context_connect(data.context, NULL /* properties */ ,
0 /* user_data size */ );
data.registry = pw_core_get_registry(data.core, PW_VERSION_REGISTRY,
0 /* user_data size */ );
pw_registry_add_listener(data.registry, &data.registry_listener,
&registry_events, &data);
pw_main_loop_run(data.loop);
pw_proxy_destroy((struct pw_proxy *)data.client);
pw_proxy_destroy((struct pw_proxy *)data.registry);
pw_core_disconnect(data.core);
pw_context_destroy(data.context);
pw_main_loop_destroy(data.loop);
return 0;
}
PW_TYPE_INTERFACE_Client
#define PW_TYPE_INTERFACE_Client
Definition client.h:31
PW_VERSION_CLIENT_EVENTS
#define PW_VERSION_CLIENT_EVENTS
Definition client.h:78
PW_VERSION_CLIENT
#define PW_VERSION_CLIENT
Definition client.h:37
pw_client_add_listener
#define pw_client_add_listener(c,...)
Definition client.h:184
pw_context_destroy
void pw_context_destroy(struct pw_context *context)
destroy a context object, all resources except the main_loop will be destroyed
Definition context.c:387
pw_context_new
struct pw_context * pw_context_new(struct pw_loop *main_loop, struct pw_properties *props, size_t user_data_size)
Make a new context object for a given main_loop.
Definition context.c:175
pw_context_connect
struct pw_core * pw_context_connect(struct pw_context *context, struct pw_properties *properties, size_t user_data_size)
Connect to a PipeWire instance.
Definition core.c:391
pw_core_disconnect
int pw_core_disconnect(struct pw_core *core)
disconnect and destroy a core
Definition core.c:478
PW_VERSION_REGISTRY
#define PW_VERSION_REGISTRY
Definition core.h:52
pw_core_get_registry
static struct pw_registry * pw_core_get_registry(struct pw_core *core, uint32_t version, size_t user_data_size)
Definition core.h:406
pw_main_loop_quit
int pw_main_loop_quit(struct pw_main_loop *loop)
Quit a main loop.
Definition main-loop.c:106
pw_main_loop_destroy
void pw_main_loop_destroy(struct pw_main_loop *loop)
Destroy a loop.
Definition main-loop.c:71
pw_main_loop_run
int pw_main_loop_run(struct pw_main_loop *loop)
Run a main loop.
Definition main-loop.c:120
pw_main_loop_new
struct pw_main_loop * pw_main_loop_new(const struct spa_dict *props)
Create a new main loop.
Definition main-loop.c:61
pw_main_loop_get_loop
struct pw_loop * pw_main_loop_get_loop(struct pw_main_loop *loop)
Get the loop implementation.
Definition main-loop.c:94
pw_init
void pw_init(int *argc, char **argv[])
Initialize PipeWire.
Definition pipewire.c:556
pw_proxy_destroy
void pw_proxy_destroy(struct pw_proxy *proxy)
destroy a proxy
Definition proxy.c:206
PW_VERSION_REGISTRY_EVENTS
#define PW_VERSION_REGISTRY_EVENTS
Definition core.h:484
pw_registry_bind
static void * pw_registry_bind(struct pw_registry *registry, uint32_t id, const char *type, uint32_t version, size_t user_data_size)
Definition core.h:573
pw_registry_add_listener
#define pw_registry_add_listener(p,...)
Registry.
Definition core.h:568
spa_dict_for_each
#define spa_dict_for_each(item, dict)
Definition dict.h:52
spa_zero
#define spa_zero(x)
Definition defs.h:417
pipewire.h
pipewire/pipewire.h
pw_client_events
Client events.
Definition client.h:76
pw_client_events::info
void(* info)(void *data, const struct pw_client_info *info)
Notify client info.
Definition client.h:85
pw_client_info
The client information.
Definition client.h:46
pw_client_info::id
uint32_t id
id of the global
Definition client.h:47
pw_client
pw_context
pw_core
pw_main_loop
A main loop object.
pw_proxy
pw_registry_events
Registry events.
Definition core.h:482
pw_registry_events::global
void(* global)(void *data, uint32_t id, uint32_t permissions, const char *type, uint32_t version, const struct spa_dict *props)
Notify of a new global object.
Definition core.h:498
pw_registry
spa_dict_item
Definition dict.h:31
spa_dict_item::key
const char * key
Definition dict.h:32
spa_dict_item::value
const char * value
Definition dict.h:33
spa_dict
Definition dict.h:39
spa_hook
A hook, contains the structure with functions and the data passed to the functions.
Definition hook.h:350

To compile the simple test application, copy it into a tutorial6.c file and use:

    gcc -Wall tutorial6.c -o tutorial6 $(pkg-config --cflags --libs libpipewire-0.3)

Most of this is the same as Tutorial - Part 2: Enumerating Objects where we simply enumerated all objects on the server. Instead of just printing the object id and some other properties, in this example we also bind to the object.

We use the `pw_registry_bind()` method on our registry object like this:

static void registry_event_global(void *_data, uint32_t id,
uint32_t permissions, const char *type,
uint32_t version, const struct spa_dict *props)
{
struct data *data = _data;
if (data->client != NULL)
return;
if (strcmp(type, PW_TYPE_INTERFACE_Client) == 0) {
data->client = pw_registry_bind(data->registry,
id, type, PW_VERSION_CLIENT, 0);
pw_client_add_listener(data->client,
&data->client_listener,
&client_events, data);
}
}

We bind to the first client object that we see. This gives us a pointer to a `struct pw_proxy` that we can also cast to a `struct pw_client`.

On the proxy we can call methods and listen for events. PipeWire will automatically serialize the method calls and events between client and server for us.

We can now listen for events by adding a listener. We're going to listen to the info event on the client object that is emitted right after we bind to it or when it changes. This is not very different from the registry listener we added before:

static void client_info(void *object, const struct pw_client_info *info)
{
struct data *data = object;
const struct spa_dict_item *item;
printf("client: id:%u\n", info->id);
printf("\tprops:\n");
spa_dict_for_each(item, info->props)
printf("\t\t%s: \"%s\"\n", item->key, item->value);
pw_main_loop_quit(data->loop);
}
static const struct pw_client_events client_events = {
PW_VERSION_CLIENT_EVENTS,
.info = client_info,
};
static void registry_event_global(void *_data, uint32_t id,
uint32_t permissions, const char *type,
uint32_t version, const struct spa_dict *props)
{
/* ... */
pw_client_add_listener(data->client,
&data->client_listener,
&client_events, data);
/* ... */
}

We're also quitting the mainloop after we get the info to nicely stop our tutorial application.

When we stop the application, don't forget to destroy all proxies that you created. Otherwise, they will be leaked:

/* ... */
pw_proxy_destroy((struct pw_proxy *)data.client);
/* ... */
return 0;
}

Tutorial - Part 5: Capturing Video Frames | Index