Tutorial - Part 4: Playing A Tone | Index | Tutorial - Part 6: Binding Objects
In this tutorial we show how to use a stream to capture a stream of video frames.
Even though we are now working with a different media type and we are capturing instead of playback, you will see that this example is very similar to Tutorial - Part 4: Playing A Tone.
Let's take a look at the code before we break it down:
#include <spa/param/video/format-utils.h>
#include <spa/param/video/type-info.h>
struct data {
};
static void on_process(void *userdata)
{
struct data *data = userdata;
return;
}
return;
}
static void on_param_changed(
void *userdata, uint32_t
id,
const struct spa_pod *param)
{
struct data *data = userdata;
return;
&data->format.media_type,
&data->format.media_subtype) < 0)
return;
return;
return;
printf("got video format:\n");
printf(" format: %d (%s)\n", data->format.info.raw.format,
data->format.info.raw.format));
printf(" size: %dx%d\n", data->format.info.raw.size.width,
data->format.info.raw.size.height);
printf(" framerate: %d/%d\n", data->format.info.raw.framerate.num,
data->format.info.raw.framerate.denom);
}
.process = on_process,
};
int main(int argc, char *argv[])
{
struct data data = { 0, };
NULL);
if (argc > 1)
"video-capture",
props,
&stream_events,
&data);
params, 1);
return 0;
}
Save as tutorial5.c and compile with:
gcc -Wall tutorial5.c -o tutorial5 -lm $(pkg-config --cflags --libs libpipewire-0.3)
Most of the application is structured like Tutorial - Part 4: Playing A Tone.
We create a stream object with different properties to make it a Camera Video Capture stream.
NULL);
if (argc > 1)
"video-capture",
props,
&stream_events,
&data);
#define PW_KEY_MEDIA_TYPE
Media.
Definition keys.h:485
#define PW_KEY_TARGET_OBJECT
a target object to link to.
Definition keys.h:552
#define PW_KEY_MEDIA_ROLE
Role: Movie, Music, Camera, Screen, Communication, Game, Notification, DSP, Production,...
Definition keys.h:491
#define PW_KEY_MEDIA_CATEGORY
Media Category: Playback, Capture, Duplex, Monitor, Manager.
Definition keys.h:488
struct pw_loop * pw_main_loop_get_loop(struct pw_main_loop *loop)
Get the loop implementation.
Definition main-loop.c:96
struct pw_properties * pw_properties_new(const char *key,...)
Make a new properties object.
Definition properties.c:96
int pw_properties_set(struct pw_properties *properties, const char *key, const char *value)
Set a property value.
Definition properties.c:589
struct pw_stream * pw_stream_new_simple(struct pw_loop *loop, const char *name, struct pw_properties *props, const struct pw_stream_events *events, void *data)
Definition stream.c:1541
We also optionally allow the user to pass the name of the target node where the session manager is supposed to connect the node. The user may also give the value of the unique target node serial (PW_KEY_OBJECT_SERIAL) as the value.
In addition to the process event, we are also going to listen to a new event, param_changed:
.process = on_process,
};
#define PW_VERSION_STREAM_EVENTS
Definition stream.h:361
Events for a stream.
Definition stream.h:359
void(* param_changed)(void *data, uint32_t id, const struct spa_pod *param)
when a parameter changed
Definition stream.h:375
Because we capture a stream of a wide range of different video formats and resolutions, we have to describe our accepted formats in a different way:
@ SPA_MEDIA_TYPE_video
Definition format.h:28
@ SPA_PARAM_EnumFormat
available formats as SPA_TYPE_OBJECT_Format
Definition param.h:33
@ SPA_FORMAT_VIDEO_framerate
frame rate (Fraction)
Definition format.h:124
@ SPA_FORMAT_mediaType
media type (Id enum spa_media_type)
Definition format.h:93
@ SPA_FORMAT_VIDEO_size
size (Rectangle)
Definition format.h:123
@ SPA_FORMAT_VIDEO_format
video format (Id enum spa_video_format)
Definition format.h:120
@ SPA_FORMAT_mediaSubtype
media subtype (Id enum spa_media_subtype)
Definition format.h:94
@ SPA_MEDIA_SUBTYPE_raw
Definition format.h:38
@ SPA_VIDEO_FORMAT_YUY2
Definition raw.h:49
@ SPA_VIDEO_FORMAT_RGBA
Definition raw.h:56
@ SPA_VIDEO_FORMAT_RGBx
Definition raw.h:52
@ SPA_VIDEO_FORMAT_BGRx
Definition raw.h:53
@ SPA_VIDEO_FORMAT_I420
Definition raw.h:47
@ SPA_VIDEO_FORMAT_RGB
Definition raw.h:60
#define SPA_POD_CHOICE_ENUM_Id(n_vals,...)
Definition vararg.h:51
#define SPA_POD_CHOICE_RANGE_Fraction(def, min, max)
Definition vararg.h:115
#define SPA_POD_Id(val)
Definition vararg.h:49
#define SPA_POD_BUILDER_INIT(buffer, size)
Definition builder.h:62
#define SPA_POD_CHOICE_RANGE_Rectangle(def, min, max)
Definition vararg.h:106
#define spa_pod_builder_add_object(b, type, id,...)
Definition builder.h:659
@ SPA_TYPE_OBJECT_Format
Definition type.h:76
#define SPA_FRACTION(num, denom)
Definition defs.h:136
#define SPA_RECTANGLE(width, height)
Definition defs.h:115
uint32_t type
Definition pod.h:45
This is using a struct spa_pod_builder to make a struct spa_pod * object in the buffer array on the stack. The parameter is of type SPA_PARAM_EnumFormat which means that it enumerates the possible formats for this stream.
In this example we use the builder to create some CHOICE entries for the format properties.
We have an enumeration of formats, we need to first give the amount of enumerations that follow, then the default (preferred) value, followed by alternatives in order of preference:
We also have a RANGE of values for the size. We need to give a default (preferred) size and then a min and max value:
We have something similar for the framerate.
Note that there are other video parameters that we don't specify here. This means that we don't have any restrictions for their values.
See SPA POD for more information about how to make these POD objects.
Now we're ready to connect the stream and run the main loop:
params, 1);
#define PW_ID_ANY
Definition core.h:66
int pw_main_loop_run(struct pw_main_loop *loop)
Run a main loop.
Definition main-loop.c:122
#define PW_DIRECTION_INPUT
Definition port.h:48
int pw_stream_connect(struct pw_stream *stream, enum pw_direction direction, uint32_t target_id, enum pw_stream_flags flags, const struct spa_pod **params, uint32_t n_params)
Connect a stream for input or output on port_path.
Definition stream.c:1842
@ PW_STREAM_FLAG_MAP_BUFFERS
mmap the buffers except DmaBuf that is not explicitly marked as mappable.
Definition stream.h:412
@ PW_STREAM_FLAG_AUTOCONNECT
try to automatically connect this stream
Definition stream.h:407
To connect we specify that we have a PW_DIRECTION_INPUT stream. The third argument is always PW_ID_ANY.
We're setting the PW_STREAM_FLAG_AUTOCONNECT flag to make an automatic connection to a suitable camera and PW_STREAM_FLAG_MAP_BUFFERS to let the stream mmap the data for us.
And last we pass the extra parameters for our stream. Here we only have the allowed formats (SPA_PARAM_EnumFormat).
Running the mainloop will start the connection and negotiation process. First our param_changed event will be called with the format that was negotiated between our stream and the camera. This is always something that is compatible with what we enumerated in the EnumFormat param when we connected.
Let's take a look at how we can parse the format in the param_changed event:
static void on_param_changed(
void *userdata, uint32_t
id,
const struct spa_pod *param)
{
struct data *data = userdata;
return;
@ SPA_PARAM_Format
configured format as SPA_TYPE_OBJECT_Format
Definition param.h:34
First check if there is a param. A NULL param means that it is cleared. The ID of the param tells you what param it is. We are only interested in Format param (SPA_PARAM_Format).
We can parse the media type and subtype as below and ensure that it is of the right type. In our example this will always be true but when your EnumFormat contains different media types or subtypes, this is how you can parse them:
&data->format.media_type,
&data->format.media_subtype) < 0)
return;
return;
static int spa_format_parse(const struct spa_pod *format, uint32_t *media_type, uint32_t *media_subtype)
Definition format-utils.h:27
For the video/raw media type/subtype there is a utility function to parse out the values into a struct spa_video_info. This makes it easier to deal with.
return;
printf("got video format:\n");
printf(" format: %d (%s)\n", data->format.info.raw.format,
data->format.info.raw.format));
printf(" size: %dx%d\n", data->format.info.raw.size.width,
data->format.info.raw.size.height);
printf(" framerate: %d/%d\n", data->format.info.raw.framerate.num,
data->format.info.raw.framerate.denom);
}
static const char * spa_debug_type_find_name(const struct spa_type_info *info, uint32_t type)
Definition types.h:53
static const struct spa_type_info spa_type_video_format[]
Definition raw-types.h:29
static int spa_format_video_raw_parse(const struct spa_pod *format, struct spa_video_info_raw *info)
Definition raw-utils.h:27
In this example we dump the video size and parameters but in a real playback or capture application you might want to set up the screen or encoder to deal with the format.
After negotiation, the process function is called for each new frame. Check out Tutorial - Part 4: Playing A Tone for another example.
static void on_process(void *userdata)
{
struct data *data = userdata;
return;
}
return;
}
In a real playback application, one would do something with the data, like copy it to the screen or encode it into a file.
Tutorial - Part 4: Playing A Tone | Index | Tutorial - Part 6: Binding Objects
1.10.0