mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-01 22:58:50 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

spa: make events and commands as objects

Browse source 
So we can serialize and introspect them more easily
This commit is contained in:
Wim Taymans 2017-03-15 16:21:05 +01:00
parent 4c4c0f2a7f
commit c951264fff
26 changed files with 423 additions and 327 deletions
Download patch file Download diff file Expand all files Collapse all files

26
spa/plugins/alsa/alsa-sink.c
View file

@ -32,7 +32,7 @@
typedef struct _SpaALSAState SpaALSASink;
static const char default_device[] = "default";
static const uint32_t default_period_size = 32;
static const uint32_t default_period_size = 128;
static const uint32_t default_periods = 2;
static const bool default_period_event = 0;
@ -136,9 +136,15 @@ spa_alsa_sink_node_set_props (SpaNode *node,
reset_alsa_sink_props (&this->props);
return SPA_RESULT_OK;
} else {
SpaPODProp *pr;
SpaPOD *p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, pr) {
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, p) {
SpaPODProp *pr;
if (p->type != SPA_POD_TYPE_PROP)
continue;
pr = (SpaPODProp *) p;
switch (pr->body.key) {
case PROP_ID_DEVICE:
strncpy (this->props.device, SPA_POD_CONTENTS (SpaPODProp, pr), 63);
@ -184,9 +190,8 @@ do_command (SpaLoop *loop,
SpaALSASink *this = user_data;
SpaResult res;
SpaNodeCommand *cmd = data;
SpaNodeEventAsyncComplete ac;
switch (cmd->type) {
switch (SPA_NODE_COMMAND_TYPE (cmd)) {
case SPA_NODE_COMMAND_START:
case SPA_NODE_COMMAND_PAUSE:
res = spa_node_port_send_command (&this->node,
@ -200,10 +205,7 @@ do_command (SpaLoop *loop,
}
if (async) {
ac.event.type = SPA_NODE_EVENT_TYPE_ASYNC_COMPLETE;
ac.event.size = sizeof (SpaNodeEventAsyncComplete);
ac.seq = seq;
ac.res = res;
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (seq, res);
spa_loop_invoke (this->main_loop,
do_send_event,
SPA_ID_INVALID,
@ -225,7 +227,7 @@ spa_alsa_sink_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaALSASink, node);
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;
@ -241,7 +243,7 @@ spa_alsa_sink_node_send_command (SpaNode *node,
return spa_loop_invoke (this->data_loop,
do_command,
++this->seq,
command->size,
SPA_POD_SIZE (command),
command,
this);
@ -680,7 +682,7 @@ spa_alsa_sink_node_port_send_command (SpaNode *node,
if (port_id != 0)
return SPA_RESULT_INVALID_PORT;
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_PAUSE:
{
if (SPA_RESULT_IS_OK (res = spa_alsa_pause (this, false))) {

27
spa/plugins/alsa/alsa-source.c
View file

@ -135,9 +135,16 @@ spa_alsa_source_node_set_props (SpaNode *node,
reset_alsa_props (&this->props);
return SPA_RESULT_OK;
} else {
SpaPODProp *pr;
SpaPOD *p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, p) {
SpaPODProp *pr;
if (p->type != SPA_POD_TYPE_PROP)
continue;
pr = (SpaPODProp *) p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, pr) {
switch (pr->body.key) {
case PROP_ID_DEVICE:
strncpy (this->props.device, SPA_POD_CONTENTS (SpaPODProp, pr), 63);
@ -183,17 +190,13 @@ do_start (SpaLoop *loop,
{
SpaALSASource *this = user_data;
SpaResult res;
SpaNodeEventAsyncComplete ac;
if (SPA_RESULT_IS_OK (res = spa_alsa_start (this, false))) {
update_state (this, SPA_NODE_STATE_STREAMING);
}
if (async) {
ac.event.type = SPA_NODE_EVENT_TYPE_ASYNC_COMPLETE;
ac.event.size = sizeof (SpaNodeEventAsyncComplete);
ac.seq = seq;
ac.res = res;
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (seq, res);
spa_loop_invoke (this->main_loop,
do_send_event,
SPA_ID_INVALID,
@ -214,17 +217,13 @@ do_pause (SpaLoop *loop,
{
SpaALSASource *this = user_data;
SpaResult res;
SpaNodeEventAsyncComplete ac;
if (SPA_RESULT_IS_OK (res = spa_alsa_pause (this, false))) {
update_state (this, SPA_NODE_STATE_PAUSED);
}
if (async) {
ac.event.type = SPA_NODE_EVENT_TYPE_ASYNC_COMPLETE;
ac.event.size = sizeof (SpaNodeEventAsyncComplete);
ac.seq = seq;
ac.res = res;
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (seq, res);
spa_loop_invoke (this->main_loop,
do_send_event,
SPA_ID_INVALID,
@ -246,7 +245,7 @@ spa_alsa_source_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaALSASource, node);
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;
@ -736,7 +735,7 @@ spa_alsa_source_node_port_send_command (SpaNode *node,
if (port_id != 0)
return SPA_RESULT_INVALID_PORT;
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_PAUSE:
{
if (SPA_RESULT_IS_OK (res = spa_alsa_pause (this, false))) {

31
spa/plugins/alsa/alsa-utils.c
View file

@ -272,10 +272,7 @@ pull_frames_queue (SpaALSAState *state,
snd_pcm_uframes_t frames)
{
if (spa_list_is_empty (&state->ready)) {
SpaNodeEvent event;
event.type = SPA_NODE_EVENT_TYPE_NEED_INPUT;
event.size = sizeof (event);
SpaNodeEvent event = SPA_NODE_EVENT_INIT (SPA_NODE_EVENT_NEED_INPUT);
state->event_cb (&state->node, &event, state->user_data);
}
if (!spa_list_is_empty (&state->ready)) {
@ -299,16 +296,12 @@ pull_frames_queue (SpaALSAState *state,
state->ready_offset += n_bytes;
if (state->ready_offset >= size) {
SpaNodeEventReuseBuffer rb;
SpaNodeEventReuseBuffer rb = SPA_NODE_EVENT_REUSE_BUFFER_INIT (0, b->outbuf->id);
spa_list_remove (&b->link);
b->outstanding = true;
rb.event.type = SPA_NODE_EVENT_TYPE_REUSE_BUFFER;
rb.event.size = sizeof (rb);
rb.port_id = 0;
rb.buffer_id = b->outbuf->id;
state->event_cb (&state->node, &rb.event, state->user_data);
state->event_cb (&state->node, (SpaNodeEvent *)&rb, state->user_data);
state->ready_offset = 0;
}
@ -329,7 +322,6 @@ pull_frames_ringbuffer (SpaALSAState *state,
size_t size, avail;
SpaALSABuffer *b;
uint8_t *src, *dst;
SpaNodeEventReuseBuffer rb;
b = state->ringbuffer;
@ -357,11 +349,10 @@ pull_frames_ringbuffer (SpaALSAState *state,
}
b->outstanding = true;
rb.event.type = SPA_NODE_EVENT_TYPE_REUSE_BUFFER;
rb.event.size = sizeof (rb);
rb.port_id = 0;
rb.buffer_id = b->outbuf->id;
state->event_cb (&state->node, &rb.event, state->user_data);
{
SpaNodeEventReuseBuffer rb = SPA_NODE_EVENT_REUSE_BUFFER_INIT (0, b->outbuf->id);
state->event_cb (&state->node, (SpaNodeEvent*)&rb, state->user_data);
}
return frames;
}
@ -493,7 +484,6 @@ mmap_read (SpaALSAState *state)
}
if (b) {
SpaNodeEvent event;
SpaData *d;
SpaPortOutput *output;
@ -507,9 +497,10 @@ mmap_read (SpaALSAState *state)
output->buffer_id = b->outbuf->id;
output->status = SPA_RESULT_OK;
}
event.type = SPA_NODE_EVENT_TYPE_HAVE_OUTPUT;
event.size = sizeof (event);
state->event_cb (&state->node, &event, state->user_data);
{
SpaNodeEvent event = SPA_NODE_EVENT_INIT (SPA_NODE_EVENT_HAVE_OUTPUT);
state->event_cb (&state->node, &event, state->user_data);
}
}
return 0;
}

2
spa/plugins/audiomixer/audiomixer.c
View file

@ -117,7 +117,7 @@ spa_audiomixer_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaAudioMixer, node);
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;

17
spa/plugins/audiotestsrc/audiotestsrc.c
View file

@ -195,9 +195,16 @@ spa_audiotestsrc_node_set_props (SpaNode *node,
if (props == NULL) {
reset_audiotestsrc_props (&this->props);
} else {
SpaPODProp *pr;
SpaPOD *p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, p) {
SpaPODProp *pr;
if (p->type != SPA_POD_TYPE_PROP)
continue;
pr = (SpaPODProp *) p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, pr) {
switch (pr->body.key) {
case PROP_ID_LIVE:
this->props.live = ((SpaPODBool*)&pr->body.value)->value;
@ -226,11 +233,9 @@ spa_audiotestsrc_node_set_props (SpaNode *node,
static SpaResult
send_have_output (SpaAudioTestSrc *this)
{
SpaNodeEvent event;
if (this->event_cb) {
event.type = SPA_NODE_EVENT_TYPE_HAVE_OUTPUT;
event.size = sizeof (event);
SpaNodeEvent event = SPA_NODE_EVENT_INIT (SPA_NODE_EVENT_HAVE_OUTPUT);
this->event_cb (&this->node, &event, this->user_data);
}
@ -324,7 +329,7 @@ spa_audiotestsrc_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaAudioTestSrc, node);
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;

2
spa/plugins/ffmpeg/ffmpeg-dec.c
View file

@ -106,7 +106,7 @@ spa_ffmpeg_dec_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaFFMpegDec, node);
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;

2
spa/plugins/ffmpeg/ffmpeg-enc.c
View file

@ -111,7 +111,7 @@ spa_ffmpeg_enc_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaFFMpegEnc, node);
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;

44
spa/plugins/v4l2/v4l2-source.c
View file

@ -200,9 +200,16 @@ spa_v4l2_source_node_set_props (SpaNode *node,
reset_v4l2_source_props (&this->props);
return SPA_RESULT_OK;
} else {
SpaPODProp *pr;
SpaPOD *p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, p) {
SpaPODProp *pr;
if (p->type != SPA_POD_TYPE_PROP)
continue;
pr = (SpaPODProp *)p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, pr) {
switch (pr->body.key) {
case PROP_ID_DEVICE:
strncpy (this->props.device, SPA_POD_CONTENTS (SpaPODProp, pr), 63);
@ -225,15 +232,14 @@ do_pause_done (SpaLoop *loop,
SpaV4l2State *state = &this->state[0];
SpaNodeEventAsyncComplete *ac = data;
if (SPA_RESULT_IS_OK (ac->body.res.value))
ac->body.res.value = spa_v4l2_stream_off (this);
if (SPA_RESULT_IS_OK (ac->res))
ac->res = spa_v4l2_stream_off (this);
if (SPA_RESULT_IS_OK (ac->res)) {
if (SPA_RESULT_IS_OK (ac->body.res.value)) {
state->started = false;
update_state (this, SPA_NODE_STATE_PAUSED);
}
this->event_cb (&this->node, &ac->event, this->user_data);
this->event_cb (&this->node, (SpaNodeEvent *)ac, this->user_data);
return SPA_RESULT_OK;
}
@ -248,7 +254,6 @@ do_pause (SpaLoop *loop,
{
SpaV4l2Source *this = user_data;
SpaResult res;
SpaNodeEventAsyncComplete ac;
SpaNodeCommand *cmd = data;
res = spa_node_port_send_command (&this->node,
@ -257,10 +262,7 @@ do_pause (SpaLoop *loop,
cmd);
if (async) {
ac.event.type = SPA_NODE_EVENT_TYPE_ASYNC_COMPLETE;
ac.event.size = sizeof (SpaNodeEventAsyncComplete);
ac.seq = seq;
ac.res = res;
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (seq, res);
spa_loop_invoke (this->state[0].main_loop,
do_pause_done,
seq,
@ -283,11 +285,11 @@ do_start_done (SpaLoop *loop,
SpaV4l2State *state = &this->state[0];
SpaNodeEventAsyncComplete *ac = data;
if (SPA_RESULT_IS_OK (ac->res)) {
if (SPA_RESULT_IS_OK (ac->body.res.value)) {
state->started = true;
update_state (this, SPA_NODE_STATE_STREAMING);
}
this->event_cb (&this->node, &ac->event, this->user_data);
this->event_cb (&this->node, (SpaNodeEvent *)ac, this->user_data);
return SPA_RESULT_OK;
}
@ -302,7 +304,6 @@ do_start (SpaLoop *loop,
{
SpaV4l2Source *this = user_data;
SpaResult res;
SpaNodeEventAsyncComplete ac;
SpaNodeCommand *cmd = data;
res = spa_node_port_send_command (&this->node,
@ -311,10 +312,7 @@ do_start (SpaLoop *loop,
cmd);
if (async) {
ac.event.type = SPA_NODE_EVENT_TYPE_ASYNC_COMPLETE;
ac.event.size = sizeof (SpaNodeEventAsyncComplete);
ac.seq = seq;
ac.res = res;
SpaNodeEventAsyncComplete ac = SPA_NODE_EVENT_ASYNC_COMPLETE_INIT (seq, res);
spa_loop_invoke (this->state[0].main_loop,
do_start_done,
seq,
@ -337,7 +335,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaV4l2Source, node);
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;
@ -361,7 +359,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
return spa_loop_invoke (this->state[0].data_loop,
do_start,
++this->seq,
command->size,
SPA_POD_SIZE (command),
command,
this);
}
@ -381,7 +379,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
return spa_loop_invoke (this->state[0].data_loop,
do_pause,
++this->seq,
command->size,
SPA_POD_SIZE (command),
command,
this);
}
@ -844,7 +842,7 @@ spa_v4l2_source_node_port_send_command (SpaNode *node,
if (port_id != 0)
return SPA_RESULT_INVALID_PORT;
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_PAUSE:
res = spa_v4l2_port_set_enabled (this, false);
break;

8
spa/plugins/v4l2/v4l2-utils.c
View file

@ -924,7 +924,6 @@ static void
v4l2_on_fd_events (SpaSource *source)
{
SpaV4l2Source *this = source->data;
SpaNodeEvent event;
if (source->rmask & SPA_IO_ERR)
return;
@ -935,9 +934,10 @@ v4l2_on_fd_events (SpaSource *source)
if (mmap_read (this) < 0)
return;
event.type = SPA_NODE_EVENT_TYPE_HAVE_OUTPUT;
event.size = sizeof (event);
this->event_cb (&this->node, &event, this->user_data);
{
SpaNodeEvent event = SPA_NODE_EVENT_INIT (SPA_NODE_EVENT_HAVE_OUTPUT);
this->event_cb (&this->node, &event, this->user_data);
}
}
static SpaResult

17
spa/plugins/videotestsrc/videotestsrc.c
View file

@ -171,9 +171,15 @@ spa_videotestsrc_node_set_props (SpaNode *node,
if (props == NULL) {
reset_videotestsrc_props (&this->props);
} else {
SpaPODProp *pr;
SpaPOD *p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, pr) {
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, p) {
SpaPODProp *pr;
if (p->type != SPA_POD_TYPE_PROP)
continue;
pr = (SpaPODProp *) p;
switch (pr->body.key) {
case PROP_ID_LIVE:
this->props.live = ((SpaPODBool*)&pr->body.value)->value;
@ -196,14 +202,11 @@ spa_videotestsrc_node_set_props (SpaNode *node,
static SpaResult
send_have_output (SpaVideoTestSrc *this)
{
SpaNodeEvent event;
if (this->event_cb) {
event.type = SPA_NODE_EVENT_TYPE_HAVE_OUTPUT;
event.size = sizeof (event);
SpaNodeEvent event = SPA_NODE_EVENT_INIT (SPA_NODE_EVENT_HAVE_OUTPUT);
this->event_cb (&this->node, &event, this->user_data);
}
return SPA_RESULT_OK;
}
@ -289,7 +292,7 @@ spa_videotestsrc_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaVideoTestSrc, node);
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;

21
spa/plugins/volume/volume.c
View file

@ -161,9 +161,15 @@ spa_volume_node_set_props (SpaNode *node,
if (props == NULL) {
reset_volume_props (&this->props);
} else {
SpaPODProp *pr;
SpaPOD *p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, pr) {
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, p) {
SpaPODProp *pr;
if (p->type != SPA_POD_TYPE_PROP)
continue;
pr = (SpaPODProp *) p;
switch (pr->body.key) {
case PROP_ID_VOLUME:
this->props.volume = ((SpaPODDouble*)&pr->body.value)->value;
@ -188,7 +194,7 @@ spa_volume_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaVolume, node);
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;
@ -663,13 +669,8 @@ find_free_buffer (SpaVolume *this, SpaVolumePort *port)
static void
release_buffer (SpaVolume *this, SpaBuffer *buffer)
{
SpaNodeEventReuseBuffer rb;
rb.event.type = SPA_NODE_EVENT_TYPE_REUSE_BUFFER;
rb.event.size = sizeof (rb);
rb.port_id = 0;
rb.buffer_id = buffer->id;
this->event_cb (&this->node, &rb.event, this->user_data);
SpaNodeEventReuseBuffer rb = SPA_NODE_EVENT_REUSE_BUFFER_INIT (0, buffer->id);
this->event_cb (&this->node, (SpaNodeEvent *)&rb, this->user_data);
}
static void

12
spa/plugins/xv/xv-sink.c
View file

@ -166,9 +166,15 @@ spa_xv_sink_node_set_props (SpaNode *node,
if (props == NULL) {
reset_xv_sink_props (&this->props);
} else {
SpaPODProp *pr;
SpaPOD *p;
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, pr) {
SPA_POD_OBJECT_BODY_FOREACH (&props->body, props->pod.size, p) {
SpaPODProp *pr;
if (p->type != SPA_POD_TYPE_PROP)
continue;
pr = (SpaPODProp *) p;
switch (pr->body.key) {
case PROP_ID_DEVICE:
strncpy (this->props.device, SPA_POD_CONTENTS (SpaPODProp, pr), 63);
@ -190,7 +196,7 @@ spa_xv_sink_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaXvSink, node);
switch (command->type) {
switch (SPA_NODE_COMMAND_TYPE (command)) {
case SPA_NODE_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;