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

859 lines
24 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"
#include "pinos/client/enumtypes.h"
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"
some more rework
2016-07-18 17:40:58 +02:00
#include "pinos/server/daemon.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/dbus/org-pinos.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
pass the client object around Pass the client object around, it's easier to deal with than the sender id. Fix the ASYNC return check Don't overwrite the fds of a pollitem, instead keep an index of their position in the global fd array.
2016-09-27 16:59:45 +02:00
PinosClient *client;
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNode1 *iface;
add missing files
2016-05-12 17:06:48 +02:00
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
uint32_t seq;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
bool async_init;
Remove direction Direction is tied to the port id. Handle nodes with fixed ports.
2016-08-29 18:31:53 +02:00
add missing files
2016-05-12 17:06:48 +02:00
guint idle_timeout;
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
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
update_port_ids (PinosNode *node, bool create)
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;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
unsigned int n_input_ports, n_output_ports, max_input_ports, max_output_ports;
unsigned int i;
SpaList *ports;
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
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
input_port_ids = g_alloca (sizeof (uint32_t) * n_input_ports);
output_port_ids = g_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);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
node->input_port_map = realloc (node->input_port_map, sizeof (PinosPort *) * max_input_ports);
node->output_port_map = realloc (node->output_port_map, sizeof (PinosPort *) * max_output_ports);
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]);
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)
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_emit (&node->core->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)
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_emit (&node->core->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]);
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)
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_emit (&node->core->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)
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_emit (&node->core->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
}
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
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
node->transport = pinos_transport_new (max_input_ports,
max_output_ports);
node->transport->area->n_inputs = n_input_ports;
node->transport->area->n_outputs = n_output_ports;
for (i = 0; i < max_input_ports; i++)
spa_node_port_set_input (node->node, i, &node->transport->inputs[i]);
for (i = 0; i < max_output_ports; i++)
spa_node_port_set_output (node->node, i, &node->transport->outputs[i]);
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_emit (&node->transport_changed, 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;
Cleanups Make events and command specific to the node Remove some unused code Improve state changes Use easier fixate by just taking the element default value Fix reuse buffer in the proxy
2016-09-06 16:43:37 +02:00
SpaNodeCommand cmd;
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
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: pause 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
Cleanups Make events and command specific to the node Remove some unused code Improve state changes Use easier fixate by just taking the element default value Fix reuse buffer in the proxy
2016-09-06 16:43:37 +02:00
cmd.type = SPA_NODE_COMMAND_PAUSE;
simplify events and commands
2016-10-24 15:30:15 +02:00
cmd.size = sizeof (cmd);
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
if ((res = spa_node_send_command (this->node, &cmd)) < 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);
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;
SpaNodeCommand cmd;
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);
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
cmd.type = SPA_NODE_COMMAND_START;
simplify events and commands
2016-10-24 15:30:15 +02:00
cmd.size = sizeof (cmd);
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
if ((res = spa_node_send_command (this->node, &cmd)) < 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);
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;
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;
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
SpaNodeCommandClockUpdate cu;
SpaResult res;
simplify events and commands
2016-10-24 15:30:15 +02:00
cu.command.type = SPA_NODE_COMMAND_CLOCK_UPDATE;
cu.command.size = sizeof (cu);
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
cu.flags = 0;
cu.change_mask = SPA_NODE_COMMAND_CLOCK_UPDATE_TIME |
SPA_NODE_COMMAND_CLOCK_UPDATE_SCALE |
SPA_NODE_COMMAND_CLOCK_UPDATE_STATE |
SPA_NODE_COMMAND_CLOCK_UPDATE_LATENCY;
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) {
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
cu.flags = SPA_NODE_COMMAND_CLOCK_UPDATE_FLAG_LIVE;
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
res = spa_clock_get_time (this->clock, &cu.rate, &cu.ticks, &cu.monotonic_time);
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
} else {
cu.rate = 1;
cu.ticks = 0;
cu.monotonic_time = 0;
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
cu.scale = (1 << 16) | 1;
cu.state = SPA_CLOCK_STATE_RUNNING;
simplify events and commands
2016-10-24 15:30:15 +02:00
if ((res = spa_node_send_command (this->node, &cu.command)) < 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
}
cleanups: Keep lock while doing recycle_buffer Pass context to main loop Recycle WorkItems in a free list Push and pull from the node data loop Do async start/pause in alsa Add alsa fds right after open.
2016-10-25 11:15:15 +02:00
static SpaResult
do_read_link (SpaPoll *poll,
bool async,
uint32_t seq,
size_t size,
void *data,
void *user_data)
Cleanups Make events and command specific to the node Remove some unused code Improve state changes Use easier fixate by just taking the element default value Fix reuse buffer in the proxy
2016-09-06 16:43:37 +02:00
{
cleanups: Keep lock while doing recycle_buffer Pass context to main loop Recycle WorkItems in a free list Push and pull from the node data loop Do async start/pause in alsa Add alsa fds right after open.
2016-10-25 11:15:15 +02:00
PinosNode *this = user_data;
PinosLink *link = ((PinosLink**)data)[0];
size_t offset;
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
SpaResult res;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
if (link->rt.input == NULL)
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
return SPA_RESULT_OK;
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 object model change Work on cleanup
2016-11-15 13:29:58 +01:00
while (link->rt.in_ready > 0 && spa_ringbuffer_get_read_offset (&link->ringbuffer, &offset) > 0) {
SpaPortInput *input = &this->transport->inputs[link->rt.input->port_id];
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
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
input->buffer_id = link->queue[offset];
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 object model change Work on cleanup
2016-11-15 13:29:58 +01:00
if ((res = spa_node_process_input (link->rt.input->node->node)) < 0)
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
pinos_log_warn ("node %p: error pushing buffer: %d, %d", this, res, input->status);
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
spa_ringbuffer_read_advance (&link->ringbuffer, 1);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
link->rt.in_ready--;
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
}
cleanups: Keep lock while doing recycle_buffer Pass context to main loop Recycle WorkItems in a free list Push and pull from the node data loop Do async start/pause in alsa Add alsa fds right after open.
2016-10-25 11:15:15 +02:00
return SPA_RESULT_OK;
Cleanups Make events and command specific to the node Remove some unused code Improve state changes Use easier fixate by just taking the element default value Fix reuse buffer in the proxy
2016-09-06 16:43:37 +02:00
}
cleanups: Keep lock while doing recycle_buffer Pass context to main loop Recycle WorkItems in a free list Push and pull from the node data loop Do async start/pause in alsa Add alsa fds right after open.
2016-10-25 11:15:15 +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
static void
Cleanups Make events and command specific to the node Remove some unused code Improve state changes Use easier fixate by just taking the element default value Fix reuse buffer in the proxy
2016-09-06 16:43:37 +02:00
on_node_event (SpaNode *node, SpaNodeEvent *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;
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
switch (event->type) {
Add support for async results Add an async result code and an event to signal the completion. Use async return values to signal completion of a method and potential state change. Add selected format to port update message. Make it possible to parse into a custom copy of the command memory. Remove state change events from the elements, we now just update the state. Implement async results in the proxy element Add support for removing buffers in the client. Fix up pinossink Deal with async return in the links.
2016-09-22 08:55:30 +02:00
case SPA_NODE_EVENT_TYPE_INVALID:
case SPA_NODE_EVENT_TYPE_ERROR:
case SPA_NODE_EVENT_TYPE_BUFFERING:
case SPA_NODE_EVENT_TYPE_REQUEST_REFRESH:
break;
case SPA_NODE_EVENT_TYPE_ASYNC_COMPLETE:
{
simplify events and commands
2016-10-24 15:30:15 +02:00
SpaNodeEventAsyncComplete *ac = (SpaNodeEventAsyncComplete *) event;
Remove direction Direction is tied to the port id. Handle nodes with fixed ports.
2016-08-29 18:31:53 +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: async complete event %d %d", this, ac->seq, ac->res);
WIP change object model
2016-11-14 12:42:00 +01:00
if (!pinos_main_loop_defer_complete (this->core->main_loop, this, ac->seq, ac->res)) {
pinos_signal_emit (&this->async_complete, this, ac->seq, ac->res);
WIP Change object model
2016-11-10 15:42:14 +01: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
break;
}
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
Add suport for clocks Add a clock interface to get raw clocking information from an element Make events and commands to request and configure clock updates. Add support for passing events and commands in control Set the size of the buffers in pinossrc
2016-09-09 16:05:58 +02:00
case SPA_NODE_EVENT_TYPE_NEED_INPUT:
{
simplify events and commands
2016-10-24 15:30:15 +02:00
SpaNodeEventNeedInput *ni = (SpaNodeEventNeedInput *) event;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
PinosPort *port = this->input_port_map[ni->port_id];
PinosLink *link;
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 object model change Work on cleanup
2016-11-15 13:29:58 +01:00
spa_list_for_each (link, &port->rt.links, rt.input_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;
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 object model change Work on cleanup
2016-11-15 13:29:58 +01:00
link->rt.in_ready++;
spa_poll_invoke (&link->rt.input->node->data_loop->poll,
cleanups: Keep lock while doing recycle_buffer Pass context to main loop Recycle WorkItems in a free list Push and pull from the node data loop Do async start/pause in alsa Add alsa fds right after open.
2016-10-25 11:15:15 +02:00
do_read_link,
SPA_ID_INVALID,
sizeof (PinosLink *),
&link,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
link->rt.input->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
}
Add suport for clocks Add a clock interface to get raw clocking information from an element Make events and commands to request and configure clock updates. Add support for passing events and commands in control Set the size of the buffers in pinossrc
2016-09-09 16:05:58 +02:00
break;
}
Cleanups Make events and command specific to the node Remove some unused code Improve state changes Use easier fixate by just taking the element default value Fix reuse buffer in the proxy
2016-09-06 16:43:37 +02:00
case SPA_NODE_EVENT_TYPE_HAVE_OUTPUT:
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
{
simplify events and commands
2016-10-24 15:30:15 +02:00
SpaNodeEventHaveOutput *ho = (SpaNodeEventHaveOutput *) event;
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;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
bool pushed = false;
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
SpaPortOutput *po = &this->transport->outputs[ho->port_id];
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
PinosPort *port = this->output_port_map[ho->port_id];
PinosLink *link;
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
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
if ((res = spa_node_process_output (node)) < 0) {
pinos_log_warn ("node %p: got pull error %d, %d", this, res, po->status);
Cleanups Make events and command specific to the node Remove some unused code Improve state changes Use easier fixate by just taking the element default value Fix reuse buffer in the proxy
2016-09-06 16:43:37 +02:00
break;
}
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 (link, &port->rt.links, rt.output_link) {
cleanups: Keep lock while doing recycle_buffer Pass context to main loop Recycle WorkItems in a free list Push and pull from the node data loop Do async start/pause in alsa Add alsa fds right after open.
2016-10-25 11:15:15 +02:00
size_t offset;
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
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;
cleanups: Keep lock while doing recycle_buffer Pass context to main loop Recycle WorkItems in a free list Push and pull from the node data loop Do async start/pause in alsa Add alsa fds right after open.
2016-10-25 11:15:15 +02:00
if (spa_ringbuffer_get_write_offset (&link->ringbuffer, &offset) > 0) {
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
link->queue[offset] = po->buffer_id;
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
spa_ringbuffer_write_advance (&link->ringbuffer, 1);
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
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
spa_poll_invoke (&link->rt.input->node->data_loop->poll,
cleanups: Keep lock while doing recycle_buffer Pass context to main loop Recycle WorkItems in a free list Push and pull from the node data loop Do async start/pause in alsa Add alsa fds right after open.
2016-10-25 11:15:15 +02:00
do_read_link,
SPA_ID_INVALID,
sizeof (PinosLink *),
&link,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
link->rt.input->node);
pushed = true;
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 (!pushed) {
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
if ((res = spa_node_port_reuse_buffer (node, ho->port_id, po->buffer_id)) < 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 ("node %p: error reuse buffer: %d", 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
}
break;
}
Cleanups Make events and command specific to the node Remove some unused code Improve state changes Use easier fixate by just taking the element default value Fix reuse buffer in the proxy
2016-09-06 16:43:37 +02:00
case SPA_NODE_EVENT_TYPE_REUSE_BUFFER:
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;
simplify events and commands
2016-10-24 15:30:15 +02:00
SpaNodeEventReuseBuffer *rb = (SpaNodeEventReuseBuffer *) event;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
PinosPort *port = this->input_port_map[rb->port_id];
PinosLink *link;
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
spa_list_for_each (link, &port->rt.links, rt.input_link) {
if (link->rt.input == NULL || link->rt.output == NULL)
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
continue;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
if ((res = spa_node_port_reuse_buffer (link->rt.output->node->node,
link->rt.output->port_id,
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
rb->buffer_id)) < 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 ("node %p: error reuse buffer: %d", 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
}
break;
}
Add suport for clocks Add a clock interface to get raw clocking information from an element Make events and commands to request and configure clock updates. Add support for passing events and commands in control Set the size of the buffers in pinossrc
2016-09-09 16:05:58 +02:00
case SPA_NODE_EVENT_TYPE_REQUEST_CLOCK_UPDATE:
add clock Add a gstreamer pinos clock that reports the time at the server
2016-09-12 12:28:51 +02:00
send_clock_update (this);
Add suport for clocks Add a clock interface to get raw clocking information from an element Make events and commands to request and configure clock updates. Add support for passing events and commands in control Set the size of the buffers in pinossrc
2016-09-09 16:05:58 +02:00
break;
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
}
}
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
static bool
some more rework
2016-07-18 17:40:58 +02:00
handle_remove (PinosNode1 *interface,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
rt-poll: make small poll helper object Remove the event loop code into a separate object so that we can share the same loop for multiple nodes. Some cleanups
2016-09-26 17:27:04 +02:00
PinosNode *this = user_data;
some more rework
2016-07-18 17:40:58 +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: remove", this);
some more rework
2016-07-18 17:40:58 +02:00
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("()"));
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
return true;
some more rework
2016-07-18 17:40:58 +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)
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (this, PinosNodeImpl, this);
PinosProperties *props = this->properties;
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
update_port_ids (this, false);
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;
if (impl->client)
pinos_node1_set_owner (impl->iface, this->global->object_path);
else
pinos_node1_set_owner (impl->iface, "/");
pinos_node1_set_name (impl->iface, this->name);
pinos_node1_set_properties (impl->iface, props ? pinos_properties_to_variant (props) : NULL);
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_update_state (this, PINOS_NODE_STATE_SUSPENDED);
}
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,
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;
WIP change object model
2016-11-14 12:42:00 +01:00
PinosObjectSkeleton *skel;
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));
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
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;
add missing files
2016-05-12 17:06:48 +02:00
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);
WIP Change object model
2016-11-10 15:42:14 +01:00
pinos_signal_init (&this->async_complete);
pinos_signal_init (&this->transport_changed);
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
impl->iface = pinos_node1_skeleton_new ();
g_signal_connect (impl->iface, "handle-remove",
some more rework
2016-07-18 17:40:58 +02:00
(GCallback) handle_remove,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this);
some more rework
2016-07-18 17:40:58 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
this->state = PINOS_NODE_STATE_CREATING;
pinos_node1_set_state (impl->iface, this->state);
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) {
unsigned int 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
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
WIP Change object model
2016-11-10 15:42:14 +01:00
if (this->node->state > SPA_NODE_STATE_INIT) {
init_complete (this);
} else {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
impl->async_init = true;
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_main_loop_defer (this->core->main_loop,
WIP Change object model
2016-11-10 15:42:14 +01:00
this,
SPA_RESULT_RETURN_ASYNC (0),
(PinosDeferFunc) init_complete,
NULL);
}
cleanups Remove hastables, use lists Remove obsolete ringbuffer some small cleanups
2016-11-15 20:12:31 +01:00
spa_list_insert (core->node_list.prev, &this->link);
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-14 12:42:00 +01:00
skel = pinos_object_skeleton_new (PINOS_DBUS_OBJECT_NODE);
pinos_object_skeleton_set_node1 (skel, impl->iface);
this->global = pinos_core_add_global (core,
core->registry.uri.node,
this,
skel);
WIP Change object model
2016-11-10 15:42:14 +01:00
return this;
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
do_node_remove_done (SpaPoll *poll,
bool async,
uint32_t seq,
size_t size,
void *data,
void *user_data)
{
PinosNode *this = user_data;
PinosNodeImpl *impl = SPA_CONTAINER_OF (this, PinosNodeImpl, this);
PinosPort *port, *tmp;
pinos_main_loop_defer_cancel (this->core->main_loop, this, 0);
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);
g_clear_object (&impl->iface);
free (this->name);
free (this->error);
if (this->properties)
pinos_properties_free (this->properties);
free (impl);
return SPA_RESULT_OK;
}
static SpaResult
do_node_remove (SpaPoll *poll,
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;
}
}
res = spa_poll_invoke (this->core->main_loop->poll,
do_node_remove_done,
seq,
0,
NULL,
this);
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
*/
track client resources
2016-11-15 17:06:09 +01:00
SpaResult
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
{
track client resources
2016-11-15 17:06:09 +01:00
SpaResult res;
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (this, PinosNodeImpl, this);
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);
cleanups Remove hastables, use lists Remove obsolete ringbuffer some small cleanups
2016-11-15 20:12:31 +01:00
spa_list_remove (&this->link);
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_core_remove_global (this->core, this->global);
some more rework
2016-07-18 17:40:58 +02:00
track client resources
2016-11-15 17:06:09 +01:00
res = spa_poll_invoke (&this->data_loop->poll,
do_node_remove,
impl->seq++,
0,
NULL,
this);
return res;
some more rework
2016-07-18 17:40:58 +02:00
}
/**
pass the client object around Pass the client object around, it's easier to deal with than the sender id. Fix the ASYNC return check Don't overwrite the fds of a pollitem, instead keep an index of their position in the global fd array.
2016-09-27 16:59:45 +02:00
* pinos_node_get_client:
some more rework
2016-07-18 17:40:58 +02:00
* @node: a #PinosNode
*
pass the client object around Pass the client object around, it's easier to deal with than the sender id. Fix the ASYNC return check Don't overwrite the fds of a pollitem, instead keep an index of their position in the global fd array.
2016-09-27 16:59:45 +02:00
* Get the owner client of @node.
some more rework
2016-07-18 17:40:58 +02:00
*
pass the client object around Pass the client object around, it's easier to deal with than the sender id. Fix the ASYNC return check Don't overwrite the fds of a pollitem, instead keep an index of their position in the global fd array.
2016-09-27 16:59:45 +02:00
* Returns: the owner client of @node.
some more rework
2016-07-18 17:40:58 +02:00
*/
pass the client object around Pass the client object around, it's easier to deal with than the sender id. Fix the ASYNC return check Don't overwrite the fds of a pollitem, instead keep an index of their position in the global fd array.
2016-09-27 16:59:45 +02:00
PinosClient *
pinos_node_get_client (PinosNode *node)
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 (node, PinosNodeImpl, this);
WIP Change object model
2016-11-10 15:42:14 +01:00
return impl->client;
some more rework
2016-07-18 17:40:58 +02:00
}
add missing files
2016-05-12 17:06:48 +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
*
* Find a new unused port id in @node with @direction
*
* Returns: the new port id or %SPA_ID_INVALID on error
*/
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)
{
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
unsigned int free_port, n_ports, max_ports;
SpaList *ports;
PinosPort *port = NULL, *p;
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 Change object model
2016-11-10 15:42:14 +01:00
g_return_val_if_fail (node, NULL);
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) {
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
max_ports = node->transport->area->max_inputs;
n_ports = node->transport->area->n_inputs;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
ports = &node->input_ports;
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 {
Optimize transport some more We can optimize the transport some more if we allow the host to configure the area used for transfering buffers. We can then also place the current status in the area and avoid calling get_status(). We can also allocate this area in shared memory, avoiding a memcpy in the client-node.
2016-11-07 18:23:09 +01:00
max_ports = node->transport->area->max_outputs;
n_ports = node->transport->area->n_outputs;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
ports = &node->output_ports;
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
}
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
free_port = 0;
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
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: direction %d max %u, n %u, free_port %u", node, direction, max_ports, n_ports, free_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
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
spa_list_for_each (p, ports, link) {
if (free_port < p->port_id) {
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
}
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
free_port = p->port_id + 1;
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
if (free_port >= max_ports && !spa_list_is_empty (ports)) {
port = spa_list_first (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
} else
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 NULL;
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
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
}
add missing files
2016-05-12 17:06:48 +02:00
static void
remove_idle_timeout (PinosNode *node)
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (node, PinosNodeImpl, this);
add missing files
2016-05-12 17:06:48 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
if (impl->idle_timeout) {
g_source_remove (impl->idle_timeout);
impl->idle_timeout = 0;
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
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,
gpointer data,
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
{
Add invoke method to schedule executing in a main loop
2016-10-24 12:20:44 +02:00
PinosNodeState state = GPOINTER_TO_INT (data);
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
char *error;
asprintf (&error, "error changing node state: %d", res);
Add invoke method to schedule executing in a main loop
2016-10-24 12:20:44 +02:00
pinos_node_report_error (node, error);
} else
pinos_node_update_state (node, 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
}
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;
add missing files
2016-05-12 17:06:48 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
g_return_val_if_fail (node, SPA_RESULT_INVALID_ARGUMENTS);
add missing files
2016-05-12 17:06:48 +02:00
remove_idle_timeout (node);
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_INITIALIZING:
break;
case PINOS_NODE_STATE_IDLE:
res = pause_node (node);
break;
case PINOS_NODE_STATE_RUNNING:
send_clock_update (node);
res = start_node (node);
break;
case PINOS_NODE_STATE_ERROR:
break;
}
if (SPA_RESULT_IS_ERROR (res))
return res;
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_main_loop_defer (node->core->main_loop,
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,
res,
(PinosDeferFunc) on_state_complete,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
GINT_TO_POINTER (state));
add missing files
2016-05-12 17:06:48 +02:00
return res;
}
/**
* pinos_node_update_state:
* @node: a #PinosNode
* @state: a #PinosNodeState
*
* Update the state of a node. This method is used from
* inside @node itself.
*/
void
pinos_node_update_state (PinosNode *node,
PinosNodeState state)
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (node, 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
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
g_return_if_fail (node);
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) {
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
node->state = state;
pinos_node1_set_state (impl->iface, state);
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_emit (&node->core->node_state_changed, node, old, state);
add missing files
2016-05-12 17:06:48 +02:00
}
}
/**
* pinos_node_report_error:
* @node: a #PinosNode
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
* @error: an error message
add missing files
2016-05-12 17:06:48 +02:00
*
* Report an error from within @node.
*/
void
pinos_node_report_error (PinosNode *node,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
char *error)
add missing files
2016-05-12 17:06:48 +02:00
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (node, PinosNodeImpl, this);
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
g_return_if_fail (node);
add missing files
2016-05-12 17:06:48 +02:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
free (node->error);
add missing files
2016-05-12 17:06:48 +02:00
remove_idle_timeout (node);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
node->error = error;
WIP change object model
2016-11-14 12:42:00 +01:00
old = node->state;
node->state = PINOS_NODE_STATE_ERROR;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
pinos_log_debug ("node %p: got error state %s", node, error);
WIP Change object model
2016-11-10 15:42:14 +01:00
pinos_node1_set_state (impl->iface, PINOS_NODE_STATE_ERROR);
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_emit (&node->core->node_state_changed, node, old, node->state);
add missing files
2016-05-12 17:06:48 +02:00
}
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
static bool
add missing files
2016-05-12 17:06:48 +02:00
idle_timeout (PinosNode *node)
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (node, PinosNodeImpl, 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->idle_timeout = 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 ("node %p: idle timeout", node);
add missing files
2016-05-12 17:06:48 +02:00
pinos_node_set_state (node, PINOS_NODE_STATE_SUSPENDED);
return G_SOURCE_REMOVE;
}
/**
* pinos_node_report_idle:
* @node: a #PinosNode
*
* Mark @node as being idle. This will start a timeout that will
* set the node to SUSPENDED.
*/
void
pinos_node_report_idle (PinosNode *node)
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNodeImpl *impl = SPA_CONTAINER_OF (node, PinosNodeImpl, this);
add missing files
2016-05-12 17:06:48 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
g_return_if_fail (node);
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: report idle", node);
add missing files
2016-05-12 17:06:48 +02:00
pinos_node_set_state (node, PINOS_NODE_STATE_IDLE);
WIP Change object model
2016-11-10 15:42:14 +01:00
impl->idle_timeout = g_timeout_add_seconds (3,
add missing files
2016-05-12 17:06:48 +02:00
(GSourceFunc) idle_timeout,
node);
}
/**
* pinos_node_report_busy:
* @node: a #PinosNode
*
* Mark @node as being busy. This will set the state of the node
* to the RUNNING state.
*/
void
pinos_node_report_busy (PinosNode *node)
{
WIP Change object model
2016-11-10 15:42:14 +01:00
g_return_if_fail (node);
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: report busy", node);
add missing files
2016-05-12 17:06:48 +02:00
pinos_node_set_state (node, PINOS_NODE_STATE_RUNNING);
}
Reference in a new issue Copy permalink