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.
struct pw_main_loop *loop;
struct pw_core *core;
struct pw_client *client;
};
static void client_info(
void *
object,
const struct pw_client_info *info)
{
printf(
"client: id:%u\n", info->
id);
printf("\tprops:\n");
printf("\t\t%s: \"%s\"\n", item->
key, item->
value);
}
.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)
{
if (
data->client != NULL)
return;
data->client = pw_registry_bind(
data->registry,
}
}
.global = registry_event_global,
};
int main(int argc, char *argv[])
{
NULL ,
0 );
0 );
0 );
®istry_events, &
data);
return 0;
}
#define PW_VERSION_CLIENT_EVENTS
Definition: client.h:78
#define PW_VERSION_REGISTRY_EVENTS
Definition: core.h:423
#define PW_TYPE_INTERFACE_Client
Definition: client.h:46
#define PW_VERSION_CLIENT
Definition: client.h:48
#define pw_client_add_listener(c,...)
Definition: client.h:169
void pw_context_destroy(struct pw_context *context)
destroy a context object, all resources except the main_loop will be destroyed
Definition: context.c:400
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:192
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:401
int pw_core_disconnect(struct pw_core *core)
disconnect and destroy a core
Definition: core.c:488
#define PW_VERSION_REGISTRY
Definition: core.h:54
struct pw_main_loop * pw_main_loop_new(const struct spa_dict *props)
Create a new main loop.
Definition: main-loop.c:86
int pw_main_loop_quit(struct pw_main_loop *loop)
Quit a main loop.
Definition: main-loop.c:131
void pw_main_loop_destroy(struct pw_main_loop *loop)
Destroy a loop.
Definition: main-loop.c:96
int pw_main_loop_run(struct pw_main_loop *loop)
Run a main loop.
Definition: main-loop.c:145
struct pw_loop * pw_main_loop_get_loop(struct pw_main_loop *loop)
Get the loop implementation.
Definition: main-loop.c:119
void pw_init(int *argc, char **argv[])
Initialize PipeWire.
Definition: pipewire.c:479
void pw_proxy_destroy(struct pw_proxy *proxy)
destroy a proxy
Definition: proxy.c:229
#define pw_registry_add_listener(p,...)
Registry.
Definition: core.h:501
#define spa_zero(x)
Definition: defs.h:288
#define spa_dict_for_each(item, dict)
Definition: utils/dict.h:58
struct pw_context * context
Definition: filter.c:76
Client events.
Definition: client.h:77
The client information.
Definition: client.h:55
uint32_t id
id of the global
Definition: client.h:56
struct spa_dict * props
extra properties
Definition: client.h:60
Registry events.
Definition: core.h:422
Definition: pipewire.c:73
Definition: utils/dict.h:41
const char * key
Definition: utils/dict.h:42
const char * value
Definition: utils/dict.h:43
Definition: utils/dict.h:48
A hook, contains the structure with functions and the data passed to the functions.
Definition: hook.h:76
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)
{
if (
data->client != NULL)
return;
data->client = pw_registry_bind(
data->registry,
}
}
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)
{
printf(
"client: id:%u\n", info->
id);
printf("\tprops:\n");
printf("\t\t%s: \"%s\"\n", item->
key, item->
value);
}
.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)
{
}
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:
Tutorial - Part 5: Capturing video frames | Index