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

968 lines
30 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>
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>
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
#include <spa/lib/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"
Use interfaces Add interfaces and events on objects. Use this to communicate with the objects and transparently convert/marshall to network in the protocols.
2017-03-02 16:06:45 +01:00
#include "pinos/client/interfaces.h"
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/server/link.h"
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
#include "pinos/server/work-queue.h"
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
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
WIP Change object model
2016-11-10 15:42:14 +01:00
typedef struct
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
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosLink this;
WIP Change object model
2016-11-10 15:42:14 +01:00
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
int refcount;
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
PinosWorkQueue *work;
track client resources
2016-11-15 17:06:09 +01:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
SpaFormat **format_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
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
WIP Change object model
2016-11-10 15:42:14 +01:00
PinosListener input_port_destroy;
PinosListener input_async_complete;
PinosListener output_port_destroy;
PinosListener output_async_complete;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
bool allocated;
Enable header metadata Enable the header metadata so that we have timestamps again. Rework allocation in the link a little. Reuse previously allocated buffers when possible. Keep track of where the buffers was allocated. Make some more convenience functions to initialize buffer headers. Make it so that we move allocations to the app. Make some helpers to make memfd memory in pinos now that we will be able to do all allocation there.
2016-09-30 17:07:38 +02:00
PinosMemblock buffer_mem;
SpaBuffer **buffers;
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
uint32_t n_buffers;
WIP Change object model
2016-11-10 15:42:14 +01:00
} PinosLinkImpl;
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
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
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
pinos_link_update_state (PinosLink *link,
PinosLinkState state,
char *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
{
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
PinosLinkState old = link->state;
if (state != old) {
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
pinos_log_debug ("link %p: update state %s -> %s (%s)", link,
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_link_state_as_string (old),
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
pinos_link_state_as_string (state),
error);
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
WIP change object model
2016-11-14 12:42:00 +01:00
link->state = state;
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
if (link->error)
free (link->error);
link->error = error;
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_signal_emit (&link->state_changed, link, old, 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
}
}
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
{
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, this);
Improve negotiation Try to link ports based on compatible formats Add methods to filter formats.
2017-02-10 10:17:07 +01:00
SpaResult res = SPA_RESULT_ERROR;
SpaFormat *format;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
char *error = 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
if (in_state != SPA_NODE_STATE_CONFIGURE && out_state != SPA_NODE_STATE_CONFIGURE)
return SPA_RESULT_OK;
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
pinos_link_update_state (this, PINOS_LINK_STATE_NEGOTIATING, 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
Fix renegotiation When we are idle and are asked to negotiate, suspend first so that we can do full negotiation again instead of using the old format. Stability fixes.
2017-02-02 17:48:39 +01:00
if (out_state > SPA_NODE_STATE_READY && this->output->node->state == PINOS_NODE_STATE_IDLE) {
pinos_node_set_state (this->output->node, PINOS_NODE_STATE_SUSPENDED);
out_state = SPA_NODE_STATE_CONFIGURE;
}
Improve negotiation Try to link ports based on compatible formats Add methods to filter formats.
2017-02-10 10:17:07 +01:00
format = pinos_core_find_format (this->core,
this->output,
this->input,
NULL,
0,
NULL,
&error);
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
if (format == NULL) {
Improve negotiation Try to link ports based on compatible formats Add methods to filter formats.
2017-02-10 10:17:07 +01:00
goto error;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
}
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
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("link %p: doing set format", this);
Improve logging
2017-01-19 18:53:45 +01:00
if (pinos_log_level_enabled (SPA_LOG_LEVEL_DEBUG))
spa_debug_format (format);
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
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) {
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("link %p: doing set format on output", this);
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
if ((res = spa_node_port_set_format (this->output->node->node,
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
SPA_DIRECTION_OUTPUT,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->output->port_id,
Cleanups
2016-09-20 11:20:43 +02:00
SPA_PORT_FORMAT_FLAG_NEAREST,
format)) < 0) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "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;
}
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_add (impl->work, this->output->node, res, NULL, NULL);
improve state change
2016-09-12 15:25:53 +02:00
} else if (in_state == SPA_NODE_STATE_CONFIGURE) {
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("link %p: doing set format on input", this);
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
if ((res = spa_node_port_set_format (this->input->node->node,
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
SPA_DIRECTION_INPUT,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->input->port_id,
Cleanups
2016-09-20 11:20:43 +02:00
SPA_PORT_FORMAT_FLAG_NEAREST,
format)) < 0) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "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;
}
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_add (impl->work, this->input->node, res, NULL, 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
}
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:
{
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
pinos_link_update_state (this, PINOS_LINK_STATE_ERROR, 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)
{
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
uint32_t i;
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
for (i = 0; i < info->n_params; i++) {
if (info->params[i]->type == type)
return info->params[i];
}
return NULL;
}
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
static void *
find_meta_enable (const SpaPortInfo *info, SpaMetaType type)
{
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
uint32_t i;
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
for (i = 0; i < info->n_params; i++) {
if (info->params[i]->type == SPA_ALLOC_PARAM_TYPE_META_ENABLE &&
((SpaAllocParamMetaEnable*)info->params[i])->type == type) {
return info->params[i];
}
}
return NULL;
}
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
static SpaBuffer **
alloc_buffers (PinosLink *this,
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
uint32_t n_buffers,
uint32_t n_params,
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
SpaAllocParam **params,
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
uint32_t n_datas,
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
size_t *data_sizes,
ssize_t *data_strides,
PinosMemblock *mem)
{
SpaBuffer **buffers, *bp;
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
uint32_t i;
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
size_t skel_size, data_size, meta_size;
SpaChunk *cdp;
void *ddp;
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
uint32_t n_metas;
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
SpaMeta *metas;
n_metas = data_size = meta_size = 0;
/* each buffer */
skel_size = sizeof (SpaBuffer);
metas = alloca (sizeof (SpaMeta) * n_params + 1);
/* add shared metadata */
metas[n_metas].type = SPA_META_TYPE_SHARED;
metas[n_metas].size = spa_meta_type_get_size (SPA_META_TYPE_SHARED);
meta_size += metas[n_metas].size;
n_metas++;
skel_size += sizeof (SpaMeta);
/* collect metadata */
for (i = 0; i < n_params; i++) {
SpaAllocParam *ap = params[i];
if (ap->type == SPA_ALLOC_PARAM_TYPE_META_ENABLE) {
SpaAllocParamMetaEnable *pme = (SpaAllocParamMetaEnable *) ap;
metas[n_metas].type = pme->type;
metas[n_metas].size = spa_meta_type_get_size (pme->type);
meta_size += metas[n_metas].size;
n_metas++;
skel_size += sizeof (SpaMeta);
}
}
data_size += meta_size;
/* data */
for (i = 0; i < n_datas; i++) {
data_size += sizeof (SpaChunk);
data_size += data_sizes[i];
skel_size += sizeof (SpaData);
}
buffers = calloc (n_buffers, skel_size + sizeof (SpaBuffer *));
/* pointer to buffer structures */
bp = SPA_MEMBER (buffers, n_buffers * sizeof (SpaBuffer *), SpaBuffer);
pinos_memblock_alloc (PINOS_MEMBLOCK_FLAG_WITH_FD |
PINOS_MEMBLOCK_FLAG_MAP_READWRITE |
PINOS_MEMBLOCK_FLAG_SEAL,
n_buffers * data_size,
mem);
for (i = 0; i < n_buffers; i++) {
int j;
SpaBuffer *b;
void *p;
buffers[i] = b = SPA_MEMBER (bp, skel_size * i, SpaBuffer);
p = SPA_MEMBER (mem->ptr, data_size * i, void);
b->id = i;
b->n_metas = n_metas;
b->metas = SPA_MEMBER (b, sizeof (SpaBuffer), SpaMeta);
for (j = 0; j < n_metas; j++) {
SpaMeta *m = &b->metas[j];
m->type = metas[j].type;
m->data = p;
m->size = metas[j].size;
switch (m->type) {
case SPA_META_TYPE_SHARED:
{
SpaMetaShared *msh = p;
msh->type = SPA_DATA_TYPE_MEMFD;
msh->flags = 0;
msh->fd = mem->fd;
msh->offset = data_size * i;
msh->size = data_size;
break;
}
case SPA_META_TYPE_RINGBUFFER:
{
SpaMetaRingbuffer *rb = p;
spa_ringbuffer_init (&rb->ringbuffer, data_sizes[0]);
break;
}
default:
break;
}
p += m->size;
}
/* pointer to data structure */
b->n_datas = n_datas;
b->datas = SPA_MEMBER (b->metas, n_metas * sizeof (SpaMeta), SpaData);
cdp = p;
ddp = SPA_MEMBER (cdp, sizeof (SpaChunk) * n_datas, void);
for (j = 0; j < n_datas; j++) {
SpaData *d = &b->datas[j];
d->chunk = &cdp[j];
if (data_sizes[j] > 0) {
d->type = SPA_DATA_TYPE_MEMFD;
d->flags = 0;
d->fd = mem->fd;
Improve upload Only send a buffer when we have received a NEED_DATA message. Add a signal to pulla buffer from the sink. Restructure the sink to use a queue like the source and only push a buffer when we can. Improve SpaData. Offset and size should be between 0 and maxsize, make sure we clamp correctly when needed. node_process_output completes the processing of the output after receiving HAVE_OUTPUT for async elements. It instructs the node that it now can produce more output.
2016-12-20 16:51:57 +01:00
d->mapoffset = SPA_PTRDIFF (ddp, mem->ptr);
d->maxsize = data_sizes[j];
d->data = SPA_MEMBER (mem->ptr, d->mapoffset, void);
d->chunk->offset = 0;
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
d->chunk->size = data_sizes[j];
d->chunk->stride = data_strides[j];
ddp += data_sizes[j];
} else {
d->type = SPA_DATA_TYPE_INVALID;
d->data = NULL;
}
}
}
return buffers;
}
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
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, this);
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;
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;
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
char *error = 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
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;
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
pinos_link_update_state (this, PINOS_LINK_STATE_ALLOCATING, 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
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("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 */
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
if ((res = spa_node_port_get_info (this->output->node->node,
SPA_DIRECTION_OUTPUT,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->output->port_id,
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
&oinfo)) < 0) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "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
}
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
if ((res = spa_node_port_get_info (this->input->node->node,
SPA_DIRECTION_INPUT,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->input->port_id,
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
&iinfo)) < 0) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "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
}
Improve logging
2017-01-19 18:53:45 +01:00
if (pinos_log_level_enabled (SPA_LOG_LEVEL_DEBUG)) {
spa_debug_port_info (oinfo);
spa_debug_port_info (iinfo);
}
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
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;
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) {
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("setting link as live");
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
this->output->node->live = true;
this->input->node->live = true;
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
}
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)) {
out_flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
in_flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
} 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 {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "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;
WIP Change object model
2016-11-10 15:42:14 +01:00
if (impl->buffers == NULL) {
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
SpaAllocParamBuffers *in_alloc, *out_alloc;
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
SpaAllocParamMetaEnableRingbuffer *in_me, *out_me;
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
uint32_t max_buffers;
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
size_t minsize, stride, blocks;
in_me = find_meta_enable (iinfo, SPA_META_TYPE_RINGBUFFER);
out_me = find_meta_enable (oinfo, SPA_META_TYPE_RINGBUFFER);
if (in_me && out_me) {
max_buffers = 1;
minsize = SPA_MAX (out_me->minsize, in_me->minsize);
stride = SPA_MAX (out_me->stride, in_me->stride);
blocks = SPA_MAX (1, SPA_MAX (out_me->blocks, in_me->blocks));
} else {
max_buffers = MAX_BUFFERS;
minsize = stride = 0;
blocks = 1;
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);
minsize = SPA_MAX (minsize, in_alloc->minsize);
stride = SPA_MAX (stride, in_alloc->stride);
}
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);
minsize = SPA_MAX (minsize, out_alloc->minsize);
stride = SPA_MAX (stride, out_alloc->stride);
}
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
}
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
if ((in_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) ||
(out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS))
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
minsize = 0;
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
Enable header metadata Enable the header metadata so that we have timestamps again. Rework allocation in the link a little. Reuse previously allocated buffers when possible. Keep track of where the buffers was allocated. Make some more convenience functions to initialize buffer headers. Make it so that we move allocations to the app. Make some helpers to make memfd memory in pinos now that we will be able to do all allocation there.
2016-09-30 17:07:38 +02:00
if (this->output->allocated) {
out_flags = 0;
in_flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
WIP Change object model
2016-11-10 15:42:14 +01:00
impl->n_buffers = this->output->n_buffers;
impl->buffers = this->output->buffers;
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
impl->allocated = false;
WIP Change object model
2016-11-10 15:42:14 +01:00
pinos_log_debug ("reusing %d output buffers %p", impl->n_buffers, impl->buffers);
Enable header metadata Enable the header metadata so that we have timestamps again. Rework allocation in the link a little. Reuse previously allocated buffers when possible. Keep track of where the buffers was allocated. Make some more convenience functions to initialize buffer headers. Make it so that we move allocations to the app. Make some helpers to make memfd memory in pinos now that we will be able to do all allocation there.
2016-09-30 17:07:38 +02:00
} else {
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
size_t data_sizes[1];
ssize_t data_strides[1];
Enable header metadata Enable the header metadata so that we have timestamps again. Rework allocation in the link a little. Reuse previously allocated buffers when possible. Keep track of where the buffers was allocated. Make some more convenience functions to initialize buffer headers. Make it so that we move allocations to the app. Make some helpers to make memfd memory in pinos now that we will be able to do all allocation there.
2016-09-30 17:07:38 +02:00
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
data_sizes[0] = minsize;
data_strides[0] = stride;
Enable header metadata Enable the header metadata so that we have timestamps again. Rework allocation in the link a little. Reuse previously allocated buffers when possible. Keep track of where the buffers was allocated. Make some more convenience functions to initialize buffer headers. Make it so that we move allocations to the app. Make some helpers to make memfd memory in pinos now that we will be able to do all allocation there.
2016-09-30 17:07:38 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
impl->n_buffers = max_buffers;
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
impl->buffers = alloc_buffers (this,
impl->n_buffers,
oinfo->n_params,
oinfo->params,
1,
data_sizes,
data_strides,
&impl->buffer_mem);
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
}
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
if (out_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) {
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
if ((res = spa_node_port_alloc_buffers (this->output->node->node,
SPA_DIRECTION_OUTPUT,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->output->port_id,
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
iinfo->params, iinfo->n_params,
WIP Change object model
2016-11-10 15:42:14 +01:00
impl->buffers, &impl->n_buffers)) < 0) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "error alloc output buffers: %d", res);
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
goto error;
}
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_add (impl->work, this->output->node, res, NULL, NULL);
WIP Change object model
2016-11-10 15:42:14 +01:00
this->output->buffers = impl->buffers;
this->output->n_buffers = impl->n_buffers;
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
this->output->allocated = true;
WIP Change object model
2016-11-10 15:42:14 +01:00
this->output->buffer_mem = impl->buffer_mem;
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
impl->allocated = false;
WIP Change object model
2016-11-10 15:42:14 +01:00
pinos_log_debug ("allocated %d buffers %p from output port", impl->n_buffers, impl->buffers);
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
} else if (in_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) {
if ((res = spa_node_port_alloc_buffers (this->input->node->node,
SPA_DIRECTION_INPUT,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->input->port_id,
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
oinfo->params, oinfo->n_params,
WIP Change object model
2016-11-10 15:42:14 +01:00
impl->buffers, &impl->n_buffers)) < 0) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "error alloc input buffers: %d", res);
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
goto error;
}
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_add (impl->work, this->input->node, res, NULL, NULL);
WIP Change object model
2016-11-10 15:42:14 +01:00
this->input->buffers = impl->buffers;
this->input->n_buffers = impl->n_buffers;
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
this->input->allocated = true;
WIP Change object model
2016-11-10 15:42:14 +01:00
this->input->buffer_mem = impl->buffer_mem;
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
impl->allocated = false;
WIP Change object model
2016-11-10 15:42:14 +01:00
pinos_log_debug ("allocated %d buffers %p from input port", impl->n_buffers, impl->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
}
}
Enable header metadata Enable the header metadata so that we have timestamps again. Rework allocation in the link a little. Reuse previously allocated buffers when possible. Keep track of where the buffers was allocated. Make some more convenience functions to initialize buffer headers. Make it so that we move allocations to the app. Make some helpers to make memfd memory in pinos now that we will be able to do all allocation there.
2016-09-30 17:07:38 +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) {
WIP Change object model
2016-11-10 15:42:14 +01:00
pinos_log_debug ("using %d buffers %p on input port", impl->n_buffers, impl->buffers);
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
if ((res = spa_node_port_use_buffers (this->input->node->node,
SPA_DIRECTION_INPUT,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->input->port_id,
WIP Change object model
2016-11-10 15:42:14 +01:00
impl->buffers,
impl->n_buffers)) < 0) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "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
}
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_add (impl->work, this->input->node, res, NULL, NULL);
WIP Change object model
2016-11-10 15:42:14 +01:00
this->input->buffers = impl->buffers;
this->input->n_buffers = impl->n_buffers;
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
this->input->allocated = false;
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) {
WIP Change object model
2016-11-10 15:42:14 +01:00
pinos_log_debug ("using %d buffers %p on output port", impl->n_buffers, impl->buffers);
Add port direction again simplify port numbering again by using 0->max_ports for bot input ports and output ports. This means we need to tall what direction the port is. Add port_info serialize functions Copy metadata and data when we are not sharing buffers. Make pinossink work again.
2016-10-03 19:43:42 +02:00
if ((res = spa_node_port_use_buffers (this->output->node->node,
SPA_DIRECTION_OUTPUT,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->output->port_id,
WIP Change object model
2016-11-10 15:42:14 +01:00
impl->buffers,
impl->n_buffers)) < 0) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "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
}
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_add (impl->work, this->output->node, res, NULL, NULL);
WIP Change object model
2016-11-10 15:42:14 +01:00
this->output->buffers = impl->buffers;
this->output->n_buffers = impl->n_buffers;
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
this->output->allocated = false;
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 {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
asprintf (&error, "no common buffer alloc found");
Enable header metadata Enable the header metadata so that we have timestamps again. Rework allocation in the link a little. Reuse previously allocated buffers when possible. Keep track of where the buffers was allocated. Make some more convenience functions to initialize buffer headers. Make it so that we move allocations to the app. Make some helpers to make memfd memory in pinos now that we will be able to do all allocation there.
2016-09-30 17:07:38 +02:00
goto 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
}
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:
{
Enable header metadata Enable the header metadata so that we have timestamps again. Rework allocation in the link a little. Reuse previously allocated buffers when possible. Keep track of where the buffers was allocated. Make some more convenience functions to initialize buffer headers. Make it so that we move allocations to the app. Make some helpers to make memfd memory in pinos now that we will be able to do all allocation there.
2016-09-30 17:07:38 +02:00
this->output->buffers = NULL;
this->output->n_buffers = 0;
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
this->output->allocated = false;
Enable header metadata Enable the header metadata so that we have timestamps again. Rework allocation in the link a little. Reuse previously allocated buffers when possible. Keep track of where the buffers was allocated. Make some more convenience functions to initialize buffer headers. Make it so that we move allocations to the app. Make some helpers to make memfd memory in pinos now that we will be able to do all allocation there.
2016-09-30 17:07:38 +02:00
this->input->buffers = NULL;
this->input->n_buffers = 0;
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
this->input->allocated = false;
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
pinos_link_update_state (this, PINOS_LINK_STATE_ERROR, 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;
Do cleanup of queues Wait for async state changes to complete
2017-01-12 20:02:58 +01:00
PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, 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
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) {
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
pinos_link_update_state (this, PINOS_LINK_STATE_RUNNING, NULL);
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
} else {
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
pinos_link_update_state (this, PINOS_LINK_STATE_PAUSED, NULL);
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
port to meson
2016-09-26 12:15:52 +02:00
if (in_state == SPA_NODE_STATE_PAUSED) {
Cleanups Remove unused events, drained and marker can be done with ASYNC_COMPLETED messages Handle result of idle callback to disable the poll item Identify poll items with a unique id. Remove set_state vfunc push_event -> send_command, commands are to do something, events are the result of something. Add poll item in v4l2 as soon as we have the fd but disable the item until streaming starts.
2016-10-21 14:57:01 +02:00
res = pinos_node_set_state (this->input->node, PINOS_NODE_STATE_RUNNING);
Do cleanup of queues Wait for async state changes to complete
2017-01-12 20:02:58 +01:00
pinos_work_queue_add (impl->work, this->input->node, res, NULL, NULL);
port to meson
2016-09-26 12:15:52 +02:00
}
if (out_state == SPA_NODE_STATE_PAUSED) {
Cleanups Remove unused events, drained and marker can be done with ASYNC_COMPLETED messages Handle result of idle callback to disable the poll item Identify poll items with a unique id. Remove set_state vfunc push_event -> send_command, commands are to do something, events are the result of something. Add poll item in v4l2 as soon as we have the fd but disable the item until streaming starts.
2016-10-21 14:57:01 +02:00
res = pinos_node_set_state (this->output->node, PINOS_NODE_STATE_RUNNING);
Do cleanup of queues Wait for async state changes to complete
2017-01-12 20:02:58 +01:00
pinos_work_queue_add (impl->work, this->input->node, res, NULL, NULL);
port to meson
2016-09-26 12:15:52 +02:00
}
Remove some events Remove port added and port removed, we can get that info by inspecting the port ids. Remove data from ringbuffer, we just need the ringbuffer to keep track of the read and write positions. Handle async-complete in the main thread Work on async node initialization Work on using a queue as the link between nodes Make the daemon link things based on the node states Use queue helper in v4l2
2016-09-23 17:08:20 +02:00
}
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
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
check_states (PinosLink *this,
remove last glib bits Improve pinossink
2016-11-26 19:18:51 +01:00
void *user_data,
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
SpaResult 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
{
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, this);
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
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:
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
if (this->state == PINOS_LINK_STATE_ERROR)
return SPA_RESULT_ERROR;
Work on main loop Make a main-loop object with associated helper functions to handle async methods. rtloop -> data_loop Handle async results a lot better. Remove REMOVE_MEM command. We don't need it. Handle stream memory updates better.
2016-10-20 16:26:55 +02:00
if (this->input == NULL || this->output == NULL)
return SPA_RESULT_OK;
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
if (this->input->node->state == PINOS_NODE_STATE_ERROR ||
this->output->node->state == PINOS_NODE_STATE_ERROR)
return SPA_RESULT_ERROR;
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
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
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("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
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
if (this->input->node->node->state != in_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
goto again;
Make PinosPort struct Keep track of the ports, their links and the allocated buffers in a small struct managed by the node.
2016-09-28 10:42:36 +02:00
if (this->output->node->node->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
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:
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_add (impl->work,
this,
SPA_RESULT_WAIT_SYNC,
(PinosWorkFunc) check_states,
this);
Wait for async changes to complete
2016-09-24 18:32:46 +02:00
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
}
static void
WIP Change object model
2016-11-10 15:42:14 +01:00
on_input_async_complete_notify (PinosListener *listener,
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNode *node,
uint32_t seq,
SpaResult res)
WIP Change object model
2016-11-10 15:42:14 +01:00
{
PinosLinkImpl *impl = SPA_CONTAINER_OF (listener, PinosLinkImpl, input_async_complete);
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_log_debug ("link %p: node %p async complete %d %d", impl, node, seq, res);
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_complete (impl->work, node, seq, res);
WIP Change object model
2016-11-10 15:42:14 +01:00
}
static void
on_output_async_complete_notify (PinosListener *listener,
WIP change object model
2016-11-14 12:42:00 +01:00
PinosNode *node,
uint32_t seq,
SpaResult 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
{
WIP Change object model
2016-11-10 15:42:14 +01:00
PinosLinkImpl *impl = SPA_CONTAINER_OF (listener, PinosLinkImpl, output_async_complete);
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_log_debug ("link %p: node %p async complete %d %d", impl, node, seq, res);
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
pinos_work_queue_complete (impl->work, node, seq, 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
}
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
WIP Change object model
2016-11-10 15:42:14 +01:00
on_port_destroy (PinosLink *this,
PinosPort *port)
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
{
WIP Change object model
2016-11-10 15:42:14 +01:00
PinosLinkImpl *impl = (PinosLinkImpl *) this;
PinosPort *other;
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
if (port == this->input) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
pinos_log_debug ("link %p: input port destroyed %p", this, port);
track client resources
2016-11-15 17:06:09 +01:00
pinos_signal_remove (&impl->input_port_destroy);
pinos_signal_remove (&impl->input_async_complete);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->input = NULL;
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
other = this->output;
WIP Change object model
2016-11-10 15:42:14 +01:00
} else if (port == this->output) {
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
pinos_log_debug ("link %p: output port destroyed %p", this, port);
track client resources
2016-11-15 17:06:09 +01:00
pinos_signal_remove (&impl->output_port_destroy);
pinos_signal_remove (&impl->output_async_complete);
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->output = NULL;
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
other = this->input;
} else
return;
if (port->allocated) {
WIP Change object model
2016-11-10 15:42:14 +01:00
impl->buffers = NULL;
impl->n_buffers = 0;
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
pinos_log_debug ("link %p: clear input allocated buffers on port %p", this, other);
More hacking Add connection message for PORT_COMMAND Add rtkit support to ask for realtime priority work on stream states and improve negotiation Rework of port linking works, keep separate state for realtime threads and use message passing to update the state. Don't try to link nodes that are removed. Open the device in the ALSA monitor to detect source or sink Implement send_command as async methods on the plugins, use async replies to sync start and stop. Work on alsa sink. Implement async PAUSE/START on v4l2 src. move the STREAMON/OFF calls to the mainloop because they have high latency, add the poll descriptors from the data loop.
2016-10-28 16:56:33 +02:00
pinos_port_clear_buffers (other);
Enable header metadata Enable the header metadata so that we have timestamps again. Rework allocation in the link a little. Reuse previously allocated buffers when possible. Keep track of where the buffers was allocated. Make some more convenience functions to initialize buffer headers. Make it so that we move allocations to the app. Make some helpers to make memfd memory in pinos now that we will be able to do all allocation there.
2016-09-30 17:07:38 +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
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_signal_emit (&this->port_unlinked, this, port);
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
pinos_link_update_state (this, PINOS_LINK_STATE_UNLINKED, NULL);
pinos_link_destroy (this);
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
WIP Change object model
2016-11-10 15:42:14 +01:00
on_input_port_destroy (PinosListener *listener,
WIP change object model
2016-11-14 12:42:00 +01:00
PinosPort *port)
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
{
WIP Change object model
2016-11-10 15:42:14 +01:00
PinosLinkImpl *impl = SPA_CONTAINER_OF (listener, PinosLinkImpl, input_port_destroy);
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
WIP change object model
2016-11-14 12:42:00 +01:00
on_port_destroy (&impl->this, port);
WIP Change object model
2016-11-10 15:42:14 +01:00
}
improve introspection Small cleanups
2016-08-18 12:17:31 +02:00
WIP Change object model
2016-11-10 15:42:14 +01:00
static void
on_output_port_destroy (PinosListener *listener,
WIP change object model
2016-11-14 12:42:00 +01:00
PinosPort *port)
WIP Change object model
2016-11-10 15:42:14 +01:00
{
PinosLinkImpl *impl = SPA_CONTAINER_OF (listener, PinosLinkImpl, output_port_destroy);
Cleanups Hide GDBus from RTKit API Remove register node from dbus API Add signal Add object and register objects in the registry Add some preregistered types to the registry Let the daemon listen to the registry
2016-11-08 18:00:52 +01:00
WIP change object model
2016-11-14 12:42:00 +01:00
on_port_destroy (&impl->this, port);
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
}
WIP change object model
2016-11-14 12:42:00 +01:00
bool
pinos_link_activate (PinosLink *this)
WIP Change object model
2016-11-10 15:42:14 +01:00
{
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, this);
pinos_work_queue_add (impl->work,
this,
SPA_RESULT_WAIT_SYNC,
(PinosWorkFunc) check_states,
this);
WIP Change object model
2016-11-10 15:42:14 +01:00
return true;
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
}
WIP change object model
2016-11-14 12:42:00 +01:00
bool
pinos_pinos_link_deactivate (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
{
WIP Change object model
2016-11-10 15:42:14 +01:00
return true;
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 refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
static void
pinos_link_free (PinosLink *link)
{
PinosLinkImpl *impl = SPA_CONTAINER_OF (link, PinosLinkImpl, this);
pinos_log_debug ("link %p: free", link);
pinos_signal_emit (&link->free_signal, link);
Do cleanup of queues Wait for async state changes to complete
2017-01-12 20:02:58 +01:00
pinos_work_queue_destroy (impl->work);
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
if (impl->allocated)
pinos_memblock_free (&impl->buffer_mem);
free (impl);
}
Add link introspection
2016-12-02 16:06:16 +01:00
static void
link_unbind_func (void *data)
{
PinosResource *resource = data;
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
PinosLink *this = resource->object;
PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, this);
Add link introspection
2016-12-02 16:06:16 +01:00
spa_list_remove (&resource->link);
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
if (--impl->refcount == 0)
pinos_link_free (this);
Add link introspection
2016-12-02 16:06:16 +01:00
}
Implement access control Move send and dispatch functions to the implementation. This makes it possible to place an access check before sending and dispatching. Add module-access that allows to bind and notify on globals owned by the client.
2017-01-10 17:12:53 +01:00
static SpaResult
Work on introspection
2016-12-02 13:38:43 +01:00
link_bind_func (PinosGlobal *global,
PinosClient *client,
uint32_t version,
uint32_t id)
{
Add link introspection
2016-12-02 16:06:16 +01:00
PinosLink *this = global->object;
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, this);
Work on introspection
2016-12-02 13:38:43 +01:00
PinosResource *resource;
Add link introspection
2016-12-02 16:06:16 +01:00
PinosLinkInfo info;
Work on introspection
2016-12-02 13:38:43 +01:00
resource = pinos_resource_new (client,
id,
Implement access control Move send and dispatch functions to the implementation. This makes it possible to place an access check before sending and dispatching. Add module-access that allows to bind and notify on globals owned by the client.
2017-01-10 17:12:53 +01:00
global->type,
Work on introspection
2016-12-02 13:38:43 +01:00
global->object,
Add link introspection
2016-12-02 16:06:16 +01:00
link_unbind_func);
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
if (resource == NULL)
goto no_mem;
Work on introspection
2016-12-02 13:38:43 +01:00
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
impl->refcount++;
Work on introspection
2016-12-02 13:38:43 +01:00
pinos_log_debug ("link %p: bound to %d", global->object, resource->id);
Add link introspection
2016-12-02 16:06:16 +01:00
spa_list_insert (this->resource_list.prev, &resource->link);
Add core introspection Use global ids in info messages to refer to global objects.
2016-12-15 20:09:48 +01:00
info.id = global->id;
Add link introspection
2016-12-02 16:06:16 +01:00
info.change_mask = ~0;
info.output_node_id = this->output ? this->output->node->global->id : -1;
info.output_port_id = this->output ? this->output->port_id : -1;
info.input_node_id = this->input ? this->input->node->global->id : -1;
info.input_port_id = this->input ? this->input->port_id : -1;
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
Use interfaces Add interfaces and events on objects. Use this to communicate with the objects and transparently convert/marshall to network in the protocols.
2017-03-02 16:06:45 +01:00
pinos_link_notify_info (resource, &info);
return SPA_RESULT_OK;
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
no_mem:
Use interfaces Add interfaces and events on objects. Use this to communicate with the objects and transparently convert/marshall to network in the protocols.
2017-03-02 16:06:45 +01:00
pinos_core_notify_error (client->core_resource,
client->core_resource->id,
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
SPA_RESULT_NO_MEMORY,
"no memory");
Implement access control Move send and dispatch functions to the implementation. This makes it possible to place an access check before sending and dispatching. Add module-access that allows to bind and notify on globals owned by the client.
2017-01-10 17:12:53 +01:00
return SPA_RESULT_NO_MEMORY;
Work on introspection
2016-12-02 13:38:43 +01:00
}
WIP Change object model
2016-11-10 15:42:14 +01:00
PinosLink *
pinos_link_new (PinosCore *core,
PinosPort *output,
WIP change object model
2016-11-14 12:42:00 +01:00
PinosPort *input,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
SpaFormat **format_filter,
WIP Change object model
2016-11-10 15:42:14 +01:00
PinosProperties *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
{
WIP Change object model
2016-11-10 15:42:14 +01:00
PinosLinkImpl *impl;
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
WIP Change object model
2016-11-10 15:42:14 +01:00
impl = calloc (1, sizeof (PinosLinkImpl));
Implement subscription with a signal Use a signal for subscription events Work on handling OOM errors and other errors.
2016-12-22 16:50:01 +01:00
if (impl == NULL)
return NULL;
WIP change object model
2016-11-14 12:42:00 +01:00
this = &impl->this;
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
pinos_log_debug ("link %p: new", this);
WIP Change object model
2016-11-10 15:42:14 +01:00
Refactor the work queue Make a separate work queue to track async operations. Keep separate work queues for links and nodes. This avoids lockups when some async operation take a long time and the work queue has SYNC_WAIT operations.
2017-01-12 16:48:17 +01:00
impl->work = pinos_work_queue_new (core->main_loop->loop);
WIP change object model
2016-11-14 12:42:00 +01:00
this->core = core;
WIP Change object model
2016-11-10 15:42:14 +01:00
this->properties = properties;
this->state = PINOS_LINK_STATE_INIT;
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
impl->refcount = 1;
WIP Change object model
2016-11-10 15:42:14 +01:00
this->input = input;
this->output = output;
Add link introspection
2016-12-02 16:06:16 +01:00
spa_list_init (&this->resource_list);
improve error reporting Move signals from core to the objects themselves Use per object info to track object signals Use periods in alsasink and source
2017-01-17 10:27:58 +01:00
pinos_signal_init (&this->port_unlinked);
pinos_signal_init (&this->state_changed);
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_init (&this->destroy_signal);
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
pinos_signal_init (&this->free_signal);
WIP Change object model
2016-11-10 15:42:14 +01:00
impl->format_filter = format_filter;
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_add (&this->input->destroy_signal,
&impl->input_port_destroy,
on_input_port_destroy);
WIP Change object model
2016-11-10 15:42:14 +01:00
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_add (&this->input->node->async_complete,
&impl->input_async_complete,
on_input_async_complete_notify);
WIP Change object model
2016-11-10 15:42:14 +01:00
track client resources
2016-11-15 17:06:09 +01:00
pinos_signal_add (&this->output->destroy_signal,
&impl->output_port_destroy,
on_output_port_destroy);
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_signal_add (&this->output->node->async_complete,
&impl->output_async_complete,
on_output_async_complete_notify);
WIP Change object model
2016-11-10 15:42:14 +01:00
pinos_log_debug ("link %p: constructed %p:%d -> %p:%d", impl,
WIP object model change Work on cleanup
2016-11-15 13:29:58 +01:00
this->output->node, this->output->port_id,
this->input->node, this->input->port_id);
WIP Change object model
2016-11-10 15:42:14 +01:00
cleanups Remove hastables, use lists Remove obsolete ringbuffer some small cleanups
2016-11-15 20:12:31 +01:00
spa_list_insert (core->link_list.prev, &this->link);
WIP change object model
2016-11-14 12:42:00 +01:00
this->global = pinos_core_add_global (core,
Implement access control Move send and dispatch functions to the implementation. This makes it possible to place an access check before sending and dispatching. Add module-access that allows to bind and notify on globals owned by the client.
2017-01-10 17:12:53 +01:00
NULL,
Use mapper to make object id Reuse object ids by using a mapper Simpify the uri struct a little.
2016-11-21 16:29:15 +01:00
core->uri.link,
Work on introspection
2016-12-02 13:38:43 +01:00
0,
this,
link_bind_func);
WIP change object model
2016-11-14 12:42:00 +01:00
return this;
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
}
track client resources
2016-11-15 17:06:09 +01:00
static void
clear_port_buffers (PinosLink *link, PinosPort *port)
{
if (!port->allocated) {
pinos_log_debug ("link %p: clear buffers on port %p", link, port);
spa_node_port_use_buffers (port->node->node,
port->direction,
port->port_id,
NULL, 0);
port->buffers = NULL;
port->n_buffers = 0;
}
}
static SpaResult
Work on event loop Make a new epoll based event loop and use it for the data tranport. Simplify the spa event api a little and rename to SpaLoop
2016-11-18 17:46:01 +01:00
do_link_remove_done (SpaLoop *loop,
track client resources
2016-11-15 17:06:09 +01:00
bool async,
uint32_t seq,
size_t size,
void *data,
void *user_data)
{
PinosLink *this = user_data;
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, this);
track client resources
2016-11-15 17:06:09 +01:00
if (this->input) {
spa_list_remove (&this->input_link);
this->input->node->n_used_input_links--;
improve states
2017-01-19 20:07:03 +01:00
clear_port_buffers (this, this->input);
track client resources
2016-11-15 17:06:09 +01:00
if (this->input->node->n_used_input_links == 0 &&
this->input->node->n_used_output_links == 0)
Move suspend on idle in module Move suspend-on-idle code from the node to a module Add some more SpaLoop API
2016-11-21 12:54:40 +01:00
pinos_node_set_state (this->input->node, PINOS_NODE_STATE_IDLE);
track client resources
2016-11-15 17:06:09 +01:00
this->input = NULL;
}
if (this->output) {
spa_list_remove (&this->output_link);
this->output->node->n_used_output_links--;
improve states
2017-01-19 20:07:03 +01:00
clear_port_buffers (this, this->output);
track client resources
2016-11-15 17:06:09 +01:00
if (this->output->node->n_used_input_links == 0 &&
this->output->node->n_used_output_links == 0)
Move suspend on idle in module Move suspend-on-idle code from the node to a module Add some more SpaLoop API
2016-11-21 12:54:40 +01:00
pinos_node_set_state (this->output->node, PINOS_NODE_STATE_IDLE);
track client resources
2016-11-15 17:06:09 +01:00
this->output = NULL;
}
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
if (--impl->refcount == 0)
pinos_link_free (this);
track client resources
2016-11-15 17:06:09 +01:00
return SPA_RESULT_OK;
}
static SpaResult
Work on event loop Make a new epoll based event loop and use it for the data tranport. Simplify the spa event api a little and rename to SpaLoop
2016-11-18 17:46:01 +01:00
do_link_remove (SpaLoop *loop,
track client resources
2016-11-15 17:06:09 +01:00
bool async,
uint32_t seq,
size_t size,
void *data,
void *user_data)
{
SpaResult res;
PinosLink *this = user_data;
if (this->rt.input) {
spa_list_remove (&this->rt.input_link);
this->rt.input = NULL;
}
if (this->rt.output) {
spa_list_remove (&this->rt.output_link);
this->rt.output = NULL;
}
Mainloop: use PinosLoop Implement the main-loop with pinos_loop except for the parts that still need to go through glib mainloop. Start working on native protocol
2016-11-22 13:06:22 +01:00
res = pinos_loop_invoke (this->core->main_loop->loop,
do_link_remove_done,
seq,
0,
NULL,
this);
track client resources
2016-11-15 17:06:09 +01:00
return res;
}
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
/**
WIP Change object model
2016-11-10 15:42:14 +01:00
* pinos_link_destroy:
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
* @link: a #PinosLink
*
* Trigger removal of @link
*/
Work on async cleanup Track all async changes and only perform free of resources when all previous async operations completed.
2016-11-25 13:06:23 +01:00
void
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_link_destroy (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
{
WIP change object model
2016-11-14 12:42:00 +01:00
PinosLinkImpl *impl = SPA_CONTAINER_OF (this, PinosLinkImpl, this);
handle cleanup of remote proxies Destroying a resource informs the client to destroy the proxy. Destroying an object destroys all the bound resources on it.
2016-12-02 17:14:32 +01:00
PinosResource *resource, *tmp;
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
WIP change object model
2016-11-14 12:42:00 +01:00
pinos_log_debug ("link %p: destroy", impl);
pinos_signal_emit (&this->destroy_signal, 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
Rework dbus handling Remove the Daemon object and remove all dbus code from the main objects. We can use the signals in a separate module to create and destroy the DBus interfaces. Move the dbus protocol in a module Move the autolink policy to a module
2016-11-16 16:57:47 +01:00
pinos_global_destroy (this->global);
cleanups Remove hastables, use lists Remove obsolete ringbuffer some small cleanups
2016-11-15 20:12:31 +01:00
spa_list_remove (&this->link);
track client resources
2016-11-15 17:06:09 +01:00
handle cleanup of remote proxies Destroying a resource informs the client to destroy the proxy. Destroying an object destroys all the bound resources on it.
2016-12-02 17:14:32 +01:00
spa_list_for_each_safe (resource, tmp, &this->resource_list, link)
pinos_resource_destroy (resource);
WIP change object model
2016-11-14 12:42:00 +01:00
if (this->input) {
pinos_signal_remove (&impl->input_port_destroy);
pinos_signal_remove (&impl->input_async_complete);
track client resources
2016-11-15 17:06:09 +01:00
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
impl->refcount++;
pinos_loop_invoke (this->input->node->data_loop->loop,
do_link_remove,
Do cleanup of queues Wait for async state changes to complete
2017-01-12 20:02:58 +01:00
1,
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
0,
NULL,
this);
WIP change object model
2016-11-14 12:42:00 +01:00
}
if (this->output) {
pinos_signal_remove (&impl->output_port_destroy);
pinos_signal_remove (&impl->output_async_complete);
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
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
impl->refcount++;
pinos_loop_invoke (this->output->node->data_loop->loop,
do_link_remove,
Do cleanup of queues Wait for async state changes to complete
2017-01-12 20:02:58 +01:00
2,
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
0,
NULL,
this);
track client resources
2016-11-15 17:06:09 +01:00
}
Use refcounting for async shutdown fix some memory leaks
2017-01-12 14:57:07 +01:00
if (--impl->refcount == 0)
pinos_link_free (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
}
Reference in a new issue Copy permalink