mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-03 09:01:54 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/pinos/server/link.c

924 lines
31 KiB
C
Raw Normal View History

work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +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.
*/
#include <string.h>
#include <gio/gio.h>
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
#include <spa/include/spa/video/format.h>
remove hardcoded negotiation Remove the hardcoded negotiation and replace by filtering accepted and possible formats. Not quite correct yet because v4l2 doesn't actually do filtering yet.
2016-08-09 15:53:12 +02:00
#include <spa/include/spa/debug.h>
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
#include "pinos/client/pinos.h"
#include "pinos/client/enumtypes.h"
#include "pinos/server/link.h"
#include "pinos/dbus/org-pinos.h"
#define PINOS_LINK_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), PINOS_TYPE_LINK, PinosLinkPrivate))
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
#define MAX_BUFFERS 16
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
struct _PinosLinkPrivate
{
PinosDaemon *daemon;
PinosLink1 *iface;
gchar *object_path;
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
GPtrArray *format_filter;
PinosProperties *properties;
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
PinosLinkState state;
GError *error;
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
uint32_t async_busy;
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
SpaBuffer *in_buffers[MAX_BUFFERS];
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
unsigned int n_in_buffers;
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
SpaBuffer *out_buffers[MAX_BUFFERS];
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
unsigned int n_out_buffers;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
};
G_DEFINE_TYPE (PinosLink, pinos_link, G_TYPE_OBJECT);
enum
{
PROP_0,
PROP_DAEMON,
PROP_OBJECT_PATH,
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
PROP_OUTPUT_NODE,
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
PROP_OUTPUT_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
PROP_OUTPUT_PORT,
PROP_INPUT_NODE,
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
PROP_INPUT_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
PROP_INPUT_PORT,
PROP_FORMAT_FILTER,
PROP_PROPERTIES,
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
PROP_STATE,
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
};
enum
{
SIGNAL_REMOVE,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
static void
pinos_link_get_property (GObject *_object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
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
PinosLink *this = PINOS_LINK (_object);
PinosLinkPrivate *priv = this->priv;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
switch (prop_id) {
case PROP_DAEMON:
g_value_set_object (value, priv->daemon);
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
case PROP_OBJECT_PATH:
g_value_set_string (value, priv->object_path);
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
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
case PROP_OUTPUT_NODE:
g_value_set_object (value, this->output_node);
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
break;
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
case PROP_OUTPUT_ID:
g_value_set_uint (value, this->output_id);
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
case PROP_OUTPUT_PORT:
g_value_set_uint (value, this->output_port);
break;
case PROP_INPUT_NODE:
g_value_set_object (value, this->input_node);
break;
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
case PROP_INPUT_ID:
g_value_set_uint (value, this->input_id);
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
case PROP_INPUT_PORT:
g_value_set_uint (value, this->input_port);
break;
case PROP_FORMAT_FILTER:
g_value_set_boxed (value, priv->format_filter);
break;
case PROP_PROPERTIES:
g_value_set_boxed (value, priv->properties);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
break;
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
case PROP_STATE:
g_value_set_enum (value, priv->state);
break;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
default:
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
G_OBJECT_WARN_INVALID_PROPERTY_ID (this, prop_id, pspec);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
break;
}
}
static void
pinos_link_set_property (GObject *_object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
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
PinosLink *this = PINOS_LINK (_object);
PinosLinkPrivate *priv = this->priv;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
switch (prop_id) {
case PROP_DAEMON:
priv->daemon = g_value_dup_object (value);
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
case PROP_OBJECT_PATH:
priv->object_path = g_value_dup_string (value);
break;
case PROP_OUTPUT_NODE:
this->output_node = g_value_dup_object (value);
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
break;
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
case PROP_OUTPUT_ID:
this->output_id = g_value_get_uint (value);
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
case PROP_OUTPUT_PORT:
this->output_port = g_value_get_uint (value);
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
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
case PROP_INPUT_NODE:
this->input_node = g_value_dup_object (value);
break;
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
case PROP_INPUT_ID:
this->input_id = g_value_get_uint (value);
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
case PROP_INPUT_PORT:
this->input_port = g_value_get_uint (value);
break;
case PROP_FORMAT_FILTER:
priv->format_filter = g_value_dup_boxed (value);
break;
case PROP_PROPERTIES:
priv->properties = g_value_dup_boxed (value);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
break;
default:
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
G_OBJECT_WARN_INVALID_PROPERTY_ID (this, prop_id, pspec);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
break;
}
}
static void
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
link_register_object (PinosLink *this)
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +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
PinosLinkPrivate *priv = this->priv;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
PinosObjectSkeleton *skel;
gchar *name;
name = g_strdup_printf (PINOS_DBUS_OBJECT_LINK);
skel = pinos_object_skeleton_new (name);
g_free (name);
pinos_object_skeleton_set_link1 (skel, priv->iface);
g_free (priv->object_path);
priv->object_path = pinos_daemon_export_uniquely (priv->daemon, G_DBUS_OBJECT_SKELETON (skel));
g_object_unref (skel);
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
g_debug ("link %p: register object %s", this, priv->object_path);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
}
static void
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
link_unregister_object (PinosLink *this)
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +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
PinosLinkPrivate *priv = this->priv;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +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
g_debug ("link %p: unregister object", this);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
pinos_daemon_unexport (priv->daemon, priv->object_path);
}
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
static void
pinos_link_update_state (PinosLink *link, PinosLinkState state)
{
PinosLinkPrivate *priv = link->priv;
if (state != priv->state) {
g_clear_error (&priv->error);
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
g_debug ("link %p: update state %s -> %s", link,
pinos_link_state_as_string (priv->state),
pinos_link_state_as_string (state));
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
priv->state = state;
g_object_notify (G_OBJECT (link), "state");
}
}
static void
pinos_link_report_error (PinosLink *link, GError *error)
{
PinosLinkPrivate *priv = link->priv;
g_clear_error (&priv->error);
priv->error = error;
priv->state = PINOS_LINK_STATE_ERROR;
g_debug ("link %p: got error state %s", link, error->message);
g_object_notify (G_OBJECT (link), "state");
}
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
static SpaResult
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
do_negotiate (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
{
SpaResult res;
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
SpaFormat *filter = NULL, *format;
remove hardcoded negotiation Remove the hardcoded negotiation and replace by filtering accepted and possible formats. Not quite correct yet because v4l2 doesn't actually do filtering yet.
2016-08-09 15:53:12 +02:00
void *istate = NULL, *ostate = NULL;
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
GError *error = NULL;
if (in_state != SPA_NODE_STATE_CONFIGURE && out_state != SPA_NODE_STATE_CONFIGURE)
return SPA_RESULT_OK;
pinos_link_update_state (this, PINOS_LINK_STATE_NEGOTIATING);
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +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
/* both ports need a format */
if (in_state == SPA_NODE_STATE_CONFIGURE && out_state == SPA_NODE_STATE_CONFIGURE) {
g_debug ("link %p: doing negotiate format", this);
remove hardcoded negotiation Remove the hardcoded negotiation and replace by filtering accepted and possible formats. Not quite correct yet because v4l2 doesn't actually do filtering yet.
2016-08-09 15:53:12 +02:00
again:
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
if ((res = spa_node_port_enum_formats (this->input_node->node,
this->input_port,
&filter,
NULL,
&istate)) < 0) {
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
if (res == SPA_RESULT_ENUM_END && istate != NULL) {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_FORMAT_NEGOTIATION,
"error input enum formats: %d", res);
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
goto error;
}
remove hardcoded negotiation Remove the hardcoded negotiation and replace by filtering accepted and possible formats. Not quite correct yet because v4l2 doesn't actually do filtering yet.
2016-08-09 15:53:12 +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
g_debug ("Try filter:");
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
spa_debug_format (filter);
if ((res = spa_node_port_enum_formats (this->output_node->node,
this->output_port,
&format,
filter,
&ostate)) < 0) {
if (res == SPA_RESULT_ENUM_END) {
ostate = NULL;
goto again;
}
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_FORMAT_NEGOTIATION,
"error output enum formats: %d", 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
goto error;
}
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
g_debug ("Got filtered:");
v4l2: implement enum_formats with filter Use the filter to query the device and return a filtered result.
2016-09-07 13:43:14 +02:00
spa_debug_format (format);
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
spa_format_fixate (format);
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
} else if (in_state == SPA_NODE_STATE_CONFIGURE && out_state > SPA_NODE_STATE_CONFIGURE) {
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
/* only input needs format */
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
if ((res = spa_node_port_get_format (this->output_node->node,
this->output_port,
(const SpaFormat **)&format)) < 0) {
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_FORMAT_NEGOTIATION,
"error get output format: %d", 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
goto error;
}
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
} else if (out_state == SPA_NODE_STATE_CONFIGURE && in_state > SPA_NODE_STATE_CONFIGURE) {
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
/* only output needs format */
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
if ((res = spa_node_port_get_format (this->input_node->node,
this->input_port,
(const SpaFormat **)&format)) < 0) {
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_FORMAT_NEGOTIATION,
"error get input format: %d", 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
goto error;
}
} else
return SPA_RESULT_OK;
Cleanups Remove old code Only depend on GStreamer for the plugins Rename STOP to PAUSE because that's what it really does Start working on format_fixate. Remove default property value from props Fix framerate
2016-08-25 14:10:38 +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
g_debug ("link %p: doing set format", this);
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
spa_debug_format (format);
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
if (out_state == SPA_NODE_STATE_CONFIGURE) {
improve state change
2016-09-12 15:25:53 +02:00
g_debug ("link %p: doing set format on output", this);
Cleanups
2016-09-20 11:20:43 +02:00
if ((res = spa_node_port_set_format (this->output_node->node,
this->output_port,
SPA_PORT_FORMAT_FLAG_NEAREST,
format)) < 0) {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_FORMAT_NEGOTIATION,
"error set output format: %d", 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
goto error;
}
improve state change
2016-09-12 15:25:53 +02:00
} else if (in_state == SPA_NODE_STATE_CONFIGURE) {
g_debug ("link %p: doing set format on input", this);
Cleanups
2016-09-20 11:20:43 +02:00
if ((res = spa_node_port_set_format (this->input_node->node,
this->input_port,
SPA_PORT_FORMAT_FLAG_NEAREST,
format)) < 0) {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_FORMAT_NEGOTIATION,
"error set input format: %d", 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
goto error;
}
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
}
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
return res;
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
error:
{
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
pinos_link_report_error (this, error);
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
return res;
}
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
}
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
static void *
find_param (const SpaPortInfo *info, SpaAllocParamType type)
{
unsigned int i;
for (i = 0; i < info->n_params; i++) {
if (info->params[i]->type == type)
return info->params[i];
}
return NULL;
}
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
static SpaResult
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
do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
{
PinosLinkPrivate *priv = this->priv;
SpaResult res;
handle set_format with existing format If one calls set-format with the current format, we return success Remove some unused utils now Work on cleanup of buffers
2016-08-11 11:20:12 +02:00
const SpaPortInfo *iinfo, *oinfo;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
SpaPortInfoFlags in_flags, out_flags;
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
GError *error = NULL;
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
unsigned int max_buffers = MAX_BUFFERS;
SpaAllocParamBuffers *in_alloc, *out_alloc;
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
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 (in_state != SPA_NODE_STATE_READY && out_state != SPA_NODE_STATE_READY)
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
return SPA_RESULT_OK;
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
pinos_link_update_state (this, PINOS_LINK_STATE_ALLOCATING);
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
g_debug ("link %p: doing alloc buffers %p %p", this, this->output_node, this->input_node);
handle set_format with existing format If one calls set-format with the current format, we return success Remove some unused utils now Work on cleanup of buffers
2016-08-11 11:20:12 +02:00
/* find out what's possible */
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_port_get_info (this->output_node->node, this->output_port, &oinfo)) < 0) {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error get output port info: %d", res);
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
goto error;
handle set_format with existing format If one calls set-format with the current format, we return success Remove some unused utils now Work on cleanup of buffers
2016-08-11 11:20:12 +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
if ((res = spa_node_port_get_info (this->input_node->node, this->input_port, &iinfo)) < 0) {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error get input port info: %d", res);
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
goto error;
handle set_format with existing format If one calls set-format with the current format, we return success Remove some unused utils now Work on cleanup of buffers
2016-08-11 11:20:12 +02:00
}
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
in_flags = iinfo->flags;
out_flags = oinfo->flags;
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
max_buffers = MAX_BUFFERS;
in_alloc = find_param (iinfo, SPA_ALLOC_PARAM_TYPE_BUFFERS);
if (in_alloc)
max_buffers = in_alloc->max_buffers == 0 ? max_buffers : SPA_MIN (in_alloc->max_buffers, max_buffers);
out_alloc = find_param (oinfo, SPA_ALLOC_PARAM_TYPE_BUFFERS);
if (out_alloc)
max_buffers = out_alloc->max_buffers == 0 ? max_buffers : SPA_MIN (out_alloc->max_buffers, max_buffers);
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 (out_flags & SPA_PORT_INFO_FLAG_LIVE) {
this->output_node->live = true;
this->input_node->live = true;
}
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 (in_state == SPA_NODE_STATE_READY && out_state == SPA_NODE_STATE_READY) {
if ((out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) &&
(in_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS)) {
out_flags = SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
in_flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
} else if ((out_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS) &&
(in_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS)) {
out_flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
in_flags = SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
} else if ((out_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS) &&
(in_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS)) {
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
priv->n_in_buffers = max_buffers;
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
out_flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
in_flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
if ((res = spa_buffer_alloc (oinfo->params, oinfo->n_params,
priv->in_buffers,
&priv->n_in_buffers)) < 0) {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error buffer alloc: %d", 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
goto error;
}
memcpy (priv->out_buffers, priv->in_buffers, priv->n_in_buffers * sizeof (SpaBuffer*));
priv->n_out_buffers = priv->n_in_buffers;
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
g_debug ("allocated out_buffers %p, in_buffers %p", priv->out_buffers, priv->in_buffers);
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
} else if ((out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) &&
(in_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS)) {
out_flags = SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
in_flags = SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
} else {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"no common buffer alloc found");
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
res = SPA_RESULT_ERROR;
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
goto error;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
}
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
} else if (in_state == SPA_NODE_STATE_READY && out_state > SPA_NODE_STATE_READY) {
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
out_flags &= ~SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
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
in_flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
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
} else if (out_state == SPA_NODE_STATE_READY && in_state > SPA_NODE_STATE_READY) {
in_flags &= ~SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
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
out_flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
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
} else
return SPA_RESULT_OK;
spa_debug_port_info (oinfo);
spa_debug_port_info (iinfo);
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
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
if (in_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS && priv->n_in_buffers == 0) {
priv->n_in_buffers = max_buffers;
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_port_alloc_buffers (this->input_node->node, this->input_port,
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
oinfo->params, oinfo->n_params,
priv->in_buffers, &priv->n_in_buffers)) < 0) {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error alloc input buffers: %d", res);
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
goto error;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
}
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
g_debug ("allocated in_buffers %p from input port", priv->in_buffers);
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
}
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
else if (out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS && priv->n_out_buffers == 0) {
priv->n_out_buffers = max_buffers;
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_port_alloc_buffers (this->output_node->node, this->output_port,
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
iinfo->params, iinfo->n_params,
priv->out_buffers, &priv->n_out_buffers)) < 0) {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error alloc output buffers: %d", res);
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
goto error;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
}
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
g_debug ("allocated out_buffers %p from output port", priv->out_buffers);
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
}
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
if (in_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS) {
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
g_debug ("using out_buffers %p on input port", priv->out_buffers);
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_port_use_buffers (this->input_node->node, this->input_port,
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
priv->out_buffers, priv->n_out_buffers)) < 0) {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error use input buffers: %d", res);
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
goto error;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
}
}
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
else if (out_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS) {
Improve memory handling Reserve 0,0 for stack allocated mem that we never free Improve allocation in the link Parse format and properties in-line, there is no need to allocate memory. Improve buffer cleanup in alsa Add timestamps and offset to alsa
2016-09-20 19:52:05 +02:00
g_debug ("using in_buffers %p on output port", priv->in_buffers);
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_port_use_buffers (this->output_node->node, this->output_port,
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
priv->in_buffers, priv->n_in_buffers)) < 0) {
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"error use output buffers: %d", res);
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
goto error;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
}
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
} else {
g_set_error (&error,
PINOS_ERROR,
PINOS_ERROR_BUFFER_ALLOCATION,
"no common buffer alloc found");
goto error;
}
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
return res;
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
error:
{
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
pinos_link_report_error (this, error);
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
return res;
}
More work on implementing remote protocol Rework things so that we negotiate buffer pools beforehand and only pass buffer ids around We can then remove the refcount of buffers, events and commands. More work on buffer reuse Use the node state changes to trigger the next step in the configuration sequence. Move most of the client-node to a plugin Do buffer allocation in the port link.
2016-08-02 16:34:44 +02:00
}
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
static SpaResult
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
do_start (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +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
SpaResult res = SPA_RESULT_OK;
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
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 (in_state < SPA_NODE_STATE_PAUSED || out_state < SPA_NODE_STATE_PAUSED)
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
else if (in_state == SPA_NODE_STATE_STREAMING && out_state == SPA_NODE_STATE_STREAMING) {
pinos_link_update_state (this, PINOS_LINK_STATE_RUNNING);
} else {
pinos_link_update_state (this, PINOS_LINK_STATE_PAUSED);
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
if (in_state == SPA_NODE_STATE_PAUSED)
pinos_node_set_state (this->input_node, PINOS_NODE_STATE_RUNNING);
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +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
if (out_state == SPA_NODE_STATE_PAUSED)
pinos_node_set_state (this->output_node, PINOS_NODE_STATE_RUNNING);
}
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
return res;
}
static SpaResult
check_states (PinosLink *this)
{
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
PinosLinkPrivate *priv = this->priv;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
SpaResult 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
SpaNodeState in_state, out_state;
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
again:
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
if (priv->async_busy != SPA_ID_INVALID)
return SPA_RESULT_OK;
Add audiotestsrc Work on idle poll Move node state to the node interface so that we can actually get it in the sync case. Add enabled field to the poll event Work on audiotestsrc
2016-09-05 16:23:40 +02:00
in_state = this->input_node->node->state;
out_state = this->output_node->node->state;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
improve state change
2016-09-12 15:25:53 +02:00
g_debug ("link %p: input state %d, output state %d", this, in_state, out_state);
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
if ((res = do_negotiate (this, in_state, out_state)) != SPA_RESULT_OK)
goto exit;
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
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
if ((res = do_allocation (this, in_state, out_state)) != SPA_RESULT_OK)
goto exit;
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
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
if ((res = do_start (this, in_state, out_state)) != SPA_RESULT_OK)
goto exit;
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
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
if (this->input_node->node->state != in_state)
goto again;
if (this->output_node->node->state != out_state)
goto again;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
return SPA_RESULT_OK;
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
exit:
if (SPA_RESULT_IS_ASYNC (res)) {
priv->async_busy = SPA_RESULT_ASYNC_SEQ (res);
g_debug ("link %p: waiting for async complete %d", this, priv->async_busy);
}
return res;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
}
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
static gboolean
do_check_states (PinosLink *this)
{
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
PinosLinkPrivate *priv = this->priv;
priv->async_busy = SPA_ID_INVALID;
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
check_states (this);
return G_SOURCE_REMOVE;
}
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
static void
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
on_async_complete_notify (PinosNode *node,
guint seq,
guint res,
PinosLink *this)
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26: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
g_debug ("link %p: node %p async complete %d %d", this, node, seq, res);
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
g_idle_add ((GSourceFunc) do_check_states, this);
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
}
improve introspection Small cleanups
2016-08-18 12:17:31 +02:00
static void
on_property_notify (GObject *obj,
GParamSpec *pspec,
gpointer user_data)
{
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
PinosLink *this = user_data;
PinosLinkPrivate *priv = this->priv;
improve introspection Small cleanups
2016-08-18 12:17:31 +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
if (pspec == NULL || strcmp (g_param_spec_get_name (pspec), "output-node") == 0) {
pinos_link1_set_output_node (priv->iface, pinos_node_get_object_path (this->output_node));
}
if (pspec == NULL || strcmp (g_param_spec_get_name (pspec), "output-port") == 0) {
pinos_link1_set_output_port (priv->iface, this->output_port);
}
if (pspec == NULL || strcmp (g_param_spec_get_name (pspec), "input-node") == 0) {
pinos_link1_set_input_node (priv->iface, pinos_node_get_object_path (this->input_node));
improve introspection Small cleanups
2016-08-18 12:17:31 +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
if (pspec == NULL || strcmp (g_param_spec_get_name (pspec), "input-port") == 0) {
pinos_link1_set_input_port (priv->iface, this->input_port);
improve introspection Small cleanups
2016-08-18 12:17:31 +02:00
}
}
Use v4l2 monitor Use the v4l2 monitor to dynamically add and remove nodes. Use the info from the monitor as parameter for the factory init and use it to configure the new node. Add info to the node. Use info from the factory as properties on the PinosNode
2016-09-15 17:51:34 +02:00
static void
on_node_remove (PinosNode *node, PinosLink *this)
{
g_signal_handlers_disconnect_by_data (node, this);
if (node == this->input_node)
g_clear_object (&this->input_node);
else
g_clear_object (&this->output_node);
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
pinos_link_update_state (this, PINOS_LINK_STATE_UNLINKED);
Use v4l2 monitor Use the v4l2 monitor to dynamically add and remove nodes. Use the info from the monitor as parameter for the factory init and use it to configure the new node. Add info to the node. Use info from the factory as properties on the PinosNode
2016-09-15 17:51:34 +02:00
}
improve introspection Small cleanups
2016-08-18 12:17:31 +02:00
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
static void
pinos_link_constructed (GObject * object)
{
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
PinosLink *this = PINOS_LINK (object);
Use v4l2 monitor Use the v4l2 monitor to dynamically add and remove nodes. Use the info from the monitor as parameter for the factory init and use it to configure the new node. Add info to the node. Use info from the factory as properties on the PinosNode
2016-09-15 17:51:34 +02:00
g_signal_connect (this->input_node, "remove", (GCallback) on_node_remove, this);
g_signal_connect (this->output_node, "remove", (GCallback) on_node_remove, this);
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +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
g_signal_connect (this->input_node, "async-complete", (GCallback) on_async_complete_notify, this);
g_signal_connect (this->output_node, "async-complete", (GCallback) on_async_complete_notify, this);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
g_signal_connect (this, "notify", (GCallback) on_property_notify, this);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
G_OBJECT_CLASS (pinos_link_parent_class)->constructed (object);
improve introspection Small cleanups
2016-08-18 12:17:31 +02:00
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
on_property_notify (G_OBJECT (this), NULL, this);
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
g_debug ("link %p: constructed %p:%d:%d -> %p:%d:%d", this,
this->output_node, this->output_id, this->output_port,
this->input_node, this->input_id, this->input_port);
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
link_register_object (this);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
}
static void
pinos_link_dispose (GObject * object)
{
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
PinosLink *this = PINOS_LINK (object);
g_debug ("link %p: dispose", this);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
Use v4l2 monitor Use the v4l2 monitor to dynamically add and remove nodes. Use the info from the monitor as parameter for the factory init and use it to configure the new node. Add info to the node. Use info from the factory as properties on the PinosNode
2016-09-15 17:51:34 +02:00
if (this->input_node)
g_signal_handlers_disconnect_by_data (this->input_node, this);
if (this->output_node)
g_signal_handlers_disconnect_by_data (this->output_node, this);
cleanups Remove some unused things. Work on shutdown.
2016-09-01 10:04:25 +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
g_signal_emit (this, signals[SIGNAL_REMOVE], 0, NULL);
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
g_clear_object (&this->input_node);
g_clear_object (&this->output_node);
channel: remove the channel Remove the channel, the functionality is now in the client-node.
2016-07-25 10:46:29 +02:00
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
link_unregister_object (this);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
G_OBJECT_CLASS (pinos_link_parent_class)->dispose (object);
}
static void
pinos_link_finalize (GObject * object)
{
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
PinosLink *this = PINOS_LINK (object);
PinosLinkPrivate *priv = this->priv;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +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
g_debug ("link %p: finalize", this);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
g_clear_object (&priv->daemon);
g_clear_object (&priv->iface);
g_free (priv->object_path);
G_OBJECT_CLASS (pinos_link_parent_class)->finalize (object);
}
static void
pinos_link_class_init (PinosLinkClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
//PinosLinkClass *link_class = PINOS_LINK_CLASS (klass);
g_type_class_add_private (klass, sizeof (PinosLinkPrivate));
gobject_class->constructed = pinos_link_constructed;
gobject_class->dispose = pinos_link_dispose;
gobject_class->finalize = pinos_link_finalize;
gobject_class->set_property = pinos_link_set_property;
gobject_class->get_property = pinos_link_get_property;
g_object_class_install_property (gobject_class,
PROP_DAEMON,
g_param_spec_object ("daemon",
"Daemon",
"The Daemon",
PINOS_TYPE_DAEMON,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
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
g_object_class_install_property (gobject_class,
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
PROP_OUTPUT_NODE,
g_param_spec_object ("output-node",
"Output Node",
"The output node",
PINOS_TYPE_NODE,
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
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
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
g_object_class_install_property (gobject_class,
PROP_OUTPUT_ID,
g_param_spec_uint ("output-id",
"Output Id",
"The output id",
0,
G_MAXUINT,
-1,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
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
g_object_class_install_property (gobject_class,
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
PROP_OUTPUT_PORT,
g_param_spec_uint ("output-port",
"Output Port",
"The output port",
0,
G_MAXUINT,
-1,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_INPUT_NODE,
g_param_spec_object ("input-node",
"Input Node",
"The input node",
PINOS_TYPE_NODE,
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
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
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
g_object_class_install_property (gobject_class,
PROP_INPUT_ID,
g_param_spec_uint ("input-id",
"Input Id",
"The input id",
0,
G_MAXUINT,
-1,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
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
g_object_class_install_property (gobject_class,
PROP_INPUT_PORT,
g_param_spec_uint ("input-port",
"Input Port",
"The input port",
0,
G_MAXUINT,
-1,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_FORMAT_FILTER,
g_param_spec_boxed ("format-filter",
"format Filter",
"The format filter",
G_TYPE_PTR_ARRAY,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_PROPERTIES,
g_param_spec_boxed ("properties",
"Properties",
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
"The properties of the 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
PINOS_TYPE_PROPERTIES,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
g_object_class_install_property (gobject_class,
PROP_STATE,
g_param_spec_enum ("state",
"State",
"The state of the link",
PINOS_TYPE_LINK_STATE,
PINOS_LINK_STATE_INIT,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
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
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
signals[SIGNAL_REMOVE] = g_signal_new ("remove",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL,
NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE,
0,
G_TYPE_NONE);
}
static void
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
pinos_link_init (PinosLink * this)
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +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
PinosLinkPrivate *priv = this->priv = PINOS_LINK_GET_PRIVATE (this);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
priv->iface = pinos_link1_skeleton_new ();
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
g_debug ("link %p: new", this);
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
priv->state = PINOS_LINK_STATE_INIT;
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 stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
/**
* pinos_link_remove:
* @link: a #PinosLink
*
* Trigger removal of @link
*/
void
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
pinos_link_remove (PinosLink *this)
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +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
g_debug ("link %p: remove", this);
g_signal_emit (this, signals[SIGNAL_REMOVE], 0, NULL);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
}
/**
* pinos_link_get_object_path:
* @link: a #PinosLink
*
* Get the object patch of @link
*
* Returns: the object path of @source.
*/
const gchar *
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
pinos_link_get_object_path (PinosLink *this)
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
{
PinosLinkPrivate *priv;
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
g_return_val_if_fail (PINOS_IS_LINK (this), NULL);
priv = this->priv;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
return priv->object_path;
}
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
PinosLinkState
pinos_link_get_state (PinosLink *this,
GError **error)
{
PinosLinkPrivate *priv;
g_return_val_if_fail (PINOS_IS_LINK (this), PINOS_LINK_STATE_ERROR);
priv = this->priv;
if (error)
*error = priv->error;
return priv->state;
}
gboolean
pinos_link_activate (PinosLink *this)
{
g_return_val_if_fail (PINOS_IS_LINK (this), FALSE);
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_init (&this->ringbuffer, SPA_N_ELEMENTS (this->queue));
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
check_states (this);
return TRUE;
}
gboolean
pinos_link_deactivate (PinosLink *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
spa_ringbuffer_clear (&this->ringbuffer);
Handle error cases Add a link state Add error quark Track the state of node we create and error when it is in error. Handle stream error states when negotiating Make the node error when a link is in error
2016-09-16 13:13:41 +02:00
return TRUE;
}
Reference in a new issue Copy permalink