mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-31 22:25:38 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/pinos/server/node.c

894 lines
26 KiB
C
Raw Normal View History

add missing files
2016-05-12 17:06:48 +02:00
/* Pinos
* Copyright (C) 2015 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
some more rework
2016-07-18 17:40:58 +02:00
#include <string.h>
#include <stdlib.h>
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
#include <errno.h>
add missing files
2016-05-12 17:06:48 +02:00
#include "pinos/client/pinos.h"
Use interfaces Add interfaces and events on objects. Use this to communicate with the objects and transparently convert/marshall to network in the protocols.
2017-03-02 16:06:45 +01:00
#include "pinos/client/interfaces.h"
add missing files
2016-05-12 17:06:48 +02:00
some more rework
2016-07-18 17:40:58 +02:00
#include "pinos/server/node.h"
Work on main loop Make a main-loop object with associated helper functions to handle async methods. rtloop -> data_loop Handle async results a lot better. Remove REMOVE_MEM command. We don't need it. Handle stream memory updates better.
2016-10-20 16:26:55 +02:00
#include "pinos/server/data-loop.h"
#include "pinos/server/main-loop.h"
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
#include "pinos/server/work-queue.h"
add missing files
2016-05-12 17:06:48 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
typedef struct
add missing files
2016-05-12 17:06:48 +02:00
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNode this;
some more rework
2016-07-18 17:40:58 +02:00
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
#define STATE_IN 0
#define STATE_OUT 1
int state;
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
PinosWorkQueue *work;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
bool async_init;
WIP Change object model
2016-11-10 15:42:14 +01:00
} PinosNodeImpl;
add missing files
2016-05-12 17:06:48 +02:00
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
static void init_complete (PinosNode *this);
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
Remove direction Direction is tied to the port id. Handle nodes with fixed ports.
2016-08-29 18:31:53 +02:00
static void
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
update_port_ids (PinosNode *node)
Remove direction Direction is tied to the port id. Handle nodes with fixed ports.
2016-08-29 18:31:53 +02:00
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (node, PinosNodeImpl, this);
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
uint32_t *input_port_ids, *output_port_ids;
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
uint32_t n_input_ports, n_output_ports, max_input_ports, max_output_ports;
uint32_t i;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
SpaList *ports;
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
SpaResult res;
Remove direction Direction is tied to the port id. Handle nodes with fixed ports.
2016-08-29 18:31:53 +02:00
if (node->node == NULL)
return;
spa_node_get_n_ports (node->node,
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
&n_input_ports,
&max_input_ports,
&n_output_ports,
&max_output_ports);
Remove direction Direction is tied to the port id. Handle nodes with fixed ports.
2016-08-29 18:31:53 +02:00
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
node->n_input_ports = n_input_ports;
node->max_input_ports = max_input_ports;
node->n_output_ports = n_output_ports;
node->max_output_ports = max_output_ports;
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
node->input_port_map = calloc (max_input_ports, sizeof (PinosPort *));
node->output_port_map = calloc (max_output_ports, sizeof (PinosPort *));
cleanups
2016-11-16 17:21:59 +01:00
input_port_ids = alloca (sizeof (uint32_t) * n_input_ports);
output_port_ids = alloca (sizeof (uint32_t) * n_output_ports);
Remove direction Direction is tied to the port id. Handle nodes with fixed ports.
2016-08-29 18:31:53 +02:00
spa_node_get_port_ids (node->node,
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
max_input_ports,
input_port_ids,
max_output_ports,
output_port_ids);
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("node %p: update_port ids %u/%u, %u/%u", node,
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
n_input_ports, max_input_ports, n_output_ports, max_output_ports);
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
i = 0;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
ports = &node->input_ports;
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
while (true) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
PinosPort *p = (ports == &node->input_ports) ? NULL : SPA_CONTAINER_OF (ports, PinosPort, link);
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
if (p && i < n_input_ports && p->port_id == input_port_ids[i]) {
node->input_port_map[p->port_id] = p;
pinos_log_debug ("node %p: exiting input port %d", node, input_port_ids[i]);
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
i++;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
ports = ports->next;
} else if ((p && i < n_input_ports && input_port_ids[i] < p->port_id) || i < n_input_ports) {
Cleanups spa_serialize -> pinos_serialize Improve PinosPort, move links to the object and make it part of PinosNode Work on improving signals to react to changes in the graph Error when a client-node becomes unlinked, like when removing a camera.
2016-10-19 17:18:30 +02:00
PinosPort *np;
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("node %p: input port added %d", node, input_port_ids[i]);
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
np = pinos_port_new (node, PINOS_DIRECTION_INPUT, input_port_ids[i]);
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
if ((res = spa_node_port_set_io (node->node, SPA_DIRECTION_INPUT, np->port_id, &np->io)) < 0)
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
pinos_log_warn ("node %p: can't set input IO %d", node, res);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
spa_list_insert (ports, &np->link);
ports = np->link.next;
node->input_port_map[np->port_id] = np;
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
if (!impl->async_init)
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_signal_emit (&node->port_added, node, np);
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
i++;
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
} else if (p) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
node->input_port_map[p->port_id] = NULL;
ports = ports->next;
WIP Change object model
2016-11-10 15:42:14 +01:00
if (!impl->async_init)
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_signal_emit (&node->port_removed, node, p);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
pinos_log_debug ("node %p: input port removed %d", node, p->port_id);
pinos_port_destroy (p);
} else {
pinos_log_debug ("node %p: no more input ports", node);
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
break;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
}
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
}
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
i = 0;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
ports = &node->output_ports;
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
while (true) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
PinosPort *p = (ports == &node->output_ports) ? NULL : SPA_CONTAINER_OF (ports, PinosPort, link);
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
if (p && i < n_output_ports && p->port_id == output_port_ids[i]) {
pinos_log_debug ("node %p: exiting output port %d", node, output_port_ids[i]);
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
i++;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
ports = ports->next;
node->output_port_map[p->port_id] = p;
} else if ((p && i < n_output_ports && output_port_ids[i] < p->port_id) || i < n_output_ports) {
Cleanups spa_serialize -> pinos_serialize Improve PinosPort, move links to the object and make it part of PinosNode Work on improving signals to react to changes in the graph Error when a client-node becomes unlinked, like when removing a camera.
2016-10-19 17:18:30 +02:00
PinosPort *np;
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("node %p: output port added %d", node, output_port_ids[i]);
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
np = pinos_port_new (node, PINOS_DIRECTION_OUTPUT, output_port_ids[i]);
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
if ((res = spa_node_port_set_io (node->node, SPA_DIRECTION_OUTPUT, np->port_id, &np->io)) < 0)
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
pinos_log_warn ("node %p: can't set output IO %d", node, res);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
spa_list_insert (ports, &np->link);
ports = np->link.next;
node->output_port_map[np->port_id] = np;
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
if (!impl->async_init)
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_signal_emit (&node->port_added, node, np);
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
i++;
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
} else if (p) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
node->output_port_map[p->port_id] = NULL;
ports = ports->next;
WIP Change object model
2016-11-10 15:42:14 +01:00
if (!impl->async_init)
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_signal_emit (&node->port_removed, node, p);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
pinos_log_debug ("node %p: output port removed %d", node, p->port_id);
pinos_port_destroy (p);
} else {
pinos_log_debug ("node %p: no more output ports", node);
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
break;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
}
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
}
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
pinos_signal_emit (&node->initialized, node);
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
}
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
static SpaResult
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
pause_node (PinosNode *this)
some more rework
2016-07-18 17:40:58 +02:00
{
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
SpaResult res;
work on port-update control message Serialize format and properties. Simplify the properties by moving the unset-mask inside the property structure. We can then also just use the index of the property as the bit in the mask. Work on stopping on disconnect
2016-08-08 22:10:57 +02:00
improve states
2017-01-19 20:07:03 +01:00
pinos_log_debug ("node %p: pause node", this);
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
{
types: more work on types
2017-03-24 11:40:58 +01:00
SpaCommand cmd = SPA_COMMAND_INIT (this->core->type.command_node.Pause);
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
if ((res = spa_node_send_command (this->node, &cmd)) < 0)
pinos_log_debug ("got error %d", res);
}
small fixes
2017-04-08 20:59:38 +02:00
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
return res;
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
}
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
static SpaResult
Fix stream restart Make sure we always send a clock update before sending a start command. Fix memory size. Follow the state of the node to do allocation Use the pinos node to control the state When doing STREAMOFF, all buffers will be dequeued. requeue them buffers for when we go to playing again.
2016-09-13 10:34:32 +02:00
start_node (PinosNode *this)
{
SpaResult res;
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("node %p: start node", this);
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
{
types: more work on types
2017-03-24 11:40:58 +01:00
SpaCommand cmd = SPA_COMMAND_INIT (this->core->type.command_node.Start);
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
if ((res = spa_node_send_command (this->node, &cmd)) < 0)
pinos_log_debug ("got error %d", res);
}
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
return res;
Fix stream restart Make sure we always send a clock update before sending a start command. Fix memory size. Follow the state of the node to do allocation Use the pinos node to control the state When doing STREAMOFF, all buffers will be dequeued. requeue them buffers for when we go to playing again.
2016-09-13 10:34:32 +02:00
}
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
static SpaResult
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
suspend_node (PinosNode *this)
{
port to meson
2016-09-26 12:15:52 +02:00
SpaResult res = SPA_RESULT_OK;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
PinosPort *p;
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("node %p: suspend node", this);
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
spa_list_for_each (p, &this->input_ports, link) {
if ((res = spa_node_port_set_format (this->node, SPA_DIRECTION_INPUT, p->port_id, 0, NULL)) < 0)
pinos_log_warn ("error unset format input: %d", res);
Cleanups spa_serialize -> pinos_serialize Improve PinosPort, move links to the object and make it part of PinosNode Work on improving signals to react to changes in the graph Error when a client-node becomes unlinked, like when removing a camera.
2016-10-19 17:18:30 +02:00
p->buffers = NULL;
p->n_buffers = 0;
if (p->allocated)
pinos_memblock_free (&p->buffer_mem);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
p->allocated = false;
small fixes
2017-04-08 20:59:38 +02:00
p->state = SPA_PORT_STATE_CONFIGURE;
port to meson
2016-09-26 12:15:52 +02:00
}
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
spa_list_for_each (p, &this->output_ports, link) {
if ((res = spa_node_port_set_format (this->node, SPA_DIRECTION_OUTPUT, p->port_id, 0, NULL)) < 0)
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_warn ("error unset format output: %d", res);
Cleanups spa_serialize -> pinos_serialize Improve PinosPort, move links to the object and make it part of PinosNode Work on improving signals to react to changes in the graph Error when a client-node becomes unlinked, like when removing a camera.
2016-10-19 17:18:30 +02:00
p->buffers = NULL;
p->n_buffers = 0;
if (p->allocated)
pinos_memblock_free (&p->buffer_mem);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
p->allocated = false;
small fixes
2017-04-08 20:59:38 +02:00
p->state = SPA_PORT_STATE_CONFIGURE;
port to meson
2016-09-26 12:15:52 +02:00
}
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
return res;
some more rework
2016-07-18 17:40:58 +02:00
}
add clock Add a gstreamer pinos clock that reports the time at the server
2016-09-12 12:28:51 +02:00
static void
send_clock_update (PinosNode *this)
{
pinossrc: handle latency and liveness Use NULL filter when the port format enumeration returns nothing. Send clock update even when there is no clock. Don't send data to a port when the node is not streaming Add latency support to the clock update Copy the unset_mask when copying the formats
2016-09-13 17:43:57 +02:00
SpaResult res;
clean up types
2017-03-23 21:15:52 +01:00
SpaCommandNodeClockUpdate cu =
SPA_COMMAND_NODE_CLOCK_UPDATE_INIT(
types: more work on types
2017-03-24 11:40:58 +01:00
this->core->type.command_node.ClockUpdate,
clean up types
2017-03-23 21:15:52 +01:00
SPA_COMMAND_NODE_CLOCK_UPDATE_TIME |
SPA_COMMAND_NODE_CLOCK_UPDATE_SCALE |
SPA_COMMAND_NODE_CLOCK_UPDATE_STATE |
SPA_COMMAND_NODE_CLOCK_UPDATE_LATENCY, /* change_mask */
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
1, /* rate */
0, /* ticks */
0, /* monotonic_time */
0, /* offset */
(1 << 16) | 1, /* scale */
SPA_CLOCK_STATE_RUNNING, /* state */
0, /* flags */
0); /* latency */
pinossrc: handle latency and liveness Use NULL filter when the port format enumeration returns nothing. Send clock update even when there is no clock. Don't send data to a port when the node is not streaming Add latency support to the clock update Copy the unset_mask when copying the formats
2016-09-13 17:43:57 +02:00
videotestsrc: remove threads Remove the threads from the element and use timerfd to schedule timeouts Propagate live flag between node links
2016-09-19 19:17:59 +02:00
if (this->clock && this->live) {
clean up types
2017-03-23 21:15:52 +01:00
cu.body.flags.value = SPA_COMMAND_NODE_CLOCK_UPDATE_FLAG_LIVE;
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
res = spa_clock_get_time (this->clock,
&cu.body.rate.value,
&cu.body.ticks.value,
&cu.body.monotonic_time.value);
add clock Add a gstreamer pinos clock that reports the time at the server
2016-09-12 12:28:51 +02:00
}
pinossrc: handle latency and liveness Use NULL filter when the port format enumeration returns nothing. Send clock update even when there is no clock. Don't send data to a port when the node is not streaming Add latency support to the clock update Copy the unset_mask when copying the formats
2016-09-13 17:43:57 +02:00
command: make commands dynamic Ensure format object type.
2017-03-22 10:04:24 +01:00
if ((res = spa_node_send_command (this->node, (SpaCommand *)&cu)) < 0)
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("got error %d", res);
add clock Add a gstreamer pinos clock that reports the time at the server
2016-09-12 12:28:51 +02:00
}
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
static SpaResult
do_pull (PinosNode *this)
{
SpaResult res = SPA_RESULT_OK;
PinosPort *inport;
spa_list_for_each (inport, &this->input_ports, link) {
PinosLink *link;
PinosPort *outport;
SpaPortIO *pi;
SpaPortIO *po;
pi = &inport->io;
pinos_log_trace ("node %p: need input port %d, %d %d", this,
inport->port_id, pi->buffer_id, pi->status);
if (pi->status != SPA_RESULT_NEED_INPUT)
continue;
spa_list_for_each (link, &inport->rt.links, rt.input_link) {
if (link->rt.input == NULL || link->rt.output == NULL)
continue;
outport = link->rt.output;
po = &outport->io;
/* pull */
*po = *pi;
pinos_log_trace ("node %p: process output %p %d", outport->node, po, po->buffer_id);
res = spa_node_process_output (outport->node->node);
if (res == SPA_RESULT_NEED_INPUT) {
res = do_pull (outport->node);
*pi = *po;
pinos_log_trace ("node %p: pull return %d", outport->node, res);
}
else if (res == SPA_RESULT_HAVE_OUTPUT) {
*pi = *po;
}
else
pinos_log_warn ("node %p: got process output %d", outport->node, res);
}
if (pi->buffer_id != SPA_ID_INVALID) {
pinos_log_trace ("node %p: process input %d %d", this, pi->status, pi->buffer_id);
res = spa_node_process_input (this->node);
if (res == SPA_RESULT_HAVE_OUTPUT)
break;
}
}
return res;
}
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
static void
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
on_node_event (SpaNode *node, SpaEvent *event, void *user_data)
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
{
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
PinosNode *this = user_data;
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (this, PinosNodeImpl, this);
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
types: more work on types
2017-03-24 11:40:58 +01:00
if (SPA_EVENT_TYPE (event) == this->core->type.event_node.AsyncComplete) {
clean up types
2017-03-23 21:15:52 +01:00
SpaEventNodeAsyncComplete *ac = (SpaEventNodeAsyncComplete *) event;
Remove direction Direction is tied to the port id. Handle nodes with fixed ports.
2016-08-29 18:31:53 +02:00
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
pinos_log_debug ("node %p: async complete event %d %d", this, ac->body.seq.value, ac->body.res.value);
if (!pinos_work_queue_complete (impl->work, this, ac->body.seq.value, ac->body.res.value)) {
pinos_signal_emit (&this->async_complete, this, ac->body.seq.value, ac->body.res.value);
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
}
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
}
types: more work on types
2017-03-24 11:40:58 +01:00
else if (SPA_EVENT_TYPE (event) == this->core->type.event_node.NeedInput) {
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
do_pull (this);
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
}
types: more work on types
2017-03-24 11:40:58 +01:00
else if (SPA_EVENT_TYPE (event) == this->core->type.event_node.HaveOutput) {
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
SpaResult res;
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
PinosPort *outport;
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
spa_list_for_each (outport, &this->output_ports, link) {
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
PinosLink *link;
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
PinosPort *inport;
improve node io Unify input and output io areas. Add support for ranges in the io area. Automatically recycle buffers in the output areas in process_output Improve the mixer, add use_buffer support, use a queue of input buffers, fix mixing, add support for ranges. Fix mixer and v4l2 tests
2017-04-03 14:56:04 +02:00
SpaPortIO *po;
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
po = &outport->io;
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
if (po->buffer_id == SPA_ID_INVALID)
continue;
implement alsa capture with timers Add timer based alsa capture support Improve format negotiation in alsa Better track buffer owner in the links
2017-03-30 17:30:28 +02:00
pinos_log_trace ("node %p: have output %d", this, po->buffer_id);
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
spa_list_for_each (link, &outport->rt.links, rt.output_link) {
if (link->rt.input == NULL || link->rt.output == NULL)
node: keep separate array of links Keep a separate array with the links that we only access and update from the data-thread.
2016-10-24 18:01:04 +02:00
continue;
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
inport = link->rt.input;
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
inport->io = *po;
optimize data transport Remove queue and ringbuffer between nodes. transfer the buffer id directly between the io areas when possible. Let only pinos send push or pull requests for now. Allow polling multiple fds, like how alsa wants it Remove port_id from events.
2017-01-18 18:29:15 +01:00
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
if ((res = spa_node_process_input (inport->node->node)) < 0)
pinos_log_warn ("node %p: got process input %d", inport->node, res);
}
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
}
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
if ((res = spa_node_process_output (this->node)) < 0)
pinos_log_warn ("node %p: got process output %d", this, res);
}
else if (SPA_EVENT_TYPE (event) == this->core->type.event_node.ReuseBuffer) {
SpaEventNodeReuseBuffer *rb = (SpaEventNodeReuseBuffer *) event;
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
PinosPort *inport;
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
pinos_log_trace ("node %p: reuse buffer %u", this, rb->body.buffer_id.value);
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
spa_list_for_each (inport, &this->input_ports, link) {
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
PinosLink *link;
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
PinosPort *outport;
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
spa_list_for_each (link, &inport->rt.links, rt.input_link) {
if (link->rt.input == NULL || link->rt.output == NULL)
continue;
outport = link->rt.output;
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
outport->io.buffer_id = rb->body.buffer_id.value;
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
}
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
}
}
types: more work on types
2017-03-24 11:40:58 +01:00
else if (SPA_EVENT_TYPE (event) == this->core->type.event_node.RequestClockUpdate) {
event: make events dynamic Use uri for the events.
2017-03-21 20:39:20 +01:00
send_clock_update (this);
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
}
}
Work on introspection
2016-12-02 13:38:43 +01:00
static void
node_unbind_func (void *data)
{
PinosResource *resource = data;
spa_list_remove (&resource->link);
}
Implement access control Move send and dispatch functions to the implementation. This makes it possible to place an access check before sending and dispatching. Add module-access that allows to bind and notify on globals owned by the client.
2017-01-10 17:12:53 +01:00
static SpaResult
Work on introspection
2016-12-02 13:38:43 +01:00
node_bind_func (PinosGlobal *global,
PinosClient *client,
uint32_t version,
uint32_t id)
{
PinosNode *this = global->object;
PinosResource *resource;
PinosNodeInfo info;
small cleanups
2017-03-24 16:14:17 +01:00
int i;
Work on introspection
2016-12-02 13:38:43 +01:00
resource = pinos_resource_new (client,
id,
Implement access control Move send and dispatch functions to the implementation. This makes it possible to place an access check before sending and dispatching. Add module-access that allows to bind and notify on globals owned by the client.
2017-01-10 17:12:53 +01:00
global->type,
Work on introspection
2016-12-02 13:38:43 +01:00
global->object,
node_unbind_func);
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
if (resource == NULL)
goto no_mem;
Work on introspection
2016-12-02 13:38:43 +01:00
pinos_log_debug ("node %p: bound to %d", this, resource->id);
spa_list_insert (this->resource_list.prev, &resource->link);
Add core introspection Use global ids in info messages to refer to global objects.
2016-12-15 20:09:48 +01:00
info.id = global->id;
Work on introspection
2016-12-02 13:38:43 +01:00
info.change_mask = ~0;
info.name = this->name;
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
info.max_inputs = this->max_input_ports;
info.n_inputs = this->n_input_ports;
Use int counters for iterating items Use counters instead of void* to iterate items. This simplifies some things and makes it easier to do over the wire. Add format description to NodeInfo and use this to add format descriptions to pinos devices. Small fixes to fix leaks and crashes.
2017-02-01 08:58:21 +01:00
info.input_formats = NULL;
for (info.n_input_formats = 0; ; info.n_input_formats++) {
SpaFormat *fmt;
if (spa_node_port_enum_formats (this->node,
SPA_DIRECTION_INPUT,
0,
&fmt,
NULL,
info.n_input_formats) < 0)
break;
info.input_formats = realloc (info.input_formats, sizeof (SpaFormat*) * (info.n_input_formats + 1));
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
info.input_formats[info.n_input_formats] = spa_format_copy (fmt);
Use int counters for iterating items Use counters instead of void* to iterate items. This simplifies some things and makes it easier to do over the wire. Add format description to NodeInfo and use this to add format descriptions to pinos devices. Small fixes to fix leaks and crashes.
2017-02-01 08:58:21 +01:00
}
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
info.max_outputs = this->max_output_ports;
info.n_outputs = this->n_output_ports;
Use int counters for iterating items Use counters instead of void* to iterate items. This simplifies some things and makes it easier to do over the wire. Add format description to NodeInfo and use this to add format descriptions to pinos devices. Small fixes to fix leaks and crashes.
2017-02-01 08:58:21 +01:00
info.output_formats = NULL;
for (info.n_output_formats = 0; ; info.n_output_formats++) {
SpaFormat *fmt;
if (spa_node_port_enum_formats (this->node,
SPA_DIRECTION_OUTPUT,
0,
&fmt,
NULL,
info.n_output_formats) < 0)
break;
info.output_formats = realloc (info.output_formats, sizeof (SpaFormat*) * (info.n_output_formats + 1));
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
info.output_formats[info.n_output_formats] = spa_format_copy (fmt);
Use int counters for iterating items Use counters instead of void* to iterate items. This simplifies some things and makes it easier to do over the wire. Add format description to NodeInfo and use this to add format descriptions to pinos devices. Small fixes to fix leaks and crashes.
2017-02-01 08:58:21 +01:00
}
Work on introspection
2016-12-02 13:38:43 +01:00
info.state = this->state;
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
info.error = this->error;
Work on introspection
2016-12-02 13:38:43 +01:00
info.props = this->properties ? &this->properties->dict : NULL;
Use interfaces Add interfaces and events on objects. Use this to communicate with the objects and transparently convert/marshall to network in the protocols.
2017-03-02 16:06:45 +01:00
pinos_node_notify_info (resource, &info);
small cleanups
2017-03-24 16:14:17 +01:00
if (info.input_formats) {
for (i = 0; i < info.n_input_formats; i++)
free (info.input_formats[i]);
free (info.input_formats);
}
if (info.output_formats) {
for (i = 0; i < info.n_output_formats; i++)
free (info.output_formats[i]);
free (info.output_formats);
}
Use interfaces Add interfaces and events on objects. Use this to communicate with the objects and transparently convert/marshall to network in the protocols.
2017-03-02 16:06:45 +01:00
return SPA_RESULT_OK;
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
no_mem:
core: handle client bind errors When a client attempts to bind to an unexisting global, don't error but instead let the client know the object was removed.
2017-03-09 15:52:19 +01:00
pinos_log_error ("can't create node resource");
Use interfaces Add interfaces and events on objects. Use this to communicate with the objects and transparently convert/marshall to network in the protocols.
2017-03-02 16:06:45 +01:00
pinos_core_notify_error (client->core_resource,
client->core_resource->id,
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
SPA_RESULT_NO_MEMORY,
"no memory");
Implement access control Move send and dispatch functions to the implementation. This makes it possible to place an access check before sending and dispatching. Add module-access that allows to bind and notify on globals owned by the client.
2017-01-10 17:12:53 +01:00
return SPA_RESULT_NO_MEMORY;
Work on introspection
2016-12-02 13:38:43 +01:00
}
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
static void
init_complete (PinosNode *this)
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (this, PinosNodeImpl, this);
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
update_port_ids (this);
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("node %p: init completed", this);
WIP change object model
2016-11-14 12:42:00 +01:00
impl->async_init = false;
Move suspend on idle in module Move suspend-on-idle code from the node to a module Add some more SpaLoop API
2016-11-21 12:54:40 +01:00
pinos_node_update_state (this, PINOS_NODE_STATE_SUSPENDED, NULL);
Work on introspection
2016-12-02 13:38:43 +01:00
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
spa_list_insert (this->core->node_list.prev, &this->link);
Work on introspection
2016-12-02 13:38:43 +01:00
this->global = pinos_core_add_global (this->core,
Implement access control Move send and dispatch functions to the implementation. This makes it possible to place an access check before sending and dispatching. Add module-access that allows to bind and notify on globals owned by the client.
2017-01-10 17:12:53 +01:00
NULL,
types: more work on types
2017-03-24 11:40:58 +01:00
this->core->type.node,
Work on introspection
2016-12-02 13:38:43 +01:00
0,
this,
node_bind_func);
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
}
WIP change object model
2016-11-14 12:42:00 +01:00
void
pinos_node_set_data_loop (PinosNode *node,
PinosDataLoop *loop)
add missing files
2016-05-12 17:06:48 +02:00
{
WIP change object model
2016-11-14 12:42:00 +01:00
node->data_loop = loop;
pinos_signal_emit (&node->loop_changed, node);
add missing files
2016-05-12 17:06:48 +02:00
}
WIP Change object model
2016-11-10 15:42:14 +01:00
PinosNode *
pinos_node_new (PinosCore *core,
const char *name,
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
bool async,
WIP Change object model
2016-11-10 15:42:14 +01:00
SpaNode *node,
SpaClock *clock,
PinosProperties *properties)
add missing files
2016-05-12 17:06:48 +02:00
{
WIP Change object model
2016-11-10 15:42:14 +01:00
PinosNodeImpl *impl;
PinosNode *this;
add missing files
2016-05-12 17:06:48 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
impl = calloc (1, sizeof (PinosNodeImpl));
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
if (impl == NULL)
return NULL;
WIP change object model
2016-11-14 12:42:00 +01:00
this = &impl->this;
this->core = core;
WIP Change object model
2016-11-10 15:42:14 +01:00
pinos_log_debug ("node %p: new", this);
Remove SpaQueue, use SpaList instead
2016-11-09 12:57:51 +01:00
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
impl->work = pinos_work_queue_new (this->core->main_loop->loop);
WIP Change object model
2016-11-10 15:42:14 +01:00
this->name = strdup (name);
this->properties = properties;
add missing files
2016-05-12 17:06:48 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
this->node = node;
this->clock = clock;
Rework dbus handling Remove the Daemon object and remove all dbus code from the main objects. We can use the signals in a separate module to create and destroy the DBus interfaces. Move the dbus protocol in a module Move the autolink policy to a module
2016-11-16 16:57:47 +01:00
this->data_loop = core->data_loop;
add missing files
2016-05-12 17:06:48 +02:00
Work on introspection
2016-12-02 13:38:43 +01:00
spa_list_init (&this->resource_list);
WIP change object model
2016-11-14 12:42:00 +01:00
if (spa_node_set_event_callback (this->node, on_node_event, this) < 0)
pinos_log_warn ("node %p: error setting callback", this);
pinos_signal_init (&this->destroy_signal);
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_signal_init (&this->port_added);
pinos_signal_init (&this->port_removed);
pinos_signal_init (&this->state_request);
pinos_signal_init (&this->state_changed);
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
pinos_signal_init (&this->free_signal);
WIP Change object model
2016-11-10 15:42:14 +01:00
pinos_signal_init (&this->async_complete);
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
pinos_signal_init (&this->initialized);
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_init (&this->loop_changed);
add missing files
2016-05-12 17:06:48 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
this->state = PINOS_NODE_STATE_CREATING;
Rework how clients connect. Add buffer flags. The idea is to make it possible to easily check when a buffer contains control information that we need to parse to update the port fields. Make the client create remote nodes and ports and set up proxies for them. Make a port base class implementing most of the logic to pass buffers locally and remotely. Remove most code from stream.c, it's now in the port. Make a portsink and portsrc that can write and read to/from any port. We use these in the server to send and receive data. Rework format negotiation. The final format is now sent in-line before the data. The server will select a format on output ports.
2016-05-17 09:38:30 +02:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
spa_list_init (&this->input_ports);
spa_list_init (&this->output_ports);
Rework how clients connect. Add buffer flags. The idea is to make it possible to easily check when a buffer contains control information that we need to parse to update the port fields. Make the client create remote nodes and ports and set up proxies for them. Make a port base class implementing most of the logic to pass buffers locally and remotely. Remove most code from stream.c, it's now in the port. Make a portsink and portsrc that can write and read to/from any port. We use these in the server to send and receive data. Rework format negotiation. The final format is now sent in-line before the data. The server will select a format on output ports.
2016-05-17 09:38:30 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
if (this->node->info) {
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
uint32_t i;
Rework how clients connect. Add buffer flags. The idea is to make it possible to easily check when a buffer contains control information that we need to parse to update the port fields. Make the client create remote nodes and ports and set up proxies for them. Make a port base class implementing most of the logic to pass buffers locally and remotely. Remove most code from stream.c, it's now in the port. Make a portsink and portsrc that can write and read to/from any port. We use these in the server to send and receive data. Rework format negotiation. The final format is now sent in-line before the data. The server will select a format on output ports.
2016-05-17 09:38:30 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
if (this->properties == NULL)
this->properties = pinos_properties_new (NULL, NULL);
Rework how clients connect. Add buffer flags. The idea is to make it possible to easily check when a buffer contains control information that we need to parse to update the port fields. Make the client create remote nodes and ports and set up proxies for them. Make a port base class implementing most of the logic to pass buffers locally and remotely. Remove most code from stream.c, it's now in the port. Make a portsink and portsrc that can write and read to/from any port. We use these in the server to send and receive data. Rework format negotiation. The final format is now sent in-line before the data. The server will select a format on output ports.
2016-05-17 09:38:30 +02:00
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
if (this->properties)
goto no_mem;
WIP Change object model
2016-11-10 15:42:14 +01:00
for (i = 0; i < this->node->info->n_items; i++)
pinos_properties_set (this->properties,
this->node->info->items[i].key,
this->node->info->items[i].value);
}
Rework how clients connect. Add buffer flags. The idea is to make it possible to easily check when a buffer contains control information that we need to parse to update the port fields. Make the client create remote nodes and ports and set up proxies for them. Make a port base class implementing most of the logic to pass buffers locally and remotely. Remove most code from stream.c, it's now in the port. Make a portsink and portsrc that can write and read to/from any port. We use these in the server to send and receive data. Rework format negotiation. The final format is now sent in-line before the data. The server will select a format on output ports.
2016-05-17 09:38:30 +02:00
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
impl->async_init = async;
if (async) {
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_add (impl->work,
this,
SPA_RESULT_RETURN_ASYNC (0),
(PinosWorkFunc) init_complete,
NULL);
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
} else {
init_complete (this);
WIP Change object model
2016-11-10 15:42:14 +01:00
}
Rework how clients connect. Add buffer flags. The idea is to make it possible to easily check when a buffer contains control information that we need to parse to update the port fields. Make the client create remote nodes and ports and set up proxies for them. Make a port base class implementing most of the logic to pass buffers locally and remotely. Remove most code from stream.c, it's now in the port. Make a portsink and portsrc that can write and read to/from any port. We use these in the server to send and receive data. Rework format negotiation. The final format is now sent in-line before the data. The server will select a format on output ports.
2016-05-17 09:38:30 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
return this;
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
no_mem:
free (this->name);
free (impl);
return NULL;
Rework how clients connect. Add buffer flags. The idea is to make it possible to easily check when a buffer contains control information that we need to parse to update the port fields. Make the client create remote nodes and ports and set up proxies for them. Make a port base class implementing most of the logic to pass buffers locally and remotely. Remove most code from stream.c, it's now in the port. Make a portsink and portsrc that can write and read to/from any port. We use these in the server to send and receive data. Rework format negotiation. The final format is now sent in-line before the data. The server will select a format on output ports.
2016-05-17 09:38:30 +02:00
}
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
static SpaResult
Work on event loop Make a new epoll based event loop and use it for the data tranport. Simplify the spa event api a little and rename to SpaLoop
2016-11-18 17:46:01 +01:00
do_node_remove_done (SpaLoop *loop,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
bool async,
uint32_t seq,
size_t size,
void *data,
void *user_data)
{
PinosNode *this = user_data;
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (this, PinosNodeImpl, this);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
PinosPort *port, *tmp;
Work on async cleanup Track all async changes and only perform free of resources when all previous async operations completed.
2016-11-25 13:06:23 +01:00
pinos_log_debug ("node %p: remove done, destroy ports", this);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
spa_list_for_each_safe (port, tmp, &this->input_ports, link)
pinos_port_destroy (port);
spa_list_for_each_safe (port, tmp, &this->output_ports, link)
pinos_port_destroy (port);
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
pinos_log_debug ("node %p: free", this);
pinos_signal_emit (&this->free_signal, this);
Do cleanup of queues Wait for async state changes to complete
2017-01-12 20:02:58 +01:00
pinos_work_queue_destroy (impl->work);
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
if (this->input_port_map)
free (this->input_port_map);
if (this->output_port_map)
free (this->output_port_map);
free (this->name);
free (this->error);
if (this->properties)
pinos_properties_free (this->properties);
free (impl);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
return SPA_RESULT_OK;
}
static SpaResult
Work on event loop Make a new epoll based event loop and use it for the data tranport. Simplify the spa event api a little and rename to SpaLoop
2016-11-18 17:46:01 +01:00
do_node_remove (SpaLoop *loop,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
bool async,
uint32_t seq,
size_t size,
void *data,
void *user_data)
{
PinosNode *this = user_data;
PinosPort *port, *tmp;
SpaResult res;
pause_node (this);
spa_list_for_each_safe (port, tmp, &this->input_ports, link) {
PinosLink *link, *tlink;
spa_list_for_each_safe (link, tlink, &port->rt.links, rt.input_link) {
spa_list_remove (&link->rt.input_link);
link->rt.input = NULL;
}
}
spa_list_for_each_safe (port, tmp, &this->output_ports, link) {
PinosLink *link, *tlink;
spa_list_for_each_safe (link, tlink, &port->rt.links, rt.output_link) {
spa_list_remove (&link->rt.output_link);
link->rt.output = NULL;
}
}
Mainloop: use PinosLoop Implement the main-loop with pinos_loop except for the parts that still need to go through glib mainloop. Start working on native protocol
2016-11-22 13:06:22 +01:00
res = pinos_loop_invoke (this->core->main_loop->loop,
do_node_remove_done,
seq,
0,
NULL,
this);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
return res;
}
some more rework
2016-07-18 17:40:58 +02:00
/**
WIP change object model
2016-11-14 12:42:00 +01:00
* pinos_node_destroy:
some more rework
2016-07-18 17:40:58 +02:00
* @node: a #PinosNode
*
WIP change object model
2016-11-14 12:42:00 +01:00
* Remove @node. This will stop the transfer on the node and
* free the resources allocated by @node.
some more rework
2016-07-18 17:40:58 +02:00
*/
Work on async cleanup Track all async changes and only perform free of resources when all previous async operations completed.
2016-11-25 13:06:23 +01:00
void
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_node_destroy (PinosNode * this)
some more rework
2016-07-18 17:40:58 +02:00
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (this, PinosNodeImpl, this);
handle cleanup of remote proxies Destroying a resource informs the client to destroy the proxy. Destroying an object destroys all the bound resources on it.
2016-12-02 17:14:32 +01:00
PinosResource *resource, *tmp;
some more rework
2016-07-18 17:40:58 +02:00
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_log_debug ("node %p: destroy", impl);
pinos_signal_emit (&this->destroy_signal, this);
Fix proxy ids The proxy/resource ids are generated by the client and so we need to used them as index in the client resource map instead of making our own number. Fix stream disconnect and client-node destroy Fix gstreamer device provider Make all sockets non-blocking to avoid errors with bad clients Advertise the subsystems we monitor and disable the gstreamer monitors. Implement core properties updates Make sure we send REMOVE_ID after we are done with the resource.
2017-01-20 15:53:03 +01:00
if (!impl->async_init) {
spa_list_remove (&this->link);
pinos_global_destroy (this->global);
}
some more rework
2016-07-18 17:40:58 +02:00
handle cleanup of remote proxies Destroying a resource informs the client to destroy the proxy. Destroying an object destroys all the bound resources on it.
2016-12-02 17:14:32 +01:00
spa_list_for_each_safe (resource, tmp, &this->resource_list, link)
pinos_resource_destroy (resource);
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
pinos_loop_invoke (this->data_loop->loop,
do_node_remove,
Do cleanup of queues Wait for async state changes to complete
2017-01-12 20:02:58 +01:00
1,
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
0,
NULL,
this);
some more rework
2016-07-18 17:40:58 +02:00
}
node: add port_id Decouple the SPA port ids from the pinos port ids, this allows us to more easily link and relink things and do dynamic connection later. Implement multiple output ports on a pinos node.
2016-09-12 18:29:59 +02:00
/**
* pinos_node_get_free_port:
* @node: a #PinosNode
* @direction: a #PinosDirection
*
Use int counters for iterating items Use counters instead of void* to iterate items. This simplifies some things and makes it easier to do over the wire. Add format description to NodeInfo and use this to add format descriptions to pinos devices. Small fixes to fix leaks and crashes.
2017-02-01 08:58:21 +01:00
* Find a new unused port in @node with @direction
node: add port_id Decouple the SPA port ids from the pinos port ids, this allows us to more easily link and relink things and do dynamic connection later. Implement multiple output ports on a pinos node.
2016-09-12 18:29:59 +02:00
*
Use int counters for iterating items Use counters instead of void* to iterate items. This simplifies some things and makes it easier to do over the wire. Add format description to NodeInfo and use this to add format descriptions to pinos devices. Small fixes to fix leaks and crashes.
2017-02-01 08:58:21 +01:00
* Returns: the new port or %NULL on error
node: add port_id Decouple the SPA port ids from the pinos port ids, this allows us to more easily link and relink things and do dynamic connection later. Implement multiple output ports on a pinos node.
2016-09-12 18:29:59 +02:00
*/
Cleanups spa_serialize -> pinos_serialize Improve PinosPort, move links to the object and make it part of PinosNode Work on improving signals to react to changes in the graph Error when a client-node becomes unlinked, like when removing a camera.
2016-10-19 17:18:30 +02:00
PinosPort *
node: add port_id Decouple the SPA port ids from the pinos port ids, this allows us to more easily link and relink things and do dynamic connection later. Implement multiple output ports on a pinos node.
2016-09-12 18:29:59 +02:00
pinos_node_get_free_port (PinosNode *node,
PinosDirection direction)
{
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
uint32_t *n_ports, max_ports;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
SpaList *ports;
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
PinosPort *port = NULL, *p, **portmap;
small fixes
2017-04-08 20:59:38 +02:00
SpaResult res;
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
int i;
node: add port_id Decouple the SPA port ids from the pinos port ids, this allows us to more easily link and relink things and do dynamic connection later. Implement multiple output ports on a pinos node.
2016-09-12 18:29:59 +02:00
if (direction == PINOS_DIRECTION_INPUT) {
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
max_ports = node->max_input_ports;
n_ports = &node->n_input_ports;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
ports = &node->input_ports;
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
portmap = node->input_port_map;
node: add port_id Decouple the SPA port ids from the pinos port ids, this allows us to more easily link and relink things and do dynamic connection later. Implement multiple output ports on a pinos node.
2016-09-12 18:29:59 +02:00
} else {
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
max_ports = node->max_output_ports;
n_ports = &node->n_output_ports;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
ports = &node->output_ports;
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
portmap = node->output_port_map;
node: add port_id Decouple the SPA port ids from the pinos port ids, this allows us to more easily link and relink things and do dynamic connection later. Implement multiple output ports on a pinos node.
2016-09-12 18:29:59 +02:00
}
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
pinos_log_debug ("node %p: direction %d max %u, n %u", node, direction, max_ports, *n_ports);
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
spa_list_for_each (p, ports, link) {
node: check links list in get_free_port() When searching for an unused port, look for an empty links list.
2016-11-11 13:57:46 +01:00
if (spa_list_is_empty (&p->links)) {
Cleanups spa_serialize -> pinos_serialize Improve PinosPort, move links to the object and make it part of PinosNode Work on improving signals to react to changes in the graph Error when a client-node becomes unlinked, like when removing a camera.
2016-10-19 17:18:30 +02:00
port = p;
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
break;
Cleanups spa_serialize -> pinos_serialize Improve PinosPort, move links to the object and make it part of PinosNode Work on improving signals to react to changes in the graph Error when a client-node becomes unlinked, like when removing a camera.
2016-10-19 17:18:30 +02:00
}
node: add port_id Decouple the SPA port ids from the pinos port ids, this allows us to more easily link and relink things and do dynamic connection later. Implement multiple output ports on a pinos node.
2016-09-12 18:29:59 +02:00
}
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
if (port == NULL) {
/* no port, can we create one ? */
if (*n_ports < max_ports) {
for (i = 0; i < max_ports && port == NULL; i++) {
if (portmap[i] == NULL) {
pinos_log_debug ("node %p: creating port direction %d %u", node, direction, i);
port = portmap[i] = pinos_port_new (node, direction, i);
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
spa_list_insert (ports, &port->link);
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
(*n_ports)++;
small fixes
2017-04-08 20:59:38 +02:00
if ((res = spa_node_add_port (node->node, direction, i)) < 0) {
pinos_log_error ("node %p: could not add port %d", node, i);
}
else {
audiomixer: improve mixing Remove PortIO flags, we can use the status Move PortIO to ports Move transport to client-node Improve scheduling
2017-04-12 10:40:17 +02:00
spa_node_port_set_io (node->node, direction, i, &port->io);
small fixes
2017-04-08 20:59:38 +02:00
}
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
}
}
} else {
/* for output we can reuse an existing port */
if (direction == PINOS_DIRECTION_OUTPUT && !spa_list_is_empty (ports)) {
port = spa_list_first (ports, PinosPort, link);
}
}
}
Cleanups spa_serialize -> pinos_serialize Improve PinosPort, move links to the object and make it part of PinosNode Work on improving signals to react to changes in the graph Error when a client-node becomes unlinked, like when removing a camera.
2016-10-19 17:18:30 +02:00
return port;
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
node: add port_id Decouple the SPA port ids from the pinos port ids, this allows us to more easily link and relink things and do dynamic connection later. Implement multiple output ports on a pinos node.
2016-09-12 18:29:59 +02:00
}
Cleanups Remove unused events, drained and marker can be done with ASYNC_COMPLETED messages Handle result of idle callback to disable the poll item Identify poll items with a unique id. Remove set_state vfunc push_event -> send_command, commands are to do something, events are the result of something. Add poll item in v4l2 as soon as we have the fd but disable the item until streaming starts.
2016-10-21 14:57:01 +02:00
static void
Add invoke method to schedule executing in a main loop
2016-10-24 12:20:44 +02:00
on_state_complete (PinosNode *node,
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
void *data,
Add invoke method to schedule executing in a main loop
2016-10-24 12:20:44 +02:00
SpaResult res)
Cleanups Remove unused events, drained and marker can be done with ASYNC_COMPLETED messages Handle result of idle callback to disable the poll item Identify poll items with a unique id. Remove set_state vfunc push_event -> send_command, commands are to do something, events are the result of something. Add poll item in v4l2 as soon as we have the fd but disable the item until streaming starts.
2016-10-21 14:57:01 +02:00
{
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
PinosNodeState state = SPA_PTR_TO_INT (data);
Move suspend on idle in module Move suspend-on-idle code from the node to a module Add some more SpaLoop API
2016-11-21 12:54:40 +01:00
char *error = NULL;
Add invoke method to schedule executing in a main loop
2016-10-24 12:20:44 +02:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
pinos_log_debug ("node %p: state complete %d", node, res);
Add invoke method to schedule executing in a main loop
2016-10-24 12:20:44 +02:00
if (SPA_RESULT_IS_ERROR (res)) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "error changing node state: %d", res);
Move suspend on idle in module Move suspend-on-idle code from the node to a module Add some more SpaLoop API
2016-11-21 12:54:40 +01:00
state = PINOS_NODE_STATE_ERROR;
}
pinos_node_update_state (node, state, error);
Cleanups Remove unused events, drained and marker can be done with ASYNC_COMPLETED messages Handle result of idle callback to disable the poll item Identify poll items with a unique id. Remove set_state vfunc push_event -> send_command, commands are to do something, events are the result of something. Add poll item in v4l2 as soon as we have the fd but disable the item until streaming starts.
2016-10-21 14:57:01 +02:00
}
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
static void
node_activate (PinosNode *this)
{
PinosPort *port;
spa_list_for_each (port, &this->input_ports, link) {
PinosLink *link;
spa_list_for_each (link, &port->links, input_link)
pinos_link_activate (link);
}
spa_list_for_each (port, &this->output_ports, link) {
PinosLink *link;
spa_list_for_each (link, &port->links, output_link)
pinos_link_activate (link);
}
}
add missing files
2016-05-12 17:06:48 +02:00
/**
* pinos_node_set_state:
* @node: a #PinosNode
* @state: a #PinosNodeState
*
* Set the state of @node to @state.
*
Cleanups Remove unused events, drained and marker can be done with ASYNC_COMPLETED messages Handle result of idle callback to disable the poll item Identify poll items with a unique id. Remove set_state vfunc push_event -> send_command, commands are to do something, events are the result of something. Add poll item in v4l2 as soon as we have the fd but disable the item until streaming starts.
2016-10-21 14:57:01 +02:00
* Returns: a #SpaResult
add missing files
2016-05-12 17:06:48 +02:00
*/
Cleanups Remove unused events, drained and marker can be done with ASYNC_COMPLETED messages Handle result of idle callback to disable the poll item Identify poll items with a unique id. Remove set_state vfunc push_event -> send_command, commands are to do something, events are the result of something. Add poll item in v4l2 as soon as we have the fd but disable the item until streaming starts.
2016-10-21 14:57:01 +02:00
SpaResult
add missing files
2016-05-12 17:06:48 +02:00
pinos_node_set_state (PinosNode *node,
PinosNodeState state)
{
Cleanups Remove unused events, drained and marker can be done with ASYNC_COMPLETED messages Handle result of idle callback to disable the poll item Identify poll items with a unique id. Remove set_state vfunc push_event -> send_command, commands are to do something, events are the result of something. Add poll item in v4l2 as soon as we have the fd but disable the item until streaming starts.
2016-10-21 14:57:01 +02:00
SpaResult res = SPA_RESULT_OK;
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (node, PinosNodeImpl, this);
add missing files
2016-05-12 17:06:48 +02:00
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_signal_emit (&node->state_request, node, state);
add missing files
2016-05-12 17:06:48 +02:00
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("node %p: set state %s", node, pinos_node_state_as_string (state));
Cleanups Remove unused events, drained and marker can be done with ASYNC_COMPLETED messages Handle result of idle callback to disable the poll item Identify poll items with a unique id. Remove set_state vfunc push_event -> send_command, commands are to do something, events are the result of something. Add poll item in v4l2 as soon as we have the fd but disable the item until streaming starts.
2016-10-21 14:57:01 +02:00
switch (state) {
case PINOS_NODE_STATE_CREATING:
return SPA_RESULT_ERROR;
case PINOS_NODE_STATE_SUSPENDED:
res = suspend_node (node);
break;
case PINOS_NODE_STATE_IDLE:
res = pause_node (node);
break;
case PINOS_NODE_STATE_RUNNING:
node: remove node state Remove the node state. The state of the node is based on the state of the ports, which can be derived directly from calling the port methods. Track this state in the Port instead. Add a mixer module that puts a mixer in from of audio sinks. This allows multiple clients to play on one sink (still has some bugs). do some fixes in the mixer and the scheduler to make this work.
2017-04-08 20:33:54 +02:00
node_activate (node);
Cleanups Remove unused events, drained and marker can be done with ASYNC_COMPLETED messages Handle result of idle callback to disable the poll item Identify poll items with a unique id. Remove set_state vfunc push_event -> send_command, commands are to do something, events are the result of something. Add poll item in v4l2 as soon as we have the fd but disable the item until streaming starts.
2016-10-21 14:57:01 +02:00
send_clock_update (node);
res = start_node (node);
break;
case PINOS_NODE_STATE_ERROR:
break;
}
if (SPA_RESULT_IS_ERROR (res))
return res;
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_add (impl->work,
node,
res,
(PinosWorkFunc) on_state_complete,
SPA_INT_TO_PTR (state));
add missing files
2016-05-12 17:06:48 +02:00
return res;
}
/**
* pinos_node_update_state:
* @node: a #PinosNode
* @state: a #PinosNodeState
Move suspend on idle in module Move suspend-on-idle code from the node to a module Add some more SpaLoop API
2016-11-21 12:54:40 +01:00
* @error: error when @state is #PINOS_NODE_STATE_ERROR
add missing files
2016-05-12 17:06:48 +02:00
*
* Update the state of a node. This method is used from
* inside @node itself.
*/
void
pinos_node_update_state (PinosNode *node,
Move suspend on idle in module Move suspend-on-idle code from the node to a module Add some more SpaLoop API
2016-11-21 12:54:40 +01:00
PinosNodeState state,
char *error)
add missing files
2016-05-12 17:06:48 +02:00
{
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
PinosNodeState old;
add missing files
2016-05-12 17:06:48 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
old = node->state;
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
if (old != state) {
Work on introspection
2016-12-02 13:38:43 +01:00
PinosNodeInfo info;
PinosResource *resource;
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("node %p: update state from %s -> %s", node,
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
pinos_node_state_as_string (old),
pinos_node_state_as_string (state));
WIP Change object model
2016-11-10 15:42:14 +01:00
Move suspend on idle in module Move suspend-on-idle code from the node to a module Add some more SpaLoop API
2016-11-21 12:54:40 +01:00
if (node->error)
free (node->error);
node->error = error;
WIP Change object model
2016-11-10 15:42:14 +01:00
node->state = state;
Work on introspection
2016-12-02 13:38:43 +01:00
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_signal_emit (&node->state_changed, node, old, state);
Work on introspection
2016-12-02 13:38:43 +01:00
spa_zero (info);
Use int counters for iterating items Use counters instead of void* to iterate items. This simplifies some things and makes it easier to do over the wire. Add format description to NodeInfo and use this to add format descriptions to pinos devices. Small fixes to fix leaks and crashes.
2017-02-01 08:58:21 +01:00
info.change_mask = 1 << 5;
Work on introspection
2016-12-02 13:38:43 +01:00
info.state = node->state;
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
info.error = node->error;
Work on introspection
2016-12-02 13:38:43 +01:00
spa_list_for_each (resource, &node->resource_list, link) {
Use interfaces Add interfaces and events on objects. Use this to communicate with the objects and transparently convert/marshall to network in the protocols.
2017-03-02 16:06:45 +01:00
/* global is only set when there are resources */
Add core introspection Use global ids in info messages to refer to global objects.
2016-12-15 20:09:48 +01:00
info.id = node->global->id;
Use interfaces Add interfaces and events on objects. Use this to communicate with the objects and transparently convert/marshall to network in the protocols.
2017-03-02 16:06:45 +01:00
pinos_node_notify_info (resource, &info);
Work on introspection
2016-12-02 13:38:43 +01:00
}
add missing files
2016-05-12 17:06:48 +02:00
}
}
Reference in a new issue Copy permalink