mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-11-01 22:58:50 -04:00
Rework node and ports
Rework the node and port API so that other implementations can be used than the spa_node. The plan is to morph this into the stream and context API. Rework the graph API a little so that init + add is separated.
This commit is contained in:
Wim Taymans
parent
b0f5d34cf7
commit
0738f7fcf5
28 changed files with 1585 additions and 857 deletions
|
|
@ -42,21 +42,24 @@ static inline void spa_graph_scheduler_init(struct spa_graph_scheduler *sched,
|
|||
sched->node = NULL;
|
||||
}
|
||||
|
||||
static inline int spa_graph_scheduler_default(struct spa_graph_node *node)
|
||||
static inline int spa_graph_scheduler_input(struct spa_graph_node *node, void *user_data)
|
||||
{
|
||||
int res;
|
||||
struct spa_node *n = node->user_data;
|
||||
|
||||
if (node->action == SPA_GRAPH_ACTION_IN)
|
||||
res = spa_node_process_input(n);
|
||||
else if (node->action == SPA_GRAPH_ACTION_OUT)
|
||||
res = spa_node_process_output(n);
|
||||
else
|
||||
res = SPA_RESULT_ERROR;
|
||||
|
||||
return res;
|
||||
return spa_node_process_input(n);
|
||||
}
|
||||
|
||||
static inline int spa_graph_scheduler_output(struct spa_graph_node *node, void *user_data)
|
||||
{
|
||||
struct spa_node *n = node->user_data;
|
||||
return spa_node_process_output(n);
|
||||
}
|
||||
|
||||
static const struct spa_graph_node_methods spa_graph_scheduler_default = {
|
||||
SPA_VERSION_GRAPH_NODE_METHODS,
|
||||
spa_graph_scheduler_input,
|
||||
spa_graph_scheduler_output,
|
||||
};
|
||||
|
||||
static inline void spa_scheduler_port_check(struct spa_graph_scheduler *sched, struct spa_graph_port *port)
|
||||
{
|
||||
struct spa_graph_node *node = port->node;
|
||||
|
|
@ -93,15 +96,21 @@ static inline bool spa_graph_scheduler_iterate(struct spa_graph_scheduler *sched
|
|||
|
||||
switch (n->action) {
|
||||
case SPA_GRAPH_ACTION_IN:
|
||||
case SPA_GRAPH_ACTION_OUT:
|
||||
n->state = n->schedule(n);
|
||||
debug("node %p scheduled action %d state %d\n", n, n->action, n->state);
|
||||
if (n->action == SPA_GRAPH_ACTION_IN && n == sched->node)
|
||||
n->state = n->methods->schedule_input(n, n->user_data);
|
||||
debug("node %p scheduled input state %d\n", n, n->state);
|
||||
if (n == sched->node)
|
||||
break;
|
||||
n->action = SPA_GRAPH_ACTION_CHECK;
|
||||
spa_list_insert(sched->ready.prev, &n->ready_link);
|
||||
break;
|
||||
|
||||
case SPA_GRAPH_ACTION_OUT:
|
||||
n->state = n->methods->schedule_output(n, n->user_data);
|
||||
debug("node %p scheduled output state %d\n", n, n->state);
|
||||
n->action = SPA_GRAPH_ACTION_CHECK;
|
||||
spa_list_insert(sched->ready.prev, &n->ready_link);
|
||||
break;
|
||||
|
||||
case SPA_GRAPH_ACTION_CHECK:
|
||||
if (n->state == SPA_RESULT_NEED_BUFFER) {
|
||||
n->ready_in = 0;
|
||||
|
|
|
|||
|
|
@ -38,21 +38,34 @@ static inline void spa_graph_scheduler_init(struct spa_graph_scheduler *sched,
|
|||
sched->node = NULL;
|
||||
}
|
||||
|
||||
static inline int spa_graph_scheduler_default(struct spa_graph_node *node)
|
||||
static inline int spa_graph_scheduler_input(struct spa_graph_node *node, void *user_data)
|
||||
{
|
||||
int res;
|
||||
struct spa_node *n = node->user_data;
|
||||
|
||||
if (node->action == SPA_GRAPH_ACTION_IN)
|
||||
res = spa_node_process_input(n);
|
||||
else if (node->action == SPA_GRAPH_ACTION_OUT)
|
||||
res = spa_node_process_output(n);
|
||||
else
|
||||
res = SPA_RESULT_ERROR;
|
||||
|
||||
return res;
|
||||
return spa_node_process_input(n);
|
||||
}
|
||||
|
||||
static inline int spa_graph_scheduler_output(struct spa_graph_node *node, void *user_data)
|
||||
{
|
||||
struct spa_node *n = node->user_data;
|
||||
return spa_node_process_output(n);
|
||||
}
|
||||
|
||||
static inline int spa_graph_scheduler_reuse_buffer(struct spa_graph_port *port,
|
||||
uint32_t buffer_id, void *user_data)
|
||||
{
|
||||
printf("port %p reuse buffer %d\n", port, buffer_id);
|
||||
struct spa_graph_node *node = port->node;
|
||||
struct spa_node *n = node->user_data;
|
||||
return spa_node_port_reuse_buffer(n, port->port_id, buffer_id);
|
||||
}
|
||||
|
||||
static const struct spa_graph_node_methods spa_graph_scheduler_default = {
|
||||
SPA_VERSION_GRAPH_NODE_METHODS,
|
||||
spa_graph_scheduler_input,
|
||||
spa_graph_scheduler_output,
|
||||
spa_graph_scheduler_reuse_buffer,
|
||||
};
|
||||
|
||||
static inline void spa_graph_scheduler_pull(struct spa_graph_scheduler *sched, struct spa_graph_node *node)
|
||||
{
|
||||
struct spa_graph_port *p;
|
||||
|
|
@ -79,9 +92,8 @@ static inline void spa_graph_scheduler_pull(struct spa_graph_scheduler *sched, s
|
|||
}
|
||||
|
||||
spa_list_for_each_safe(n, t, &ready, ready_link) {
|
||||
n->action = SPA_GRAPH_ACTION_OUT;
|
||||
n->state = n->schedule(n);
|
||||
debug("peer %p scheduled %d %d\n", n, n->action, n->state);
|
||||
n->state = n->methods->schedule_output(n, n->user_data);
|
||||
debug("peer %p scheduled out %d\n", n, n->state);
|
||||
if (n->state == SPA_RESULT_NEED_BUFFER)
|
||||
spa_graph_scheduler_pull(sched, n);
|
||||
else {
|
||||
|
|
@ -97,9 +109,8 @@ static inline void spa_graph_scheduler_pull(struct spa_graph_scheduler *sched, s
|
|||
debug("node %p %d %d\n", node, node->ready_in, node->required_in);
|
||||
|
||||
if (node->required_in > 0 && node->ready_in == node->required_in) {
|
||||
node->action = SPA_GRAPH_ACTION_IN;
|
||||
node->state = node->schedule(node);
|
||||
debug("node %p scheduled %d %d\n", node, node->action, node->state);
|
||||
node->state = node->methods->schedule_input(node, node->user_data);
|
||||
debug("node %p scheduled in %d\n", node, node->state);
|
||||
if (node->state == SPA_RESULT_HAVE_BUFFER) {
|
||||
spa_list_for_each(p, &node->ports[SPA_DIRECTION_OUTPUT], link) {
|
||||
if (p->io->status == SPA_RESULT_HAVE_BUFFER)
|
||||
|
|
@ -143,9 +154,8 @@ static inline void spa_graph_scheduler_push(struct spa_graph_scheduler *sched, s
|
|||
}
|
||||
|
||||
spa_list_for_each_safe(n, t, &ready, ready_link) {
|
||||
n->action = SPA_GRAPH_ACTION_IN;
|
||||
n->state = n->schedule(n);
|
||||
debug("peer %p scheduled %d %d\n", n, n->action, n->state);
|
||||
n->state = n->methods->schedule_input(n, n->user_data);
|
||||
debug("peer %p scheduled in %d\n", n, n->state);
|
||||
if (n->state == SPA_RESULT_HAVE_BUFFER)
|
||||
spa_graph_scheduler_push(sched, n);
|
||||
else {
|
||||
|
|
@ -159,9 +169,8 @@ static inline void spa_graph_scheduler_push(struct spa_graph_scheduler *sched, s
|
|||
n->ready_link.next = NULL;
|
||||
}
|
||||
|
||||
node->action = SPA_GRAPH_ACTION_OUT;
|
||||
node->state = node->schedule(node);
|
||||
debug("node %p scheduled %d %d\n", node, node->action, node->state);
|
||||
node->state = node->methods->schedule_output(node, node->user_data);
|
||||
debug("node %p scheduled out %d\n", node, node->state);
|
||||
if (node->state == SPA_RESULT_NEED_BUFFER) {
|
||||
node->ready_in = 0;
|
||||
spa_list_for_each(p, &node->ports[SPA_DIRECTION_INPUT], link) {
|
||||
|
|
|
|||
|
|
@ -42,7 +42,14 @@ struct spa_graph {
|
|||
struct spa_list nodes;
|
||||
};
|
||||
|
||||
typedef int (*spa_graph_node_func_t) (struct spa_graph_node * node);
|
||||
#define SPA_VERSION_GRAPH_NODE_METHODS 0
|
||||
struct spa_graph_node_methods {
|
||||
uint32_t version;
|
||||
|
||||
int (*schedule_input) (struct spa_graph_node *node, void *user_data);
|
||||
int (*schedule_output) (struct spa_graph_node *node, void *user_data);
|
||||
int (*reuse_buffer) (struct spa_graph_port *port, uint32_t buffer_id, void *user_data);
|
||||
};
|
||||
|
||||
struct spa_graph_node {
|
||||
struct spa_list link;
|
||||
|
|
@ -55,7 +62,7 @@ struct spa_graph_node {
|
|||
#define SPA_GRAPH_ACTION_IN 1
|
||||
#define SPA_GRAPH_ACTION_OUT 2
|
||||
uint32_t action;
|
||||
spa_graph_node_func_t schedule;
|
||||
const struct spa_graph_node_methods *methods;
|
||||
void *user_data;
|
||||
uint32_t max_in;
|
||||
uint32_t required_in;
|
||||
|
|
@ -78,44 +85,57 @@ static inline void spa_graph_init(struct spa_graph *graph)
|
|||
}
|
||||
|
||||
static inline void
|
||||
spa_graph_node_add(struct spa_graph *graph, struct spa_graph_node *node,
|
||||
spa_graph_node_func_t schedule, void *user_data)
|
||||
spa_graph_node_init(struct spa_graph_node *node,
|
||||
const struct spa_graph_node_methods *methods,
|
||||
void *user_data)
|
||||
{
|
||||
spa_list_init(&node->ports[SPA_DIRECTION_INPUT]);
|
||||
spa_list_init(&node->ports[SPA_DIRECTION_OUTPUT]);
|
||||
node->flags = 0;
|
||||
node->methods = methods;
|
||||
node->user_data = user_data;
|
||||
node->max_in = node->required_in = node->ready_in = 0;
|
||||
debug("node %p init\n", node);
|
||||
}
|
||||
|
||||
static inline void
|
||||
spa_graph_node_add(struct spa_graph *graph,
|
||||
struct spa_graph_node *node)
|
||||
{
|
||||
node->state = SPA_RESULT_NEED_BUFFER;
|
||||
node->action = SPA_GRAPH_ACTION_OUT;
|
||||
node->schedule = schedule;
|
||||
node->user_data = user_data;
|
||||
node->ready_link.next = NULL;
|
||||
spa_list_insert(graph->nodes.prev, &node->link);
|
||||
node->max_in = node->required_in = node->ready_in = 0;
|
||||
debug("node %p add\n", node);
|
||||
}
|
||||
|
||||
static inline void
|
||||
spa_graph_port_add(struct spa_graph *graph,
|
||||
struct spa_graph_node *node,
|
||||
struct spa_graph_port *port,
|
||||
enum spa_direction direction,
|
||||
uint32_t port_id,
|
||||
uint32_t flags,
|
||||
struct spa_port_io *io)
|
||||
spa_graph_port_init(struct spa_graph_port *port,
|
||||
enum spa_direction direction,
|
||||
uint32_t port_id,
|
||||
uint32_t flags,
|
||||
struct spa_port_io *io)
|
||||
{
|
||||
debug("port %p add type %d id %d to node %p \n", port, direction, port_id, node);
|
||||
port->node = node;
|
||||
debug("port %p init type %d id %d\n", port, direction, port_id);
|
||||
port->direction = direction;
|
||||
port->port_id = port_id;
|
||||
port->flags = flags;
|
||||
port->io = io;
|
||||
spa_list_insert(node->ports[direction].prev, &port->link);
|
||||
}
|
||||
|
||||
static inline void
|
||||
spa_graph_port_add(struct spa_graph_node *node,
|
||||
struct spa_graph_port *port)
|
||||
{
|
||||
debug("port %p add to node %p\n", port, node);
|
||||
port->node = node;
|
||||
spa_list_insert(node->ports[port->direction].prev, &port->link);
|
||||
node->max_in++;
|
||||
if (!(port->flags & SPA_PORT_INFO_FLAG_OPTIONAL) && direction == SPA_DIRECTION_INPUT)
|
||||
if (!(port->flags & SPA_PORT_INFO_FLAG_OPTIONAL) && port->direction == SPA_DIRECTION_INPUT)
|
||||
node->required_in++;
|
||||
}
|
||||
|
||||
static inline void spa_graph_node_remove(struct spa_graph *graph, struct spa_graph_node *node)
|
||||
static inline void spa_graph_node_remove(struct spa_graph_node *node)
|
||||
{
|
||||
debug("node %p remove\n", node);
|
||||
spa_list_remove(&node->link);
|
||||
|
|
@ -123,7 +143,7 @@ static inline void spa_graph_node_remove(struct spa_graph *graph, struct spa_gra
|
|||
spa_list_remove(&node->ready_link);
|
||||
}
|
||||
|
||||
static inline void spa_graph_port_remove(struct spa_graph *graph, struct spa_graph_port *port)
|
||||
static inline void spa_graph_port_remove(struct spa_graph_port *port)
|
||||
{
|
||||
debug("port %p remove\n", port);
|
||||
spa_list_remove(&port->link);
|
||||
|
|
@ -132,7 +152,7 @@ static inline void spa_graph_port_remove(struct spa_graph *graph, struct spa_gra
|
|||
}
|
||||
|
||||
static inline void
|
||||
spa_graph_port_link(struct spa_graph *graph, struct spa_graph_port *out, struct spa_graph_port *in)
|
||||
spa_graph_port_link(struct spa_graph_port *out, struct spa_graph_port *in)
|
||||
{
|
||||
debug("port %p link to %p \n", out, in);
|
||||
out->peer = in;
|
||||
|
|
@ -140,7 +160,7 @@ spa_graph_port_link(struct spa_graph *graph, struct spa_graph_port *out, struct
|
|||
}
|
||||
|
||||
static inline void
|
||||
spa_graph_port_unlink(struct spa_graph *graph, struct spa_graph_port *port)
|
||||
spa_graph_port_unlink(struct spa_graph_port *port)
|
||||
{
|
||||
debug("port %p unlink from %p \n", port, port->peer);
|
||||
if (port->peer) {
|
||||
|
|
|
|||
|
|
@ -340,27 +340,27 @@ static int make_nodes(struct data *data, const char *device)
|
|||
spa_node_port_set_io(data->volume, SPA_DIRECTION_OUTPUT, 0, &data->volume_sink_io[0]);
|
||||
spa_node_port_set_io(data->sink, SPA_DIRECTION_INPUT, 0, &data->volume_sink_io[0]);
|
||||
|
||||
spa_graph_node_add(&data->graph, &data->source_node, spa_graph_scheduler_default,
|
||||
data->source);
|
||||
spa_graph_port_add(&data->graph, &data->source_node, &data->source_out,
|
||||
SPA_DIRECTION_OUTPUT, 0, 0, &data->source_volume_io[0]);
|
||||
spa_graph_node_init(&data->source_node, &spa_graph_scheduler_default, data->source);
|
||||
spa_graph_node_add(&data->graph, &data->source_node);
|
||||
spa_graph_port_init(&data->source_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source_volume_io[0]);
|
||||
spa_graph_port_add(&data->source_node, &data->source_out);
|
||||
|
||||
spa_graph_node_add(&data->graph, &data->volume_node, spa_graph_scheduler_default,
|
||||
data->volume);
|
||||
spa_graph_port_add(&data->graph, &data->volume_node, &data->volume_in, SPA_DIRECTION_INPUT,
|
||||
0, 0, &data->source_volume_io[0]);
|
||||
spa_graph_node_init(&data->volume_node, &spa_graph_scheduler_default, data->volume);
|
||||
spa_graph_node_add(&data->graph, &data->volume_node);
|
||||
spa_graph_port_init(&data->volume_in, SPA_DIRECTION_INPUT, 0, 0, &data->source_volume_io[0]);
|
||||
spa_graph_port_add(&data->volume_node, &data->volume_in);
|
||||
|
||||
spa_graph_port_link(&data->graph, &data->source_out, &data->volume_in);
|
||||
spa_graph_port_link(&data->source_out, &data->volume_in);
|
||||
|
||||
spa_graph_port_add(&data->graph, &data->volume_node,
|
||||
&data->volume_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->volume_sink_io[0]);
|
||||
spa_graph_port_init(&data->volume_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->volume_sink_io[0]);
|
||||
spa_graph_port_add(&data->volume_node, &data->volume_out);
|
||||
|
||||
spa_graph_node_add(&data->graph, &data->sink_node, spa_graph_scheduler_default,
|
||||
data->sink);
|
||||
spa_graph_port_add(&data->graph, &data->sink_node, &data->sink_in, SPA_DIRECTION_INPUT, 0,
|
||||
0, &data->volume_sink_io[0]);
|
||||
spa_graph_node_init(&data->sink_node, &spa_graph_scheduler_default, data->sink);
|
||||
spa_graph_node_add(&data->graph, &data->sink_node);
|
||||
spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0, &data->volume_sink_io[0]);
|
||||
spa_graph_port_add(&data->sink_node, &data->sink_in);
|
||||
|
||||
spa_graph_port_link(&data->graph, &data->volume_out, &data->sink_in);
|
||||
spa_graph_port_link(&data->volume_out, &data->sink_in);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -418,35 +418,37 @@ static int make_nodes(struct data *data, const char *device)
|
|||
spa_node_port_set_io(data->sink, SPA_DIRECTION_INPUT, 0, &data->mix_sink_io[0]);
|
||||
|
||||
#ifdef USE_GRAPH
|
||||
spa_graph_node_add(&data->graph, &data->source1_node, spa_graph_scheduler_default,
|
||||
data->source1);
|
||||
spa_graph_port_add(&data->graph, &data->source1_node, &data->source1_out,
|
||||
SPA_DIRECTION_OUTPUT, 0, 0, &data->source1_mix_io[0]);
|
||||
spa_graph_node_init(&data->source1_node, &spa_graph_scheduler_default, data->source1);
|
||||
spa_graph_port_init(&data->source1_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source1_mix_io[0]);
|
||||
spa_graph_port_add(&data->source1_node, &data->source1_out);
|
||||
spa_graph_node_add(&data->graph, &data->source1_node);
|
||||
|
||||
spa_graph_node_add(&data->graph, &data->source2_node, spa_graph_scheduler_default,
|
||||
data->source2);
|
||||
spa_graph_port_add(&data->graph, &data->source2_node, &data->source2_out,
|
||||
SPA_DIRECTION_OUTPUT, 0, 0, &data->source2_mix_io[0]);
|
||||
spa_graph_node_init(&data->source2_node, &spa_graph_scheduler_default, data->source2);
|
||||
spa_graph_port_init(&data->source2_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source2_mix_io[0]);
|
||||
spa_graph_port_add(&data->source2_node, &data->source2_out);
|
||||
spa_graph_node_add(&data->graph, &data->source2_node);
|
||||
|
||||
spa_graph_node_add(&data->graph, &data->mix_node, spa_graph_scheduler_default,
|
||||
data->mix);
|
||||
spa_graph_port_add(&data->graph, &data->mix_node, &data->mix_in[0], SPA_DIRECTION_INPUT,
|
||||
data->mix_ports[0], 0, &data->source1_mix_io[0]);
|
||||
spa_graph_port_add(&data->graph, &data->mix_node, &data->mix_in[1], SPA_DIRECTION_INPUT,
|
||||
spa_graph_node_init(&data->mix_node, &spa_graph_scheduler_default, data->mix);
|
||||
spa_graph_port_init(&data->mix_in[0], SPA_DIRECTION_INPUT,
|
||||
data->mix_ports[0], 0, &data->source1_mix_io[0]);
|
||||
spa_graph_port_add(&data->mix_node, &data->mix_in[0]);
|
||||
spa_graph_port_init(&data->mix_in[1], SPA_DIRECTION_INPUT,
|
||||
data->mix_ports[1], 0, &data->source2_mix_io[0]);
|
||||
spa_graph_port_add(&data->mix_node, &data->mix_in[1]);
|
||||
spa_graph_node_add(&data->graph, &data->mix_node);
|
||||
|
||||
spa_graph_port_link(&data->graph, &data->source1_out, &data->mix_in[0]);
|
||||
spa_graph_port_link(&data->graph, &data->source2_out, &data->mix_in[1]);
|
||||
spa_graph_port_link(&data->source1_out, &data->mix_in[0]);
|
||||
spa_graph_port_link(&data->source2_out, &data->mix_in[1]);
|
||||
|
||||
spa_graph_port_add(&data->graph, &data->mix_node,
|
||||
&data->mix_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->mix_sink_io[0]);
|
||||
spa_graph_port_init(&data->mix_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->mix_sink_io[0]);
|
||||
spa_graph_port_add(&data->mix_node, &data->mix_out);
|
||||
|
||||
spa_graph_node_add(&data->graph, &data->sink_node, spa_graph_scheduler_default,
|
||||
data->sink);
|
||||
spa_graph_port_add(&data->graph, &data->sink_node, &data->sink_in, SPA_DIRECTION_INPUT, 0,
|
||||
0, &data->mix_sink_io[0]);
|
||||
spa_graph_node_init(&data->sink_node, &spa_graph_scheduler_default, data->sink);
|
||||
spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0, &data->mix_sink_io[0]);
|
||||
spa_graph_port_add(&data->sink_node, &data->sink_in);
|
||||
spa_graph_node_add(&data->graph, &data->sink_node);
|
||||
|
||||
spa_graph_port_link(&data->graph, &data->mix_out, &data->sink_in);
|
||||
spa_graph_port_link(&data->mix_out, &data->sink_in);
|
||||
#endif
|
||||
|
||||
return res;
|
||||
|
|
|
|||
|
|
@ -366,19 +366,21 @@ static int make_nodes(struct data *data)
|
|||
spa_node_port_set_io(data->source, SPA_DIRECTION_OUTPUT, 0, &data->source_sink_io[0]);
|
||||
spa_node_port_set_io(data->sink, SPA_DIRECTION_INPUT, 0, &data->source_sink_io[0]);
|
||||
|
||||
spa_graph_node_add(&data->graph, &data->source_node,
|
||||
spa_graph_scheduler_default, data->source);
|
||||
spa_graph_node_init(&data->source_node, &spa_graph_scheduler_default, data->source);
|
||||
spa_graph_node_add(&data->graph, &data->source_node);
|
||||
|
||||
data->source_node.flags = (data->mode & MODE_ASYNC_PUSH) ? SPA_GRAPH_NODE_FLAG_ASYNC : 0;
|
||||
spa_graph_port_add(&data->graph, &data->source_node,
|
||||
&data->source_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source_sink_io[0]);
|
||||
spa_graph_port_init( &data->source_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source_sink_io[0]);
|
||||
spa_graph_port_add(&data->source_node, &data->source_out);
|
||||
|
||||
spa_graph_node_init(&data->sink_node, &spa_graph_scheduler_default, data->sink);
|
||||
spa_graph_node_add(&data->graph, &data->sink_node);
|
||||
|
||||
spa_graph_node_add(&data->graph, &data->sink_node, spa_graph_scheduler_default,
|
||||
data->sink);
|
||||
data->sink_node.flags = (data->mode & MODE_ASYNC_PULL) ? SPA_GRAPH_NODE_FLAG_ASYNC : 0;
|
||||
spa_graph_port_add(&data->graph, &data->sink_node,
|
||||
&data->sink_in, SPA_DIRECTION_INPUT, 0, 0, &data->source_sink_io[0]);
|
||||
spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0, &data->source_sink_io[0]);
|
||||
spa_graph_port_add(&data->sink_node, &data->sink_in);
|
||||
|
||||
spa_graph_port_link(&data->graph, &data->source_out, &data->sink_in);
|
||||
spa_graph_port_link(&data->source_out, &data->sink_in);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue