mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-29 05:40:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

More hacking

Browse source 
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
This commit is contained in:
Wim Taymans 2016-11-03 19:41:53 +01:00
parent a1c0bef2ed
commit 7e46f9e3ad
81 changed files with 1831 additions and 1030 deletions
Download patch file Download diff file Expand all files Collapse all files

105
pinos/client/array.h Normal file
View file

@ -0,0 +1,105 @@
/* Simple Plugin API
* Copyright (C) 2016 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.
*/
#ifndef __PINOS_ARRAY_H__
#define __PINOS_ARRAY_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _PinosArray PinosArray;
#include <string.h>
#include <spa/defs.h>
struct _PinosArray {
void *data;
size_t size;
size_t alloc;
};
#define pinos_array_get_len_s(a,s) ((a)->size / (s))
#define pinos_array_get_unchecked_s(a,idx,s,t) SPA_MEMBER ((a)->data,(idx)*(s),t)
#define pinos_array_check_index_s(a,idx,s) ((idx) < pinos_array_get_len(a,s))
#define pinos_array_get_len(a,t) pinos_array_get_len_s(a,sizeof(t))
#define pinos_array_get_unchecked(a,idx,t) pinos_array_get_unchecked_s(a,idx,sizeof(t),t)
#define pinos_array_check_index(a,idx,t) pinos_array_check_index_s(a,idx,sizeof(t))
#define pinos_array_for_each(pos, array) \
for (pos = (array)->data; \
(const char *) pos < ((const char *) (array)->data + (array)->size); \
(pos)++)
static inline void
pinos_array_init (PinosArray *arr)
{
memset (arr, 0, sizeof (PinosArray));
}
static inline void
pinos_array_clear (PinosArray *arr)
{
free (arr->data);
}
static inline bool
pinos_array_ensure_size (PinosArray *arr,
size_t size)
{
size_t alloc, need;
alloc = arr->alloc;
need = alloc + size;
if (SPA_UNLIKELY (alloc < need)) {
void *data;
alloc = SPA_MAX (alloc, 16);
while (alloc < need)
alloc *= 2;
if (SPA_UNLIKELY ((data = realloc (arr->data, alloc)) == NULL))
return false;
arr->data = data;
arr->alloc = alloc;
}
return true;
}
static inline void *
pinos_array_add (PinosArray *arr,
size_t size)
{
void *p;
if (!pinos_array_ensure_size (arr, size))
return NULL;
p = arr->data + arr->size;
arr->size += size;
return p;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __PINOS_ARRAY_H__ */

405
pinos/client/connection.c
View file

@ -27,23 +27,24 @@
#include "connection.h"
#include "serialize.h"
#include "log.h"
#define MAX_BUFFER_SIZE 1024
#define MAX_FDS 28
typedef struct {
uint8_t *buffer_data;
size_t buffer_size;
size_t buffer_maxsize;
int fds[MAX_FDS];
unsigned int n_fds;
uint8_t *buffer_data;
size_t buffer_size;
size_t buffer_maxsize;
int fds[MAX_FDS];
unsigned int n_fds;
PinosControlCmd cmd;
off_t offset;
void *data;
size_t size;
PinosMessageType type;
off_t offset;
void *data;
size_t size;
bool update;
bool update;
} ConnectionBuffer;
struct _PinosConnection {
@ -52,9 +53,9 @@ struct _PinosConnection {
};
#if 0
#define PINOS_DEBUG_CONTROL(format,args...) g_debug(format,##args)
#define PINOS_DEBUG_MESSAGE(format,args...) pinos_log_debug(stderr, format,##args)
#else
#define PINOS_DEBUG_CONTROL(format,args...)
#define PINOS_DEBUG_MESSAGE(format,args...)
#endif
static bool
@ -80,20 +81,20 @@ read_length (uint8_t * data, unsigned int size, size_t * length, size_t * skip)
}
static void
connection_parse_node_update (PinosConnection *conn, PinosControlCmdNodeUpdate *nu)
connection_parse_node_update (PinosConnection *conn, PinosMessageNodeUpdate *nu)
{
memcpy (nu, conn->in.data, sizeof (PinosControlCmdNodeUpdate));
memcpy (nu, conn->in.data, sizeof (PinosMessageNodeUpdate));
if (nu->props)
nu->props = pinos_serialize_props_deserialize (conn->in.data, SPA_PTR_TO_INT (nu->props));
}
static void
connection_parse_port_update (PinosConnection *conn, PinosControlCmdPortUpdate *pu)
connection_parse_port_update (PinosConnection *conn, PinosMessagePortUpdate *pu)
{
void *p;
unsigned int i;
memcpy (pu, conn->in.data, sizeof (PinosControlCmdPortUpdate));
memcpy (pu, conn->in.data, sizeof (PinosMessagePortUpdate));
p = conn->in.data;
@ -115,47 +116,47 @@ connection_parse_port_update (PinosConnection *conn, PinosControlCmdPortUpdate *
}
static void
connection_parse_set_format (PinosConnection *conn, PinosControlCmdSetFormat *cmd)
connection_parse_set_format (PinosConnection *conn, PinosMessageSetFormat *cmd)
{
memcpy (cmd, conn->in.data, sizeof (PinosControlCmdSetFormat));
memcpy (cmd, conn->in.data, sizeof (PinosMessageSetFormat));
if (cmd->format)
cmd->format = pinos_serialize_format_deserialize (conn->in.data, SPA_PTR_TO_INT (cmd->format));
}
static void
connection_parse_use_buffers (PinosConnection *conn, PinosControlCmdUseBuffers *cmd)
connection_parse_use_buffers (PinosConnection *conn, PinosMessageUseBuffers *cmd)
{
void *p;
p = conn->in.data;
memcpy (cmd, p, sizeof (PinosControlCmdUseBuffers));
memcpy (cmd, p, sizeof (PinosMessageUseBuffers));
if (cmd->buffers)
cmd->buffers = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->buffers), PinosControlMemRef);
cmd->buffers = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->buffers), PinosMessageMemRef);
}
static void
connection_parse_node_event (PinosConnection *conn, PinosControlCmdNodeEvent *cmd)
connection_parse_node_event (PinosConnection *conn, PinosMessageNodeEvent *cmd)
{
void *p = conn->in.data;
memcpy (cmd, p, sizeof (PinosControlCmdNodeEvent));
memcpy (cmd, p, sizeof (PinosMessageNodeEvent));
if (cmd->event)
cmd->event = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->event), SpaNodeEvent);
}
static void
connection_parse_node_command (PinosConnection *conn, PinosControlCmdNodeCommand *cmd)
connection_parse_node_command (PinosConnection *conn, PinosMessageNodeCommand *cmd)
{
void *p = conn->in.data;
memcpy (cmd, p, sizeof (PinosControlCmdNodeCommand));
memcpy (cmd, p, sizeof (PinosMessageNodeCommand));
if (cmd->command)
cmd->command = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->command), SpaNodeCommand);
}
static void
connection_parse_port_command (PinosConnection *conn, PinosControlCmdPortCommand *cmd)
connection_parse_port_command (PinosConnection *conn, PinosMessagePortCommand *cmd)
{
void *p = conn->in.data;
memcpy (cmd, p, sizeof (PinosControlCmdPortCommand));
memcpy (cmd, p, sizeof (PinosMessagePortCommand));
if (cmd->command)
cmd->command = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->command), SpaNodeCommand);
}
@ -165,14 +166,14 @@ connection_ensure_size (PinosConnection *conn, ConnectionBuffer *buf, size_t siz
{
if (buf->buffer_size + size > buf->buffer_maxsize) {
buf->buffer_maxsize = buf->buffer_size + MAX_BUFFER_SIZE * ((size + MAX_BUFFER_SIZE-1) / MAX_BUFFER_SIZE);
g_debug ("connection %p: resize buffer to %zd", conn, buf->buffer_maxsize);
pinos_log_warn ("connection %p: resize buffer to %zd", conn, buf->buffer_maxsize);
buf->buffer_data = realloc (buf->buffer_data, buf->buffer_maxsize);
}
return (uint8_t *) buf->buffer_data + buf->buffer_size;
}
static void *
connection_add_cmd (PinosConnection *conn, PinosControlCmd cmd, size_t size)
connection_add_message (PinosConnection *conn, PinosMessageType type, size_t size)
{
uint8_t *p;
unsigned int plen;
@ -185,11 +186,11 @@ connection_add_cmd (PinosConnection *conn, PinosControlCmd cmd, size_t size)
/* 1 for cmd, plen for size and size for payload */
p = connection_ensure_size (conn, buf, 1 + plen + size);
buf->cmd = cmd;
buf->type = type;
buf->offset = buf->buffer_size;
buf->buffer_size += 1 + plen + size;
*p++ = cmd;
*p++ = type;
/* write length */
while (plen) {
plen--;
@ -199,21 +200,21 @@ connection_add_cmd (PinosConnection *conn, PinosControlCmd cmd, size_t size)
}
static void
connection_add_node_update (PinosConnection *conn, PinosControlCmdNodeUpdate *nu)
connection_add_node_update (PinosConnection *conn, PinosMessageNodeUpdate *nu)
{
size_t len;
void *p;
PinosControlCmdNodeUpdate *d;
PinosMessageNodeUpdate *d;
/* calc len */
len = sizeof (PinosControlCmdNodeUpdate);
len = sizeof (PinosMessageNodeUpdate);
len += pinos_serialize_props_get_size (nu->props);
p = connection_add_cmd (conn, PINOS_CONTROL_CMD_NODE_UPDATE, len);
memcpy (p, nu, sizeof (PinosControlCmdNodeUpdate));
p = connection_add_message (conn, PINOS_MESSAGE_NODE_UPDATE, len);
memcpy (p, nu, sizeof (PinosMessageNodeUpdate));
d = p;
p = SPA_MEMBER (d, sizeof (PinosControlCmdNodeUpdate), void);
p = SPA_MEMBER (d, sizeof (PinosMessageNodeUpdate), void);
if (nu->props) {
len = pinos_serialize_props_serialize (p, nu->props);
d->props = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
@ -223,16 +224,16 @@ connection_add_node_update (PinosConnection *conn, PinosControlCmdNodeUpdate *nu
}
static void
connection_add_port_update (PinosConnection *conn, PinosControlCmdPortUpdate *pu)
connection_add_port_update (PinosConnection *conn, PinosMessagePortUpdate *pu)
{
size_t len;
void *p;
int i;
SpaFormat **bfa;
PinosControlCmdPortUpdate *d;
PinosMessagePortUpdate *d;
/* calc len */
len = sizeof (PinosControlCmdPortUpdate);
len = sizeof (PinosMessagePortUpdate);
len += pu->n_possible_formats * sizeof (SpaFormat *);
for (i = 0; i < pu->n_possible_formats; i++) {
len += pinos_serialize_format_get_size (pu->possible_formats[i]);
@ -242,11 +243,11 @@ connection_add_port_update (PinosConnection *conn, PinosControlCmdPortUpdate *pu
if (pu->info)
len += pinos_serialize_port_info_get_size (pu->info);
p = connection_add_cmd (conn, PINOS_CONTROL_CMD_PORT_UPDATE, len);
memcpy (p, pu, sizeof (PinosControlCmdPortUpdate));
p = connection_add_message (conn, PINOS_MESSAGE_PORT_UPDATE, len);
memcpy (p, pu, sizeof (PinosMessagePortUpdate));
d = p;
p = SPA_MEMBER (d, sizeof (PinosControlCmdPortUpdate), void);
p = SPA_MEMBER (d, sizeof (PinosMessagePortUpdate), void);
bfa = p;
if (pu->n_possible_formats)
d->possible_formats = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
@ -284,19 +285,19 @@ connection_add_port_update (PinosConnection *conn, PinosControlCmdPortUpdate *pu
}
static void
connection_add_set_format (PinosConnection *conn, PinosControlCmdSetFormat *sf)
connection_add_set_format (PinosConnection *conn, PinosMessageSetFormat *sf)
{
size_t len;
void *p;
/* calculate length */
/* port_id + format + mask */
len = sizeof (PinosControlCmdSetFormat) + pinos_serialize_format_get_size (sf->format);
p = connection_add_cmd (conn, PINOS_CONTROL_CMD_SET_FORMAT, len);
memcpy (p, sf, sizeof (PinosControlCmdSetFormat));
len = sizeof (PinosMessageSetFormat) + pinos_serialize_format_get_size (sf->format);
p = connection_add_message (conn, PINOS_MESSAGE_SET_FORMAT, len);
memcpy (p, sf, sizeof (PinosMessageSetFormat));
sf = p;
p = SPA_MEMBER (sf, sizeof (PinosControlCmdSetFormat), void);
p = SPA_MEMBER (sf, sizeof (PinosMessageSetFormat), void);
if (sf->format) {
len = pinos_serialize_format_serialize (p, sf->format);
sf->format = SPA_INT_TO_PTR (SPA_PTRDIFF (p, sf));
@ -305,21 +306,21 @@ connection_add_set_format (PinosConnection *conn, PinosControlCmdSetFormat *sf)
}
static void
connection_add_use_buffers (PinosConnection *conn, PinosControlCmdUseBuffers *ub)
connection_add_use_buffers (PinosConnection *conn, PinosMessageUseBuffers *ub)
{
size_t len;
int i;
PinosControlCmdUseBuffers *d;
PinosControlMemRef *mr;
PinosMessageUseBuffers *d;
PinosMessageMemRef *mr;
/* calculate length */
len = sizeof (PinosControlCmdUseBuffers);
len += ub->n_buffers * sizeof (PinosControlMemRef);
len = sizeof (PinosMessageUseBuffers);
len += ub->n_buffers * sizeof (PinosMessageMemRef);
d = connection_add_cmd (conn, PINOS_CONTROL_CMD_USE_BUFFERS, len);
memcpy (d, ub, sizeof (PinosControlCmdUseBuffers));
d = connection_add_message (conn, PINOS_MESSAGE_USE_BUFFERS, len);
memcpy (d, ub, sizeof (PinosMessageUseBuffers));
mr = SPA_MEMBER (d, sizeof (PinosControlCmdUseBuffers), void);
mr = SPA_MEMBER (d, sizeof (PinosMessageUseBuffers), void);
if (d->n_buffers)
d->buffers = SPA_INT_TO_PTR (SPA_PTRDIFF (mr, d));
@ -327,73 +328,73 @@ connection_add_use_buffers (PinosConnection *conn, PinosControlCmdUseBuffers *ub
d->buffers = 0;
for (i = 0; i < ub->n_buffers; i++)
memcpy (&mr[i], &ub->buffers[i], sizeof (PinosControlMemRef));
memcpy (&mr[i], &ub->buffers[i], sizeof (PinosMessageMemRef));
}
static void
connection_add_node_event (PinosConnection *conn, PinosControlCmdNodeEvent *ev)
connection_add_node_event (PinosConnection *conn, PinosMessageNodeEvent *ev)
{
size_t len;
void *p;
PinosControlCmdNodeEvent *d;
PinosMessageNodeEvent *d;
/* calculate length */
len = sizeof (PinosControlCmdNodeEvent);
len = sizeof (PinosMessageNodeEvent);
len += ev->event->size;
p = connection_add_cmd (conn, PINOS_CONTROL_CMD_NODE_EVENT, len);
memcpy (p, ev, sizeof (PinosControlCmdNodeEvent));
p = connection_add_message (conn, PINOS_MESSAGE_NODE_EVENT, len);
memcpy (p, ev, sizeof (PinosMessageNodeEvent));
d = p;
p = SPA_MEMBER (d, sizeof (PinosControlCmdNodeEvent), void);
p = SPA_MEMBER (d, sizeof (PinosMessageNodeEvent), void);
d->event = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
memcpy (p, ev->event, ev->event->size);
}
static void
connection_add_node_command (PinosConnection *conn, PinosControlCmdNodeCommand *cm)
connection_add_node_command (PinosConnection *conn, PinosMessageNodeCommand *cm)
{
size_t len;
void *p;
PinosControlCmdNodeCommand *d;
PinosMessageNodeCommand *d;
/* calculate length */
len = sizeof (PinosControlCmdNodeCommand);
len = sizeof (PinosMessageNodeCommand);
len += cm->command->size;
p = connection_add_cmd (conn, PINOS_CONTROL_CMD_NODE_COMMAND, len);
memcpy (p, cm, sizeof (PinosControlCmdNodeCommand));
p = connection_add_message (conn, PINOS_MESSAGE_NODE_COMMAND, len);
memcpy (p, cm, sizeof (PinosMessageNodeCommand));
d = p;
p = SPA_MEMBER (d, sizeof (PinosControlCmdNodeCommand), void);
p = SPA_MEMBER (d, sizeof (PinosMessageNodeCommand), void);
d->command = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
memcpy (p, cm->command, cm->command->size);
}
static void
connection_add_port_command (PinosConnection *conn, PinosControlCmdPortCommand *cm)
connection_add_port_command (PinosConnection *conn, PinosMessagePortCommand *cm)
{
size_t len;
void *p;
PinosControlCmdPortCommand *d;
PinosMessagePortCommand *d;
/* calculate length */
len = sizeof (PinosControlCmdPortCommand);
len = sizeof (PinosMessagePortCommand);
len += cm->command->size;
p = connection_add_cmd (conn, PINOS_CONTROL_CMD_PORT_COMMAND, len);
memcpy (p, cm, sizeof (PinosControlCmdPortCommand));
p = connection_add_message (conn, PINOS_MESSAGE_PORT_COMMAND, len);
memcpy (p, cm, sizeof (PinosMessagePortCommand));
d = p;
p = SPA_MEMBER (d, sizeof (PinosControlCmdPortCommand), void);
p = SPA_MEMBER (d, sizeof (PinosMessagePortCommand), void);
d->command = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
memcpy (p, cm->command, cm->command->size);
}
static gboolean
static bool
refill_buffer (PinosConnection *conn, ConnectionBuffer *buf)
{
ssize_t len;
@ -422,7 +423,7 @@ refill_buffer (PinosConnection *conn, ConnectionBuffer *buf)
}
if (len < 4)
return FALSE;
return false;
buf->buffer_size += len;
@ -434,15 +435,15 @@ refill_buffer (PinosConnection *conn, ConnectionBuffer *buf)
buf->n_fds = (cmsg->cmsg_len - ((char *)CMSG_DATA (cmsg) - (char *)cmsg)) / sizeof (int);
memcpy (buf->fds, CMSG_DATA (cmsg), buf->n_fds * sizeof (int));
}
PINOS_DEBUG_CONTROL ("connection %p: %d read %zd bytes and %d fds", conn, conn->fd, len, buf->n_fds);
PINOS_DEBUG_MESSAGE ("connection %p: %d read %zd bytes and %d fds", conn, conn->fd, len, buf->n_fds);
return TRUE;
return true;
/* ERRORS */
recv_error:
{
g_warning ("could not recvmsg on fd %d: %s", conn->fd, strerror (errno));
return FALSE;
pinos_log_error ("could not recvmsg on fd %d: %s", conn->fd, strerror (errno));
return false;
}
}
@ -458,7 +459,7 @@ clear_buffer (ConnectionBuffer *buf)
}
}
buf->n_fds = 0;
buf->cmd = PINOS_CONTROL_CMD_INVALID;
buf->type = PINOS_MESSAGE_INVALID;
buf->offset = 0;
buf->size = 0;
buf->buffer_size = 0;
@ -494,16 +495,16 @@ pinos_connection_free (PinosConnection *conn)
*
* Move to the next packet in @conn.
*
* Returns: %TRUE if more packets are available.
* Returns: %true if more packets are available.
*/
gboolean
bool
pinos_connection_has_next (PinosConnection *conn)
{
size_t len, size, skip;
uint8_t *data;
ConnectionBuffer *buf;
g_return_val_if_fail (conn != NULL, FALSE);
spa_return_val_if_fail (conn != NULL, false);
buf = &conn->in;
@ -523,13 +524,13 @@ again:
if (buf->offset >= size) {
clear_buffer (buf);
buf->update = true;
return FALSE;
return false;
}
data += buf->offset;
size -= buf->offset;
buf->cmd = *data;
buf->type = *data;
data++;
size--;
@ -542,97 +543,97 @@ again:
buf->data = data + skip;
buf->offset += 1 + skip;
return TRUE;
return true;
}
PinosControlCmd
pinos_connection_get_cmd (PinosConnection *conn)
PinosMessageType
pinos_connection_get_type (PinosConnection *conn)
{
g_return_val_if_fail (conn != NULL, PINOS_CONTROL_CMD_INVALID);
spa_return_val_if_fail (conn != NULL, PINOS_MESSAGE_INVALID);
return conn->in.cmd;
return conn->in.type;
}
gboolean
pinos_connection_parse_cmd (PinosConnection *conn,
gpointer command)
bool
pinos_connection_parse_message (PinosConnection *conn,
void *message)
{
g_return_val_if_fail (conn != NULL, FALSE);
spa_return_val_if_fail (conn != NULL, false);
switch (conn->in.cmd) {
switch (conn->in.type) {
/* C -> S */
case PINOS_CONTROL_CMD_NODE_UPDATE:
connection_parse_node_update (conn, command);
case PINOS_MESSAGE_NODE_UPDATE:
connection_parse_node_update (conn, message);
break;
case PINOS_CONTROL_CMD_PORT_UPDATE:
connection_parse_port_update (conn, command);
case PINOS_MESSAGE_PORT_UPDATE:
connection_parse_port_update (conn, message);
break;
case PINOS_CONTROL_CMD_PORT_STATUS_CHANGE:
g_warning ("implement iter of %d", conn->in.cmd);
case PINOS_MESSAGE_PORT_STATUS_CHANGE:
pinos_log_warn ("implement iter of %d", conn->in.type);
break;
case PINOS_CONTROL_CMD_NODE_STATE_CHANGE:
if (conn->in.size < sizeof (PinosControlCmdNodeStateChange))
return FALSE;
memcpy (command, conn->in.data, sizeof (PinosControlCmdNodeStateChange));
case PINOS_MESSAGE_NODE_STATE_CHANGE:
if (conn->in.size < sizeof (PinosMessageNodeStateChange))
return false;
memcpy (message, conn->in.data, sizeof (PinosMessageNodeStateChange));
break;
/* S -> C */
case PINOS_CONTROL_CMD_ADD_PORT:
if (conn->in.size < sizeof (PinosControlCmdAddPort))
return FALSE;
memcpy (command, conn->in.data, sizeof (PinosControlCmdAddPort));
case PINOS_MESSAGE_ADD_PORT:
if (conn->in.size < sizeof (PinosMessageAddPort))
return false;
memcpy (message, conn->in.data, sizeof (PinosMessageAddPort));
break;
case PINOS_CONTROL_CMD_REMOVE_PORT:
if (conn->in.size < sizeof (PinosControlCmdRemovePort))
return FALSE;
memcpy (command, conn->in.data, sizeof (PinosControlCmdRemovePort));
case PINOS_MESSAGE_REMOVE_PORT:
if (conn->in.size < sizeof (PinosMessageRemovePort))
return false;
memcpy (message, conn->in.data, sizeof (PinosMessageRemovePort));
break;
case PINOS_CONTROL_CMD_SET_FORMAT:
connection_parse_set_format (conn, command);
case PINOS_MESSAGE_SET_FORMAT:
connection_parse_set_format (conn, message);
break;
case PINOS_CONTROL_CMD_SET_PROPERTY:
g_warning ("implement iter of %d", conn->in.cmd);
case PINOS_MESSAGE_SET_PROPERTY:
pinos_log_warn ("implement iter of %d", conn->in.type);
break;
/* bidirectional */
case PINOS_CONTROL_CMD_ADD_MEM:
if (conn->in.size < sizeof (PinosControlCmdAddMem))
return FALSE;
memcpy (command, conn->in.data, sizeof (PinosControlCmdAddMem));
case PINOS_MESSAGE_ADD_MEM:
if (conn->in.size < sizeof (PinosMessageAddMem))
return false;
memcpy (message, conn->in.data, sizeof (PinosMessageAddMem));
break;
case PINOS_CONTROL_CMD_USE_BUFFERS:
connection_parse_use_buffers (conn, command);
case PINOS_MESSAGE_USE_BUFFERS:
connection_parse_use_buffers (conn, message);
break;
case PINOS_CONTROL_CMD_PROCESS_BUFFER:
if (conn->in.size < sizeof (PinosControlCmdProcessBuffer))
return FALSE;
memcpy (command, conn->in.data, sizeof (PinosControlCmdProcessBuffer));
case PINOS_MESSAGE_PROCESS_BUFFER:
if (conn->in.size < sizeof (PinosMessageProcessBuffer))
return false;
memcpy (message, conn->in.data, sizeof (PinosMessageProcessBuffer));
break;
case PINOS_CONTROL_CMD_NODE_EVENT:
connection_parse_node_event (conn, command);
case PINOS_MESSAGE_NODE_EVENT:
connection_parse_node_event (conn, message);
break;
case PINOS_CONTROL_CMD_NODE_COMMAND:
connection_parse_node_command (conn, command);
case PINOS_MESSAGE_NODE_COMMAND:
connection_parse_node_command (conn, message);
break;
case PINOS_CONTROL_CMD_PORT_COMMAND:
connection_parse_port_command (conn, command);
case PINOS_MESSAGE_PORT_COMMAND:
connection_parse_port_command (conn, message);
break;
case PINOS_CONTROL_CMD_INVALID:
return FALSE;
case PINOS_MESSAGE_INVALID:
return false;
}
return TRUE;
return true;
}
/**
@ -648,13 +649,13 @@ pinos_connection_parse_cmd (PinosConnection *conn,
*/
int
pinos_connection_get_fd (PinosConnection *conn,
guint index,
gboolean close)
unsigned int index,
bool close)
{
int fd;
g_return_val_if_fail (conn != NULL, -1);
g_return_val_if_fail (index < conn->in.n_fds, -1);
spa_return_val_if_fail (conn != NULL, -1);
spa_return_val_if_fail (index < conn->in.n_fds, -1);
fd = conn->in.fds[index];
if (fd < 0)
@ -677,11 +678,11 @@ pinos_connection_get_fd (PinosConnection *conn,
int
pinos_connection_add_fd (PinosConnection *conn,
int fd,
gboolean close)
bool close)
{
int index, i;
g_return_val_if_fail (conn != NULL, -1);
spa_return_val_if_fail (conn != NULL, -1);
for (i = 0; i < conn->out.n_fds; i++) {
if (conn->out.fds[i] == fd || conn->out.fds[i] == -fd)
@ -696,97 +697,97 @@ pinos_connection_add_fd (PinosConnection *conn,
}
/**
* pinos_connection_add_cmd:
* pinos_connection_add_message:
* @conn: a #PinosConnection
* @cmd: a #PinosControlCmd
* @command: a command
* @type: a #PinosMessageType
* @message: a message
*
* Add a @cmd to @conn with data from @command.
* Add a @cmd to @conn with data from @message.
*
* Returns: %TRUE on success.
* Returns: %true on success.
*/
gboolean
pinos_connection_add_cmd (PinosConnection *conn,
PinosControlCmd cmd,
gpointer command)
bool
pinos_connection_add_message (PinosConnection *conn,
PinosMessageType type,
void *message)
{
void *p;
g_return_val_if_fail (conn != NULL, FALSE);
g_return_val_if_fail (command != NULL, FALSE);
spa_return_val_if_fail (conn != NULL, false);
spa_return_val_if_fail (message != NULL, false);
switch (cmd) {
switch (type) {
/* C -> S */
case PINOS_CONTROL_CMD_NODE_UPDATE:
connection_add_node_update (conn, command);
case PINOS_MESSAGE_NODE_UPDATE:
connection_add_node_update (conn, message);
break;
case PINOS_CONTROL_CMD_PORT_UPDATE:
connection_add_port_update (conn, command);
case PINOS_MESSAGE_PORT_UPDATE:
connection_add_port_update (conn, message);
break;
case PINOS_CONTROL_CMD_PORT_STATUS_CHANGE:
p = connection_add_cmd (conn, cmd, 0);
case PINOS_MESSAGE_PORT_STATUS_CHANGE:
p = connection_add_message (conn, type, 0);
break;
case PINOS_CONTROL_CMD_NODE_STATE_CHANGE:
p = connection_add_cmd (conn, cmd, sizeof (PinosControlCmdNodeStateChange));
memcpy (p, command, sizeof (PinosControlCmdNodeStateChange));
case PINOS_MESSAGE_NODE_STATE_CHANGE:
p = connection_add_message (conn, type, sizeof (PinosMessageNodeStateChange));
memcpy (p, message, sizeof (PinosMessageNodeStateChange));
break;
/* S -> C */
case PINOS_CONTROL_CMD_ADD_PORT:
p = connection_add_cmd (conn, cmd, sizeof (PinosControlCmdAddPort));
memcpy (p, command, sizeof (PinosControlCmdAddPort));
case PINOS_MESSAGE_ADD_PORT:
p = connection_add_message (conn, type, sizeof (PinosMessageAddPort));
memcpy (p, message, sizeof (PinosMessageAddPort));
break;
case PINOS_CONTROL_CMD_REMOVE_PORT:
p = connection_add_cmd (conn, cmd, sizeof (PinosControlCmdRemovePort));
memcpy (p, command, sizeof (PinosControlCmdRemovePort));
case PINOS_MESSAGE_REMOVE_PORT:
p = connection_add_message (conn, type, sizeof (PinosMessageRemovePort));
memcpy (p, message, sizeof (PinosMessageRemovePort));
break;
case PINOS_CONTROL_CMD_SET_FORMAT:
connection_add_set_format (conn, command);
case PINOS_MESSAGE_SET_FORMAT:
connection_add_set_format (conn, message);
break;
case PINOS_CONTROL_CMD_SET_PROPERTY:
g_warning ("implement builder of %d", cmd);
case PINOS_MESSAGE_SET_PROPERTY:
pinos_log_warn ("implement builder of %d", type);
break;
/* bidirectional */
case PINOS_CONTROL_CMD_ADD_MEM:
p = connection_add_cmd (conn, cmd, sizeof (PinosControlCmdAddMem));
memcpy (p, command, sizeof (PinosControlCmdAddMem));
case PINOS_MESSAGE_ADD_MEM:
p = connection_add_message (conn, type, sizeof (PinosMessageAddMem));
memcpy (p, message, sizeof (PinosMessageAddMem));
break;
case PINOS_CONTROL_CMD_USE_BUFFERS:
connection_add_use_buffers (conn, command);
case PINOS_MESSAGE_USE_BUFFERS:
connection_add_use_buffers (conn, message);
break;
case PINOS_CONTROL_CMD_PROCESS_BUFFER:
p = connection_add_cmd (conn, cmd, sizeof (PinosControlCmdProcessBuffer));
memcpy (p, command, sizeof (PinosControlCmdProcessBuffer));
case PINOS_MESSAGE_PROCESS_BUFFER:
p = connection_add_message (conn, type, sizeof (PinosMessageProcessBuffer));
memcpy (p, message, sizeof (PinosMessageProcessBuffer));
break;
case PINOS_CONTROL_CMD_NODE_EVENT:
connection_add_node_event (conn, command);
case PINOS_MESSAGE_NODE_EVENT:
connection_add_node_event (conn, message);
break;
case PINOS_CONTROL_CMD_NODE_COMMAND:
connection_add_node_command (conn, command);
case PINOS_MESSAGE_NODE_COMMAND:
connection_add_node_command (conn, message);
break;
case PINOS_CONTROL_CMD_PORT_COMMAND:
connection_add_port_command (conn, command);
case PINOS_MESSAGE_PORT_COMMAND:
connection_add_port_command (conn, message);
break;
case PINOS_CONTROL_CMD_INVALID:
return FALSE;
case PINOS_MESSAGE_INVALID:
return false;
}
return TRUE;
return true;
}
gboolean
bool
pinos_connection_flush (PinosConnection *conn)
{
ssize_t len;
@ -797,12 +798,12 @@ pinos_connection_flush (PinosConnection *conn)
int *cm, i, fds_len;
ConnectionBuffer *buf;
g_return_val_if_fail (conn != NULL, FALSE);
spa_return_val_if_fail (conn != NULL, false);
buf = &conn->out;
if (buf->buffer_size == 0)
return TRUE;
return true;
fds_len = buf->n_fds * sizeof (int);
@ -840,26 +841,26 @@ pinos_connection_flush (PinosConnection *conn)
buf->buffer_size -= len;
buf->n_fds = 0;
PINOS_DEBUG_CONTROL ("connection %p: %d written %zd bytes and %u fds", conn, conn->fd, len, buf->n_fds);
PINOS_DEBUG_MESSAGE ("connection %p: %d written %zd bytes and %u fds", conn, conn->fd, len, buf->n_fds);
return TRUE;
return true;
/* ERRORS */
send_error:
{
g_warning ("could not sendmsg: %s", strerror (errno));
return FALSE;
pinos_log_error ("could not sendmsg: %s", strerror (errno));
return false;
}
}
gboolean
bool
pinos_connection_clear (PinosConnection *conn)
{
g_return_val_if_fail (conn != NULL, FALSE);
spa_return_val_if_fail (conn != NULL, false);
clear_buffer (&conn->out);
clear_buffer (&conn->in);
conn->in.update = true;
return TRUE;
return true;
}

155
pinos/client/connection.h
View file

@ -17,12 +17,12 @@
* Boston, MA 02110-1301, USA.
*/
#ifndef __PINOS_CONTROL_H__
#define __PINOS_CONTROL_H__
#ifndef __PINOS_CONNECTION_H__
#define __PINOS_CONNECTION_H__
#include <glib-object.h>
G_BEGIN_DECLS
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/defs.h>
#include <spa/props.h>
@ -33,113 +33,116 @@ G_BEGIN_DECLS
typedef struct _PinosConnection PinosConnection;
typedef enum {
PINOS_CONTROL_CMD_INVALID = 0,
PINOS_MESSAGE_INVALID = 0,
/* client to server */
PINOS_CONTROL_CMD_NODE_UPDATE = 1,
PINOS_CONTROL_CMD_PORT_UPDATE = 2,
PINOS_CONTROL_CMD_NODE_STATE_CHANGE = 3,
PINOS_MESSAGE_NODE_UPDATE = 1,
PINOS_MESSAGE_PORT_UPDATE = 2,
PINOS_MESSAGE_NODE_STATE_CHANGE = 3,
PINOS_CONTROL_CMD_PORT_STATUS_CHANGE = 4,
PINOS_MESSAGE_PORT_STATUS_CHANGE = 4,
PINOS_MESSAGE_NODE_EVENT = 5,
/* server to client */
PINOS_CONTROL_CMD_ADD_PORT = 32,
PINOS_CONTROL_CMD_REMOVE_PORT = 33,
PINOS_MESSAGE_ADD_PORT = 32,
PINOS_MESSAGE_REMOVE_PORT = 33,
PINOS_CONTROL_CMD_SET_FORMAT = 34,
PINOS_CONTROL_CMD_SET_PROPERTY = 35,
PINOS_MESSAGE_SET_FORMAT = 34,
PINOS_MESSAGE_SET_PROPERTY = 35,
PINOS_CONTROL_CMD_NODE_COMMAND = 36,
PINOS_CONTROL_CMD_PORT_COMMAND = 37,
PINOS_MESSAGE_NODE_COMMAND = 36,
PINOS_MESSAGE_PORT_COMMAND = 37,
/* both */
PINOS_CONTROL_CMD_ADD_MEM = 64,
PINOS_CONTROL_CMD_USE_BUFFERS = 66,
PINOS_CONTROL_CMD_PROCESS_BUFFER = 67,
PINOS_MESSAGE_ADD_MEM = 64,
PINOS_MESSAGE_USE_BUFFERS = 66,
PINOS_MESSAGE_PROCESS_BUFFER = 67,
PINOS_CONTROL_CMD_NODE_EVENT = 68,
} PinosControlCmd;
} PinosMessageType;
/* PINOS_CONTROL_CMD_NODE_UPDATE */
/* PINOS_MESSAGE_NODE_UPDATE */
typedef struct {
#define PINOS_CONTROL_CMD_NODE_UPDATE_MAX_INPUTS (1 << 0)
#define PINOS_CONTROL_CMD_NODE_UPDATE_MAX_OUTPUTS (1 << 1)
#define PINOS_CONTROL_CMD_NODE_UPDATE_PROPS (1 << 2)
#define PINOS_MESSAGE_NODE_UPDATE_MAX_INPUTS (1 << 0)
#define PINOS_MESSAGE_NODE_UPDATE_MAX_OUTPUTS (1 << 1)
#define PINOS_MESSAGE_NODE_UPDATE_PROPS (1 << 2)
uint32_t change_mask;
unsigned int max_input_ports;
unsigned int max_output_ports;
const SpaProps *props;
} PinosControlCmdNodeUpdate;
} PinosMessageNodeUpdate;
/* PINOS_CONTROL_CMD_PORT_UPDATE */
/* PINOS_MESSAGE_PORT_UPDATE */
typedef struct {
SpaDirection direction;
uint32_t port_id;
#define PINOS_CONTROL_CMD_PORT_UPDATE_POSSIBLE_FORMATS (1 << 0)
#define PINOS_CONTROL_CMD_PORT_UPDATE_FORMAT (1 << 1)
#define PINOS_CONTROL_CMD_PORT_UPDATE_PROPS (1 << 2)
#define PINOS_CONTROL_CMD_PORT_UPDATE_INFO (1 << 3)
#define PINOS_MESSAGE_PORT_UPDATE_POSSIBLE_FORMATS (1 << 0)
#define PINOS_MESSAGE_PORT_UPDATE_FORMAT (1 << 1)
#define PINOS_MESSAGE_PORT_UPDATE_PROPS (1 << 2)
#define PINOS_MESSAGE_PORT_UPDATE_INFO (1 << 3)
uint32_t change_mask;
unsigned int n_possible_formats;
SpaFormat **possible_formats;
SpaFormat *format;
const SpaProps *props;
const SpaPortInfo *info;
} PinosControlCmdPortUpdate;
} PinosMessagePortUpdate;
/* PINOS_CONTROL_CMD_PORT_STATUS_CHANGE */
/* PINOS_CONTROL_CMD_NODE_STATE_CHANGE */
/* PINOS_MESSAGE_NODE_STATE_CHANGE */
typedef struct {
SpaNodeState state;
} PinosControlCmdNodeStateChange;
} PinosMessageNodeStateChange;
/* PINOS_CONTROL_CMD_ADD_PORT */
/* PINOS_MESSAGE_PORT_STATUS_CHANGE */
/* PINOS_MESSAGE_NODE_EVENT */
typedef struct {
SpaNodeEvent *event;
} PinosMessageNodeEvent;
/* PINOS_MESSAGE_ADD_PORT */
typedef struct {
uint32_t seq;
SpaDirection direction;
uint32_t port_id;
} PinosControlCmdAddPort;
} PinosMessageAddPort;
/* PINOS_CONTROL_CMD_REMOVE_PORT */
/* PINOS_MESSAGE_REMOVE_PORT */
typedef struct {
uint32_t seq;
SpaDirection direction;
uint32_t port_id;
} PinosControlCmdRemovePort;
} PinosMessageRemovePort;
/* PINOS_CONTROL_CMD_SET_FORMAT */
/* PINOS_MESSAGE_SET_FORMAT */
typedef struct {
uint32_t seq;
SpaDirection direction;
uint32_t port_id;
SpaPortFormatFlags flags;
SpaFormat *format;
} PinosControlCmdSetFormat;
} PinosMessageSetFormat;
/* PINOS_CONTROL_CMD_SET_PROPERTY */
/* PINOS_MESSAGE_SET_PROPERTY */
typedef struct {
uint32_t seq;
SpaDirection direction;
uint32_t port_id;
uint32_t id;
size_t size;
void *value;
} PinosControlCmdSetProperty;
} PinosMessageSetProperty;
/* PINOS_CONTROL_CMD_NODE_COMMAND */
/* PINOS_MESSAGE_NODE_COMMAND */
typedef struct {
uint32_t seq;
SpaNodeCommand *command;
} PinosControlCmdNodeCommand;
} PinosMessageNodeCommand;
/* PINOS_CONTROL_CMD_PORT_COMMAND */
/* PINOS_MESSAGE_PORT_COMMAND */
typedef struct {
uint32_t port_id;
SpaNodeCommand *command;
} PinosControlCmdPortCommand;
} PinosMessagePortCommand;
/* PINOS_CONTROL_CMD_ADD_MEM */
/* PINOS_MESSAGE_ADD_MEM */
typedef struct {
SpaDirection direction;
uint32_t port_id;
@ -149,57 +152,53 @@ typedef struct {
uint32_t flags;
off_t offset;
size_t size;
} PinosControlCmdAddMem;
} PinosMessageAddMem;
typedef struct {
uint32_t mem_id;
off_t offset;
size_t size;
} PinosControlMemRef;
} PinosMessageMemRef;
/* PINOS_CONTROL_CMD_USE_BUFFERS */
/* PINOS_MESSAGE_USE_BUFFERS */
typedef struct {
uint32_t seq;
SpaDirection direction;
uint32_t port_id;
unsigned int n_buffers;
PinosControlMemRef *buffers;
} PinosControlCmdUseBuffers;
PinosMessageMemRef *buffers;
} PinosMessageUseBuffers;
/* PINOS_CONTROL_CMD_PROCESS_BUFFER */
/* PINOS_MESSAGE_PROCESS_BUFFER */
typedef struct {
SpaDirection direction;
uint32_t port_id;
uint32_t buffer_id;
} PinosControlCmdProcessBuffer;
/* PINOS_CONTROL_CMD_NODE_EVENT */
typedef struct {
SpaNodeEvent *event;
} PinosControlCmdNodeEvent;
} PinosMessageProcessBuffer;
PinosConnection * pinos_connection_new (int fd);
void pinos_connection_free (PinosConnection *conn);
gboolean pinos_connection_has_next (PinosConnection *conn);
PinosControlCmd pinos_connection_get_cmd (PinosConnection *conn);
gboolean pinos_connection_parse_cmd (PinosConnection *conn,
gpointer command);
bool pinos_connection_has_next (PinosConnection *conn);
PinosMessageType pinos_connection_get_type (PinosConnection *conn);
bool pinos_connection_parse_message (PinosConnection *conn,
void *msg);
int pinos_connection_get_fd (PinosConnection *conn,
guint index,
gboolean close);
unsigned int index,
bool close);
int pinos_connection_add_fd (PinosConnection *conn,
int fd,
gboolean close);
gboolean pinos_connection_add_cmd (PinosConnection *conn,
PinosControlCmd cmd,
gpointer command);
bool close);
bool pinos_connection_add_message (PinosConnection *conn,
PinosMessageType type,
void *msg);
gboolean pinos_connection_flush (PinosConnection *conn);
gboolean pinos_connection_clear (PinosConnection *conn);
bool pinos_connection_flush (PinosConnection *conn);
bool pinos_connection_clear (PinosConnection *conn);
G_END_DECLS
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __PINOS_CONTROL_H__ */
#endif /* __PINOS_CONNECTION_H__ */

4
pinos/client/context.c
View file

@ -137,7 +137,7 @@ pinos_context_finalize (GObject * object)
PinosContext *context = PINOS_CONTEXT (object);
PinosContextPrivate *priv = context->priv;
g_debug ("free context %p", context);
pinos_log_debug ("free context %p", context);
if (priv->id)
g_bus_unwatch_name(priv->id);
@ -277,7 +277,7 @@ pinos_context_init (PinosContext * context)
{
PinosContextPrivate *priv = context->priv = PINOS_CONTEXT_GET_PRIVATE (context);
g_debug ("new context %p", context);
pinos_log_debug ("new context %p", context);
priv->state = PINOS_CONTEXT_STATE_UNCONNECTED;

106
pinos/client/log.c Normal file
View file

@ -0,0 +1,106 @@
/* 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 <stdio.h>
#include <pinos/client/log.h>
static void
do_logv (SpaLog *log,
SpaLogLevel level,
const char *file,
int line,
const char *func,
const char *fmt,
va_list args)
{
char text[16*1024], location[128];
static const char *levels[] = {
"-",
"E",
"W",
"I",
"D",
"T",
};
vsnprintf (text, sizeof(text), fmt, args);
if (1) {
snprintf (location, sizeof(location), "%s:%i %s()", strrchr (file, '/')+1, line, func);
fprintf(stderr, "[%s][%s] %s\n", levels[level], location, text);
} else {
fprintf(stderr, "[%s] %s\n", levels[level], text);
}
}
static void
do_log (SpaLog *log,
SpaLogLevel level,
const char *file,
int line,
const char *func,
const char *fmt, ...)
{
va_list args;
va_start (args, fmt);
do_logv (log, level, file, line, func, fmt, args);
va_end (args);
}
static SpaLog log = {
sizeof (SpaLog),
NULL,
SPA_LOG_LEVEL_DEBUG,
do_log,
do_logv,
};
SpaLog *
pinos_log_get (void)
{
return &log;
}
void
pinos_log_log (SpaLogLevel level,
const char *file,
int line,
const char *func,
const char *fmt, ...)
{
if (log.level >= level) {
va_list args;
va_start (args, fmt);
do_logv (&log, level, file, line, func, fmt, args);
va_end (args);
}
}
void
pinos_log_logv (SpaLogLevel level,
const char *file,
int line,
const char *func,
const char *fmt,
va_list args)
{
if (log.level >= level) {
do_logv (&log, level, file, line, func, fmt, args);
}
}

74
pinos/client/log.h Normal file
View file

@ -0,0 +1,74 @@
/* 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.
*/
#ifndef __PINOS_LOG_H__
#define __PINOS_LOG_H__
#include <spa/log.h>
#ifdef __cplusplus
extern "C" {
#endif
SpaLog * pinos_log_get (void);
void pinos_log_log (SpaLogLevel level,
const char *file,
int line,
const char *func,
const char *fmt, ...) SPA_PRINTF_FUNC(5, 6);
void pinos_log_logv (SpaLogLevel level,
const char *file,
int line,
const char *func,
const char *fmt,
va_list args) SPA_PRINTF_FUNC(5, 0);
#if __STDC_VERSION__ >= 199901L
#define pinos_log_error(...) pinos_log_log(SPA_LOG_LEVEL_ERROR,__FILE__,__LINE__,__func__,__VA_ARGS__)
#define pinos_log_warn(...) pinos_log_log(SPA_LOG_LEVEL_WARN,__FILE__,__LINE__,__func__,__VA_ARGS__)
#define pinos_log_info(...) pinos_log_log(SPA_LOG_LEVEL_INFO,__FILE__,__LINE__,__func__,__VA_ARGS__)
#define pinos_log_debug(...) pinos_log_log(SPA_LOG_LEVEL_DEBUG,__FILE__,__LINE__,__func__,__VA_ARGS__)
#define pinos_log_trace(...) pinos_log_log(SPA_LOG_LEVEL_TRACE,__FILE__,__LINE__,__func__,__VA_ARGS__)
#else
#define PINOS_LOG_FUNC(name,lev) \
static inline void pinos_log_##name (const char *format, ...) \
{ \
va_list varargs; \
va_start (varargs, format); \
pinos_log_logv (lev,__FILE__,__LINE__,__func__,format,varargs); \
va_end (varargs); \
}
PINOS_LOG_FUNC(error, SPA_LOG_LEVEL_ERROR)
PINOS_LOG_FUNC(warn, SPA_LOG_LEVEL_WARN)
PINOS_LOG_FUNC(info, SPA_LOG_LEVEL_INFO)
PINOS_LOG_FUNC(debug, SPA_LOG_LEVEL_DEBUG)
PINOS_LOG_FUNC(trace, SPA_LOG_LEVEL_TRACE)
#endif
#ifdef __cplusplus
}
#endif
#endif /* __PINOS_LOG_H__ */

111
pinos/client/map.h Normal file
View file

@ -0,0 +1,111 @@
/* Simple Plugin API
* Copyright (C) 2016 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.
*/
#ifndef __PINOS_MAP_H__
#define __PINOS_MAP_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _PinosMap PinosMap;
#include <string.h>
#include <stdio.h>
#include <spa/defs.h>
#include <pinos/client/array.h>
#include <pinos/client/log.h>
typedef union {
uint32_t next;
void *data;
} PinosMapItem;
struct _PinosMap {
PinosArray items;
uint32_t free_list;
};
#define pinos_map_get_size(m) pinos_array_get_len (&(m)->items, PinosMapItem)
#define pinos_map_get_item(m,id) pinos_array_get_unchecked(&(m)->items,id,PinosMapItem)
#define pinos_map_item_is_free(m,id) (pinos_map_get_item(m,id)->next & 0x1)
#define pinos_map_check_id(m,id) ((id) < pinos_map_get_size (m))
#define pinos_map_has_item(m,id) (pinos_map_check_id(m,id) && !pinos_map_item_is_free(m, id))
#define pinos_map_lookup_unchecked(m,id) pinos_map_get_item(m,id)->data
static inline void
pinos_map_init (PinosMap *map,
size_t size)
{
pinos_array_init (&map->items);
pinos_array_ensure_size (&map->items, size * sizeof (PinosMapItem));
map->free_list = 0;
}
static inline void
pinos_map_clear (PinosMap *map)
{
pinos_array_clear (&map->items);
}
static inline uint32_t
pinos_map_insert_new (PinosMap *map,
void *data)
{
PinosMapItem *start, *item;
uint32_t id;
if (map->free_list) {
start = map->items.data;
item = &start[map->free_list >> 1];
map->free_list = item->next;
} else {
item = pinos_array_add (&map->items, sizeof (PinosMapItem));
if (!item)
return SPA_ID_INVALID;
start = map->items.data;
}
item->data = data;
id = (item - start);
return id;
}
static inline void
pinos_map_remove (PinosMap *map,
uint32_t id)
{
pinos_map_get_item (map, id)->next = map->free_list;
map->free_list = (id << 1) | 1;
}
static inline void *
pinos_map_lookup (PinosMap *map,
uint32_t id)
{
if (SPA_LIKELY (pinos_map_check_id (map, id)))
return pinos_map_lookup_unchecked (map, id);
return NULL;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __PINOS_MAP_H__ */

74
pinos/client/mapper.c Normal file
View file

@ -0,0 +1,74 @@
/* Simple Plugin API
* Copyright (C) 2016 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 <stdint.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <spa/id-map.h>
#include <pinos/client/map.h>
#define MAX_URIS 4096
typedef struct {
SpaIDMap map;
PinosMap uris;
} IDMap;
static uint32_t
id_map_get_id (SpaIDMap *map, const char *uri)
{
IDMap *this = SPA_CONTAINER_OF (map, IDMap, map);
uint32_t i = 0;
if (uri != NULL) {
for (i = 0; i < pinos_map_get_size (&this->uris); i++) {
if (strcmp (pinos_map_lookup_unchecked (&this->uris, i), uri) == 0)
return i;
}
i = pinos_map_insert_new (&this->uris, (char *)uri);
}
return i;
}
static const char *
id_map_get_uri (SpaIDMap *map, uint32_t id)
{
IDMap *this = SPA_CONTAINER_OF (map, IDMap, map);
if (id == SPA_ID_INVALID)
return NULL;
return pinos_map_lookup (&this->uris, id);
}
static IDMap default_id_map = {
{ sizeof (SpaIDMap),
NULL,
id_map_get_id,
id_map_get_uri,
},
{ { NULL, } },
};
SpaIDMap *
pinos_id_map_get_default (void)
{
return &default_id_map.map;
}

5
pinos/client/meson.build
View file

@ -1,7 +1,10 @@
pinos_headers = [
'array.h',
'context.h',
'format.h',
'introspect.h',
'log.h',
'map.h',
'pinos.h',
'properties.h',
'ringbuffer.h',
@ -16,6 +19,8 @@ pinos_sources = [
'context.c',
'format.c',
'introspect.c',
'log.c',
'mapper.c',
'properties.c',
'serialize.c',
'stream.c',

4
pinos/client/pinos.h
View file

@ -25,11 +25,13 @@ extern const char g_log_domain_pinos[];
#include <pinos/client/context.h>
#include <pinos/client/enumtypes.h>
#include <pinos/client/introspect.h>
#include <pinos/client/log.h>
#include <pinos/client/thread-mainloop.h>
#include <pinos/client/properties.h>
#include <pinos/client/ringbuffer.h>
#include <pinos/client/stream.h>
#include <pinos/client/subscribe.h>
#include <spa/include/spa/id-map.h>
#define PINOS_DBUS_SERVICE "org.pinos"
#define PINOS_DBUS_OBJECT_PREFIX "/org/pinos"
@ -59,4 +61,6 @@ void pinos_fill_stream_properties (PinosProperties *properties);
PinosDirection pinos_direction_reverse (PinosDirection direction);
SpaIDMap * pinos_id_map_get_default (void);
#endif /* __PINOS_H__ */

10
pinos/client/serialize.h
View file

@ -20,9 +20,9 @@
#ifndef __PINOS_SERIALIZE_H__
#define __PINOS_SERIALIZE_H__
#include <glib-object.h>
G_BEGIN_DECLS
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/include/spa/buffer.h>
#include <spa/include/spa/format.h>
@ -48,6 +48,8 @@ size_t pinos_serialize_props_serialize (void *dest, const SpaProp
SpaProps * pinos_serialize_props_deserialize (void *src, off_t offset);
SpaProps * pinos_serialize_props_copy_into (void *dest, const SpaProps *props);
G_END_DECLS
#ifdef __cplusplus
}
#endif
#endif /* __PINOS_SERIALIZE_H__ */

338
pinos/client/stream.c
View file

@ -22,7 +22,7 @@
#include <sys/mman.h>
#include <errno.h>
#include "spa/include/spa/debug.h"
#include "spa/lib/debug.h"
#include <gio/gio.h>
#include <gio/gunixfdlist.h>
@ -50,7 +50,6 @@ typedef struct {
uint32_t flags;
void *ptr;
size_t size;
bool cleanup;
} MemId;
typedef struct {
@ -100,8 +99,8 @@ struct _PinosStreamPrivate
GSource *timeout_source;
GArray *mem_ids;
GArray *buffer_ids;
PinosArray mem_ids;
PinosArray buffer_ids;
gboolean in_order;
gint64 last_ticks;
@ -139,15 +138,13 @@ static void
clear_buffers (PinosStream *stream)
{
PinosStreamPrivate *priv = stream->priv;
guint i;
for (i = 0; i < priv->buffer_ids->len; i++) {
BufferId *bid = &g_array_index (priv->buffer_ids, BufferId, i);
BufferId *bid;
pinos_array_for_each (bid, &priv->buffer_ids) {
g_signal_emit (stream, signals[SIGNAL_REMOVE_BUFFER], 0, bid->id);
bid->buf = NULL;
}
g_array_set_size (priv->buffer_ids, 0);
priv->buffer_ids.size = 0;
priv->in_order = TRUE;
}
@ -263,7 +260,7 @@ on_node_info (PinosContext *c,
PinosStream *stream = PINOS_STREAM (user_data);
if (info->state == PINOS_NODE_STATE_ERROR) {
g_debug ("stream %p: node %s in error", stream, info->node_path);
pinos_log_debug ("stream %p: node %s in error", stream, info->node_path);
stream_set_state (stream,
PINOS_STREAM_STATE_ERROR,
g_error_new (PINOS_ERROR,
@ -278,7 +275,7 @@ info_ready (GObject *o, GAsyncResult *res, gpointer user_data)
GError *error = NULL;
if (!pinos_context_info_finish (o, res, &error)) {
g_printerr ("introspection failure: %s\n", error->message);
pinos_log_error ("introspection failure: %s\n", error->message);
g_clear_error (&error);
}
}
@ -341,7 +338,7 @@ pinos_stream_finalize (GObject * object)
PinosStream *stream = PINOS_STREAM (object);
PinosStreamPrivate *priv = stream->priv;
g_debug ("free stream %p", stream);
pinos_log_debug ("free stream %p", stream);
g_clear_object (&priv->node);
@ -353,6 +350,9 @@ pinos_stream_finalize (GObject * object)
g_free (priv->path);
g_clear_error (&priv->error);
pinos_array_clear (&priv->buffer_ids);
pinos_array_clear (&priv->mem_ids);
if (priv->properties)
pinos_properties_free (priv->properties);
g_signal_handler_disconnect (priv->context->priv->subscribe, priv->id);
@ -513,12 +513,14 @@ pinos_stream_init (PinosStream * stream)
{
PinosStreamPrivate *priv = stream->priv = PINOS_STREAM_GET_PRIVATE (stream);
g_debug ("new stream %p", stream);
pinos_log_debug ("new stream %p", stream);
priv->state = PINOS_STREAM_STATE_UNCONNECTED;
priv->node_state = SPA_NODE_STATE_INIT;
priv->mem_ids = g_array_sized_new (FALSE, FALSE, sizeof (MemId), 64);
priv->buffer_ids = g_array_sized_new (FALSE, FALSE, sizeof (BufferId), 64);
pinos_array_init (&priv->mem_ids);
pinos_array_ensure_size (&priv->mem_ids, sizeof (MemId) * 64);
pinos_array_init (&priv->buffer_ids);
pinos_array_ensure_size (&priv->buffer_ids, sizeof (BufferId) * 64);
priv->pending_seq = SPA_ID_INVALID;
}
@ -614,26 +616,26 @@ static void
add_node_update (PinosStream *stream, uint32_t change_mask)
{
PinosStreamPrivate *priv = stream->priv;
PinosControlCmdNodeUpdate nu = { 0, };
PinosMessageNodeUpdate nu = { 0, };
nu.change_mask = change_mask;
if (change_mask & PINOS_CONTROL_CMD_NODE_UPDATE_MAX_INPUTS)
if (change_mask & PINOS_MESSAGE_NODE_UPDATE_MAX_INPUTS)
nu.max_input_ports = priv->direction == SPA_DIRECTION_INPUT ? 1 : 0;
if (change_mask & PINOS_CONTROL_CMD_NODE_UPDATE_MAX_OUTPUTS)
if (change_mask & PINOS_MESSAGE_NODE_UPDATE_MAX_OUTPUTS)
nu.max_output_ports = priv->direction == SPA_DIRECTION_OUTPUT ? 1 : 0;
nu.props = NULL;
pinos_connection_add_cmd (priv->conn, PINOS_CONTROL_CMD_NODE_UPDATE, &nu);
pinos_connection_add_message (priv->conn, PINOS_MESSAGE_NODE_UPDATE, &nu);
}
static void
add_state_change (PinosStream *stream, SpaNodeState state)
{
PinosStreamPrivate *priv = stream->priv;
PinosControlCmdNodeStateChange sc;
PinosMessageNodeStateChange sc;
if (priv->node_state != state) {
sc.state = priv->node_state = state;
pinos_connection_add_cmd (priv->conn, PINOS_CONTROL_CMD_NODE_STATE_CHANGE, &sc);
pinos_connection_add_message (priv->conn, PINOS_MESSAGE_NODE_STATE_CHANGE, &sc);
}
}
@ -641,47 +643,47 @@ static void
add_port_update (PinosStream *stream, uint32_t change_mask)
{
PinosStreamPrivate *priv = stream->priv;
PinosControlCmdPortUpdate pu = { 0, };;
PinosMessagePortUpdate pu = { 0, };;
pu.direction = priv->direction;
pu.port_id = priv->port_id;
pu.change_mask = change_mask;
if (change_mask & PINOS_CONTROL_CMD_PORT_UPDATE_POSSIBLE_FORMATS) {
if (change_mask & PINOS_MESSAGE_PORT_UPDATE_POSSIBLE_FORMATS) {
pu.n_possible_formats = priv->possible_formats->len;
pu.possible_formats = (SpaFormat **)priv->possible_formats->pdata;
}
if (change_mask & PINOS_CONTROL_CMD_PORT_UPDATE_FORMAT) {
if (change_mask & PINOS_MESSAGE_PORT_UPDATE_FORMAT) {
pu.format = priv->format;
}
pu.props = NULL;
if (change_mask & PINOS_CONTROL_CMD_PORT_UPDATE_INFO) {
if (change_mask & PINOS_MESSAGE_PORT_UPDATE_INFO) {
pu.info = &priv->port_info;
}
pinos_connection_add_cmd (priv->conn, PINOS_CONTROL_CMD_PORT_UPDATE, &pu);
pinos_connection_add_message (priv->conn, PINOS_MESSAGE_PORT_UPDATE, &pu);
}
static void
send_need_input (PinosStream *stream, uint32_t port_id)
{
PinosStreamPrivate *priv = stream->priv;
PinosControlCmdNodeEvent cne;
PinosMessageNodeEvent cne;
SpaNodeEventNeedInput ni;
cne.event = &ni.event;
ni.event.type = SPA_NODE_EVENT_TYPE_NEED_INPUT;
ni.event.size = sizeof (ni);
ni.port_id = port_id;
pinos_connection_add_cmd (priv->rtconn, PINOS_CONTROL_CMD_NODE_EVENT, &cne);
pinos_connection_add_message (priv->rtconn, PINOS_MESSAGE_NODE_EVENT, &cne);
if (!pinos_connection_flush (priv->rtconn))
g_warning ("stream %p: error writing connection", stream);
pinos_log_warn ("stream %p: error writing connection", stream);
}
static void
add_request_clock_update (PinosStream *stream)
{
PinosStreamPrivate *priv = stream->priv;
PinosControlCmdNodeEvent cne;
PinosMessageNodeEvent cne;
SpaNodeEventRequestClockUpdate rcu;
cne.event = &rcu.event;
@ -690,7 +692,7 @@ add_request_clock_update (PinosStream *stream)
rcu.update_mask = SPA_NODE_EVENT_REQUEST_CLOCK_UPDATE_TIME;
rcu.timestamp = 0;
rcu.offset = 0;
pinos_connection_add_cmd (priv->conn, PINOS_CONTROL_CMD_NODE_EVENT, &cne);
pinos_connection_add_message (priv->conn, PINOS_MESSAGE_NODE_EVENT, &cne);
}
static void
@ -699,7 +701,7 @@ add_async_complete (PinosStream *stream,
SpaResult res)
{
PinosStreamPrivate *priv = stream->priv;
PinosControlCmdNodeEvent cne;
PinosMessageNodeEvent cne;
SpaNodeEventAsyncComplete ac;
cne.event = &ac.event;
@ -707,14 +709,14 @@ add_async_complete (PinosStream *stream,
ac.event.size = sizeof (ac);
ac.seq = seq;
ac.res = res;
pinos_connection_add_cmd (priv->conn, PINOS_CONTROL_CMD_NODE_EVENT, &cne);
pinos_connection_add_message (priv->conn, PINOS_MESSAGE_NODE_EVENT, &cne);
}
static void
send_reuse_buffer (PinosStream *stream, uint32_t port_id, uint32_t buffer_id)
{
PinosStreamPrivate *priv = stream->priv;
PinosControlCmdNodeEvent cne;
PinosMessageNodeEvent cne;
SpaNodeEventReuseBuffer rb;
cne.event = &rb.event;
@ -722,33 +724,33 @@ send_reuse_buffer (PinosStream *stream, uint32_t port_id, uint32_t buffer_id)
rb.event.size = sizeof (rb);
rb.port_id = port_id;
rb.buffer_id = buffer_id;
pinos_connection_add_cmd (priv->rtconn, PINOS_CONTROL_CMD_NODE_EVENT, &cne);
pinos_connection_add_message (priv->rtconn, PINOS_MESSAGE_NODE_EVENT, &cne);
if (!pinos_connection_flush (priv->rtconn))
g_warning ("stream %p: error writing connection", stream);
pinos_log_warn ("stream %p: error writing connection", stream);
}
static void
send_process_buffer (PinosStream *stream, uint32_t port_id, uint32_t buffer_id)
{
PinosStreamPrivate *priv = stream->priv;
PinosControlCmdProcessBuffer pb;
PinosControlCmdNodeEvent cne;
PinosMessageProcessBuffer pb;
PinosMessageNodeEvent cne;
SpaNodeEventHaveOutput ho;
pb.direction = priv->direction;
pb.port_id = port_id;
pb.buffer_id = buffer_id;
pinos_connection_add_cmd (priv->rtconn, PINOS_CONTROL_CMD_PROCESS_BUFFER, &pb);
pinos_connection_add_message (priv->rtconn, PINOS_MESSAGE_PROCESS_BUFFER, &pb);
cne.event = &ho.event;
ho.event.type = SPA_NODE_EVENT_TYPE_HAVE_OUTPUT;
ho.event.size = sizeof (ho);
ho.port_id = port_id;
pinos_connection_add_cmd (priv->rtconn, PINOS_CONTROL_CMD_NODE_EVENT, &cne);
pinos_connection_add_message (priv->rtconn, PINOS_MESSAGE_NODE_EVENT, &cne);
if (!pinos_connection_flush (priv->rtconn))
g_warning ("stream %p: error writing connection", stream);
pinos_log_warn ("stream %p: error writing connection", stream);
}
static void
@ -756,27 +758,26 @@ do_node_init (PinosStream *stream)
{
PinosStreamPrivate *priv = stream->priv;
add_node_update (stream, PINOS_CONTROL_CMD_NODE_UPDATE_MAX_INPUTS |
PINOS_CONTROL_CMD_NODE_UPDATE_MAX_OUTPUTS);
add_node_update (stream, PINOS_MESSAGE_NODE_UPDATE_MAX_INPUTS |
PINOS_MESSAGE_NODE_UPDATE_MAX_OUTPUTS);
priv->port_info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
add_port_update (stream, PINOS_CONTROL_CMD_PORT_UPDATE_POSSIBLE_FORMATS |
PINOS_CONTROL_CMD_PORT_UPDATE_INFO);
add_port_update (stream, PINOS_MESSAGE_PORT_UPDATE_POSSIBLE_FORMATS |
PINOS_MESSAGE_PORT_UPDATE_INFO);
add_state_change (stream, SPA_NODE_STATE_CONFIGURE);
if (!pinos_connection_flush (priv->conn))
g_warning ("stream %p: error writing connection", stream);
pinos_log_warn ("stream %p: error writing connection", stream);
}
static MemId *
find_mem (PinosStream *stream, uint32_t id)
{
PinosStreamPrivate *priv = stream->priv;
guint i;
MemId *mid;
for (i = 0; i < priv->mem_ids->len; i++) {
MemId *mid = &g_array_index (priv->mem_ids, MemId, i);
pinos_array_for_each (mid, &priv->mem_ids) {
if (mid->id == id)
return mid;
}
@ -787,13 +788,13 @@ static BufferId *
find_buffer (PinosStream *stream, uint32_t id)
{
PinosStreamPrivate *priv = stream->priv;
guint i;
if (priv->in_order && id < priv->buffer_ids->len) {
return &g_array_index (priv->buffer_ids, BufferId, id);
if (priv->in_order && pinos_array_check_index (&priv->buffer_ids, id, BufferId)) {
return pinos_array_get_unchecked (&priv->buffer_ids, id, BufferId);
} else {
for (i = 0; i < priv->buffer_ids->len; i++) {
BufferId *bid = &g_array_index (priv->buffer_ids, BufferId, i);
BufferId *bid;
pinos_array_for_each (bid, &priv->buffer_ids) {
if (bid->id == id)
return bid;
}
@ -815,7 +816,7 @@ handle_node_event (PinosStream *stream,
case SPA_NODE_EVENT_TYPE_BUFFERING:
case SPA_NODE_EVENT_TYPE_REQUEST_REFRESH:
case SPA_NODE_EVENT_TYPE_REQUEST_CLOCK_UPDATE:
g_warning ("unhandled node event %d", event->type);
pinos_log_warn ("unhandled node event %d", event->type);
break;
}
return TRUE;
@ -834,12 +835,12 @@ handle_rtnode_event (PinosStream *stream,
case SPA_NODE_EVENT_TYPE_BUFFERING:
case SPA_NODE_EVENT_TYPE_REQUEST_REFRESH:
case SPA_NODE_EVENT_TYPE_REQUEST_CLOCK_UPDATE:
g_warning ("unexpected node event %d", event->type);
pinos_log_warn ("unexpected node event %d", event->type);
break;
case SPA_NODE_EVENT_TYPE_HAVE_OUTPUT:
case SPA_NODE_EVENT_TYPE_NEED_INPUT:
g_warning ("unhandled node event %d", event->type);
pinos_log_warn ("unhandled node event %d", event->type);
break;
case SPA_NODE_EVENT_TYPE_REUSE_BUFFER:
@ -874,25 +875,25 @@ handle_node_command (PinosStream *stream,
break;
case SPA_NODE_COMMAND_PAUSE:
{
g_debug ("stream %p: pause %d", stream, seq);
pinos_log_debug ("stream %p: pause %d", stream, seq);
add_state_change (stream, SPA_NODE_STATE_PAUSED);
add_async_complete (stream, seq, SPA_RESULT_OK);
if (!pinos_connection_flush (priv->conn))
g_warning ("stream %p: error writing connection", stream);
pinos_log_warn ("stream %p: error writing connection", stream);
stream_set_state (stream, PINOS_STREAM_STATE_PAUSED, NULL);
break;
}
case SPA_NODE_COMMAND_START:
{
g_debug ("stream %p: start %d", stream, seq);
pinos_log_debug ("stream %p: start %d", stream, seq);
add_state_change (stream, SPA_NODE_STATE_STREAMING);
add_async_complete (stream, seq, SPA_RESULT_OK);
if (!pinos_connection_flush (priv->conn))
g_warning ("stream %p: error writing connection", stream);
pinos_log_warn ("stream %p: error writing connection", stream);
if (priv->direction == SPA_DIRECTION_INPUT)
send_need_input (stream, priv->port_id);
@ -904,11 +905,11 @@ handle_node_command (PinosStream *stream,
case SPA_NODE_COMMAND_DRAIN:
case SPA_NODE_COMMAND_MARKER:
{
g_warning ("unhandled node command %d", command->type);
pinos_log_warn ("unhandled node command %d", command->type);
add_async_complete (stream, seq, SPA_RESULT_NOT_IMPLEMENTED);
if (!pinos_connection_flush (priv->conn))
g_warning ("stream %p: error writing connection", stream);
pinos_log_warn ("stream %p: error writing connection", stream);
break;
}
case SPA_NODE_COMMAND_CLOCK_UPDATE:
@ -936,28 +937,28 @@ parse_connection (PinosStream *stream)
PinosConnection *conn = priv->conn;
while (pinos_connection_has_next (conn)) {
PinosControlCmd cmd = pinos_connection_get_cmd (conn);
PinosMessageType type = pinos_connection_get_type (conn);
switch (cmd) {
case PINOS_CONTROL_CMD_NODE_UPDATE:
case PINOS_CONTROL_CMD_PORT_UPDATE:
case PINOS_CONTROL_CMD_PORT_STATUS_CHANGE:
case PINOS_CONTROL_CMD_NODE_STATE_CHANGE:
case PINOS_CONTROL_CMD_PROCESS_BUFFER:
g_warning ("got unexpected command %d", cmd);
switch (type) {
case PINOS_MESSAGE_NODE_UPDATE:
case PINOS_MESSAGE_PORT_UPDATE:
case PINOS_MESSAGE_PORT_STATUS_CHANGE:
case PINOS_MESSAGE_NODE_STATE_CHANGE:
case PINOS_MESSAGE_PROCESS_BUFFER:
pinos_log_warn ("got unexpected message %d", type);
break;
case PINOS_CONTROL_CMD_ADD_PORT:
case PINOS_CONTROL_CMD_REMOVE_PORT:
g_warning ("add/remove port not supported");
case PINOS_MESSAGE_ADD_PORT:
case PINOS_MESSAGE_REMOVE_PORT:
pinos_log_warn ("add/remove port not supported");
break;
case PINOS_CONTROL_CMD_SET_FORMAT:
case PINOS_MESSAGE_SET_FORMAT:
{
PinosControlCmdSetFormat p;
PinosMessageSetFormat p;
gpointer mem;
if (!pinos_connection_parse_cmd (conn, &p))
if (!pinos_connection_parse_message (conn, &p))
break;
if (priv->format)
@ -970,17 +971,17 @@ parse_connection (PinosStream *stream)
stream_set_state (stream, PINOS_STREAM_STATE_READY, NULL);
break;
}
case PINOS_CONTROL_CMD_SET_PROPERTY:
g_warning ("set property not implemented");
case PINOS_MESSAGE_SET_PROPERTY:
pinos_log_warn ("set property not implemented");
break;
case PINOS_CONTROL_CMD_ADD_MEM:
case PINOS_MESSAGE_ADD_MEM:
{
PinosControlCmdAddMem p;
PinosMessageAddMem p;
int fd;
MemId mid, *m;
MemId *m;
if (!pinos_connection_parse_cmd (conn, &p))
if (!pinos_connection_parse_message (conn, &p))
break;
fd = pinos_connection_get_fd (conn, p.fd_index, false);
@ -989,33 +990,26 @@ parse_connection (PinosStream *stream)
m = find_mem (stream, p.mem_id);
if (m) {
g_debug ("update mem %u, fd %d, flags %d, size %zd", p.mem_id, fd, p.flags, p.size);
m->id = p.mem_id;
m->fd = fd;
m->flags = p.flags;
m->ptr = NULL;
m->size = p.size;
pinos_log_debug ("update mem %u, fd %d, flags %d, size %zd", p.mem_id, fd, p.flags, p.size);
} else {
mid.id = p.mem_id;
mid.fd = fd;
mid.flags = p.flags;
mid.ptr = NULL;
mid.size = p.size;
g_debug ("add mem %u, fd %d, flags %d, size %zd", p.mem_id, fd, p.flags, p.size);
g_array_append_val (priv->mem_ids, mid);
m = pinos_array_add (&priv->mem_ids, sizeof (MemId));
pinos_log_debug ("add mem %u, fd %d, flags %d, size %zd", p.mem_id, fd, p.flags, p.size);
}
m->id = p.mem_id;
m->fd = fd;
m->flags = p.flags;
m->ptr = NULL;
m->size = p.size;
break;
}
case PINOS_CONTROL_CMD_USE_BUFFERS:
case PINOS_MESSAGE_USE_BUFFERS:
{
PinosControlCmdUseBuffers p;
BufferId bid;
unsigned int i, j;
PinosMessageUseBuffers p;
BufferId *bid;
unsigned int i, j, len;
SpaBuffer *b;
if (!pinos_connection_parse_cmd (conn, &p))
if (!pinos_connection_parse_message (conn, &p))
break;
/* clear previous buffers */
@ -1024,7 +1018,7 @@ parse_connection (PinosStream *stream)
for (i = 0; i < p.n_buffers; i++) {
MemId *mid = find_mem (stream, p.buffers[i].mem_id);
if (mid == NULL) {
g_warning ("unknown memory id %u", mid->id);
pinos_log_warn ("unknown memory id %u", mid->id);
continue;
}
@ -1032,18 +1026,20 @@ parse_connection (PinosStream *stream)
mid->ptr = mmap (NULL, mid->size, PROT_READ | PROT_WRITE, MAP_SHARED, mid->fd, 0);
if (mid->ptr == MAP_FAILED) {
mid->ptr = NULL;
g_warning ("Failed to mmap memory %zd %p: %s", mid->size, mid, strerror (errno));
pinos_log_warn ("Failed to mmap memory %zd %p: %s", mid->size, mid, strerror (errno));
continue;
}
}
len = pinos_array_get_len (&priv->buffer_ids, BufferId);
bid = pinos_array_add (&priv->buffer_ids, sizeof (BufferId));
bid.buf_ptr = SPA_MEMBER (mid->ptr, p.buffers[i].offset, void);
bid->buf_ptr = SPA_MEMBER (mid->ptr, p.buffers[i].offset, void);
{
size_t size;
unsigned int i;
SpaMeta *m;
b = bid.buf_ptr;
b = bid->buf_ptr;
size = sizeof (SpaBuffer);
m = SPA_MEMBER (b, SPA_PTR_TO_INT (b->metas), SpaMeta);
for (i = 0; i < b->n_metas; i++)
@ -1051,24 +1047,28 @@ parse_connection (PinosStream *stream)
for (i = 0; i < b->n_datas; i++)
size += sizeof (SpaData);
b = bid.buf = g_memdup (bid.buf_ptr, size);
b = bid->buf = g_memdup (bid->buf_ptr, size);
if (b->metas)
b->metas = SPA_MEMBER (b, SPA_PTR_TO_INT (b->metas), SpaMeta);
if (b->datas) {
bid.datas = SPA_MEMBER (bid.buf_ptr, SPA_PTR_TO_INT (b->datas), SpaData);
bid->datas = SPA_MEMBER (bid->buf_ptr, SPA_PTR_TO_INT (b->datas), SpaData);
b->datas = SPA_MEMBER (b, SPA_PTR_TO_INT (b->datas), SpaData);
}
}
bid.id = b->id;
bid->id = b->id;
g_debug ("add buffer %d %d %zd", mid->id, bid.id, p.buffers[i].offset);
if (bid->id != len) {
pinos_log_warn ("unexpected id %u found, expected %u", bid->id, len);
priv->in_order = FALSE;
}
pinos_log_debug ("add buffer %d %d %zd", mid->id, bid->id, p.buffers[i].offset);
for (j = 0; j < b->n_metas; j++) {
SpaMeta *m = &b->metas[j];
if (m->data)
m->data = SPA_MEMBER (bid.buf_ptr, SPA_PTR_TO_INT (m->data), void);
m->data = SPA_MEMBER (bid->buf_ptr, SPA_PTR_TO_INT (m->data), void);
}
for (j = 0; j < b->n_datas; j++) {
@ -1081,28 +1081,23 @@ parse_connection (PinosStream *stream)
d->type = SPA_DATA_TYPE_MEMFD;
d->data = NULL;
d->fd = bmid->fd;
g_debug (" data %d %u -> fd %d", j, bmid->id, bmid->fd);
pinos_log_debug (" data %d %u -> fd %d", j, bmid->id, bmid->fd);
break;
}
case SPA_DATA_TYPE_MEMPTR:
{
d->data = SPA_MEMBER (bid.buf_ptr, SPA_PTR_TO_INT (d->data), void);
d->data = SPA_MEMBER (bid->buf_ptr, SPA_PTR_TO_INT (d->data), void);
d->fd = -1;
g_debug (" data %d %u -> mem %p", j, bid.id, d->data);
pinos_log_debug (" data %d %u -> mem %p", j, bid->id, d->data);
break;
}
default:
g_warning ("unknown buffer data type %d", d->type);
pinos_log_warn ("unknown buffer data type %d", d->type);
break;
}
}
if (bid.id != priv->buffer_ids->len) {
g_warning ("unexpected id %u found, expected %u", bid.id, priv->buffer_ids->len);
priv->in_order = FALSE;
}
g_array_append_val (priv->buffer_ids, bid);
g_signal_emit (stream, signals[SIGNAL_ADD_BUFFER], 0, bid.id);
g_signal_emit (stream, signals[SIGNAL_ADD_BUFFER], 0, bid->id);
}
if (p.n_buffers) {
@ -1113,7 +1108,7 @@ parse_connection (PinosStream *stream)
add_async_complete (stream, p.seq, SPA_RESULT_OK);
if (!pinos_connection_flush (conn))
g_warning ("stream %p: error writing connection", stream);
pinos_log_warn ("stream %p: error writing connection", stream);
if (p.n_buffers)
stream_set_state (stream, PINOS_STREAM_STATE_PAUSED, NULL);
@ -1121,37 +1116,37 @@ parse_connection (PinosStream *stream)
stream_set_state (stream, PINOS_STREAM_STATE_READY, NULL);
break;
}
case PINOS_CONTROL_CMD_NODE_EVENT:
case PINOS_MESSAGE_NODE_EVENT:
{
PinosControlCmdNodeEvent p;
PinosMessageNodeEvent p;
if (!pinos_connection_parse_cmd (conn, &p))
if (!pinos_connection_parse_message (conn, &p))
break;
handle_node_event (stream, p.event);
break;
}
case PINOS_CONTROL_CMD_NODE_COMMAND:
case PINOS_MESSAGE_NODE_COMMAND:
{
PinosControlCmdNodeCommand p;
PinosMessageNodeCommand p;
if (!pinos_connection_parse_cmd (conn, &p))
if (!pinos_connection_parse_message (conn, &p))
break;
handle_node_command (stream, p.seq, p.command);
break;
}
case PINOS_CONTROL_CMD_PORT_COMMAND:
case PINOS_MESSAGE_PORT_COMMAND:
{
PinosControlCmdPortCommand p;
PinosMessagePortCommand p;
if (!pinos_connection_parse_cmd (conn, &p))
if (!pinos_connection_parse_message (conn, &p))
break;
break;
}
case PINOS_CONTROL_CMD_INVALID:
g_warning ("unhandled command %d", cmd);
case PINOS_MESSAGE_INVALID:
pinos_log_warn ("unhandled message %d", type);
break;
}
}
@ -1165,34 +1160,34 @@ parse_rtconnection (PinosStream *stream)
PinosConnection *conn = priv->rtconn;
while (pinos_connection_has_next (conn)) {
PinosControlCmd cmd = pinos_connection_get_cmd (conn);
PinosMessageType type = pinos_connection_get_type (conn);
switch (cmd) {
case PINOS_CONTROL_CMD_INVALID:
case PINOS_CONTROL_CMD_NODE_UPDATE:
case PINOS_CONTROL_CMD_PORT_UPDATE:
case PINOS_CONTROL_CMD_PORT_STATUS_CHANGE:
case PINOS_CONTROL_CMD_NODE_STATE_CHANGE:
case PINOS_CONTROL_CMD_ADD_PORT:
case PINOS_CONTROL_CMD_REMOVE_PORT:
case PINOS_CONTROL_CMD_SET_FORMAT:
case PINOS_CONTROL_CMD_SET_PROPERTY:
case PINOS_CONTROL_CMD_ADD_MEM:
case PINOS_CONTROL_CMD_USE_BUFFERS:
case PINOS_CONTROL_CMD_NODE_COMMAND:
g_warning ("got unexpected command %d", cmd);
switch (type) {
case PINOS_MESSAGE_INVALID:
case PINOS_MESSAGE_NODE_UPDATE:
case PINOS_MESSAGE_PORT_UPDATE:
case PINOS_MESSAGE_PORT_STATUS_CHANGE:
case PINOS_MESSAGE_NODE_STATE_CHANGE:
case PINOS_MESSAGE_ADD_PORT:
case PINOS_MESSAGE_REMOVE_PORT:
case PINOS_MESSAGE_SET_FORMAT:
case PINOS_MESSAGE_SET_PROPERTY:
case PINOS_MESSAGE_ADD_MEM:
case PINOS_MESSAGE_USE_BUFFERS:
case PINOS_MESSAGE_NODE_COMMAND:
pinos_log_warn ("got unexpected command %d", type);
break;
case PINOS_CONTROL_CMD_PROCESS_BUFFER:
case PINOS_MESSAGE_PROCESS_BUFFER:
{
PinosControlCmdProcessBuffer p;
PinosMessageProcessBuffer p;
guint i;
BufferId *bid;
if (priv->direction != SPA_DIRECTION_INPUT)
break;
if (!pinos_connection_parse_cmd (conn, &p))
if (!pinos_connection_parse_message (conn, &p))
break;
if ((bid = find_buffer (stream, p.buffer_id))) {
@ -1205,17 +1200,17 @@ parse_rtconnection (PinosStream *stream)
}
break;
}
case PINOS_CONTROL_CMD_NODE_EVENT:
case PINOS_MESSAGE_NODE_EVENT:
{
PinosControlCmdNodeEvent p;
PinosMessageNodeEvent p;
if (!pinos_connection_parse_cmd (conn, &p))
if (!pinos_connection_parse_message (conn, &p))
break;
handle_rtnode_event (stream, p.event);
break;
}
case PINOS_CONTROL_CMD_PORT_COMMAND:
case PINOS_MESSAGE_PORT_COMMAND:
{
break;
}
@ -1240,7 +1235,7 @@ on_socket_condition (GSocket *socket,
}
case G_IO_OUT:
g_warning ("can do IO\n");
pinos_log_warn ("can do IO\n");
break;
default:
@ -1264,7 +1259,7 @@ on_rtsocket_condition (GSocket *socket,
}
case G_IO_OUT:
g_warning ("can do IO\n");
pinos_log_warn ("can do IO\n");
break;
default:
@ -1282,7 +1277,7 @@ on_timeout (gpointer user_data)
add_request_clock_update (stream);
if (!pinos_connection_flush (priv->conn))
g_warning ("stream %p: error writing connection", stream);
pinos_log_warn ("stream %p: error writing connection", stream);
return G_SOURCE_CONTINUE;
}
@ -1321,7 +1316,7 @@ handle_socket (PinosStream *stream, gint fd, gint rtfd)
/* ERRORS */
socket_failed:
{
g_warning ("failed to create socket: %s", error->message);
pinos_log_warn ("failed to create socket: %s", error->message);
stream_set_state (stream, PINOS_STREAM_STATE_ERROR, error);
return;
}
@ -1368,7 +1363,7 @@ on_node_proxy (GObject *source_object,
node_failed:
{
g_warning ("failed to get node proxy: %s", error->message);
pinos_log_warn ("failed to get node proxy: %s", error->message);
stream_set_state (stream, PINOS_STREAM_STATE_ERROR, error);
g_object_unref (stream);
return;
@ -1425,12 +1420,12 @@ on_node_created (GObject *source_object,
/* ERRORS */
create_failed:
{
g_warning ("failed to connect: %s", error->message);
pinos_log_warn ("failed to connect: %s", error->message);
goto exit_error;
}
fd_failed:
{
g_warning ("failed to get FD: %s", error->message);
pinos_log_warn ("failed to get FD: %s", error->message);
g_object_unref (fd_list);
goto exit_error;
}
@ -1479,12 +1474,12 @@ on_node_registered (GObject *source_object,
/* ERRORS */
create_failed:
{
g_warning ("failed to connect: %s", error->message);
pinos_log_warn ("failed to connect: %s", error->message);
goto exit_error;
}
fd_failed:
{
g_warning ("failed to get FD: %s", error->message);
pinos_log_warn ("failed to get FD: %s", error->message);
g_object_unref (fd_list);
goto exit_error;
}
@ -1635,8 +1630,8 @@ pinos_stream_finish_format (PinosStream *stream,
priv->port_info.n_params = n_params;
if (SPA_RESULT_IS_OK (res)) {
add_port_update (stream, PINOS_CONTROL_CMD_PORT_UPDATE_INFO |
PINOS_CONTROL_CMD_PORT_UPDATE_FORMAT);
add_port_update (stream, PINOS_MESSAGE_PORT_UPDATE_INFO |
PINOS_MESSAGE_PORT_UPDATE_FORMAT);
if (priv->format) {
add_state_change (stream, SPA_NODE_STATE_READY);
} else {
@ -1652,7 +1647,7 @@ pinos_stream_finish_format (PinosStream *stream,
priv->pending_seq = SPA_ID_INVALID;
if (!pinos_connection_flush (priv->conn))
g_warning ("stream %p: error writing connection", stream);
pinos_log_warn ("stream %p: error writing connection", stream);
return TRUE;
}
@ -1752,7 +1747,7 @@ on_node_removed (GObject *source_object,
/* ERRORS */
proxy_failed:
{
g_warning ("failed to disconnect: %s", error->message);
pinos_log_warn ("failed to disconnect: %s", error->message);
stream_set_state (stream, PINOS_STREAM_STATE_ERROR, error);
g_object_unref (stream);
return;
@ -1841,14 +1836,13 @@ guint
pinos_stream_get_empty_buffer (PinosStream *stream)
{
PinosStreamPrivate *priv;
guint i;
BufferId *bid;
g_return_val_if_fail (PINOS_IS_STREAM (stream), FALSE);
priv = stream->priv;
g_return_val_if_fail (priv->direction == SPA_DIRECTION_OUTPUT, FALSE);
for (i = 0; i < priv->buffer_ids->len; i++) {
BufferId *bid = &g_array_index (priv->buffer_ids, BufferId, i);
pinos_array_for_each (bid, &priv->buffer_ids) {
if (!bid->used)
return bid->id;
}

6
pinos/client/subscribe.c
View file

@ -196,7 +196,7 @@ on_proxy_created (GObject *source_object,
data->proxy = g_dbus_proxy_new_finish (res, &error);
if (data->proxy == NULL) {
priv->objects = g_list_remove (priv->objects, data);
g_warning ("could not create proxy: %s", error->message);
pinos_log_warn ("could not create proxy: %s", error->message);
subscription_set_state (subscribe, PINOS_SUBSCRIPTION_STATE_ERROR);
priv->error = error;
return;
@ -365,7 +365,7 @@ on_managed_objects_ready (GObject *source_object,
objects = g_dbus_proxy_call_finish (priv->manager_proxy, res, &error);
if (objects == NULL) {
g_warning ("could not get objects: %s", error->message);
pinos_log_warn ("could not get objects: %s", error->message);
subscription_set_state (subscribe, PINOS_SUBSCRIPTION_STATE_ERROR);
priv->error = error;
return;
@ -464,7 +464,7 @@ on_manager_proxy_ready (GObject *source_object,
/* ERRORS */
manager_error:
{
g_warning ("could not create client manager: %s", error->message);
pinos_log_warn ("could not create client manager: %s", error->message);
subscription_set_state (subscribe, PINOS_SUBSCRIPTION_STATE_ERROR);
priv->error = error;
g_object_unref (subscribe);

6
pinos/client/thread-mainloop.c
View file

@ -110,7 +110,7 @@ pinos_thread_main_loop_constructed (GObject * object)
PinosThreadMainLoopPrivate *priv = loop->priv;
priv->mainloop = g_main_loop_new (priv->maincontext, FALSE);
g_debug ("thread-mainloop %p: contructed %p %p", loop, priv->maincontext, priv->mainloop);
pinos_log_debug ("thread-mainloop %p: contructed %p %p", loop, priv->maincontext, priv->mainloop);
G_OBJECT_CLASS (pinos_thread_main_loop_parent_class)->constructed (object);
}
@ -269,9 +269,9 @@ handle_mainloop (PinosThreadMainLoop *loop)
g_main_context_set_poll_func (priv->maincontext, do_poll);
g_main_context_push_thread_default (priv->maincontext);
g_debug ("thread-mainloop %p: run mainloop %p context %p", loop, priv->mainloop, priv->maincontext);
pinos_log_debug ("thread-mainloop %p: run mainloop %p context %p", loop, priv->mainloop, priv->maincontext);
g_main_loop_run (priv->mainloop);
g_debug ("thread-mainloop %p: done", loop);
pinos_log_debug ("thread-mainloop %p: done", loop);
g_main_context_pop_thread_default (priv->maincontext);
g_main_context_set_poll_func (priv->maincontext, priv->poll_func);

6
pinos/daemon/daemon-config.c
View file

@ -135,7 +135,7 @@ pinos_daemon_config_load_file (PinosDaemonConfig * config,
g_return_val_if_fail (config != NULL, FALSE);
g_return_val_if_fail (filename != NULL && *filename != '\0', FALSE);
g_debug ("deamon-config %p loading file %s", config, filename);
pinos_log_debug ("deamon-config %p loading file %s", config, filename);
if (!g_file_get_contents (filename, &data, NULL, err)) {
return FALSE;
@ -175,7 +175,7 @@ pinos_daemon_config_load (PinosDaemonConfig * config,
filename = g_getenv ("PINOS_CONFIG_FILE");
if (filename != NULL && *filename != '\0') {
g_debug ("PINOS_CONFIG_FILE set to: %s", filename);
pinos_log_debug ("PINOS_CONFIG_FILE set to: %s", filename);
} else {
filename = DEFAULT_CONFIG_FILE;
}
@ -206,7 +206,7 @@ pinos_daemon_config_run_commands (PinosDaemonConfig * config,
for (walk = config->commands; walk != NULL; walk = walk->next) {
PinosCommand *command = (PinosCommand *)walk->data;
if (!pinos_command_run (command, daemon, &err)) {
g_warning ("could not run command %s: %s",
pinos_log_warn ("could not run command %s: %s",
pinos_command_get_name (command), err->message);
g_clear_error (&err);
ret = FALSE;

13
pinos/gst/gstpinospool.c
View file

@ -105,9 +105,10 @@ do_start (GstBufferPool * pool)
guint size;
guint min_buffers;
guint max_buffers;
SpaAllocParam *port_params[2];
SpaAllocParamMetaEnable param_meta_enable;
SpaAllocParam *port_params[3];
SpaAllocParamBuffers param_buffers;
SpaAllocParamMetaEnable param_meta_enable;
SpaAllocParamMetaEnableRingbuffer param_meta_enable_rb;
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_get_params (config, &caps, &size, &min_buffers, &max_buffers);
@ -124,6 +125,14 @@ do_start (GstBufferPool * pool)
param_meta_enable.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
param_meta_enable.param.size = sizeof (SpaAllocParamMetaEnable);
param_meta_enable.type = SPA_META_TYPE_HEADER;
port_params[2] = &param_meta_enable_rb.param;
param_meta_enable_rb.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
param_meta_enable_rb.param.size = sizeof (SpaAllocParamMetaEnableRingbuffer);
param_meta_enable_rb.type = SPA_META_TYPE_RINGBUFFER;
param_meta_enable_rb.minsize = size * SPA_MAX (4, SPA_MAX (min_buffers, max_buffers));
param_meta_enable_rb.stride = 0;
param_meta_enable_rb.blocks = 1;
param_meta_enable_rb.align = 16;
pinos_stream_finish_format (p->stream, SPA_RESULT_OK, port_params, 2);

16
pinos/modules/spa/spa-alsa-monitor.c
View file

@ -31,6 +31,8 @@
#include <spa/include/spa/node.h>
#include <spa/include/spa/monitor.h>
#include <pinos/client/log.h>
#include "spa-alsa-monitor.h"
#define PINOS_SPA_ALSA_MONITOR_GET_PRIVATE(obj) \
@ -109,7 +111,7 @@ add_item (PinosSpaALSAMonitor *this, SpaMonitorItem *item)
void *node_iface, *clock_iface;
PinosProperties *props = NULL;
g_debug ("alsa-monitor %p: add: \"%s\" (%s)", this, item->name, item->id);
pinos_log_debug ("alsa-monitor %p: add: \"%s\" (%s)", this, item->name, item->id);
handle = calloc (1, item->factory->size);
if ((res = spa_handle_factory_init (item->factory,
@ -125,7 +127,7 @@ add_item (PinosSpaALSAMonitor *this, SpaMonitorItem *item)
return;
}
if ((res = spa_handle_get_interface (handle, priv->uri.clock, &clock_iface)) < 0) {
g_debug ("can't get CLOCK interface: %d", res);
pinos_log_debug ("can't get CLOCK interface: %d", res);
clock_iface = NULL;
}
@ -157,7 +159,7 @@ remove_item (PinosSpaALSAMonitor *this, SpaMonitorItem *item)
PinosSpaALSAMonitorPrivate *priv = this->priv;
PinosNode *node;
g_debug ("alsa-monitor %p: remove: \"%s\" (%s)", this, item->name, item->id);
pinos_log_debug ("alsa-monitor %p: remove: \"%s\" (%s)", this, item->name, item->id);
node = g_hash_table_lookup (priv->nodes, item->id);
if (node) {
@ -188,7 +190,7 @@ on_monitor_event (SpaMonitor *monitor,
case SPA_MONITOR_EVENT_TYPE_CHANGED:
{
SpaMonitorItem *item = (SpaMonitorItem *) event;
g_debug ("alsa-monitor %p: changed: \"%s\"", this, item->name);
pinos_log_debug ("alsa-monitor %p: changed: \"%s\"", this, item->name);
break;
}
default:
@ -204,7 +206,7 @@ monitor_constructed (GObject * object)
SpaResult res;
void *state = NULL;
g_debug ("spa-monitor %p: constructed", this);
pinos_log_debug ("spa-monitor %p: constructed", this);
G_OBJECT_CLASS (pinos_spa_alsa_monitor_parent_class)->constructed (object);
@ -216,7 +218,7 @@ monitor_constructed (GObject * object)
if ((res = spa_monitor_enum_items (priv->monitor, &item, &state)) < 0) {
if (res != SPA_RESULT_ENUM_END)
g_debug ("spa_monitor_enum_items: got error %d\n", res);
pinos_log_debug ("spa_monitor_enum_items: got error %d\n", res);
break;
}
add_item (this, item);
@ -278,7 +280,7 @@ monitor_finalize (GObject * object)
PinosSpaALSAMonitor *this = PINOS_SPA_ALSA_MONITOR (object);
PinosSpaALSAMonitorPrivate *priv = this->priv;
g_debug ("spa-monitor %p: dispose", this);
pinos_log_debug ("spa-monitor %p: dispose", this);
spa_handle_clear (priv->handle);
g_free (priv->handle);
g_hash_table_unref (priv->nodes);

6
pinos/modules/spa/spa-audiotestsrc.c
View file

@ -100,10 +100,10 @@ setup_node (PinosSpaAudioTestSrc *this)
SpaPropValue value;
if ((res = spa_node_get_props (node->node, &props)) < 0)
g_debug ("got get_props error %d", res);
pinos_log_debug ("got get_props error %d", res);
if ((res = spa_node_set_props (node->node, props)) < 0)
g_debug ("got set_props error %d", res);
pinos_log_debug ("got set_props error %d", res);
#endif
}
@ -149,7 +149,7 @@ src_finalize (GObject * object)
PinosSpaAudioTestSrc *src = PINOS_SPA_AUDIOTESTSRC (object);
PinosSpaAudioTestSrcPrivate *priv = src->priv;
g_debug ("audiotestsrc %p: dispose", src);
pinos_log_debug ("audiotestsrc %p: dispose", src);
spa_handle_clear (priv->handle);
g_free (priv->handle);

15
pinos/modules/spa/spa-v4l2-monitor.c
View file

@ -26,10 +26,9 @@
#include <unistd.h>
#include <sys/mman.h>
#include <gio/gio.h>
#include <spa/include/spa/node.h>
#include <spa/include/spa/monitor.h>
#include <pinos/client/log.h>
#include "spa-v4l2-monitor.h"
@ -110,7 +109,7 @@ add_item (PinosSpaV4l2Monitor *this, SpaMonitorItem *item)
void *clock_iface;
PinosProperties *props = NULL;
g_debug ("v4l2-monitor %p: add: \"%s\" (%s)", this, item->name, item->id);
pinos_log_debug ("v4l2-monitor %p: add: \"%s\" (%s)", this, item->name, item->id);
handle = calloc (1, item->factory->size);
if ((res = spa_handle_factory_init (item->factory,
@ -158,7 +157,7 @@ remove_item (PinosSpaV4l2Monitor *this, SpaMonitorItem *item)
PinosSpaV4l2MonitorPrivate *priv = this->priv;
PinosNode *node;
g_debug ("v4l2-monitor %p: remove: \"%s\" (%s)", this, item->name, item->id);
pinos_log_debug ("v4l2-monitor %p: remove: \"%s\" (%s)", this, item->name, item->id);
node = g_hash_table_lookup (priv->nodes, item->id);
if (node) {
@ -189,7 +188,7 @@ on_monitor_event (SpaMonitor *monitor,
case SPA_MONITOR_EVENT_TYPE_CHANGED:
{
SpaMonitorItem *item = (SpaMonitorItem *) event;
g_debug ("v4l2-monitor %p: changed: \"%s\"", this, item->name);
pinos_log_debug ("v4l2-monitor %p: changed: \"%s\"", this, item->name);
break;
}
default:
@ -205,7 +204,7 @@ monitor_constructed (GObject * object)
SpaResult res;
void *state = NULL;
g_debug ("spa-monitor %p: constructed", this);
pinos_log_debug ("spa-monitor %p: constructed", this);
G_OBJECT_CLASS (pinos_spa_v4l2_monitor_parent_class)->constructed (object);
@ -217,7 +216,7 @@ monitor_constructed (GObject * object)
if ((res = spa_monitor_enum_items (priv->monitor, &item, &state)) < 0) {
if (res != SPA_RESULT_ENUM_END)
g_debug ("spa_monitor_enum_items: got error %d\n", res);
pinos_log_debug ("spa_monitor_enum_items: got error %d\n", res);
break;
}
add_item (this, item);
@ -279,7 +278,7 @@ monitor_finalize (GObject * object)
PinosSpaV4l2Monitor *this = PINOS_SPA_V4L2_MONITOR (object);
PinosSpaV4l2MonitorPrivate *priv = this->priv;
g_debug ("spa-monitor %p: dispose", this);
pinos_log_debug ("spa-monitor %p: dispose", this);
spa_handle_clear (priv->handle);
g_free (priv->handle);
g_hash_table_unref (priv->nodes);

226
pinos/server/client-node.c
View file

@ -164,7 +164,7 @@ static SpaResult
clear_buffers (SpaProxy *this, SpaProxyPort *port)
{
if (port->n_buffers) {
spa_log_info (this->log, "proxy %p: clear buffers\n", this);
spa_log_info (this->log, "proxy %p: clear buffers", this);
munmap (port->buffer_mem_ptr, port->buffer_mem_size);
close (port->buffer_mem_fd);
@ -211,15 +211,15 @@ spa_proxy_node_send_command (SpaNode *node,
case SPA_NODE_COMMAND_DRAIN:
case SPA_NODE_COMMAND_MARKER:
{
PinosControlCmdNodeCommand cnc;
PinosMessageNodeCommand cnc;
/* send start */
cnc.seq = this->seq++;
cnc.command = command;
pinos_connection_add_cmd (this->conn, PINOS_CONTROL_CMD_NODE_COMMAND, &cnc);
pinos_connection_add_message (this->conn, PINOS_MESSAGE_NODE_COMMAND, &cnc);
if (!pinos_connection_flush (this->conn)) {
spa_log_error (this->log, "proxy %p: error writing connection\n", this);
spa_log_error (this->log, "proxy %p: error writing connection", this);
res = SPA_RESULT_ERROR;
} else
res = SPA_RESULT_RETURN_ASYNC (cnc.seq);
@ -228,14 +228,14 @@ spa_proxy_node_send_command (SpaNode *node,
case SPA_NODE_COMMAND_CLOCK_UPDATE:
{
PinosControlCmdNodeCommand cnc;
PinosMessageNodeCommand cnc;
/* send start */
cnc.command = command;
pinos_connection_add_cmd (this->conn, PINOS_CONTROL_CMD_NODE_COMMAND, &cnc);
pinos_connection_add_message (this->conn, PINOS_MESSAGE_NODE_COMMAND, &cnc);
if (!pinos_connection_flush (this->conn)) {
spa_log_error (this->log, "proxy %p: error writing connection\n", this);
spa_log_error (this->log, "proxy %p: error writing connection", this);
res = SPA_RESULT_ERROR;
}
break;
@ -319,7 +319,7 @@ spa_proxy_node_get_port_ids (SpaNode *node,
static void
do_update_port (SpaProxy *this,
PinosControlCmdPortUpdate *pu)
PinosMessagePortUpdate *pu)
{
SpaProxyPort *port;
unsigned int i;
@ -331,7 +331,7 @@ do_update_port (SpaProxy *this,
port = &this->out_ports[pu->port_id];
}
if (pu->change_mask & PINOS_CONTROL_CMD_PORT_UPDATE_POSSIBLE_FORMATS) {
if (pu->change_mask & PINOS_MESSAGE_PORT_UPDATE_POSSIBLE_FORMATS) {
for (i = 0; i < port->n_formats; i++)
free (port->formats[i]);
port->n_formats = pu->n_possible_formats;
@ -341,17 +341,17 @@ do_update_port (SpaProxy *this,
port->formats[i] = pinos_serialize_format_copy_into (malloc (size), pu->possible_formats[i]);
}
}
if (pu->change_mask & PINOS_CONTROL_CMD_PORT_UPDATE_FORMAT) {
if (pu->change_mask & PINOS_MESSAGE_PORT_UPDATE_FORMAT) {
if (port->format)
free (port->format);
size = pinos_serialize_format_get_size (pu->format);
port->format = pinos_serialize_format_copy_into (malloc (size), pu->format);
}
if (pu->change_mask & PINOS_CONTROL_CMD_PORT_UPDATE_PROPS) {
if (pu->change_mask & PINOS_MESSAGE_PORT_UPDATE_PROPS) {
}
if (pu->change_mask & PINOS_CONTROL_CMD_PORT_UPDATE_INFO && pu->info) {
if (pu->change_mask & PINOS_MESSAGE_PORT_UPDATE_INFO && pu->info) {
if (port->info)
free (port->info);
size = pinos_serialize_port_info_get_size (pu->info);
@ -359,7 +359,7 @@ do_update_port (SpaProxy *this,
}
if (!port->valid) {
spa_log_info (this->log, "proxy %p: adding port %d\n", this, pu->port_id);
spa_log_info (this->log, "proxy %p: adding port %d", this, pu->port_id);
port->format = NULL;
port->valid = true;
@ -376,12 +376,12 @@ clear_port (SpaProxy *this,
SpaDirection direction,
uint32_t port_id)
{
PinosControlCmdPortUpdate pu;
PinosMessagePortUpdate pu;
pu.change_mask = PINOS_CONTROL_CMD_PORT_UPDATE_POSSIBLE_FORMATS |
PINOS_CONTROL_CMD_PORT_UPDATE_FORMAT |
PINOS_CONTROL_CMD_PORT_UPDATE_PROPS |
PINOS_CONTROL_CMD_PORT_UPDATE_INFO;
pu.change_mask = PINOS_MESSAGE_PORT_UPDATE_POSSIBLE_FORMATS |
PINOS_MESSAGE_PORT_UPDATE_FORMAT |
PINOS_MESSAGE_PORT_UPDATE_PROPS |
PINOS_MESSAGE_PORT_UPDATE_INFO;
pu.direction = direction;
pu.port_id = port_id;
pu.n_possible_formats = 0;
@ -400,7 +400,7 @@ do_uninit_port (SpaProxy *this,
{
SpaProxyPort *port;
spa_log_info (this->log, "proxy %p: removing port %d\n", this, port_id);
spa_log_info (this->log, "proxy %p: removing port %d", this, port_id);
if (direction == SPA_DIRECTION_INPUT) {
port = &this->in_ports[port_id];
this->n_inputs--;
@ -495,7 +495,7 @@ spa_proxy_node_port_set_format (SpaNode *node,
const SpaFormat *format)
{
SpaProxy *this;
PinosControlCmdSetFormat sf;
PinosMessageSetFormat sf;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -510,10 +510,10 @@ spa_proxy_node_port_set_format (SpaNode *node,
sf.port_id = port_id;
sf.flags = flags;
sf.format = (SpaFormat *) format;
pinos_connection_add_cmd (this->conn, PINOS_CONTROL_CMD_SET_FORMAT, &sf);
pinos_connection_add_message (this->conn, PINOS_MESSAGE_SET_FORMAT, &sf);
if (!pinos_connection_flush (this->conn))
spa_log_error (this->log, "proxy %p: error writing connection\n", this);
spa_log_error (this->log, "proxy %p: error writing connection", this);
return SPA_RESULT_RETURN_ASYNC (sf.seq);
}
@ -624,17 +624,17 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
SpaProxy *this;
SpaProxyPort *port;
unsigned int i, j;
PinosControlCmdAddMem am;
PinosControlCmdUseBuffers ub;
PinosMessageAddMem am;
PinosMessageUseBuffers ub;
size_t size, n_mem;
PinosControlMemRef *memref;
PinosMessageMemRef *memref;
void *p;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, SpaProxy, node);
spa_log_info (this->log, "proxy %p: use buffers %p %u\n", this, buffers, n_buffers);
spa_log_info (this->log, "proxy %p: use buffers %p %u", this, buffers, n_buffers);
if (!CHECK_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
@ -680,7 +680,7 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
am.flags = d->flags;
am.offset = d->offset;
am.size = d->maxsize;
pinos_connection_add_cmd (this->conn, PINOS_CONTROL_CMD_ADD_MEM, &am);
pinos_connection_add_message (this->conn, PINOS_MESSAGE_ADD_MEM, &am);
b->buffer.datas[j].type = SPA_DATA_TYPE_ID;
b->buffer.datas[j].data = SPA_UINT32_TO_PTR (n_mem);
@ -693,7 +693,7 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
default:
b->buffer.datas[j].type = SPA_DATA_TYPE_INVALID;
b->buffer.datas[j].data = 0;
spa_log_error (this->log, "invalid memory type %d\n", d->type);
spa_log_error (this->log, "invalid memory type %d", d->type);
break;
}
}
@ -707,7 +707,7 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
port->buffer_mem_fd = memfd_create ("spa-memfd", MFD_CLOEXEC | MFD_ALLOW_SEALING);
if (ftruncate (port->buffer_mem_fd, size) < 0) {
spa_log_error (this->log, "Failed to truncate temporary file: %s\n", strerror (errno));
spa_log_error (this->log, "Failed to truncate temporary file: %s", strerror (errno));
close (port->buffer_mem_fd);
return SPA_RESULT_ERROR;
}
@ -715,7 +715,7 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
{
unsigned int seals = F_SEAL_GROW | F_SEAL_SHRINK | F_SEAL_SEAL;
if (fcntl (port->buffer_mem_fd, F_ADD_SEALS, seals) == -1) {
spa_log_error (this->log, "Failed to add seals: %s\n", strerror (errno));
spa_log_error (this->log, "Failed to add seals: %s", strerror (errno));
}
}
#endif
@ -752,9 +752,9 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
am.flags = 0;
am.offset = 0;
am.size = size;
pinos_connection_add_cmd (this->conn, PINOS_CONTROL_CMD_ADD_MEM, &am);
pinos_connection_add_message (this->conn, PINOS_MESSAGE_ADD_MEM, &am);
memref = alloca (n_buffers * sizeof (PinosControlMemRef));
memref = alloca (n_buffers * sizeof (PinosMessageMemRef));
for (i = 0; i < n_buffers; i++) {
memref[i].mem_id = port->buffer_mem_id;
memref[i].offset = port->buffers[i].offset;
@ -770,10 +770,10 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
ub.port_id = port_id;
ub.n_buffers = n_buffers;
ub.buffers = memref;
pinos_connection_add_cmd (this->conn, PINOS_CONTROL_CMD_USE_BUFFERS, &ub);
pinos_connection_add_message (this->conn, PINOS_MESSAGE_USE_BUFFERS, &ub);
if (!pinos_connection_flush (this->conn))
spa_log_error (this->log, "proxy %p: error writing connection\n", this);
spa_log_error (this->log, "proxy %p: error writing connection", this);
return SPA_RESULT_RETURN_ASYNC (ub.seq);
}
@ -820,7 +820,7 @@ copy_meta_in (SpaProxy *this, SpaProxyPort *port, uint32_t buffer_id)
for (i = 0; i < b->outbuf->n_datas; i++) {
b->outbuf->datas[i].size = b->buffer.datas[i].size;
if (b->outbuf->datas[i].type == SPA_DATA_TYPE_MEMPTR) {
spa_log_info (this->log, "memcpy in %zd\n", b->buffer.datas[i].size);
spa_log_info (this->log, "memcpy in %zd", b->buffer.datas[i].size);
memcpy (b->outbuf->datas[i].data, b->datas[i].data, b->buffer.datas[i].size);
}
}
@ -840,7 +840,7 @@ copy_meta_out (SpaProxy *this, SpaProxyPort *port, uint32_t buffer_id)
for (i = 0; i < b->outbuf->n_datas; i++) {
b->buffer.datas[i].size = b->outbuf->datas[i].size;
if (b->datas[i].type == SPA_DATA_TYPE_MEMPTR) {
spa_log_info (this->log, "memcpy out %zd\n", b->outbuf->datas[i].size);
spa_log_info (this->log, "memcpy out %zd", b->outbuf->datas[i].size);
memcpy (b->datas[i].data, b->outbuf->datas[i].data, b->outbuf->datas[i].size);
}
}
@ -855,7 +855,7 @@ spa_proxy_node_port_push_input (SpaNode *node,
SpaProxyPort *port;
unsigned int i;
bool have_error = false;
PinosControlCmdProcessBuffer pb;
PinosMessageProcessBuffer pb;
if (node == NULL || n_info == 0 || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -864,7 +864,7 @@ spa_proxy_node_port_push_input (SpaNode *node,
for (i = 0; i < n_info; i++) {
if (!CHECK_IN_PORT (this, SPA_DIRECTION_INPUT, info[i].port_id)) {
spa_log_warn (this->log, "invalid port %d\n", info[i].port_id);
spa_log_warn (this->log, "invalid port %d", info[i].port_id);
info[i].status = SPA_RESULT_INVALID_PORT;
have_error = true;
continue;
@ -890,7 +890,7 @@ spa_proxy_node_port_push_input (SpaNode *node,
pb.direction = SPA_DIRECTION_INPUT;
pb.port_id = info[i].port_id;
pb.buffer_id = info[i].buffer_id;
pinos_connection_add_cmd (this->rtconn, PINOS_CONTROL_CMD_PROCESS_BUFFER, &pb);
pinos_connection_add_message (this->rtconn, PINOS_MESSAGE_PROCESS_BUFFER, &pb);
info[i].status = SPA_RESULT_OK;
}
@ -899,7 +899,7 @@ spa_proxy_node_port_push_input (SpaNode *node,
return SPA_RESULT_ERROR;
if (!pinos_connection_flush (this->rtconn))
spa_log_error (this->log, "proxy %p: error writing connection\n", this);
spa_log_error (this->log, "proxy %p: error writing connection", this);
return SPA_RESULT_OK;
}
@ -923,7 +923,7 @@ spa_proxy_node_port_pull_output (SpaNode *node,
ProxyBuffer *b;
if (!CHECK_OUT_PORT (this, SPA_DIRECTION_OUTPUT, info[i].port_id)) {
spa_log_warn (this->log, "invalid port %u\n", info[i].port_id);
spa_log_warn (this->log, "invalid port %u", info[i].port_id);
info[i].status = SPA_RESULT_INVALID_PORT;
have_error = true;
continue;
@ -960,7 +960,7 @@ spa_proxy_node_port_reuse_buffer (SpaNode *node,
uint32_t buffer_id)
{
SpaProxy *this;
PinosControlCmdNodeEvent cne;
PinosMessageNodeEvent cne;
SpaNodeEventReuseBuffer rb;
if (node == NULL)
@ -977,10 +977,10 @@ spa_proxy_node_port_reuse_buffer (SpaNode *node,
rb.event.size = sizeof (rb);
rb.port_id = port_id;
rb.buffer_id = buffer_id;
pinos_connection_add_cmd (this->rtconn, PINOS_CONTROL_CMD_NODE_EVENT, &cne);
pinos_connection_add_message (this->rtconn, PINOS_MESSAGE_NODE_EVENT, &cne);
if (!pinos_connection_flush (this->rtconn))
spa_log_error (this->log, "proxy %p: error writing connection\n", this);
spa_log_error (this->log, "proxy %p: error writing connection", this);
return SPA_RESULT_OK;
}
@ -1009,21 +1009,21 @@ spa_proxy_node_port_send_command (SpaNode *node,
case SPA_NODE_COMMAND_DRAIN:
case SPA_NODE_COMMAND_MARKER:
{
PinosControlCmdPortCommand cpc;
PinosMessagePortCommand cpc;
cpc.port_id = port_id;
cpc.command = command;
pinos_connection_add_cmd (this->rtconn, PINOS_CONTROL_CMD_PORT_COMMAND, &cpc);
pinos_connection_add_message (this->rtconn, PINOS_MESSAGE_PORT_COMMAND, &cpc);
if (!pinos_connection_flush (this->rtconn)) {
spa_log_error (this->log, "proxy %p: error writing connection\n", this);
spa_log_error (this->log, "proxy %p: error writing connection", this);
res = SPA_RESULT_ERROR;
}
break;
}
default:
spa_log_warn (this->log, "unhandled command %d\n", command->type);
spa_log_warn (this->log, "unhandled command %d", command->type);
res = SPA_RESULT_NOT_IMPLEMENTED;
break;
}
@ -1059,45 +1059,45 @@ parse_connection (SpaProxy *this)
PinosConnection *conn = this->conn;
while (pinos_connection_has_next (conn)) {
PinosControlCmd cmd = pinos_connection_get_cmd (conn);
PinosMessageType type = pinos_connection_get_type (conn);
switch (cmd) {
case PINOS_CONTROL_CMD_INVALID:
case PINOS_CONTROL_CMD_ADD_PORT:
case PINOS_CONTROL_CMD_REMOVE_PORT:
case PINOS_CONTROL_CMD_SET_FORMAT:
case PINOS_CONTROL_CMD_SET_PROPERTY:
case PINOS_CONTROL_CMD_NODE_COMMAND:
case PINOS_CONTROL_CMD_PORT_COMMAND:
case PINOS_CONTROL_CMD_PROCESS_BUFFER:
spa_log_error (this->log, "proxy %p: got unexpected command %d\n", this, cmd);
switch (type) {
case PINOS_MESSAGE_INVALID:
case PINOS_MESSAGE_ADD_PORT:
case PINOS_MESSAGE_REMOVE_PORT:
case PINOS_MESSAGE_SET_FORMAT:
case PINOS_MESSAGE_SET_PROPERTY:
case PINOS_MESSAGE_NODE_COMMAND:
case PINOS_MESSAGE_PORT_COMMAND:
case PINOS_MESSAGE_PROCESS_BUFFER:
spa_log_error (this->log, "proxy %p: got unexpected command %d", this, type);
break;
case PINOS_CONTROL_CMD_NODE_UPDATE:
case PINOS_MESSAGE_NODE_UPDATE:
{
PinosControlCmdNodeUpdate nu;
PinosMessageNodeUpdate nu;
if (!pinos_connection_parse_cmd (conn, &nu))
if (!pinos_connection_parse_message (conn, &nu))
break;
if (nu.change_mask & PINOS_CONTROL_CMD_NODE_UPDATE_MAX_INPUTS)
if (nu.change_mask & PINOS_MESSAGE_NODE_UPDATE_MAX_INPUTS)
this->max_inputs = nu.max_input_ports;
if (nu.change_mask & PINOS_CONTROL_CMD_NODE_UPDATE_MAX_OUTPUTS)
if (nu.change_mask & PINOS_MESSAGE_NODE_UPDATE_MAX_OUTPUTS)
this->max_outputs = nu.max_output_ports;
spa_log_info (this->log, "proxy %p: got node update %d, max_in %u, max_out %u\n", this, cmd,
spa_log_info (this->log, "proxy %p: got node update %d, max_in %u, max_out %u", this, type,
this->max_inputs, this->max_outputs);
break;
}
case PINOS_CONTROL_CMD_PORT_UPDATE:
case PINOS_MESSAGE_PORT_UPDATE:
{
PinosControlCmdPortUpdate pu;
PinosMessagePortUpdate pu;
bool remove;
spa_log_info (this->log, "proxy %p: got port update %d\n", this, cmd);
if (!pinos_connection_parse_cmd (conn, &pu))
spa_log_info (this->log, "proxy %p: got port update %d", this, type);
if (!pinos_connection_parse_message (conn, &pu))
break;
if (!CHECK_PORT_ID (this, pu.direction, pu.port_id))
@ -1113,21 +1113,21 @@ parse_connection (SpaProxy *this)
break;
}
case PINOS_CONTROL_CMD_PORT_STATUS_CHANGE:
case PINOS_MESSAGE_PORT_STATUS_CHANGE:
{
spa_log_warn (this->log, "proxy %p: command not implemented %d\n", this, cmd);
spa_log_warn (this->log, "proxy %p: command not implemented %d", this, type);
break;
}
case PINOS_CONTROL_CMD_NODE_STATE_CHANGE:
case PINOS_MESSAGE_NODE_STATE_CHANGE:
{
PinosControlCmdNodeStateChange sc;
PinosMessageNodeStateChange sc;
SpaNodeState old = this->node.state;
if (!pinos_connection_parse_cmd (conn, &sc))
if (!pinos_connection_parse_message (conn, &sc))
break;
spa_log_info (this->log, "proxy %p: got node state change %d -> %d\n", this, old, sc.state);
spa_log_info (this->log, "proxy %p: got node state change %d -> %d", this, old, sc.state);
this->node.state = sc.state;
if (old == SPA_NODE_STATE_INIT)
send_async_complete (this, 0, SPA_RESULT_OK);
@ -1135,16 +1135,16 @@ parse_connection (SpaProxy *this)
break;
}
case PINOS_CONTROL_CMD_ADD_MEM:
case PINOS_MESSAGE_ADD_MEM:
break;
case PINOS_CONTROL_CMD_USE_BUFFERS:
case PINOS_MESSAGE_USE_BUFFERS:
break;
case PINOS_CONTROL_CMD_NODE_EVENT:
case PINOS_MESSAGE_NODE_EVENT:
{
PinosControlCmdNodeEvent cne;
PinosMessageNodeEvent cne;
if (!pinos_connection_parse_cmd (conn, &cne))
if (!pinos_connection_parse_message (conn, &cne))
break;
handle_node_event (this, cne.event);
@ -1162,63 +1162,63 @@ parse_rtconnection (SpaProxy *this)
PinosConnection *conn = this->rtconn;
while (pinos_connection_has_next (conn)) {
PinosControlCmd cmd = pinos_connection_get_cmd (conn);
PinosMessageType type = pinos_connection_get_type (conn);
switch (cmd) {
case PINOS_CONTROL_CMD_INVALID:
case PINOS_CONTROL_CMD_NODE_UPDATE:
case PINOS_CONTROL_CMD_PORT_UPDATE:
case PINOS_CONTROL_CMD_NODE_STATE_CHANGE:
case PINOS_CONTROL_CMD_PORT_STATUS_CHANGE:
case PINOS_CONTROL_CMD_ADD_PORT:
case PINOS_CONTROL_CMD_REMOVE_PORT:
case PINOS_CONTROL_CMD_SET_FORMAT:
case PINOS_CONTROL_CMD_SET_PROPERTY:
case PINOS_CONTROL_CMD_NODE_COMMAND:
case PINOS_CONTROL_CMD_ADD_MEM:
case PINOS_CONTROL_CMD_USE_BUFFERS:
spa_log_error (this->log, "proxy %p: got unexpected connection %d\n", this, cmd);
switch (type) {
case PINOS_MESSAGE_INVALID:
case PINOS_MESSAGE_NODE_UPDATE:
case PINOS_MESSAGE_PORT_UPDATE:
case PINOS_MESSAGE_NODE_STATE_CHANGE:
case PINOS_MESSAGE_PORT_STATUS_CHANGE:
case PINOS_MESSAGE_ADD_PORT:
case PINOS_MESSAGE_REMOVE_PORT:
case PINOS_MESSAGE_SET_FORMAT:
case PINOS_MESSAGE_SET_PROPERTY:
case PINOS_MESSAGE_NODE_COMMAND:
case PINOS_MESSAGE_ADD_MEM:
case PINOS_MESSAGE_USE_BUFFERS:
spa_log_error (this->log, "proxy %p: got unexpected message %d", this, type);
break;
case PINOS_CONTROL_CMD_PROCESS_BUFFER:
case PINOS_MESSAGE_PROCESS_BUFFER:
{
PinosControlCmdProcessBuffer cmd;
PinosMessageProcessBuffer msg;
SpaProxyPort *port;
ProxyBuffer *b;
if (!pinos_connection_parse_cmd (conn, &cmd))
if (!pinos_connection_parse_message (conn, &msg))
break;
if (!CHECK_PORT (this, cmd.direction, cmd.port_id))
if (!CHECK_PORT (this, msg.direction, msg.port_id))
break;
port = cmd.direction == SPA_DIRECTION_INPUT ? &this->in_ports[cmd.port_id] : &this->out_ports[cmd.port_id];
port = msg.direction == SPA_DIRECTION_INPUT ? &this->in_ports[msg.port_id] : &this->out_ports[msg.port_id];
if (!CHECK_PORT_BUFFER (this, cmd.buffer_id, port))
if (!CHECK_PORT_BUFFER (this, msg.buffer_id, port))
break;
copy_meta_in (this, port, cmd.buffer_id);
copy_meta_in (this, port, msg.buffer_id);
b = &port->buffers[cmd.buffer_id];
b = &port->buffers[msg.buffer_id];
b->next = NULL;
SPA_QUEUE_PUSH_TAIL (&port->ready, ProxyBuffer, next, b);
break;
}
case PINOS_CONTROL_CMD_NODE_EVENT:
case PINOS_MESSAGE_NODE_EVENT:
{
PinosControlCmdNodeEvent cne;
PinosMessageNodeEvent cne;
if (!pinos_connection_parse_cmd (conn, &cne))
if (!pinos_connection_parse_message (conn, &cne))
break;
handle_node_event (this, cne.event);
break;
}
case PINOS_CONTROL_CMD_PORT_COMMAND:
case PINOS_MESSAGE_PORT_COMMAND:
{
PinosControlCmdPortCommand cm;
PinosMessagePortCommand cm;
if (!pinos_connection_parse_cmd (conn, &cm))
if (!pinos_connection_parse_message (conn, &cm))
break;
break;
@ -1387,7 +1387,7 @@ pinos_client_node_dispose (GObject * object)
PinosClientNode *this = PINOS_CLIENT_NODE (object);
PinosClientNodePrivate *priv = this->priv;
g_debug ("client-node %p: dispose", this);
pinos_log_debug ("client-node %p: dispose", this);
proxy_clear (priv->proxy);
@ -1400,7 +1400,7 @@ pinos_client_node_finalize (GObject * object)
PinosClientNode *this = PINOS_CLIENT_NODE (object);
PinosClientNodePrivate *priv = this->priv;
g_debug ("client-node %p: finalize", this);
pinos_log_debug ("client-node %p: finalize", this);
g_clear_object (&priv->sockets[0]);
g_clear_object (&priv->sockets[1]);
@ -1416,7 +1416,7 @@ pinos_client_node_constructed (GObject * object)
PinosClientNode *this = PINOS_CLIENT_NODE (object);
PinosClientNodePrivate *priv = this->priv;
g_debug ("client-node %p: constructed", this);
pinos_log_debug ("client-node %p: constructed", this);
G_OBJECT_CLASS (pinos_client_node_parent_class)->constructed (object);
@ -1443,7 +1443,7 @@ pinos_client_node_init (PinosClientNode * node)
{
node->priv = PINOS_CLIENT_NODE_GET_PRIVATE (node);
g_debug ("client-node %p: new", node);
pinos_log_debug ("client-node %p: new", node);
}
/**

21
pinos/server/client.c
View file

@ -70,7 +70,7 @@ client_name_appeared_handler (GDBusConnection *connection,
{
PinosClient *client = user_data;
g_debug ("client %p: appeared %s %s", client, name, name_owner);
pinos_log_debug ("client %p: appeared %s %s", client, name, name_owner);
g_signal_emit (client, signals[SIGNAL_APPEARED], 0, NULL);
}
@ -83,7 +83,7 @@ client_name_vanished_handler (GDBusConnection *connection,
PinosClient *client = user_data;
PinosClientPrivate *priv = client->priv;
g_debug ("client %p: vanished %s", client, name);
pinos_log_debug ("client %p: vanished %s", client, name);
g_signal_emit (client, signals[SIGNAL_VANISHED], 0, NULL);
g_bus_unwatch_name (priv->id);
@ -186,7 +186,9 @@ client_register_object (PinosClient *client)
priv->object_path = pinos_daemon_export_uniquely (daemon, G_DBUS_OBJECT_SKELETON (skel));
g_object_unref (skel);
g_debug ("client %p: register %s", client, priv->object_path);
client->id = pinos_map_insert_new (&daemon->registry.clients, client);
pinos_log_debug ("client %p: register %s", client, priv->object_path);
}
static void
@ -195,8 +197,9 @@ client_unregister_object (PinosClient *client)
PinosClientPrivate *priv = client->priv;
PinosDaemon *daemon = priv->daemon;
g_debug ("client %p: unregister", client);
pinos_log_debug ("client %p: unregister", client);
pinos_daemon_unexport (daemon, priv->object_path);
pinos_map_remove (&daemon->registry.clients, client->id);
}
static void
@ -206,7 +209,7 @@ pinos_client_dispose (GObject * object)
PinosClientPrivate *priv = client->priv;
GList *copy;
g_debug ("client %p: dispose", client);
pinos_log_debug ("client %p: dispose", client);
copy = g_list_copy (priv->objects);
g_list_free_full (copy, g_object_unref);
g_list_free (priv->objects);
@ -222,7 +225,7 @@ pinos_client_finalize (GObject * object)
PinosClient *client = PINOS_CLIENT (object);
PinosClientPrivate *priv = client->priv;
g_debug ("client %p: finalize", client);
pinos_log_debug ("client %p: finalize", client);
g_clear_object (&priv->daemon);
g_clear_object (&priv->iface);
g_free (priv->sender);
@ -238,7 +241,7 @@ pinos_client_constructed (GObject * object)
{
PinosClient *client = PINOS_CLIENT (object);
g_debug ("client %p: constructed", client);
pinos_log_debug ("client %p: constructed", client);
client_watch_name (client);
client_register_object (client);
@ -335,7 +338,7 @@ pinos_client_init (PinosClient * client)
PinosClientPrivate *priv = client->priv = PINOS_CLIENT_GET_PRIVATE (client);
priv->iface = pinos_client1_skeleton_new ();
g_debug ("client %p: new", client);
pinos_log_debug ("client %p: new", client);
}
/**
@ -373,7 +376,7 @@ pinos_client_remove (PinosClient *client)
{
g_return_if_fail (PINOS_IS_CLIENT (client));
g_debug ("client %p: remove", client);
pinos_log_debug ("client %p: remove", client);
g_signal_emit (client, signals[SIGNAL_REMOVE], 0, NULL);
}

2
pinos/server/client.h
View file

@ -47,6 +47,8 @@ typedef struct _PinosClientPrivate PinosClientPrivate;
struct _PinosClient {
GObject object;
uint32_t id;
PinosClientPrivate *priv;
};

130
pinos/server/daemon.c
View file

@ -26,6 +26,7 @@
#include "config.h"
#include "pinos/client/pinos.h"
#include "pinos/client/log.h"
#include "pinos/server/daemon.h"
#include "pinos/server/node.h"
@ -50,8 +51,6 @@ struct _PinosDaemonPrivate
gchar *object_path;
GList *nodes;
GHashTable *clients;
PinosDataLoop *data_loop;
PinosMainLoop *main_loop;
@ -61,7 +60,6 @@ struct _PinosDaemonPrivate
GHashTable *node_factories;
SpaSupport support[4];
SpaLog log;
};
enum
@ -80,7 +78,7 @@ handle_client_appeared (PinosClient *client, gpointer user_data)
PinosDaemon *daemon = user_data;
PinosDaemonPrivate *priv = daemon->priv;
g_debug ("daemon %p: appeared %p", daemon, client);
pinos_log_debug ("daemon %p: appeared %p", daemon, client);
g_hash_table_insert (priv->clients, (gpointer) pinos_client_get_sender (client), client);
}
@ -91,7 +89,7 @@ handle_client_vanished (PinosClient *client, gpointer user_data)
PinosDaemon *daemon = user_data;
PinosDaemonPrivate *priv = daemon->priv;
g_debug ("daemon %p: vanished %p", daemon, client);
pinos_log_debug ("daemon %p: vanished %p", daemon, client);
g_hash_table_remove (priv->clients, (gpointer) pinos_client_get_sender (client));
}
@ -107,7 +105,7 @@ sender_get_client (PinosDaemon *daemon,
if (client == NULL && create) {
client = pinos_client_new (daemon, sender, NULL);
g_debug ("daemon %p: new client %p for %s", daemon, client, sender);
pinos_log_debug ("daemon %p: new client %p for %s", daemon, client, sender);
g_signal_connect (client,
"appeared",
(GCallback) handle_client_appeared,
@ -126,7 +124,7 @@ handle_remove_node (PinosNode *node,
{
PinosClient *client = user_data;
g_debug ("client %p: node %p remove", daemon, node);
pinos_log_debug ("client %p: node %p remove", daemon, node);
pinos_client_remove_object (client, G_OBJECT (node));
}
@ -149,7 +147,7 @@ handle_create_node (PinosDaemon1 *interface,
sender = g_dbus_method_invocation_get_sender (invocation);
client = sender_get_client (daemon, sender, TRUE);
g_debug ("daemon %p: create node: %s", daemon, sender);
pinos_log_debug ("daemon %p: create node: %s", daemon, sender);
props = pinos_properties_from_variant (arg_properties);
@ -158,7 +156,6 @@ handle_create_node (PinosDaemon1 *interface,
goto no_factory;
node = pinos_node_factory_create_node (factory,
daemon,
client,
arg_name,
props);
@ -175,7 +172,7 @@ handle_create_node (PinosDaemon1 *interface,
client);
object_path = pinos_node_get_object_path (node);
g_debug ("daemon %p: added node %p with path %s", daemon, node, object_path);
pinos_log_debug ("daemon %p: added node %p with path %s", daemon, node, object_path);
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(o)", object_path));
g_object_unref (node);
@ -185,14 +182,14 @@ handle_create_node (PinosDaemon1 *interface,
/* ERRORS */
no_factory:
{
g_debug ("daemon %p: could find factory named %s", daemon, arg_factory_name);
pinos_log_debug ("daemon %p: could find factory named %s", daemon, arg_factory_name);
g_dbus_method_invocation_return_dbus_error (invocation,
"org.pinos.Error", "can't find factory");
return TRUE;
}
no_node:
{
g_debug ("daemon %p: could create node named %s from factory %s", daemon, arg_name, arg_factory_name);
pinos_log_debug ("daemon %p: could create node named %s from factory %s", daemon, arg_name, arg_factory_name);
g_dbus_method_invocation_return_dbus_error (invocation,
"org.pinos.Error", "can't create node");
return TRUE;
@ -205,7 +202,7 @@ on_link_port_unlinked (PinosLink *link,
PinosPort *port,
PinosDaemon *this)
{
g_debug ("daemon %p: link %p: port %p unlinked", this, link, port);
pinos_log_debug ("daemon %p: link %p: port %p unlinked", this, link, port);
if (port->direction == PINOS_DIRECTION_OUTPUT && link->input)
try_link_port (link->input->node, link->input, this);
@ -224,7 +221,7 @@ on_link_state_notify (GObject *obj,
switch (state) {
case PINOS_LINK_STATE_ERROR:
{
g_debug ("daemon %p: link %p: state error: %s", daemon, link, error->message);
pinos_log_debug ("daemon %p: link %p: state error: %s", daemon, link, error->message);
if (link->input && link->input->node)
pinos_node_report_error (link->input->node, g_error_copy (error));
@ -234,7 +231,7 @@ on_link_state_notify (GObject *obj,
}
case PINOS_LINK_STATE_UNLINKED:
g_debug ("daemon %p: link %p: unlinked", daemon, link);
pinos_log_debug ("daemon %p: link %p: unlinked", daemon, link);
#if 0
g_set_error (&error,
@ -348,7 +345,7 @@ on_node_state_change (PinosNode *node,
PinosNodeState state,
PinosDaemon *this)
{
g_debug ("daemon %p: node %p state change %s -> %s", this, node,
pinos_log_debug ("daemon %p: node %p state change %s -> %s", this, node,
pinos_node_state_as_string (old),
pinos_node_state_as_string (state));
@ -362,7 +359,7 @@ on_node_added (PinosDaemon *daemon, PinosNode *node)
PinosNodeState state;
PinosDaemonPrivate *priv = daemon->priv;
g_debug ("daemon %p: node %p added", daemon, node);
pinos_log_debug ("daemon %p: node %p added", daemon, node);
g_object_set (node, "data-loop", priv->data_loop, NULL);
@ -377,7 +374,7 @@ on_node_added (PinosDaemon *daemon, PinosNode *node)
static void
on_node_removed (PinosDaemon *daemon, PinosNode *node)
{
g_debug ("daemon %p: node %p removed", daemon, node);
pinos_log_debug ("daemon %p: node %p removed", daemon, node);
g_signal_handlers_disconnect_by_data (node, daemon);
}
@ -401,7 +398,7 @@ handle_create_client_node (PinosDaemon1 *interface,
sender = g_dbus_method_invocation_get_sender (invocation);
client = sender_get_client (daemon, sender, TRUE);
g_debug ("daemon %p: create client-node: %s", daemon, sender);
pinos_log_debug ("daemon %p: create client-node: %s", daemon, sender);
props = pinos_properties_from_variant (arg_properties);
node = pinos_client_node_new (daemon,
@ -421,7 +418,7 @@ handle_create_client_node (PinosDaemon1 *interface,
pinos_client_add_object (client, G_OBJECT (node));
object_path = pinos_node_get_object_path (PINOS_NODE (node));
g_debug ("daemon %p: add client-node %p, %s", daemon, node, object_path);
pinos_log_debug ("daemon %p: add client-node %p, %s", daemon, node, object_path);
g_object_unref (node);
fdlist = g_unix_fd_list_new ();
@ -438,7 +435,7 @@ handle_create_client_node (PinosDaemon1 *interface,
no_socket:
{
g_debug ("daemon %p: could not create socket %s", daemon, error->message);
pinos_log_debug ("daemon %p: could not create socket %s", daemon, error->message);
g_object_unref (node);
goto exit_error;
}
@ -470,7 +467,7 @@ handle_register_client_node (PinosDaemon1 *interface,
sender = g_dbus_method_invocation_get_sender (invocation);
client = sender_get_client (daemon, sender, TRUE);
g_debug ("daemon %p: register client-node: %s", daemon, sender);
pinos_log_debug ("daemon %p: register client-node: %s", daemon, sender);
props = pinos_properties_from_variant (arg_properties);
node = pinos_dbus_client_node_new (daemon,
@ -498,7 +495,7 @@ handle_register_client_node (PinosDaemon1 *interface,
no_socket:
{
g_debug ("daemon %p: could not create socket %s", daemon, error->message);
pinos_log_debug ("daemon %p: could not create socket %s", daemon, error->message);
g_object_unref (node);
goto exit_error;
}
@ -606,7 +603,7 @@ pinos_daemon_start (PinosDaemon *daemon)
priv = daemon->priv;
g_return_if_fail (priv->id == 0);
g_debug ("daemon %p: start", daemon);
pinos_log_debug ("daemon %p: start", daemon);
priv->id = g_bus_own_name (G_BUS_TYPE_SESSION,
PINOS_DBUS_SERVICE,
@ -631,7 +628,7 @@ pinos_daemon_stop (PinosDaemon *daemon)
g_return_if_fail (PINOS_IS_DAEMON (daemon));
g_debug ("daemon %p: stop", daemon);
pinos_log_debug ("daemon %p: stop", daemon);
if (priv->id != 0) {
g_bus_unown_name (priv->id);
@ -688,13 +685,9 @@ void
pinos_daemon_add_node (PinosDaemon *daemon,
PinosNode *node)
{
PinosDaemonPrivate *priv;
g_return_if_fail (PINOS_IS_DAEMON (daemon));
g_return_if_fail (PINOS_IS_NODE (node));
priv = daemon->priv;
priv->nodes = g_list_prepend (priv->nodes, node);
on_node_added (daemon, node);
}
@ -709,14 +702,10 @@ void
pinos_daemon_remove_node (PinosDaemon *daemon,
PinosNode *node)
{
PinosDaemonPrivate *priv;
g_return_if_fail (PINOS_IS_DAEMON (daemon));
g_return_if_fail (PINOS_IS_NODE (node));
priv = daemon->priv;
on_node_removed (daemon, node);
priv->nodes = g_list_remove (priv->nodes, node);
}
/**
@ -740,29 +729,27 @@ pinos_daemon_find_port (PinosDaemon *daemon,
GPtrArray *format_filters,
GError **error)
{
PinosDaemonPrivate *priv;
PinosPort *best = NULL;
GList *nodes;
gboolean have_name;
guint i;
g_return_val_if_fail (PINOS_IS_DAEMON (daemon), NULL);
priv = daemon->priv;
have_name = name ? strlen (name) > 0 : FALSE;
g_debug ("name \"%s\", %d", name, have_name);
pinos_log_debug ("name \"%s\", %d", name, have_name);
for (nodes = priv->nodes; nodes; nodes = g_list_next (nodes)) {
PinosNode *n = nodes->data;
for (i = 0; i < pinos_map_get_size (&daemon->registry.nodes); i++) {
PinosNode *n = pinos_map_lookup (&daemon->registry.nodes, i);
if (n->flags & PINOS_NODE_FLAG_REMOVING)
if (n == NULL || n->flags & PINOS_NODE_FLAG_REMOVING)
continue;
g_debug ("node path \"%s\"", pinos_node_get_object_path (n));
pinos_log_debug ("node path \"%s\"", pinos_node_get_object_path (n));
if (have_name) {
if (g_str_has_suffix (pinos_node_get_object_path (n), name)) {
g_debug ("name \"%s\" matches node %p", name, n);
pinos_log_debug ("name \"%s\" matches node %p", name, n);
best = pinos_node_get_free_port (n, pinos_direction_reverse (other_port->direction));
if (best)
@ -839,7 +826,7 @@ pinos_daemon_constructed (GObject * object)
PinosDaemon *daemon = PINOS_DAEMON_CAST (object);
PinosDaemonPrivate *priv = daemon->priv;
g_debug ("daemon %p: constructed", object);
pinos_log_debug ("daemon %p: constructed", object);
pinos_daemon1_set_user_name (priv->iface, g_get_user_name ());
pinos_daemon1_set_host_name (priv->iface, g_get_host_name ());
pinos_daemon1_set_version (priv->iface, PACKAGE_VERSION);
@ -855,7 +842,7 @@ pinos_daemon_dispose (GObject * object)
{
PinosDaemon *daemon = PINOS_DAEMON_CAST (object);
g_debug ("daemon %p: dispose", object);
pinos_log_debug ("daemon %p: dispose", object);
pinos_daemon_stop (daemon);
@ -868,7 +855,7 @@ pinos_daemon_finalize (GObject * object)
PinosDaemon *daemon = PINOS_DAEMON_CAST (object);
PinosDaemonPrivate *priv = daemon->priv;
g_debug ("daemon %p: finalize", object);
pinos_log_debug ("daemon %p: finalize", object);
g_clear_object (&priv->server_manager);
g_clear_object (&priv->iface);
g_clear_object (&priv->data_loop);
@ -922,55 +909,19 @@ pinos_daemon_class_init (PinosDaemonClass * klass)
}
static void
do_logv (SpaLog *log,
SpaLogLevel level,
const char *file,
int line,
const char *func,
const char *fmt,
va_list args)
{
char text[16*1024], location[128];
static const char *levels[] = {
"-",
"E",
"W",
"I",
"D",
"T",
};
vsnprintf (text, sizeof(text), fmt, args);
snprintf (location, sizeof(location), "%s:%i %s()", file, line, func);
fprintf(stderr, "[%s][%s] %s", levels[level], location, text);
}
static void
do_log (SpaLog *log,
SpaLogLevel level,
const char *file,
int line,
const char *func,
const char *fmt, ...)
{
va_list args;
va_start (args, fmt);
do_logv (log, level, file, line, func, fmt, args);
va_end (args);
}
static void
pinos_daemon_init (PinosDaemon * daemon)
{
PinosDaemonPrivate *priv = daemon->priv = PINOS_DAEMON_GET_PRIVATE (daemon);
g_debug ("daemon %p: new", daemon);
pinos_log_debug ("daemon %p: new", daemon);
priv->iface = pinos_daemon1_skeleton_new ();
g_signal_connect (priv->iface, "handle-create-node", (GCallback) handle_create_node, daemon);
g_signal_connect (priv->iface, "handle-create-client-node", (GCallback) handle_create_client_node, daemon);
g_signal_connect (priv->iface, "handle-register-client-node", (GCallback) handle_register_client_node, daemon);
pinos_registry_init (&daemon->registry);
priv->server_manager = g_dbus_object_manager_server_new (PINOS_DBUS_OBJECT_PREFIX);
priv->clients = g_hash_table_new (g_str_hash, g_str_equal);
priv->node_factories = g_hash_table_new_full (g_str_hash,
@ -979,17 +930,10 @@ pinos_daemon_init (PinosDaemon * daemon)
g_object_unref);
daemon->main_loop = pinos_main_loop_new (g_main_context_get_thread_default ());
priv->data_loop = pinos_data_loop_new();
priv->log.size = sizeof (SpaLog);
priv->log.info = NULL;
priv->log.level = SPA_LOG_LEVEL_INFO;
priv->log.log = do_log;
priv->log.logv = do_logv;
daemon->map = spa_id_map_get_default();
daemon->log = &priv->log;
daemon->map = pinos_id_map_get_default();
daemon->log = pinos_log_get();
priv->support[0].uri = SPA_ID_MAP_URI;
priv->support[0].data = daemon->map;

3
pinos/server/daemon.h
View file

@ -44,6 +44,7 @@ typedef struct _PinosDaemonPrivate PinosDaemonPrivate;
#include <pinos/server/node-factory.h>
#include <pinos/server/main-loop.h>
#include <pinos/client/properties.h>
#include <pinos/server/registry.h>
/**
* PinosDaemon:
@ -61,6 +62,8 @@ struct _PinosDaemon {
SpaSupport *support;
unsigned int n_support;
PinosRegistry registry;
PinosDaemonPrivate *priv;
};

51
pinos/server/data-loop.c
View file

@ -27,9 +27,8 @@
#include <sys/time.h>
#include <sys/resource.h>
#include <gio/gio.h>
#include "spa/include/spa/ringbuffer.h"
#include "pinos/client/log.h"
#include "pinos/client/rtkit.h"
#include "pinos/server/data-loop.h"
@ -63,7 +62,7 @@ struct _PinosDataLoopPrivate
uint32_t counter;
uint32_t seq;
gboolean running;
bool running;
pthread_t thread;
};
@ -97,31 +96,31 @@ make_realtime (PinosDataLoop *this)
sp.sched_priority = rtprio;
if (pthread_setschedparam (pthread_self(), SCHED_RR|SCHED_RESET_ON_FORK, &sp) == 0) {
g_debug ("SCHED_OTHER|SCHED_RESET_ON_FORK worked.");
pinos_log_debug ("SCHED_OTHER|SCHED_RESET_ON_FORK worked.");
return;
}
system_bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL);
rl.rlim_cur = rl.rlim_max = rttime;
if ((r = setrlimit (RLIMIT_RTTIME, &rl)) < 0)
g_debug ("setrlimit() failed: %s", strerror (errno));
pinos_log_debug ("setrlimit() failed: %s", strerror (errno));
if (rttime >= 0) {
r = getrlimit (RLIMIT_RTTIME, &rl);
if (r >= 0 && (long long) rl.rlim_max > rttime) {
g_debug ("Clamping rlimit-rttime to %lld for RealtimeKit", rttime);
pinos_log_debug ("Clamping rlimit-rttime to %lld for RealtimeKit", rttime);
rl.rlim_cur = rl.rlim_max = rttime;
if ((r = setrlimit (RLIMIT_RTTIME, &rl)) < 0)
g_debug ("setrlimit() failed: %s", strerror (errno));
pinos_log_debug ("setrlimit() failed: %s", strerror (errno));
}
}
if (!pinos_rtkit_make_realtime (system_bus, 0, rtprio, &error)) {
g_debug ("could not make thread realtime: %s", error->message);
pinos_log_debug ("could not make thread realtime: %s", error->message);
g_clear_error (&error);
} else {
g_debug ("thread made realtime");
pinos_log_debug ("thread made realtime");
}
g_object_unref (system_bus);
}
@ -136,7 +135,7 @@ loop (void *user_data)
make_realtime (this);
g_debug ("data-loop %p: enter thread", this);
pinos_log_debug ("data-loop %p: enter thread", this);
while (priv->running) {
SpaPollNotifyData ndata;
unsigned int n_idle = 0;
@ -196,7 +195,7 @@ loop (void *user_data)
break;
}
if (r == 0) {
g_warning ("data-loop %p: select timeout should not happen", this);
pinos_log_warn ("data-loop %p: select timeout should not happen", this);
continue;
}
@ -206,7 +205,7 @@ loop (void *user_data)
size_t offset;
if (read (priv->fds[0].fd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
g_warning ("data-loop %p: failed to read fd: %s", this, strerror (errno));
pinos_log_warn ("data-loop %p: failed to read fd: %s", this, strerror (errno));
while (spa_ringbuffer_get_read_offset (&priv->buffer, &offset) > 0) {
InvokeItem *item = SPA_MEMBER (priv->buffer_data, offset, InvokeItem);
@ -232,7 +231,7 @@ loop (void *user_data)
}
}
}
g_debug ("data-loop %p: leave thread", this);
pinos_log_debug ("data-loop %p: leave thread", this);
return NULL;
}
@ -244,7 +243,7 @@ wakeup_thread (PinosDataLoop *this)
uint64_t u = 1;
if (write (priv->fds[0].fd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
g_warning ("data-loop %p: failed to write fd: %s", this, strerror (errno));
pinos_log_warn ("data-loop %p: failed to write fd: %s", this, strerror (errno));
}
static void
@ -256,14 +255,14 @@ start_thread (PinosDataLoop *this)
if (!priv->running) {
priv->running = true;
if ((err = pthread_create (&priv->thread, NULL, loop, this)) != 0) {
g_warning ("data-loop %p: can't create thread: %s", this, strerror (err));
pinos_log_warn ("data-loop %p: can't create thread: %s", this, strerror (err));
priv->running = false;
}
}
}
static void
stop_thread (PinosDataLoop *this, gboolean in_thread)
stop_thread (PinosDataLoop *this, bool in_thread)
{
PinosDataLoopPrivate *priv = this->priv;
@ -282,7 +281,7 @@ do_add_item (SpaPoll *poll,
{
PinosDataLoop *this = SPA_CONTAINER_OF (poll, PinosDataLoop, poll);
PinosDataLoopPrivate *priv = this->priv;
gboolean in_thread = pthread_equal (priv->thread, pthread_self());
bool in_thread = pthread_equal (priv->thread, pthread_self());
item->id = ++priv->counter;
priv->poll[priv->n_poll] = *item;
@ -304,7 +303,7 @@ do_update_item (SpaPoll *poll,
{
PinosDataLoop *this = SPA_CONTAINER_OF (poll, PinosDataLoop, poll);
PinosDataLoopPrivate *priv = this->priv;
gboolean in_thread = pthread_equal (priv->thread, pthread_self());
bool in_thread = pthread_equal (priv->thread, pthread_self());
unsigned int i;
for (i = 0; i < priv->n_poll; i++) {
@ -326,7 +325,7 @@ do_remove_item (SpaPoll *poll,
{
PinosDataLoop *this = SPA_CONTAINER_OF (poll, PinosDataLoop, poll);
PinosDataLoopPrivate *priv = this->priv;
gboolean in_thread = pthread_equal (priv->thread, pthread_self());
bool in_thread = pthread_equal (priv->thread, pthread_self());
unsigned int i;
for (i = 0; i < priv->n_poll; i++) {
@ -355,7 +354,7 @@ do_invoke (SpaPoll *poll,
{
PinosDataLoop *this = SPA_CONTAINER_OF (poll, PinosDataLoop, poll);
PinosDataLoopPrivate *priv = this->priv;
gboolean in_thread = pthread_equal (priv->thread, pthread_self());
bool in_thread = pthread_equal (priv->thread, pthread_self());
SpaRingbufferArea areas[2];
InvokeItem *item;
SpaResult res;
@ -365,7 +364,7 @@ do_invoke (SpaPoll *poll,
} else {
spa_ringbuffer_get_write_areas (&priv->buffer, areas);
if (areas[0].len < sizeof (InvokeItem)) {
g_warning ("queue full");
pinos_log_warn ("queue full");
return SPA_RESULT_ERROR;
}
item = SPA_MEMBER (priv->buffer_data, areas[0].offset, InvokeItem);
@ -403,7 +402,7 @@ pinos_data_loop_constructed (GObject * obj)
PinosDataLoop *this = PINOS_DATA_LOOP (obj);
PinosDataLoopPrivate *priv = this->priv;
g_debug ("data-loop %p: constructed", this);
pinos_log_debug ("data-loop %p: constructed", this);
G_OBJECT_CLASS (pinos_data_loop_parent_class)->constructed (obj);
@ -418,7 +417,7 @@ pinos_data_loop_dispose (GObject * obj)
{
PinosDataLoop *this = PINOS_DATA_LOOP (obj);
g_debug ("data-loop %p: dispose", this);
pinos_log_debug ("data-loop %p: dispose", this);
stop_thread (this, FALSE);
G_OBJECT_CLASS (pinos_data_loop_parent_class)->dispose (obj);
@ -429,7 +428,7 @@ pinos_data_loop_finalize (GObject * obj)
{
PinosDataLoop *this = PINOS_DATA_LOOP (obj);
g_debug ("data-loop %p: finalize", this);
pinos_log_debug ("data-loop %p: finalize", this);
G_OBJECT_CLASS (pinos_data_loop_parent_class)->finalize (obj);
}
@ -451,7 +450,7 @@ pinos_data_loop_init (PinosDataLoop * this)
{
PinosDataLoopPrivate *priv = this->priv = PINOS_DATA_LOOP_GET_PRIVATE (this);
g_debug ("data-loop %p: new", this);
pinos_log_debug ("data-loop %p: new", this);
this->poll.size = sizeof (SpaPoll);
this->poll.info = NULL;
@ -476,7 +475,7 @@ pinos_data_loop_new (void)
return g_object_new (PINOS_TYPE_DATA_LOOP, NULL);
}
gboolean
bool
pinos_data_loop_in_thread (PinosDataLoop *loop)
{
return pthread_equal (loop->priv->thread, pthread_self());

2
pinos/server/data-loop.h
View file

@ -67,7 +67,7 @@ GType pinos_data_loop_get_type (void);
PinosDataLoop * pinos_data_loop_new (void);
gboolean pinos_data_loop_in_thread (PinosDataLoop *loop);
bool pinos_data_loop_in_thread (PinosDataLoop *loop);
G_END_DECLS

2
pinos/server/dbus-client-node.c
View file

@ -27,6 +27,8 @@
#include <poll.h>
#include <sys/eventfd.h>
#include "spa/lib/props.h"
#include "pinos/client/pinos.h"
#include "pinos/client/enumtypes.h"
#include "pinos/client/private.h"

126
pinos/server/link.c
View file

@ -22,7 +22,7 @@
#include <gio/gio.h>
#include <spa/include/spa/video/format.h>
#include <spa/include/spa/debug.h>
#include <spa/lib/debug.h>
#include "pinos/client/pinos.h"
#include "pinos/client/enumtypes.h"
@ -181,7 +181,9 @@ link_register_object (PinosLink *this)
priv->object_path = pinos_daemon_export_uniquely (priv->daemon, G_DBUS_OBJECT_SKELETON (skel));
g_object_unref (skel);
g_debug ("link %p: register object %s", this, priv->object_path);
this->id = pinos_map_insert_new (&priv->daemon->registry.links, this);
pinos_log_debug ("link %p: register object %s, id %u", this, priv->object_path, this->id);
}
static void
@ -189,8 +191,9 @@ link_unregister_object (PinosLink *this)
{
PinosLinkPrivate *priv = this->priv;
g_debug ("link %p: unregister object", this);
pinos_log_debug ("link %p: unregister object", this);
pinos_daemon_unexport (priv->daemon, priv->object_path);
pinos_map_remove (&priv->daemon->registry.links, this->id);
}
static void
@ -200,7 +203,7 @@ pinos_link_update_state (PinosLink *link, PinosLinkState state)
if (state != priv->state) {
g_clear_error (&priv->error);
g_debug ("link %p: update state %s -> %s", link,
pinos_log_debug ("link %p: update state %s -> %s", link,
pinos_link_state_as_string (priv->state),
pinos_link_state_as_string (state));
priv->state = state;
@ -216,7 +219,7 @@ pinos_link_report_error (PinosLink *link, GError *error)
g_clear_error (&priv->error);
priv->error = error;
priv->state = PINOS_LINK_STATE_ERROR;
g_debug ("link %p: got error state %s", link, error->message);
pinos_log_debug ("link %p: got error state %s", link, error->message);
g_object_notify (G_OBJECT (link), "state");
}
@ -235,7 +238,7 @@ do_negotiate (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
/* both ports need a format */
if (in_state == SPA_NODE_STATE_CONFIGURE && out_state == SPA_NODE_STATE_CONFIGURE) {
g_debug ("link %p: doing negotiate format", this);
pinos_log_debug ("link %p: doing negotiate format", this);
again:
if ((res = spa_node_port_enum_formats (this->input->node->node,
SPA_DIRECTION_INPUT,
@ -251,7 +254,7 @@ again:
goto error;
}
}
g_debug ("Try filter:");
pinos_log_debug ("Try filter:");
spa_debug_format (filter);
if ((res = spa_node_port_enum_formats (this->output->node->node,
@ -270,7 +273,7 @@ again:
"error output enum formats: %d", res);
goto error;
}
g_debug ("Got filtered:");
pinos_log_debug ("Got filtered:");
spa_debug_format (format);
spa_format_fixate (format);
} else if (in_state == SPA_NODE_STATE_CONFIGURE && out_state > SPA_NODE_STATE_CONFIGURE) {
@ -300,11 +303,11 @@ again:
} else
return SPA_RESULT_OK;
g_debug ("link %p: doing set format", this);
pinos_log_debug ("link %p: doing set format", this);
spa_debug_format (format);
if (out_state == SPA_NODE_STATE_CONFIGURE) {
g_debug ("link %p: doing set format on output", this);
pinos_log_debug ("link %p: doing set format on output", this);
if ((res = spa_node_port_set_format (this->output->node->node,
SPA_DIRECTION_OUTPUT,
this->output->port,
@ -317,7 +320,7 @@ again:
goto error;
}
} else if (in_state == SPA_NODE_STATE_CONFIGURE) {
g_debug ("link %p: doing set format on input", this);
pinos_log_debug ("link %p: doing set format on input", this);
if ((res = spa_node_port_set_format (this->input->node->node,
SPA_DIRECTION_INPUT,
this->input->port,
@ -351,6 +354,20 @@ find_param (const SpaPortInfo *info, SpaAllocParamType type)
return NULL;
}
static void *
find_meta_enable (const SpaPortInfo *info, SpaMetaType type)
{
unsigned int i;
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;
}
static SpaResult
do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
{
@ -365,7 +382,7 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
pinos_link_update_state (this, PINOS_LINK_STATE_ALLOCATING);
g_debug ("link %p: doing alloc buffers %p %p", this, this->output->node, this->input->node);
pinos_log_debug ("link %p: doing alloc buffers %p %p", this, this->output->node, this->input->node);
/* find out what's possible */
if ((res = spa_node_port_get_info (this->output->node->node,
SPA_DIRECTION_OUTPUT,
@ -394,7 +411,7 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
out_flags = oinfo->flags;
if (out_flags & SPA_PORT_INFO_FLAG_LIVE) {
g_debug ("setting link as live");
pinos_log_debug ("setting link as live");
this->output->node->live = true;
this->input->node->live = true;
}
@ -435,21 +452,33 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
if (priv->buffers == NULL) {
SpaAllocParamBuffers *in_alloc, *out_alloc;
guint max_buffers = MAX_BUFFERS;
size_t minsize = 0, stride = 0;
SpaAllocParamMetaEnableRingbuffer *in_me, *out_me;
guint max_buffers;
size_t minsize, stride, blocks;
max_buffers = MAX_BUFFERS;
in_alloc = find_param (iinfo, SPA_ALLOC_PARAM_TYPE_BUFFERS);
if (in_alloc) {
max_buffers = in_alloc->max_buffers == 0 ? max_buffers : SPA_MIN (in_alloc->max_buffers, max_buffers);
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);
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);
}
}
if ((in_flags & SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS) ||
@ -462,7 +491,7 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
priv->n_buffers = this->output->n_buffers;
priv->buffers = this->output->buffers;
priv->allocated = FALSE;
g_debug ("reusing %d output buffers %p", priv->n_buffers, priv->buffers);
pinos_log_debug ("reusing %d output buffers %p", priv->n_buffers, priv->buffers);
} else {
guint i, j;
size_t hdr_size, buf_size, arr_size;
@ -486,7 +515,7 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
}
hdr_size += n_metas * sizeof (SpaMeta);
buf_size = SPA_ROUND_UP_N (hdr_size + minsize, 64);
buf_size = SPA_ROUND_UP_N (hdr_size + (minsize * blocks), 64);
priv->n_buffers = max_buffers;
pinos_memblock_alloc (PINOS_MEMBLOCK_FLAG_WITH_FD |
@ -523,6 +552,17 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
b->metas[mi].type = pme->type;
b->metas[mi].data = pd;
b->metas[mi].size = spa_meta_type_get_size (pme->type);
switch (pme->type) {
case SPA_META_TYPE_RINGBUFFER:
{
SpaMetaRingbuffer *rb = pd;
spa_ringbuffer_init (&rb->ringbuffer, minsize);
break;
}
default:
break;
}
pd = SPA_MEMBER (pd, b->metas[mi].size, void);
mi++;
}
@ -543,7 +583,7 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
d->data = NULL;
}
}
g_debug ("allocated %d buffers %p %zd", priv->n_buffers, priv->buffers, minsize);
pinos_log_debug ("allocated %d buffers %p %zd", priv->n_buffers, priv->buffers, minsize);
priv->allocated = TRUE;
}
@ -564,7 +604,7 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
this->output->allocated = TRUE;
this->output->buffer_mem = priv->buffer_mem;
priv->allocated = FALSE;
g_debug ("allocated %d buffers %p from output port", priv->n_buffers, priv->buffers);
pinos_log_debug ("allocated %d buffers %p from output port", priv->n_buffers, priv->buffers);
} 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,
@ -582,12 +622,12 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
this->input->allocated = TRUE;
this->input->buffer_mem = priv->buffer_mem;
priv->allocated = FALSE;
g_debug ("allocated %d buffers %p from input port", priv->n_buffers, priv->buffers);
pinos_log_debug ("allocated %d buffers %p from input port", priv->n_buffers, priv->buffers);
}
}
if (in_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS) {
g_debug ("using %d buffers %p on input port", priv->n_buffers, priv->buffers);
pinos_log_debug ("using %d buffers %p on input port", priv->n_buffers, priv->buffers);
if ((res = spa_node_port_use_buffers (this->input->node->node,
SPA_DIRECTION_INPUT,
this->input->port,
@ -604,7 +644,7 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
this->input->allocated = FALSE;
}
else if (out_flags & SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS) {
g_debug ("using %d buffers %p on output port", priv->n_buffers, priv->buffers);
pinos_log_debug ("using %d buffers %p on output port", priv->n_buffers, priv->buffers);
if ((res = spa_node_port_use_buffers (this->output->node->node,
SPA_DIRECTION_OUTPUT,
this->output->port,
@ -673,7 +713,7 @@ check_states (PinosLink *this,
PinosLinkPrivate *priv = this->priv;
if (res != SPA_RESULT_OK) {
g_warning ("link %p: error: %d", this, res);
pinos_log_warn ("link %p: error: %d", this, res);
return res;
}
@ -684,7 +724,7 @@ again:
in_state = this->input->node->node->state;
out_state = this->output->node->node->state;
g_debug ("link %p: input state %d, output state %d", this, in_state, out_state);
pinos_log_debug ("link %p: input state %d, output state %d", this, in_state, out_state);
if ((res = do_negotiate (this, in_state, out_state)) != SPA_RESULT_OK)
goto exit;
@ -714,7 +754,7 @@ on_async_complete_notify (PinosNode *node,
PinosLink *this)
{
PinosLinkPrivate *priv = this->priv;
g_debug ("link %p: node %p async complete %d %d", this, node, seq, res);
pinos_log_debug ("link %p: node %p async complete %d %d", this, node, seq, res);
pinos_main_loop_defer_complete (priv->main_loop, this, seq, res);
}
@ -782,7 +822,7 @@ on_node_remove (PinosNode *node, PinosLink *this)
priv->buffers = NULL;
priv->n_buffers = 0;
g_debug ("link %p: clear input allocated buffers on port %p", link, other);
pinos_log_debug ("link %p: clear input allocated buffers on port %p", link, other);
pinos_port_clear_buffers (other);
}
@ -814,7 +854,7 @@ pinos_link_constructed (GObject * object)
G_OBJECT_CLASS (pinos_link_parent_class)->constructed (object);
on_property_notify (G_OBJECT (this), NULL, this);
g_debug ("link %p: constructed %p:%d -> %p:%d", this,
pinos_log_debug ("link %p: constructed %p:%d -> %p:%d", this,
this->output->node, this->output->port,
this->input->node, this->input->port);
link_register_object (this);
@ -826,7 +866,7 @@ pinos_link_dispose (GObject * object)
PinosLink *this = PINOS_LINK (object);
PinosLinkPrivate *priv = this->priv;
g_debug ("link %p: dispose", this);
pinos_log_debug ("link %p: dispose", this);
if (this->input && this->input->node)
g_signal_handlers_disconnect_by_data (this->input->node, this);
@ -853,7 +893,7 @@ pinos_link_finalize (GObject * object)
PinosLink *this = PINOS_LINK (object);
PinosLinkPrivate *priv = this->priv;
g_debug ("link %p: finalize", this);
pinos_log_debug ("link %p: finalize", this);
g_clear_object (&priv->daemon);
g_clear_object (&priv->iface);
g_free (priv->object_path);
@ -963,7 +1003,7 @@ pinos_link_init (PinosLink * this)
PinosLinkPrivate *priv = this->priv = PINOS_LINK_GET_PRIVATE (this);
priv->iface = pinos_link1_skeleton_new ();
g_debug ("link %p: new", this);
pinos_log_debug ("link %p: new", this);
priv->state = PINOS_LINK_STATE_INIT;
}
@ -976,7 +1016,7 @@ pinos_link_init (PinosLink * this)
void
pinos_link_remove (PinosLink *this)
{
g_debug ("link %p: remove", this);
pinos_log_debug ("link %p: remove", this);
g_signal_emit (this, signals[SIGNAL_REMOVE], 0, NULL);
}

2
pinos/server/link.h
View file

@ -50,6 +50,8 @@ typedef struct _PinosLinkPrivate PinosLinkPrivate;
struct _PinosLink {
GObject object;
uint32_t id;
PinosPort *output;
PinosPort *input;

33
pinos/server/main-loop.c
View file

@ -27,6 +27,7 @@
#include "spa/include/spa/queue.h"
#include "spa/include/spa/ringbuffer.h"
#include "pinos/client/log.h"
#include "pinos/server/main-loop.h"
#define PINOS_MAIN_LOOP_GET_PRIVATE(loop) \
@ -130,7 +131,7 @@ do_add_item (SpaPoll *poll,
item->id = g_source_attach (source, g_main_context_get_thread_default ());
g_source_unref (source);
g_debug ("added main poll %d", item->id);
pinos_log_debug ("added main poll %d", item->id);
return SPA_RESULT_OK;
}
@ -139,7 +140,7 @@ static SpaResult
do_update_item (SpaPoll *poll,
SpaPollItem *item)
{
g_debug ("update main poll %d", item->id);
pinos_log_debug ("update main poll %d", item->id);
return SPA_RESULT_OK;
}
@ -149,7 +150,7 @@ do_remove_item (SpaPoll *poll,
{
GSource *source;
g_debug ("remove main poll %d", item->id);
pinos_log_debug ("remove main poll %d", item->id);
source = g_main_context_find_source_by_id (g_main_context_get_thread_default (), item->id);
g_source_destroy (source);
@ -167,7 +168,7 @@ main_loop_dispatch (SpaPollNotifyData *data)
InvokeItem *item;
if (read (priv->fds[0].fd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
g_warning ("main-loop %p: failed to read fd", strerror (errno));
pinos_log_warn ("main-loop %p: failed to read fd", strerror (errno));
while (spa_ringbuffer_get_read_offset (&priv->buffer, &offset) > 0) {
item = SPA_MEMBER (priv->buffer_data, offset, InvokeItem);
@ -199,7 +200,7 @@ do_invoke (SpaPoll *poll,
} else {
spa_ringbuffer_get_write_areas (&priv->buffer, areas);
if (areas[0].len < sizeof (InvokeItem)) {
g_warning ("queue full");
pinos_log_warn ("queue full");
return SPA_RESULT_ERROR;
}
item = SPA_MEMBER (priv->buffer_data, areas[0].offset, InvokeItem);
@ -222,7 +223,7 @@ do_invoke (SpaPoll *poll,
spa_ringbuffer_write_advance (&priv->buffer, item->item_size);
if (write (priv->fds[0].fd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
g_warning ("data-loop %p: failed to write fd", strerror (errno));
pinos_log_warn ("data-loop %p: failed to write fd", strerror (errno));
res = SPA_RESULT_RETURN_ASYNC (seq);
}
@ -276,7 +277,7 @@ pinos_main_loop_constructed (GObject * obj)
PinosMainLoop *this = PINOS_MAIN_LOOP (obj);
PinosMainLoopPrivate *priv = this->priv;
g_debug ("main-loop %p: constructed", this);
pinos_log_debug ("main-loop %p: constructed", this);
priv->loop = g_main_loop_new (priv->context, FALSE);
priv->fds[0].fd = eventfd (0, 0);
@ -301,7 +302,7 @@ pinos_main_loop_dispose (GObject * obj)
{
PinosMainLoop *this = PINOS_MAIN_LOOP (obj);
g_debug ("main-loop %p: dispose", this);
pinos_log_debug ("main-loop %p: dispose", this);
G_OBJECT_CLASS (pinos_main_loop_parent_class)->dispose (obj);
}
@ -312,7 +313,7 @@ pinos_main_loop_finalize (GObject * obj)
PinosMainLoop *this = PINOS_MAIN_LOOP (obj);
PinosMainLoopPrivate *priv = this->priv;
g_debug ("main-loop %p: finalize", this);
pinos_log_debug ("main-loop %p: finalize", this);
g_slice_free_chain (WorkItem, priv->free_list, next);
@ -349,7 +350,7 @@ pinos_main_loop_init (PinosMainLoop * this)
{
PinosMainLoopPrivate *priv = this->priv = PINOS_MAIN_LOOP_GET_PRIVATE (this);
g_debug ("main-loop %p: new", this);
pinos_log_debug ("main-loop %p: new", this);
this->poll.size = sizeof (SpaPoll);
this->poll.info = NULL;
@ -400,7 +401,7 @@ process_work_queue (PinosMainLoop *this)
prev->next = next;
if (item->func) {
g_debug ("main-loop %p: process work item %p", this, item->obj);
pinos_log_debug ("main-loop %p: process work item %p", this, item->obj);
item->func (item->obj, item->data, item->res, item->id);
}
if (item->notify)
@ -445,12 +446,12 @@ pinos_main_loop_defer (PinosMainLoop *loop,
if (SPA_RESULT_IS_ASYNC (res)) {
item->seq = SPA_RESULT_ASYNC_SEQ (res);
item->res = res;
g_debug ("main-loop %p: defer async %d for object %p", loop, item->seq, obj);
pinos_log_debug ("main-loop %p: defer async %d for object %p", loop, item->seq, obj);
} else {
item->seq = SPA_ID_INVALID;
item->res = res;
have_work = TRUE;
g_debug ("main-loop %p: defer object %p", loop, obj);
pinos_log_debug ("main-loop %p: defer object %p", loop, obj);
}
SPA_QUEUE_PUSH_TAIL (&priv->work, WorkItem, next, item);
@ -474,7 +475,7 @@ pinos_main_loop_defer_cancel (PinosMainLoop *loop,
for (item = priv->work.head; item; item = item->next) {
if ((id == 0 || item->id == id) && (obj == NULL || item->obj == obj)) {
g_debug ("main-loop %p: cancel defer %d for object %p", loop, item->seq, item->obj);
pinos_log_debug ("main-loop %p: cancel defer %d for object %p", loop, item->seq, item->obj);
item->seq = SPA_ID_INVALID;
item->func = NULL;
have_work = TRUE;
@ -499,14 +500,14 @@ pinos_main_loop_defer_complete (PinosMainLoop *loop,
for (item = priv->work.head; item; item = item->next) {
if (item->obj == obj && item->seq == seq) {
g_debug ("main-loop %p: found defered %d for object %p", loop, seq, obj);
pinos_log_debug ("main-loop %p: found defered %d for object %p", loop, seq, obj);
item->seq = SPA_ID_INVALID;
item->res = res;
have_work = TRUE;
}
}
if (!have_work)
g_debug ("main-loop %p: no defered %d found for object %p", loop, seq, obj);
pinos_log_debug ("main-loop %p: no defered %d found for object %p", loop, seq, obj);
if (priv->work_id == 0 && have_work)
priv->work_id = g_idle_add ((GSourceFunc) process_work_queue, loop);

2
pinos/server/meson.build
View file

@ -10,6 +10,7 @@ pinoscore_headers = [
'module.h',
'node.h',
'node-factory.h',
'registry.h',
'utils.h',
]
@ -25,6 +26,7 @@ pinoscore_sources = [
'module.c',
'node.c',
'node-factory.c',
'registry.c',
'utils.c',
]

10
pinos/server/module.c
View file

@ -180,7 +180,7 @@ find_module (const gchar * path, const gchar *name)
dir = g_dir_open (path, 0, &err);
if (dir == NULL) {
g_warning ("could not open %s: %s", path, err->message);
pinos_log_warn ("could not open %s: %s", path, err->message);
g_error_free (err);
return NULL;
}
@ -241,7 +241,7 @@ pinos_module_load (PinosDaemon * daemon,
gchar **l;
gint i;
g_debug ("PINOS_MODULE_DIR set to: %s", module_dir);
pinos_log_debug ("PINOS_MODULE_DIR set to: %s", module_dir);
l = g_strsplit (module_dir, G_SEARCHPATH_SEPARATOR_S, 0);
for (i = 0; l[i] != NULL; i++) {
@ -251,7 +251,7 @@ pinos_module_load (PinosDaemon * daemon,
}
g_strfreev (l);
} else {
g_debug ("moduledir set to: %s", MODULEDIR);
pinos_log_debug ("moduledir set to: %s", MODULEDIR);
filename = find_module (MODULEDIR, name);
}
@ -262,7 +262,7 @@ pinos_module_load (PinosDaemon * daemon,
return NULL;
}
g_debug ("trying to load module: %s (%s)", name, filename);
pinos_log_debug ("trying to load module: %s (%s)", name, filename);
gmodule = g_module_open (filename, G_MODULE_BIND_LOCAL);
g_free (filename);
@ -295,7 +295,7 @@ pinos_module_load (PinosDaemon * daemon,
return NULL;
}
g_debug ("loaded module: %s", module->name);
pinos_log_debug ("loaded module: %s", module->name);
return module;
}

29
pinos/server/node-factory.c
View file

@ -25,6 +25,8 @@
struct _PinosNodeFactoryPrivate
{
PinosDaemon *daemon;
gchar *name;
};
@ -33,6 +35,7 @@ G_DEFINE_ABSTRACT_TYPE (PinosNodeFactory, pinos_node_factory, G_TYPE_OBJECT);
enum
{
PROP_0,
PROP_DAEMON,
PROP_NAME,
};
@ -46,6 +49,10 @@ pinos_node_factory_get_property (GObject *_object,
PinosNodeFactoryPrivate *priv = factory->priv;
switch (prop_id) {
case PROP_DAEMON:
g_value_set_object (value, priv->daemon);
break;
case PROP_NAME:
g_value_set_string (value, priv->name);
break;
@ -66,6 +73,10 @@ pinos_node_factory_set_property (GObject *_object,
PinosNodeFactoryPrivate *priv = factory->priv;
switch (prop_id) {
case PROP_DAEMON:
priv->daemon = g_value_dup_object (value);
break;
case PROP_NAME:
priv->name = g_value_dup_string (value);
break;
@ -80,9 +91,12 @@ static void
pinos_node_factory_constructed (GObject * obj)
{
PinosNodeFactory *factory = PINOS_NODE_FACTORY (obj);
PinosNodeFactoryPrivate *priv = factory->priv;
g_debug ("node factory %p: constructed", factory);
factory->id = pinos_map_insert_new (&priv->daemon->registry.node_factories, factory);
G_OBJECT_CLASS (pinos_node_factory_parent_class)->constructed (obj);
}
@ -93,6 +107,7 @@ pinos_node_factory_finalize (GObject * obj)
PinosNodeFactoryPrivate *priv = factory->priv;
g_debug ("node factory %p: finalize", factory);
pinos_map_remove (&priv->daemon->registry.node_factories, factory->id);
g_free (priv->name);
@ -111,6 +126,16 @@ pinos_node_factory_class_init (PinosNodeFactoryClass * klass)
gobject_class->set_property = pinos_node_factory_set_property;
gobject_class->get_property = pinos_node_factory_get_property;
g_object_class_install_property (gobject_class,
PROP_DAEMON,
g_param_spec_object ("daemon",
"Daemon",
"The Daemon",
PINOS_TYPE_DAEMON,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_NAME,
g_param_spec_string ("name",
@ -152,7 +177,6 @@ pinos_node_factory_get_name (PinosNodeFactory *factory)
/**
* pinos_node_factory_create_node:
* @factory: A #PinosNodeFactory
* @daemon: a #PinosDaemon
* @client: the owner client
* @name: node name
* @props: #PinosProperties for the node
@ -163,7 +187,6 @@ pinos_node_factory_get_name (PinosNodeFactory *factory)
*/
PinosNode *
pinos_node_factory_create_node (PinosNodeFactory *factory,
PinosDaemon *daemon,
PinosClient *client,
const gchar *name,
PinosProperties *props)
@ -177,5 +200,5 @@ pinos_node_factory_create_node (PinosNodeFactory *factory,
return NULL;
g_debug ("node factory %p: create node", factory);
return klass->create_node (factory, daemon, client, name, props);
return klass->create_node (factory, factory->priv->daemon, client, name, props);
}

3
pinos/server/node-factory.h
View file

@ -48,6 +48,8 @@ typedef struct _PinosNodeFactoryPrivate PinosNodeFactoryPrivate;
struct _PinosNodeFactory {
GObject object;
uint32_t id;
PinosNodeFactoryPrivate *priv;
};
@ -71,7 +73,6 @@ struct _PinosNodeFactoryClass {
GType pinos_node_factory_get_type (void);
PinosNode * pinos_node_factory_create_node (PinosNodeFactory *factory,
PinosDaemon *daemon,
PinosClient *client,
const gchar *name,
PinosProperties *props);

87
pinos/server/node.c
View file

@ -144,7 +144,7 @@ update_port_ids (PinosNode *node, gboolean create)
max_output_ports,
output_port_ids);
g_debug ("node %p: update_port ids %u/%u, %u/%u", node,
pinos_log_debug ("node %p: update_port ids %u/%u, %u/%u", node,
n_input_ports, max_input_ports, n_output_ports, max_output_ports);
i = 0;
@ -157,7 +157,7 @@ update_port_ids (PinosNode *node, gboolean create)
ports = g_list_next (ports);
} else if ((p && i < n_input_ports && input_port_ids[i] < p->port) || i < n_input_ports) {
PinosPort *np;
g_debug ("node %p: input port added %d", node, input_port_ids[i]);
pinos_log_debug ("node %p: input port added %d", node, input_port_ids[i]);
np = new_pinos_port (node, PINOS_DIRECTION_INPUT, input_port_ids[i]);
priv->input_ports = g_list_insert_before (priv->input_ports, ports, np);
@ -167,7 +167,7 @@ update_port_ids (PinosNode *node, gboolean create)
i++;
} else if (p) {
GList *next;
g_debug ("node %p: input port removed %d", node, p->port);
pinos_log_debug ("node %p: input port removed %d", node, p->port);
next = g_list_next (ports);
priv->input_ports = g_list_delete_link (priv->input_ports, ports);
@ -191,7 +191,7 @@ update_port_ids (PinosNode *node, gboolean create)
ports = g_list_next (ports);
} else if ((p && i < n_output_ports && output_port_ids[i] < p->port) || i < n_output_ports) {
PinosPort *np;
g_debug ("node %p: output port added %d", node, output_port_ids[i]);
pinos_log_debug ("node %p: output port added %d", node, output_port_ids[i]);
np = new_pinos_port (node, PINOS_DIRECTION_OUTPUT, output_port_ids[i]);
priv->output_ports = g_list_insert_before (priv->output_ports, ports, np);
@ -201,7 +201,7 @@ update_port_ids (PinosNode *node, gboolean create)
i++;
} else if (p) {
GList *next;
g_debug ("node %p: output port removed %d", node, p->port);
pinos_log_debug ("node %p: output port removed %d", node, p->port);
next = g_list_next (ports);
priv->output_ports = g_list_delete_link (priv->output_ports, ports);
@ -231,12 +231,12 @@ pause_node (PinosNode *this)
SpaResult res;
SpaNodeCommand cmd;
g_debug ("node %p: pause node", this);
pinos_log_debug ("node %p: pause node", this);
cmd.type = SPA_NODE_COMMAND_PAUSE;
cmd.size = sizeof (cmd);
if ((res = spa_node_send_command (this->node, &cmd)) < 0)
g_debug ("got error %d", res);
pinos_log_debug ("got error %d", res);
return res;
}
@ -247,12 +247,12 @@ start_node (PinosNode *this)
SpaResult res;
SpaNodeCommand cmd;
g_debug ("node %p: start node", this);
pinos_log_debug ("node %p: start node", this);
cmd.type = SPA_NODE_COMMAND_START;
cmd.size = sizeof (cmd);
if ((res = spa_node_send_command (this->node, &cmd)) < 0)
g_debug ("got error %d", res);
pinos_log_debug ("got error %d", res);
return res;
}
@ -264,12 +264,12 @@ suspend_node (PinosNode *this)
SpaResult res = SPA_RESULT_OK;
GList *walk;
g_debug ("node %p: suspend node", this);
pinos_log_debug ("node %p: suspend node", this);
for (walk = priv->input_ports; walk; walk = g_list_next (walk)) {
PinosPort *p = walk->data;
if ((res = spa_node_port_set_format (this->node, SPA_DIRECTION_INPUT, p->port, 0, NULL)) < 0)
g_warning ("error unset format output: %d", res);
pinos_log_warn ("error unset format output: %d", res);
p->buffers = NULL;
p->n_buffers = 0;
if (p->allocated)
@ -279,7 +279,7 @@ suspend_node (PinosNode *this)
for (walk = priv->output_ports; walk; walk = g_list_next (walk)) {
PinosPort *p = walk->data;
if ((res = spa_node_port_set_format (this->node, SPA_DIRECTION_OUTPUT, p->port, 0, NULL)) < 0)
g_warning ("error unset format output: %d", res);
pinos_log_warn ("error unset format output: %d", res);
p->buffers = NULL;
p->n_buffers = 0;
if (p->allocated)
@ -314,7 +314,7 @@ send_clock_update (PinosNode *this)
cu.state = SPA_CLOCK_STATE_RUNNING;
if ((res = spa_node_send_command (this->node, &cu.command)) < 0)
g_debug ("got error %d", res);
pinos_log_debug ("got error %d", res);
}
static SpaResult
@ -341,7 +341,7 @@ do_read_link (SpaPoll *poll,
iinfo[0].flags = SPA_PORT_INPUT_FLAG_NONE;
if ((res = spa_node_port_push_input (link->input->node->node, 1, iinfo)) < 0)
g_warning ("node %p: error pushing buffer: %d, %d", this, res, iinfo[0].status);
pinos_log_warn ("node %p: error pushing buffer: %d, %d", this, res, iinfo[0].status);
spa_ringbuffer_read_advance (&link->ringbuffer, 1);
link->in_ready--;
@ -367,7 +367,7 @@ on_node_event (SpaNode *node, SpaNodeEvent *event, void *user_data)
{
SpaNodeEventAsyncComplete *ac = (SpaNodeEventAsyncComplete *) event;
g_debug ("node %p: async complete event %d %d", this, ac->seq, ac->res);
pinos_log_debug ("node %p: async complete event %d %d", this, ac->seq, ac->res);
if (!pinos_main_loop_defer_complete (priv->main_loop, this, ac->seq, ac->res))
g_signal_emit (this, signals[SIGNAL_ASYNC_COMPLETE], 0, ac->seq, ac->res);
break;
@ -405,7 +405,7 @@ on_node_event (SpaNode *node, SpaNodeEvent *event, void *user_data)
oinfo[0].port_id = ho->port_id;
if ((res = spa_node_port_pull_output (node, 1, oinfo)) < 0) {
g_warning ("node %p: got pull error %d, %d", this, res, oinfo[0].status);
pinos_log_warn ("node %p: got pull error %d, %d", this, res, oinfo[0].status);
break;
}
@ -434,7 +434,7 @@ on_node_event (SpaNode *node, SpaNodeEvent *event, void *user_data)
}
if (!pushed) {
if ((res = spa_node_port_reuse_buffer (node, oinfo[0].port_id, oinfo[0].buffer_id)) < 0)
g_warning ("node %p: error reuse buffer: %d", node, res);
pinos_log_warn ("node %p: error reuse buffer: %d", node, res);
}
break;
}
@ -453,7 +453,7 @@ on_node_event (SpaNode *node, SpaNodeEvent *event, void *user_data)
if ((res = spa_node_port_reuse_buffer (link->output->node->node,
link->output->port,
rb->buffer_id)) < 0)
g_warning ("node %p: error reuse buffer: %d", node, res);
pinos_log_warn ("node %p: error reuse buffer: %d", node, res);
}
break;
}
@ -470,7 +470,7 @@ handle_remove (PinosNode1 *interface,
{
PinosNode *this = user_data;
g_debug ("node %p: remove", this);
pinos_log_debug ("node %p: remove", this);
pinos_node_remove (this);
g_dbus_method_invocation_return_value (invocation,
@ -554,7 +554,7 @@ pinos_node_set_property (GObject *_object,
if (priv->data_loop) {
if ((res = spa_node_set_event_callback (this->node, on_node_event, this)) < 0)
g_warning ("node %p: error setting callback", this);
pinos_log_warn ("node %p: error setting callback", this);
}
break;
}
@ -599,7 +599,9 @@ node_register_object (PinosNode *this)
priv->object_path = pinos_daemon_export_uniquely (daemon, G_DBUS_OBJECT_SKELETON (skel));
g_object_unref (skel);
g_debug ("node %p: register object %s", this, priv->object_path);
this->id = pinos_map_insert_new (&daemon->registry.nodes, this);
pinos_log_debug ("node %p: register object %s, id %u", this, priv->object_path, this->id);
pinos_daemon_add_node (daemon, this);
return;
@ -610,10 +612,11 @@ node_unregister_object (PinosNode *this)
{
PinosNodePrivate *priv = this->priv;
g_debug ("node %p: unregister object %s", this, priv->object_path);
pinos_log_debug ("node %p: unregister object %s", this, priv->object_path);
pinos_daemon_unexport (priv->daemon, priv->object_path);
g_clear_pointer (&priv->object_path, g_free);
pinos_daemon_remove_node (priv->daemon, this);
pinos_map_remove (&priv->daemon->registry.nodes, this->id);
}
static void
@ -645,7 +648,7 @@ init_complete (PinosNode *this)
PinosNodePrivate *priv = this->priv;
update_port_ids (this, FALSE);
g_debug ("node %p: init completed", this);
pinos_log_debug ("node %p: init completed", this);
priv->async_init = FALSE;
on_property_notify (G_OBJECT (this), NULL, this);
pinos_node_update_state (this, PINOS_NODE_STATE_SUSPENDED);
@ -657,7 +660,7 @@ pinos_node_constructed (GObject * obj)
PinosNode *this = PINOS_NODE (obj);
PinosNodePrivate *priv = this->priv;
g_debug ("node %p: constructed", this);
pinos_log_debug ("node %p: constructed", this);
priv->main_loop = priv->daemon->main_loop;
@ -696,7 +699,7 @@ pinos_node_dispose (GObject * obj)
PinosNode *node = PINOS_NODE (obj);
PinosNodePrivate *priv = node->priv;
g_debug ("node %p: dispose", node);
pinos_log_debug ("node %p: dispose", node);
pinos_node_set_state (node, PINOS_NODE_STATE_SUSPENDED);
node_unregister_object (node);
@ -712,7 +715,7 @@ pinos_node_finalize (GObject * obj)
PinosNode *node = PINOS_NODE (obj);
PinosNodePrivate *priv = node->priv;
g_debug ("node %p: finalize", node);
pinos_log_debug ("node %p: finalize", node);
g_clear_object (&priv->daemon);
g_clear_object (&priv->iface);
g_clear_object (&priv->data_loop);
@ -871,7 +874,7 @@ pinos_node_init (PinosNode * node)
{
PinosNodePrivate *priv = node->priv = PINOS_NODE_GET_PRIVATE (node);
g_debug ("node %p: new", node);
pinos_log_debug ("node %p: new", node);
priv->iface = pinos_node1_skeleton_new ();
g_signal_connect (priv->iface, "handle-remove",
(GCallback) handle_remove,
@ -1009,7 +1012,7 @@ pinos_node_remove (PinosNode *node)
if (node->flags & PINOS_NODE_FLAG_REMOVING)
return;
g_debug ("node %p: remove", node);
pinos_log_debug ("node %p: remove", node);
node->flags |= PINOS_NODE_FLAG_REMOVING;
g_signal_emit (node, signals[SIGNAL_REMOVE], 0, NULL);
}
@ -1046,7 +1049,7 @@ pinos_node_get_free_port (PinosNode *node,
}
free_port = 0;
g_debug ("node %p: direction %d max %u, n %u, free_port %u", node, direction, max_ports, n_ports, free_port);
pinos_log_debug ("node %p: direction %d max %u, n %u, free_port %u", node, direction, max_ports, n_ports, free_port);
for (walk = ports; walk; walk = g_list_next (walk)) {
PinosPort *p = walk->data;
@ -1140,7 +1143,7 @@ pinos_port_link (PinosPort *output_port,
priv = output_node->priv;
input_node = input_port->node;
g_debug ("port link %p:%u -> %p:%u", output_node, output_port->port, input_node, input_port->port);
pinos_log_debug ("port link %p:%u -> %p:%u", output_node, output_port->port, input_node, input_port->port);
if (output_node == input_node)
goto same_node;
@ -1156,7 +1159,7 @@ pinos_port_link (PinosPort *output_port,
input_node->live = output_node->live;
if (output_node->clock)
input_node->clock = output_node->clock;
g_debug ("node %p: clock %p, live %d", output_node, output_node->clock, output_node->live);
pinos_log_debug ("node %p: clock %p, live %d", output_node, output_node->clock, output_node->live);
link = g_object_new (PINOS_TYPE_LINK,
"daemon", priv->daemon,
@ -1231,7 +1234,7 @@ do_remove_link_done (SpaPoll *poll,
PinosNodePrivate *priv = this->priv;
PinosLink *link = ((PinosLink**)data)[0];
g_debug ("port %p: finish unlink", port);
pinos_log_debug ("port %p: finish unlink", port);
if (port->direction == PINOS_DIRECTION_OUTPUT) {
if (g_ptr_array_remove_fast (port->links, link))
priv->n_used_output_links--;
@ -1248,7 +1251,7 @@ do_remove_link_done (SpaPoll *poll,
}
if (!port->allocated) {
g_debug ("port %p: clear buffers on port", port);
pinos_log_debug ("port %p: clear buffers on port", port);
spa_node_port_use_buffers (port->node->node,
port->direction,
port->port,
@ -1302,7 +1305,7 @@ pinos_port_unlink (PinosPort *port, PinosLink *link)
{
SpaResult res;
g_debug ("port %p: start unlink %p", port, link);
pinos_log_debug ("port %p: start unlink %p", port, link);
g_object_ref (link);
g_object_ref (port->node);
@ -1328,7 +1331,7 @@ do_clear_buffers_done (SpaPoll *poll,
PinosNodePrivate *priv = this->priv;
SpaResult res;
g_debug ("port %p: clear buffers finish", port);
pinos_log_debug ("port %p: clear buffers finish", port);
res = spa_node_port_use_buffers (port->node->node,
port->direction,
@ -1372,7 +1375,7 @@ pinos_port_clear_buffers (PinosPort *port)
{
SpaResult res;
g_debug ("port %p: clear buffers", port);
pinos_log_debug ("port %p: clear buffers", port);
res = spa_poll_invoke (&port->node->priv->data_loop->poll,
do_clear_buffers,
port->node->priv->seq++,
@ -1457,7 +1460,7 @@ pinos_node_set_state (PinosNode *node,
remove_idle_timeout (node);
g_debug ("node %p: set state %s", node, pinos_node_state_as_string (state));
pinos_log_debug ("node %p: set state %s", node, pinos_node_state_as_string (state));
switch (state) {
case PINOS_NODE_STATE_CREATING:
@ -1515,7 +1518,7 @@ pinos_node_update_state (PinosNode *node,
old = priv->state;
if (old != state) {
g_debug ("node %p: update state from %s -> %s", node,
pinos_log_debug ("node %p: update state from %s -> %s", node,
pinos_node_state_as_string (old),
pinos_node_state_as_string (state));
priv->state = state;
@ -1546,7 +1549,7 @@ pinos_node_report_error (PinosNode *node,
remove_idle_timeout (node);
priv->error = error;
priv->state = PINOS_NODE_STATE_ERROR;
g_debug ("node %p: got error state %s", node, error->message);
pinos_log_debug ("node %p: got error state %s", node, error->message);
pinos_node1_set_state (priv->iface, PINOS_NODE_STATE_ERROR);
g_signal_emit (node, signals[SIGNAL_STATE_CHANGE], 0, old, priv->state);
}
@ -1557,7 +1560,7 @@ idle_timeout (PinosNode *node)
PinosNodePrivate *priv = node->priv;
priv->idle_timeout = 0;
g_debug ("node %p: idle timeout", node);
pinos_log_debug ("node %p: idle timeout", node);
pinos_node_set_state (node, PINOS_NODE_STATE_SUSPENDED);
return G_SOURCE_REMOVE;
@ -1578,7 +1581,7 @@ pinos_node_report_idle (PinosNode *node)
g_return_if_fail (PINOS_IS_NODE (node));
priv = node->priv;
g_debug ("node %p: report idle", node);
pinos_log_debug ("node %p: report idle", node);
pinos_node_set_state (node, PINOS_NODE_STATE_IDLE);
priv->idle_timeout = g_timeout_add_seconds (3,
@ -1598,6 +1601,6 @@ pinos_node_report_busy (PinosNode *node)
{
g_return_if_fail (PINOS_IS_NODE (node));
g_debug ("node %p: report busy", node);
pinos_log_debug ("node %p: report busy", node);
pinos_node_set_state (node, PINOS_NODE_STATE_RUNNING);
}

3
pinos/server/node.h
View file

@ -44,6 +44,7 @@ typedef enum {
#include <pinos/server/utils.h>
struct _PinosPort {
uint32_t id;
PinosNode *node;
PinosDirection direction;
uint32_t port;
@ -71,6 +72,8 @@ struct _PinosPort {
struct _PinosNode {
GObject object;
uint32_t id;
PinosNodeFlags flags;
SpaNode *node;

36
pinos/server/registry.c Normal file
View file

@ -0,0 +1,36 @@
/* Pinos
* Copyright (C) 2015 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <string.h>
#include "pinos/client/pinos.h"
#include "pinos/server/registry.h"
void
pinos_registry_init (PinosRegistry *reg)
{
reg->map = pinos_id_map_get_default();
pinos_map_init (&reg->clients, 64);
pinos_map_init (&reg->nodes, 128);
pinos_map_init (&reg->ports, 512);
pinos_map_init (&reg->links, 256);
pinos_map_init (&reg->modules, 128);
pinos_map_init (&reg->monitors, 64);
}

57
pinos/server/registry.h Normal file
View file

@ -0,0 +1,57 @@
/* 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.
*/
#ifndef __PINOS_REGISTRY_H__
#define __PINOS_REGISTRY_H__
#include <glib-object.h>
G_BEGIN_DECLS
#include <pinos/client/map.h>
#include <spa/include/spa/id-map.h>
typedef struct _PinosRegistry PinosRegistry;
/**
* PinosRegistry:
*
* Pinos registry struct.
*/
struct _PinosRegistry {
SpaIDMap *map;
PinosMap objects;
PinosMap clients;
PinosMap node_factories;
PinosMap nodes;
PinosMap ports;
PinosMap links;
PinosMap modules;
PinosMap monitors;
PinosMap devices;
};
void pinos_registry_init (PinosRegistry *reg);
G_END_DECLS
#endif /* __PINOS_REGISTRY_H__ */

9
pinos/server/utils.c
View file

@ -28,6 +28,7 @@
#include "memfd-wrappers.h"
#include <pinos/client/log.h>
#include <pinos/server/utils.h>
#undef USE_MEMFD
@ -47,21 +48,21 @@ pinos_memblock_alloc (PinosMemblockFlags flags,
#ifdef USE_MEMFD
mem->fd = memfd_create ("pinos-memfd", MFD_CLOEXEC | MFD_ALLOW_SEALING);
if (mem->fd == -1) {
fprintf (stderr, "Failed to create memfd: %s\n", strerror (errno));
pinos_log_error ("Failed to create memfd: %s\n", strerror (errno));
return FALSE;
}
#else
char filename[] = "/dev/shm/spa-tmpfile.XXXXXX";
mem->fd = mkostemp (filename, O_CLOEXEC);
if (mem->fd == -1) {
fprintf (stderr, "Failed to create temporary file: %s\n", strerror (errno));
pinos_log_error ("Failed to create temporary file: %s\n", strerror (errno));
return FALSE;
}
unlink (filename);
#endif
if (ftruncate (mem->fd, size) < 0) {
g_warning ("Failed to truncate temporary file: %s", strerror (errno));
pinos_log_warn ("Failed to truncate temporary file: %s", strerror (errno));
close (mem->fd);
return FALSE;
}
@ -69,7 +70,7 @@ pinos_memblock_alloc (PinosMemblockFlags flags,
if (flags & PINOS_MEMBLOCK_FLAG_SEAL) {
unsigned int seals = F_SEAL_GROW | F_SEAL_SHRINK | F_SEAL_SEAL;
if (fcntl (mem->fd, F_ADD_SEALS, seals) == -1) {
g_warning ("Failed to add seals: %s", strerror (errno));
pinos_log_warn ("Failed to add seals: %s", strerror (errno));
}
}
#endif

11
spa/include/spa/buffer.h
View file

@ -64,6 +64,7 @@ typedef enum {
#include <spa/defs.h>
#include <spa/port.h>
#include <spa/ringbuffer.h>
/**
* SpaBufferFlags:
@ -112,16 +113,10 @@ typedef struct {
/**
* SpaMetaRingbuffer:
* @readindex:
* @writeindex:
* @size:
* @size_mask:
* @ringbuffer:
*/
typedef struct {
volatile int readindex;
volatile int writeindex;
int size;
int size_mask;
SpaRingbuffer ringbuffer;
} SpaMetaRingbuffer;
/**

2
spa/include/spa/id-map.h
View file

@ -57,8 +57,6 @@ struct _SpaIDMap {
#define spa_id_map_get_id(n,...) (n)->get_id((n),__VA_ARGS__)
#define spa_id_map_get_uri(n,...) (n)->get_uri((n),__VA_ARGS__)
SpaIDMap * spa_id_map_get_default (void);
#ifdef __cplusplus
} /* extern "C" */
#endif

9
spa/include/spa/port.h
View file

@ -70,6 +70,15 @@ typedef struct {
SpaMetaType type;
} SpaAllocParamMetaEnable;
typedef struct {
SpaAllocParam param;
SpaMetaType type;
size_t minsize;
size_t stride;
size_t blocks;
uint32_t align;
} SpaAllocParamMetaEnableRingbuffer;
typedef struct {
SpaAllocParam param;
unsigned int padding_top;

38
spa/include/spa/props.h
View file

@ -197,44 +197,6 @@ spa_props_index_for_name (const SpaProps *props, const char *name)
return SPA_IDX_INVALID;
}
/**
* spa_props_set_value:
* @props: a #SpaProps
* @index: the index of the property in the prop_info array
* @value: the value to set
*
* Sets @value in @prop. type should match the type specified
* in the #SpaPropInfo at @index or else #SPA_RESULT_WRONG_PROPERTY_TYPE
* is returned.
*
* Returns: #SPA_RESULT_OK on success.
* #SPA_RESULT_INVALID_PROPERTY_INDEX when @index is not valid
* #SPA_RESULT_WRONG_PROPERTY_TYPE when type is not correct
*/
SpaResult spa_props_set_value (SpaProps *props,
unsigned int index,
const SpaPropValue *value);
/**
* spa_props_get_value:
* @props: a #SpaProps
* @index: the property index in the prop_info array
* @value: a location for the type, size and value
*
* Get the size and value of the property at @index.
*
* Returns: #SPA_RESULT_OK on success.
* #SPA_RESULT_INVALID_PROPERTY_INDEX when @index is not valid
* #SPA_RESULT_PROPERTY_UNSET when no value has been set yet
*/
SpaResult spa_props_get_value (const SpaProps *props,
unsigned int index,
SpaPropValue *value);
SpaResult spa_props_copy_values (const SpaProps *src,
SpaProps *dest);
#ifdef __cplusplus
} /* extern "C" */
#endif

1
spa/lib/audio-raw.c
View file

@ -24,6 +24,7 @@
#include <spa/audio/raw.h>
#include <spa/audio/format.h>
#include <lib/props.h>
static const uint32_t format_values[] = {
SPA_AUDIO_FORMAT_S8,

27
spa/lib/debug.c
View file

@ -19,9 +19,8 @@
#include <stdio.h>
#include "spa/debug.h"
#include "spa/props.h"
#include "spa/format.h"
#include "debug.h"
#include "props.h"
struct meta_type_name {
const char *name;
@ -83,6 +82,19 @@ spa_debug_port_info (const SpaPortInfo *info)
SpaAllocParamMetaEnable *p = (SpaAllocParamMetaEnable *)param;
fprintf (stderr, " SpaAllocParamMetaEnable:\n");
fprintf (stderr, " type: \t%d (%s)\n", p->type, META_TYPE_NAME(p->type));
switch (p->type) {
case SPA_META_TYPE_RINGBUFFER:
{
SpaAllocParamMetaEnableRingbuffer *rb = (SpaAllocParamMetaEnableRingbuffer *)p;
fprintf (stderr, " minsize: \t\t%zd\n", rb->minsize);
fprintf (stderr, " stride: \t\t%zd\n", rb->stride);
fprintf (stderr, " blocks: \t\t%zd\n", rb->blocks);
fprintf (stderr, " align: \t\t%d\n", rb->align);
break;
}
default:
break;
}
break;
}
case SPA_ALLOC_PARAM_TYPE_VIDEO_PADDING:
@ -153,10 +165,11 @@ spa_debug_buffer (const SpaBuffer *buffer)
{
SpaMetaRingbuffer *h = m->data;
fprintf (stderr, " SpaMetaRingbuffer:\n");
fprintf (stderr, " readindex: %d\n", h->readindex);
fprintf (stderr, " writeindex: %d\n", h->writeindex);
fprintf (stderr, " size: %d\n", h->size);
fprintf (stderr, " size_mask: %d\n", h->size_mask);
fprintf (stderr, " readindex: %zd\n", h->ringbuffer.readindex);
fprintf (stderr, " writeindex: %zd\n", h->ringbuffer.writeindex);
fprintf (stderr, " size: %zd\n", h->ringbuffer.size);
fprintf (stderr, " mask: %zd\n", h->ringbuffer.mask);
fprintf (stderr, " mask2: %zd\n", h->ringbuffer.mask2);
break;
}
default:

6
spa/include/spa/debug.h → spa/lib/debug.h
View file

@ -17,8 +17,8 @@
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_DEBUG_H__
#define __SPA_DEBUG_H__
#ifndef __SPA_LIBDEBUG_H__
#define __SPA_LIBDEBUG_H__
#ifdef __cplusplus
extern "C" {
@ -43,4 +43,4 @@ SpaResult spa_debug_dict (const SpaDict *dict);
#endif
#endif /* __SPA_DEBUG_H__ */
#endif /* __SPA_LIBDEBUG_H__ */

3
spa/lib/mapper.c
View file

@ -36,7 +36,8 @@
#include <spa/props.h>
#include <spa/queue.h>
#include <spa/ringbuffer.h>
#include <spa/debug.h>
#include <lib/debug.h>
#define MAX_URIS 4096

35
spa/lib/mapper.h Normal file
View file

@ -0,0 +1,35 @@
/* Simple Plugin API
* Copyright (C) 2016 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.
*/
#ifndef __SPA_LIBMAPPER_H__
#define __SPA_LIBMAPPER_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/id-map.h>
SpaIDMap * spa_id_map_get_default (void);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_LIBMAPPER_H__ */

2
spa/lib/meson.build
View file

@ -6,7 +6,7 @@ spalib_sources = ['audio-raw.c',
spalib = shared_library('spa-lib',
spalib_sources,
include_directories : spa_inc,
include_directories : [ spa_inc, spa_libinc ],
install : true)
spalib_dep = declare_dependency(link_with : spalib,

71
spa/lib/props.h Normal file
View file

@ -0,0 +1,71 @@
/* Simple Plugin API
* Copyright (C) 2016 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.
*/
#ifndef __SPA_LIBPROPS_H__
#define __SPA_LIBPROPS_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/props.h>
/**
* spa_props_set_value:
* @props: a #SpaProps
* @index: the index of the property in the prop_info array
* @value: the value to set
*
* Sets @value in @prop. type should match the type specified
* in the #SpaPropInfo at @index or else #SPA_RESULT_WRONG_PROPERTY_TYPE
* is returned.
*
* Returns: #SPA_RESULT_OK on success.
* #SPA_RESULT_INVALID_PROPERTY_INDEX when @index is not valid
* #SPA_RESULT_WRONG_PROPERTY_TYPE when type is not correct
*/
SpaResult spa_props_set_value (SpaProps *props,
unsigned int index,
const SpaPropValue *value);
/**
* spa_props_get_value:
* @props: a #SpaProps
* @index: the property index in the prop_info array
* @value: a location for the type, size and value
*
* Get the size and value of the property at @index.
*
* Returns: #SPA_RESULT_OK on success.
* #SPA_RESULT_INVALID_PROPERTY_INDEX when @index is not valid
* #SPA_RESULT_PROPERTY_UNSET when no value has been set yet
*/
SpaResult spa_props_get_value (const SpaProps *props,
unsigned int index,
SpaPropValue *value);
SpaResult spa_props_copy_values (const SpaProps *src,
SpaProps *dest);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_LIBPROPS_H__ */

2
spa/lib/video-raw.c
View file

@ -25,6 +25,8 @@
#include <spa/video/raw.h>
#include <spa/video/format.h>
#include "props.h"
static const uint32_t format_values[] = {
SPA_VIDEO_FORMAT_UNKNOWN,
SPA_VIDEO_FORMAT_ENCODED,

1
spa/meson.build
View file

@ -17,6 +17,7 @@ dl_lib = cc.find_library('dl', required : true)
pthread_lib = cc.find_library('pthread', required : true)
spa_inc = include_directories('include')
spa_libinc = include_directories('.')
subdir('include')
subdir('lib')

8
spa/plugins/alsa/alsa-monitor.c
View file

@ -31,7 +31,7 @@
#include <spa/id-map.h>
#include <spa/poll.h>
#include <spa/monitor.h>
#include <spa/debug.h>
#include <lib/debug.h>
extern const SpaHandleFactory spa_alsa_sink_factory;
extern const SpaHandleFactory spa_alsa_source_factory;
@ -100,7 +100,7 @@ path_get_card_id (const char *path)
return e + 5;
}
#define CHECK(s,msg) if ((err = (s)) < 0) { spa_log_error (state->log, msg ": %s\n", snd_strerror(err)); return err; }
#define CHECK(s,msg) if ((err = (s)) < 0) { spa_log_error (state->log, msg ": %s", snd_strerror(err)); return err; }
static int
fill_item (SpaALSAMonitor *this, ALSAItem *item, struct udev_device *udevice)
@ -136,7 +136,7 @@ fill_item (SpaALSAMonitor *this, ALSAItem *item, struct udev_device *udevice)
SND_PCM_NO_AUTO_RESAMPLE |
SND_PCM_NO_AUTO_CHANNELS |
SND_PCM_NO_AUTO_FORMAT)) < 0) {
spa_log_error (this->log, "PLAYBACK open failed: %s\n", snd_strerror(err));
spa_log_error (this->log, "PLAYBACK open failed: %s", snd_strerror(err));
if ((err = snd_pcm_open (&hndl,
device,
SND_PCM_STREAM_CAPTURE,
@ -144,7 +144,7 @@ fill_item (SpaALSAMonitor *this, ALSAItem *item, struct udev_device *udevice)
SND_PCM_NO_AUTO_RESAMPLE |
SND_PCM_NO_AUTO_CHANNELS |
SND_PCM_NO_AUTO_FORMAT)) < 0) {
spa_log_error (this->log, "CAPTURE open failed: %s\n", snd_strerror(err));
spa_log_error (this->log, "CAPTURE open failed: %s", snd_strerror(err));
return -1;
} else {
item->item.factory = &spa_alsa_source_factory;

32
spa/plugins/alsa/alsa-sink.c
View file

@ -23,6 +23,7 @@
#include <spa/node.h>
#include <spa/audio/format.h>
#include <lib/props.h>
#include "alsa-utils.h"
@ -47,7 +48,7 @@ reset_alsa_sink_props (SpaALSAProps *props)
static void
update_state (SpaALSASink *this, SpaNodeState state)
{
spa_log_info (this->log, "update state %d\n", state);
spa_log_info (this->log, "update state %d", state);
this->node.state = state;
}
@ -367,6 +368,7 @@ spa_alsa_clear_buffers (SpaALSASink *this)
if (this->n_buffers > 0) {
SPA_QUEUE_INIT (&this->ready);
this->n_buffers = 0;
this->ringbuffer = NULL;
}
return SPA_RESULT_OK;
}
@ -390,7 +392,7 @@ spa_alsa_sink_node_port_set_format (SpaNode *node,
return SPA_RESULT_INVALID_PORT;
if (format == NULL) {
spa_log_info (this->log, "clear format\n");
spa_log_info (this->log, "clear format");
spa_alsa_pause (this, false);
spa_alsa_clear_buffers (this);
spa_alsa_close (this);
@ -409,7 +411,7 @@ spa_alsa_sink_node_port_set_format (SpaNode *node,
SPA_PORT_INFO_FLAG_LIVE;
this->info.maxbuffering = this->buffer_frames * this->frame_size;
this->info.latency = (this->period_frames * SPA_NSEC_PER_SEC) / this->rate;
this->info.n_params = 2;
this->info.n_params = 3;
this->info.params = this->params;
this->params[0] = &this->param_buffers.param;
this->param_buffers.param.type = SPA_ALLOC_PARAM_TYPE_BUFFERS;
@ -423,6 +425,14 @@ spa_alsa_sink_node_port_set_format (SpaNode *node,
this->param_meta.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
this->param_meta.param.size = sizeof (this->param_meta);
this->param_meta.type = SPA_META_TYPE_HEADER;
this->params[2] = &this->param_meta_rb.param;
this->param_meta_rb.param.type = SPA_ALLOC_PARAM_TYPE_META_ENABLE;
this->param_meta_rb.param.size = sizeof (this->param_meta_rb);
this->param_meta_rb.type = SPA_META_TYPE_RINGBUFFER;
this->param_meta_rb.minsize = this->period_frames * this->frame_size * 32;
this->param_meta_rb.stride = 0;
this->param_meta_rb.blocks = 1;
this->param_meta_rb.align = 16;
this->info.extra = NULL;
this->have_format = true;
@ -512,7 +522,7 @@ spa_alsa_sink_node_port_use_buffers (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaALSASink, node);
spa_log_info (this->log, "use buffers %d\n", n_buffers);
spa_log_info (this->log, "use buffers %d", n_buffers);
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
@ -530,13 +540,16 @@ spa_alsa_sink_node_port_use_buffers (SpaNode *node,
b->outstanding = true;
b->h = spa_buffer_find_meta (b->outbuf, SPA_META_TYPE_HEADER);
b->rb = spa_buffer_find_meta (b->outbuf, SPA_META_TYPE_RINGBUFFER);
if (b->rb)
this->ringbuffer = b;
switch (buffers[i]->datas[0].type) {
case SPA_DATA_TYPE_MEMFD:
case SPA_DATA_TYPE_DMABUF:
case SPA_DATA_TYPE_MEMPTR:
if (buffers[i]->datas[0].data == NULL) {
spa_log_error (this->log, "alsa-source: need mapped memory\n");
spa_log_error (this->log, "alsa-source: need mapped memory");
continue;
}
break;
@ -637,9 +650,14 @@ spa_alsa_sink_node_port_push_input (SpaNode *node,
have_error = true;
continue;
}
if (this->ringbuffer) {
this->ringbuffer->outstanding = true;
this->ringbuffer = b;
} else {
b->next = NULL;
SPA_QUEUE_PUSH_TAIL (&this->ready, SpaALSABuffer, next, b);
}
b->outstanding = false;
b->next = NULL;
SPA_QUEUE_PUSH_TAIL (&this->ready, SpaALSABuffer, next, b);
info[i].status = SPA_RESULT_OK;
}
if (have_error)

7
spa/plugins/alsa/alsa-source.c
View file

@ -24,6 +24,7 @@
#include <spa/node.h>
#include <spa/queue.h>
#include <spa/audio/format.h>
#include <lib/props.h>
#include "alsa-utils.h"
@ -583,7 +584,7 @@ spa_alsa_source_node_port_use_buffers (SpaNode *node,
case SPA_DATA_TYPE_DMABUF:
case SPA_DATA_TYPE_MEMPTR:
if (buffers[i]->datas[0].data == NULL) {
spa_log_error (this->log, "alsa-source: need mapped memory\n");
spa_log_error (this->log, "alsa-source: need mapped memory");
continue;
}
break;
@ -697,7 +698,7 @@ spa_alsa_source_node_port_pull_output (SpaNode *node,
info[i].buffer_id = b->outbuf->id;
info[i].status = SPA_RESULT_OK;
spa_log_debug (this->log, "pull buffer %u\n", b->outbuf->id);
spa_log_debug (this->log, "pull buffer %u", b->outbuf->id);
}
if (have_error)
return SPA_RESULT_ERROR;
@ -727,7 +728,7 @@ spa_alsa_source_node_port_reuse_buffer (SpaNode *node,
if (buffer_id >= this->n_buffers)
return SPA_RESULT_INVALID_BUFFER_ID;
spa_log_debug (this->log, "recycle buffer %u\n", buffer_id);
spa_log_debug (this->log, "recycle buffer %u", buffer_id);
recycle_buffer (this, buffer_id);
return SPA_RESULT_OK;

204
spa/plugins/alsa/alsa-utils.c
View file

@ -7,9 +7,10 @@
#include <sys/time.h>
#include <math.h>
#include <lib/debug.h>
#include "alsa-utils.h"
#define CHECK(s,msg) if ((err = (s)) < 0) { spa_log_error (state->log, msg ": %s\n", snd_strerror(err)); return err; }
#define CHECK(s,msg) if ((err = (s)) < 0) { spa_log_error (state->log, msg ": %s", snd_strerror(err)); return err; }
static int alsa_on_fd_events (SpaPollNotifyData *data);
@ -24,7 +25,7 @@ spa_alsa_open (SpaALSAState *state)
CHECK (snd_output_stdio_attach (&state->output, stderr, 0), "attach failed");
spa_log_info (state->log, "ALSA device open '%s'\n", props->device);
spa_log_info (state->log, "ALSA device open '%s'", props->device);
CHECK (snd_pcm_open (&state->hndl,
props->device,
state->stream,
@ -59,7 +60,7 @@ spa_alsa_close (SpaALSAState *state)
spa_poll_remove_item (state->data_loop, &state->poll);
spa_log_info (state->log, "Device closing\n");
spa_log_info (state->log, "Device closing");
CHECK (snd_pcm_close (state->hndl), "close failed");
state->opened = false;
@ -147,14 +148,14 @@ spa_alsa_set_format (SpaALSAState *state, SpaFormatAudio *fmt, SpaPortFormatFlag
/* set the sample format */
format = spa_alsa_format_to_alsa (info->format);
spa_log_info (state->log, "Stream parameters are %iHz, %s, %i channels\n", info->rate, snd_pcm_format_name(format), info->channels);
spa_log_info (state->log, "Stream parameters are %iHz, %s, %i channels", info->rate, snd_pcm_format_name(format), info->channels);
CHECK (snd_pcm_hw_params_set_format (hndl, params, format), "set_format");
/* set the count of channels */
rchannels = info->channels;
CHECK (snd_pcm_hw_params_set_channels_near (hndl, params, &rchannels), "set_channels");
if (rchannels != info->channels) {
spa_log_info (state->log, "Channels doesn't match (requested %u, get %u\n", info->channels, rchannels);
spa_log_info (state->log, "Channels doesn't match (requested %u, get %u", info->channels, rchannels);
if (flags & SPA_PORT_FORMAT_FLAG_NEAREST)
info->channels = rchannels;
else
@ -165,7 +166,7 @@ spa_alsa_set_format (SpaALSAState *state, SpaFormatAudio *fmt, SpaPortFormatFlag
rrate = info->rate;
CHECK (snd_pcm_hw_params_set_rate_near (hndl, params, &rrate, 0), "set_rate_near");
if (rrate != info->rate) {
spa_log_info (state->log, "Rate doesn't match (requested %iHz, get %iHz)\n", info->rate, rrate);
spa_log_info (state->log, "Rate doesn't match (requested %iHz, get %iHz)", info->rate, rrate);
if (flags & SPA_PORT_FORMAT_FLAG_NEAREST)
info->rate = rrate;
else
@ -189,6 +190,8 @@ spa_alsa_set_format (SpaALSAState *state, SpaFormatAudio *fmt, SpaPortFormatFlag
CHECK (snd_pcm_hw_params_get_period_size (params, &size, &dir), "get_period_size");
state->period_frames = size;
spa_log_info (state->log, "buffer frames %zd, period frames %zd", state->buffer_frames, state->period_frames);
/* write the parameters to device */
CHECK (snd_pcm_hw_params (hndl, params), "set_hw_params");
@ -210,10 +213,13 @@ set_swparams (SpaALSAState *state)
CHECK (snd_pcm_sw_params_set_tstamp_mode (hndl, params, SND_PCM_TSTAMP_ENABLE), "sw_params_set_tstamp_mode");
/* start the transfer when the buffer is almost full: */
/* (buffer_frames / avail_min) * avail_min */
CHECK (snd_pcm_sw_params_set_start_threshold (hndl, params,
(state->buffer_frames / state->period_frames) * state->period_frames), "set_start_threshold");
/* start the transfer */
CHECK (snd_pcm_sw_params_set_start_threshold (hndl, params, 0U), "set_start_threshold");
CHECK (snd_pcm_sw_params_set_stop_threshold (hndl, params,
(state->buffer_frames / state->period_frames) * state->period_frames), "set_stop_threshold");
// CHECK (snd_pcm_sw_params_set_stop_threshold (hndl, params, -1), "set_stop_threshold");
CHECK (snd_pcm_sw_params_set_silence_threshold (hndl, params, 0U), "set_silence_threshold");
/* allow the transfer when at least period_size samples can be processed */
/* or disable this mechanism when period event is enabled (aka interrupt like style processing) */
@ -240,18 +246,18 @@ xrun_recovery (SpaALSAState *state, snd_pcm_t *hndl, int err)
snd_pcm_status_alloca (&status);
if ((err = snd_pcm_status (hndl, status)) < 0) {
spa_log_error (state->log, "snd_pcm_status error: %s\n", snd_strerror (err));
spa_log_error (state->log, "snd_pcm_status error: %s", snd_strerror (err));
}
if (snd_pcm_status_get_state (status) == SND_PCM_STATE_SUSPENDED) {
spa_log_info (state->log, "SUSPENDED, trying to resume\n");
spa_log_warn (state->log, "SUSPENDED, trying to resume");
if ((err = snd_pcm_prepare (hndl)) < 0) {
spa_log_error (state->log, "snd_pcm_prepare error: %s\n", snd_strerror (err));
spa_log_error (state->log, "snd_pcm_prepare error: %s", snd_strerror (err));
}
}
if (snd_pcm_status_get_state (status) == SND_PCM_STATE_XRUN) {
spa_log_info (state->log, "XRUN\n");
spa_log_warn (state->log, "XRUN");
}
if (spa_alsa_pause (state, true) != SPA_RESULT_OK)
@ -262,6 +268,98 @@ xrun_recovery (SpaALSAState *state, snd_pcm_t *hndl, int err)
return err;
}
static snd_pcm_uframes_t
pull_frames_queue (SpaALSAState *state,
const snd_pcm_channel_area_t *my_areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t frames)
{
SpaALSABuffer *b;
SPA_QUEUE_PEEK_HEAD (&state->ready, SpaALSABuffer, b);
if (b) {
uint8_t *src, *dst;
size_t n_bytes;
src = SPA_MEMBER (b->outbuf->datas[0].data, b->outbuf->datas[0].offset + state->ready_offset, uint8_t);
dst = SPA_MEMBER (my_areas[0].addr, offset * state->frame_size, uint8_t);
n_bytes = SPA_MIN (b->outbuf->datas[0].size - state->ready_offset, frames * state->frame_size);
frames = SPA_MIN (frames, n_bytes / state->frame_size);
memcpy (dst, src, n_bytes);
state->ready_offset += n_bytes;
if (state->ready_offset >= b->outbuf->datas[0].size) {
SpaNodeEventReuseBuffer rb;
SPA_QUEUE_POP_HEAD (&state->ready, SpaALSABuffer, next, b);
b->outstanding = true;
rb.event.type = SPA_NODE_EVENT_TYPE_REUSE_BUFFER;
rb.event.size = sizeof (rb);
rb.port_id = 0;
rb.buffer_id = b->outbuf->id;
state->event_cb (&state->node, &rb.event, state->user_data);
state->ready_offset = 0;
}
} else {
spa_log_warn (state->log, "underrun");
snd_pcm_areas_silence (my_areas, offset, state->channels, frames, state->format);
}
return frames;
}
static snd_pcm_uframes_t
pull_frames_ringbuffer (SpaALSAState *state,
const snd_pcm_channel_area_t *my_areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t frames)
{
SpaRingbufferArea areas[2];
size_t size, avail;
SpaALSABuffer *b;
uint8_t *src, *dst;
SpaNodeEventReuseBuffer rb;
b = state->ringbuffer;
src = SPA_MEMBER (b->outbuf->datas[0].data, b->outbuf->datas[0].offset, void);
dst = SPA_MEMBER (my_areas[0].addr, offset * state->frame_size, uint8_t);
spa_ringbuffer_get_read_areas (&b->rb->ringbuffer, areas);
avail = areas[0].len + areas[1].len;
size = SPA_MIN (avail, frames * state->frame_size);
spa_log_debug (state->log, "%zd %zd %zd %zd %zd %zd",
areas[0].offset, areas[0].len,
areas[1].offset, areas[1].len, offset, size);
if (size > 0) {
areas[0].len = SPA_MIN (areas[0].len, size);
areas[1].len = SPA_MIN (areas[1].len, size - areas[0].len);
memcpy (dst, src + areas[0].offset, areas[0].len);
if (areas[1].len)
memcpy (dst + areas[0].len, src + areas[1].offset, areas[1].len);
spa_ringbuffer_read_advance (&b->rb->ringbuffer, size);
frames = size / state->frame_size;
} else {
spa_log_warn (state->log, "underrun");
snd_pcm_areas_silence (my_areas, offset, state->channels, frames, state->format);
}
b->outstanding = true;
rb.event.type = SPA_NODE_EVENT_TYPE_REUSE_BUFFER;
rb.event.size = sizeof (rb);
rb.port_id = 0;
rb.buffer_id = b->outbuf->id;
state->event_cb (&state->node, &rb.event, state->user_data);
return frames;
}
static int
mmap_write (SpaALSAState *state)
{
@ -270,71 +368,42 @@ mmap_write (SpaALSAState *state)
snd_pcm_sframes_t avail;
snd_pcm_uframes_t offset, frames, size;
const snd_pcm_channel_area_t *my_areas;
SpaNodeEventNeedInput ni;
SpaALSABuffer *b;
snd_pcm_status_t *status;
SpaNodeEventNeedInput ni;
snd_pcm_status_alloca (&status);
if ((err = snd_pcm_status (hndl, status)) < 0) {
spa_log_error (state->log, "snd_pcm_status error: %s\n", snd_strerror (err));
spa_log_error (state->log, "snd_pcm_status error: %s", snd_strerror (err));
return -1;
}
avail = snd_pcm_status_get_avail (status);
ni.event.type = SPA_NODE_EVENT_TYPE_NEED_INPUT;
ni.event.size = sizeof (ni);
ni.port_id = 0;
state->event_cb (&state->node, &ni.event, state->user_data);
size = avail;
while (size > 0) {
frames = size;
if ((err = snd_pcm_mmap_begin (hndl, &my_areas, &offset, &frames)) < 0) {
spa_log_error (state->log, "snd_pcm_mmap_begin error: %s\n", snd_strerror(err));
spa_log_error (state->log, "snd_pcm_mmap_begin error: %s", snd_strerror(err));
return -1;
}
ni.event.type = SPA_NODE_EVENT_TYPE_NEED_INPUT;
ni.event.size = sizeof (ni);
ni.port_id = 0;
state->event_cb (&state->node, &ni.event, state->user_data);
SPA_QUEUE_PEEK_HEAD (&state->ready, SpaALSABuffer, b);
if (b) {
uint8_t *src;
size_t n_bytes;
src = SPA_MEMBER (b->outbuf->datas[0].data, b->outbuf->datas[0].offset + state->ready_offset, void);
n_bytes = SPA_MIN (b->outbuf->datas[0].size - state->ready_offset, frames * state->frame_size);
frames = SPA_MIN (frames, n_bytes / state->frame_size);
memcpy ((uint8_t *)my_areas[0].addr + (offset * state->frame_size),
src,
n_bytes);
state->ready_offset += n_bytes;
if (state->ready_offset >= b->outbuf->datas[0].size) {
SpaNodeEventReuseBuffer rb;
SPA_QUEUE_POP_HEAD (&state->ready, SpaALSABuffer, next, b);
b->outstanding = true;
rb.event.type = SPA_NODE_EVENT_TYPE_REUSE_BUFFER;
rb.event.size = sizeof (rb);
rb.port_id = 0;
rb.buffer_id = b->outbuf->id;
state->event_cb (&state->node, &rb.event, state->user_data);
state->ready_offset = 0;
}
} else {
spa_log_warn (state->log, "underrun\n");
snd_pcm_areas_silence (my_areas, offset, state->channels, frames, state->format);
}
if (state->ringbuffer)
frames = pull_frames_ringbuffer (state, my_areas, offset, frames);
else
frames = pull_frames_queue (state, my_areas, offset, frames);
if ((err = snd_pcm_mmap_commit (hndl, offset, frames)) < 0) {
spa_log_error (state->log, "snd_pcm_mmap_commit error: %s\n", snd_strerror(err));
spa_log_error (state->log, "snd_pcm_mmap_commit error: %s", snd_strerror(err));
if (err != -EPIPE && err != -ESTRPIPE)
return -1;
}
spa_log_debug (state->log, "write %zd/%zd/%zd %u", frames, size, avail, state->ready.length);
size -= frames;
}
return 0;
@ -358,7 +427,7 @@ mmap_read (SpaALSAState *state)
snd_pcm_status_alloca(&status);
if ((err = snd_pcm_status (hndl, status)) < 0) {
spa_log_error (state->log, "snd_pcm_status error: %s\n", snd_strerror(err));
spa_log_error (state->log, "snd_pcm_status error: %s", snd_strerror(err));
return err;
}
@ -371,7 +440,7 @@ mmap_read (SpaALSAState *state)
SPA_QUEUE_POP_HEAD (&state->free, SpaALSABuffer, next, b);
if (b == NULL) {
spa_log_warn (state->log, "no more buffers\n");
spa_log_warn (state->log, "no more buffers");
} else {
dest = SPA_MEMBER (b->outbuf->datas[0].data, b->outbuf->datas[0].offset, void);
destsize = b->outbuf->datas[0].size;
@ -390,7 +459,7 @@ mmap_read (SpaALSAState *state)
while (size > 0) {
frames = size;
if ((err = snd_pcm_mmap_begin (hndl, &my_areas, &offset, &frames)) < 0) {
spa_log_error (state->log, "snd_pcm_mmap_begin error: %s\n", snd_strerror (err));
spa_log_error (state->log, "snd_pcm_mmap_begin error: %s", snd_strerror (err));
return -1;
}
@ -404,13 +473,12 @@ mmap_read (SpaALSAState *state)
}
if ((err = snd_pcm_mmap_commit (hndl, offset, frames)) < 0) {
spa_log_error (state->log, "snd_pcm_mmap_commit error: %s\n", snd_strerror(err));
spa_log_error (state->log, "snd_pcm_mmap_commit error: %s", snd_strerror(err));
return -1;
}
size -= frames;
}
if (b) {
SpaNodeEventHaveOutput ho;
SpaData *d;
@ -443,7 +511,7 @@ alsa_on_fd_events (SpaPollNotifyData *data)
&revents);
if (revents & POLLERR) {
if ((err = xrun_recovery (state, hndl, err)) < 0) {
spa_log_error (state->log, "error: %s\n", snd_strerror (err));
spa_log_error (state->log, "error: %s", snd_strerror (err));
return -1;
}
}
@ -476,16 +544,16 @@ spa_alsa_start (SpaALSAState *state, bool xrun_recover)
snd_pcm_dump (state->hndl, state->output);
if ((err = snd_pcm_prepare (state->hndl)) < 0) {
spa_log_error (state->log, "snd_pcm_prepare error: %s\n", snd_strerror (err));
spa_log_error (state->log, "snd_pcm_prepare error: %s", snd_strerror (err));
return SPA_RESULT_ERROR;
}
if ((state->poll.n_fds = snd_pcm_poll_descriptors_count (state->hndl)) <= 0) {
spa_log_error (state->log, "Invalid poll descriptors count %d\n", state->poll.n_fds);
spa_log_error (state->log, "Invalid poll descriptors count %d", state->poll.n_fds);
return SPA_RESULT_ERROR;
}
if ((err = snd_pcm_poll_descriptors (state->hndl, (struct pollfd *)state->fds, state->poll.n_fds)) < 0) {
spa_log_error (state->log, "snd_pcm_poll_descriptors: %s\n", snd_strerror(err));
spa_log_error (state->log, "snd_pcm_poll_descriptors: %s", snd_strerror(err));
return SPA_RESULT_ERROR;
}
@ -499,7 +567,7 @@ spa_alsa_start (SpaALSAState *state, bool xrun_recover)
}
if ((err = snd_pcm_start (state->hndl)) < 0) {
spa_log_error (state->log, "snd_pcm_start: %s\n", snd_strerror (err));
spa_log_error (state->log, "snd_pcm_start: %s", snd_strerror (err));
return SPA_RESULT_ERROR;
}
@ -522,7 +590,7 @@ spa_alsa_pause (SpaALSAState *state, bool xrun_recover)
}
if ((err = snd_pcm_drop (state->hndl)) < 0)
spa_log_error (state->log, "snd_pcm_drop %s\n", snd_strerror (err));
spa_log_error (state->log, "snd_pcm_drop %s", snd_strerror (err));
state->started = false;

7
spa/plugins/alsa/alsa-utils.h
View file

@ -32,6 +32,7 @@ extern "C" {
#include <spa/log.h>
#include <spa/queue.h>
#include <spa/node.h>
#include <spa/ringbuffer.h>
#include <spa/audio/format.h>
typedef struct _SpaALSAState SpaALSAState;
@ -52,6 +53,7 @@ typedef struct {
struct _SpaALSABuffer {
SpaBuffer *outbuf;
SpaMetaHeader *h;
SpaMetaRingbuffer *rb;
bool outstanding;
SpaALSABuffer *next;
};
@ -96,13 +98,16 @@ struct _SpaALSAState {
size_t frame_size;
SpaPortInfo info;
SpaAllocParam *params[2];
SpaAllocParam *params[3];
SpaAllocParamBuffers param_buffers;
SpaAllocParamMetaEnable param_meta;
SpaAllocParamMetaEnableRingbuffer param_meta_rb;
SpaPortStatus status;
SpaALSABuffer buffers[MAX_BUFFERS];
unsigned int n_buffers;
bool use_ringbuffer;
SpaALSABuffer *ringbuffer;
SpaQueue free;
SpaQueue ready;

2
spa/plugins/alsa/meson.build
View file

@ -6,7 +6,7 @@ spa_alsa_sources = ['alsa.c',
spa_alsa = shared_library('spa-alsa',
spa_alsa_sources,
include_directories : spa_inc,
include_directories : [spa_inc, spa_libinc],
dependencies : [ alsa_dep, libudev_dep ],
link_with : spalib,
install : true,

3
spa/plugins/audiomixer/audiomixer.c
View file

@ -24,6 +24,7 @@
#include <spa/id-map.h>
#include <spa/node.h>
#include <spa/audio/format.h>
#include <lib/props.h>
#define MAX_PORTS 128
@ -700,7 +701,7 @@ spa_audiomixer_node_port_pull_output (SpaNode *node,
for (i = 0; i < n_info; i++) {
if ((info[i].status = mix_data (this, &info[i])) < 0) {
spa_log_error (this->log, "error mixing: %d\n", info[i].status);
spa_log_error (this->log, "error mixing: %d", info[i].status);
have_error = true;
continue;
}

2
spa/plugins/audiomixer/meson.build
View file

@ -2,7 +2,7 @@ audiomixer_sources = ['audiomixer.c', 'plugin.c']
audiomixerlib = shared_library('spa-audiomixer',
audiomixer_sources,
include_directories : spa_inc,
include_directories : [spa_inc, spa_libinc],
link_with : spalib,
install : true,
install_dir : '@0@/spa'.format(get_option('libdir')))

5
spa/plugins/audiotestsrc/audiotestsrc.c
View file

@ -29,6 +29,7 @@
#include <spa/node.h>
#include <spa/queue.h>
#include <spa/audio/format.h>
#include <lib/props.h>
#define SAMPLES_TO_TIME(this,s) ((s) * SPA_NSEC_PER_SEC / (this)->current_format.info.raw.rate)
#define BYTES_TO_SAMPLES(this,b) ((b)/(this)->bpf)
@ -526,7 +527,7 @@ static SpaResult
clear_buffers (SpaAudioTestSrc *this)
{
if (this->n_buffers > 0) {
spa_log_info (this->log, "audiotestsrc %p: clear buffers\n", this);
spa_log_info (this->log, "audiotestsrc %p: clear buffers", this);
this->n_buffers = 0;
SPA_QUEUE_INIT (&this->empty);
SPA_QUEUE_INIT (&this->ready);
@ -690,7 +691,7 @@ spa_audiotestsrc_node_port_use_buffers (SpaNode *node,
case SPA_DATA_TYPE_MEMFD:
case SPA_DATA_TYPE_DMABUF:
if (d[0].data == NULL) {
spa_log_error (this->log, "audiotestsrc %p: invalid memory on buffer %p\n", this, buffers[i]);
spa_log_error (this->log, "audiotestsrc %p: invalid memory on buffer %p", this, buffers[i]);
continue;
}
b->ptr = SPA_MEMBER (d[0].data, d[0].offset, void);

2
spa/plugins/audiotestsrc/meson.build
View file

@ -2,7 +2,7 @@ audiotestsrc_sources = ['audiotestsrc.c', 'plugin.c']
audiotestsrclib = shared_library('spa-audiotestsrc',
audiotestsrc_sources,
include_directories : spa_inc,
include_directories : [spa_inc, spa_libinc],
link_with : spalib,
install : true,
install_dir : '@0@/spa'.format(get_option('libdir')))

1
spa/plugins/ffmpeg/ffmpeg-dec.c
View file

@ -26,6 +26,7 @@
#include <spa/log.h>
#include <spa/node.h>
#include <spa/video/format.h>
#include <lib/props.h>
typedef struct _SpaFFMpegDec SpaFFMpegDec;

1
spa/plugins/ffmpeg/ffmpeg-enc.c
View file

@ -26,6 +26,7 @@
#include <spa/id-map.h>
#include <spa/node.h>
#include <spa/video/format.h>
#include <lib/props.h>
typedef struct _SpaFFMpegEnc SpaFFMpegEnc;

2
spa/plugins/ffmpeg/meson.build
View file

@ -4,7 +4,7 @@ ffmpeg_sources = ['ffmpeg.c',
ffmpeglib = shared_library('spa-ffmpeg',
ffmpeg_sources,
include_directories : spa_inc,
include_directories : [spa_inc, spa_libinc],
dependencies : [ avcodec_dep, avformat_dep ],
link_with : spalib,
install : true,

2
spa/plugins/v4l2/meson.build
View file

@ -4,7 +4,7 @@ v4l2_sources = ['v4l2.c',
v4l2lib = shared_library('spa-v4l2',
v4l2_sources,
include_directories : spa_inc,
include_directories : [ spa_inc, spa_libinc ],
dependencies : [ v4l2_dep, libudev_dep ],
link_with : spalib,
install : true,

2
spa/plugins/v4l2/v4l2-monitor.c
View file

@ -30,7 +30,7 @@
#include <spa/id-map.h>
#include <spa/poll.h>
#include <spa/monitor.h>
#include <spa/debug.h>
#include <lib/debug.h>
extern const SpaHandleFactory spa_v4l2_source_factory;

5
spa/plugins/v4l2/v4l2-source.c
View file

@ -26,10 +26,11 @@
#include <spa/node.h>
#include <spa/video/format.h>
#include <spa/debug.h>
#include <spa/queue.h>
#include <spa/log.h>
#include <spa/id-map.h>
#include <lib/debug.h>
#include <lib/props.h>
typedef struct _SpaV4l2Source SpaV4l2Source;
@ -150,7 +151,7 @@ struct _SpaV4l2Source {
static void
update_state (SpaV4l2Source *this, SpaNodeState state)
{
spa_log_info (this->log, "state: %d\n", state);
spa_log_info (this->log, "state: %d", state);
this->node.state = state;
}
#include "v4l2-utils.c"

42
spa/plugins/v4l2/v4l2-utils.c
View file

@ -34,27 +34,27 @@ spa_v4l2_open (SpaV4l2Source *this)
return 0;
if (props->props.unset_mask & 1) {
spa_log_error (state->log, "v4l2: Device property not set\n");
spa_log_error (state->log, "v4l2: Device property not set");
return -1;
}
spa_log_info (state->log, "v4l2: Playback device is '%s'\n", props->device);
spa_log_info (state->log, "v4l2: Playback device is '%s'", props->device);
if (stat (props->device, &st) < 0) {
spa_log_error (state->log, "v4l2: Cannot identify '%s': %d, %s\n",
spa_log_error (state->log, "v4l2: Cannot identify '%s': %d, %s",
props->device, errno, strerror (errno));
return -1;
}
if (!S_ISCHR (st.st_mode)) {
spa_log_error (state->log, "v4l2: %s is no device\n", props->device);
spa_log_error (state->log, "v4l2: %s is no device", props->device);
return -1;
}
state->fd = open (props->device, O_RDWR | O_NONBLOCK, 0);
if (state->fd == -1) {
spa_log_error (state->log, "v4l2: Cannot open '%s': %d, %s\n",
spa_log_error (state->log, "v4l2: Cannot open '%s': %d, %s",
props->device, errno, strerror (errno));
return -1;
}
@ -65,7 +65,7 @@ spa_v4l2_open (SpaV4l2Source *this)
}
if ((state->cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) {
spa_log_error (state->log, "v4l2: %s is no video capture device\n", props->device);
spa_log_error (state->log, "v4l2: %s is no video capture device", props->device);
return -1;
}
@ -120,7 +120,7 @@ spa_v4l2_clear_buffers (SpaV4l2Source *this)
b = &state->buffers[i];
if (b->outstanding) {
spa_log_info (state->log, "v4l2: queueing outstanding buffer %p\n", b);
spa_log_info (state->log, "v4l2: queueing outstanding buffer %p", b);
spa_v4l2_buffer_recycle (this, i);
}
if (b->allocated) {
@ -156,7 +156,7 @@ spa_v4l2_close (SpaV4l2Source *this)
if (state->n_buffers > 0)
return 0;
spa_log_info (state->log, "v4l2: close\n");
spa_log_info (state->log, "v4l2: close");
spa_poll_remove_item (state->data_loop, &state->poll);
@ -768,7 +768,7 @@ spa_v4l2_set_format (SpaV4l2Source *this, V4l2Format *f, bool try_only)
f->format,
0);
if (info == NULL) {
spa_log_error (state->log, "v4l2: unknown media type %d %d %d\n", f->fmt.media_type,
spa_log_error (state->log, "v4l2: unknown media type %d %d %d", f->fmt.media_type,
f->fmt.media_subtype, f->format);
return -1;
}
@ -780,7 +780,7 @@ spa_v4l2_set_format (SpaV4l2Source *this, V4l2Format *f, bool try_only)
streamparm.parm.capture.timeperframe.numerator = f->framerate.denom;
streamparm.parm.capture.timeperframe.denominator = f->framerate.num;
spa_log_info (state->log, "v4l2: set %08x %dx%d %d/%d\n", fmt.fmt.pix.pixelformat,
spa_log_info (state->log, "v4l2: set %08x %dx%d %d/%d", fmt.fmt.pix.pixelformat,
fmt.fmt.pix.width, fmt.fmt.pix.height,
streamparm.parm.capture.timeperframe.numerator,
streamparm.parm.capture.timeperframe.denominator);
@ -800,7 +800,7 @@ spa_v4l2_set_format (SpaV4l2Source *this, V4l2Format *f, bool try_only)
if (xioctl (state->fd, VIDIOC_S_PARM, &streamparm) < 0)
perror ("VIDIOC_S_PARM");
spa_log_info (state->log, "v4l2: got %08x %dx%d %d/%d\n", fmt.fmt.pix.pixelformat,
spa_log_info (state->log, "v4l2: got %08x %dx%d %d/%d", fmt.fmt.pix.pixelformat,
fmt.fmt.pix.width, fmt.fmt.pix.height,
streamparm.parm.capture.timeperframe.numerator,
streamparm.parm.capture.timeperframe.denominator);
@ -932,7 +932,7 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe
state->memtype = V4L2_MEMORY_DMABUF;
break;
default:
spa_log_error (state->log, "v4l2: can't use buffers\n");
spa_log_error (state->log, "v4l2: can't use buffers");
return SPA_RESULT_ERROR;
}
}
@ -946,9 +946,9 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe
perror ("VIDIOC_REQBUFS");
return SPA_RESULT_ERROR;
}
spa_log_info (state->log, "v4l2: got %d buffers\n", reqbuf.count);
spa_log_info (state->log, "v4l2: got %d buffers", reqbuf.count);
if (reqbuf.count < 2) {
spa_log_error (state->log, "v4l2: can't allocate enough buffers\n");
spa_log_error (state->log, "v4l2: can't allocate enough buffers");
return SPA_RESULT_ERROR;
}
@ -961,10 +961,10 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe
b->allocated = false;
b->h = spa_buffer_find_meta (b->outbuf, SPA_META_TYPE_HEADER);
spa_log_info (state->log, "v4l2: import buffer %p\n", buffers[i]);
spa_log_info (state->log, "v4l2: import buffer %p", buffers[i]);
if (buffers[i]->n_datas < 1) {
spa_log_error (state->log, "v4l2: invalid memory on buffer %p\n", buffers[i]);
spa_log_error (state->log, "v4l2: invalid memory on buffer %p", buffers[i]);
continue;
}
d = buffers[i]->datas;
@ -977,7 +977,7 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe
case SPA_DATA_TYPE_MEMPTR:
case SPA_DATA_TYPE_MEMFD:
if (d[0].data == NULL) {
spa_log_error (state->log, "v4l2: need mmaped memory\n");
spa_log_error (state->log, "v4l2: need mmaped memory");
continue;
}
b->v4l2_buffer.m.userptr = (unsigned long) SPA_MEMBER (d[0].data, d[0].offset, void *);
@ -1019,22 +1019,22 @@ mmap_init (SpaV4l2Source *this,
return SPA_RESULT_ERROR;
}
spa_log_info (state->log, "v4l2: got %d buffers\n", reqbuf.count);
spa_log_info (state->log, "v4l2: got %d buffers", reqbuf.count);
*n_buffers = reqbuf.count;
if (reqbuf.count < 2) {
spa_log_error (state->log, "v4l2: can't allocate enough buffers\n");
spa_log_error (state->log, "v4l2: can't allocate enough buffers");
return SPA_RESULT_ERROR;
}
if (state->export_buf)
spa_log_info (state->log, "v4l2: using EXPBUF\n");
spa_log_info (state->log, "v4l2: using EXPBUF");
for (i = 0; i < reqbuf.count; i++) {
V4l2Buffer *b;
SpaData *d;
if (buffers[i]->n_datas < 1) {
spa_log_error (state->log, "v4l2: invalid buffer data\n");
spa_log_error (state->log, "v4l2: invalid buffer data");
return SPA_RESULT_ERROR;
}

2
spa/plugins/videotestsrc/meson.build
View file

@ -2,7 +2,7 @@ videotestsrc_sources = ['videotestsrc.c', 'plugin.c']
videotestsrclib = shared_library('spa-videotestsrc',
videotestsrc_sources,
include_directories : spa_inc,
include_directories : [ spa_inc, spa_libinc],
dependencies : threads_dep,
link_with : spalib,
install : true,

5
spa/plugins/videotestsrc/videotestsrc.c
View file

@ -30,6 +30,7 @@
#include <spa/node.h>
#include <spa/queue.h>
#include <spa/video/format.h>
#include <lib/props.h>
#define FRAMES_TO_TIME(this,f) ((this->current_format.info.raw.framerate.num * (f) * SPA_NSEC_PER_SEC) / \
(this->current_format.info.raw.framerate.denom))
@ -474,7 +475,7 @@ static SpaResult
clear_buffers (SpaVideoTestSrc *this)
{
if (this->n_buffers > 0) {
spa_log_info (this->log, "videotestsrc %p: clear buffers\n", this);
spa_log_info (this->log, "videotestsrc %p: clear buffers", this);
this->n_buffers = 0;
SPA_QUEUE_INIT (&this->empty);
SPA_QUEUE_INIT (&this->ready);
@ -639,7 +640,7 @@ spa_videotestsrc_node_port_use_buffers (SpaNode *node,
case SPA_DATA_TYPE_MEMFD:
case SPA_DATA_TYPE_DMABUF:
if (d[0].data == NULL) {
spa_log_error (this->log, "videotestsrc %p: invalid memory on buffer %p\n", this, buffers[i]);
spa_log_error (this->log, "videotestsrc %p: invalid memory on buffer %p", this, buffers[i]);
continue;
}
b->ptr = SPA_MEMBER (d[0].data, d[0].offset, void);

2
spa/plugins/volume/meson.build
View file

@ -2,7 +2,7 @@ volume_sources = ['volume.c', 'plugin.c']
volumelib = shared_library('spa-volume',
volume_sources,
include_directories : spa_inc,
include_directories : [spa_inc, spa_libinc],
link_with : spalib,
install : true,
install_dir : '@0@/spa'.format(get_option('libdir')))

1
spa/plugins/volume/volume.c
View file

@ -24,6 +24,7 @@
#include <spa/id-map.h>
#include <spa/node.h>
#include <spa/audio/format.h>
#include <lib/props.h>
typedef struct _SpaVolume SpaVolume;

2
spa/plugins/xv/meson.build
View file

@ -3,7 +3,7 @@ xv_sources = ['xv.c',
xvlib = shared_library('spa-xv',
xv_sources,
include_directories : spa_inc,
include_directories : [spa_inc, spa_libinc],
dependencies : xv_dep,
link_with : spalib,
install : true,

1
spa/plugins/xv/xv-sink.c
View file

@ -28,6 +28,7 @@
#include <spa/log.h>
#include <spa/node.h>
#include <spa/video/format.h>
#include <lib/props.h>
typedef struct _SpaXvSink SpaXvSink;

4
spa/tests/meson.build
View file

@ -1,11 +1,11 @@
executable('test-mixer', 'test-mixer.c',
include_directories : spa_inc,
include_directories : [spa_inc, spa_libinc ],
dependencies : [dl_lib, pthread_lib],
link_with : spalib,
install : false)
executable('test-v4l2', 'test-v4l2.c',
include_directories : spa_inc,
include_directories : [spa_inc, spa_libinc ],
dependencies : [dl_lib, sdl_dep, pthread_lib],
link_with : spalib,
install : false)

2
spa/tests/test-mixer.c
View file

@ -30,6 +30,8 @@
#include <spa/log.h>
#include <spa/id-map.h>
#include <spa/audio/format.h>
#include <lib/mapper.h>
#include <lib/props.h>
typedef struct {
uint32_t node;

4
spa/tests/test-v4l2.c
View file

@ -31,8 +31,10 @@
#include <spa/id-map.h>
#include <spa/log.h>
#include <spa/node.h>
#include <spa/debug.h>
#include <spa/video/format.h>
#include <lib/debug.h>
#include <lib/props.h>
#include <lib/mapper.h>
#define MAX_BUFFERS 8

4
spa/tools/meson.build
View file

@ -1,11 +1,11 @@
executable('spa-inspect', 'spa-inspect.c',
include_directories : spa_inc,
include_directories : [spa_inc, spa_libinc],
dependencies : [dl_lib],
link_with : spalib,
install : true)
executable('spa-monitor', 'spa-monitor.c',
include_directories : spa_inc,
include_directories : [spa_inc, spa_libinc],
dependencies : [dl_lib],
link_with : spalib,
install : true)

3
spa/tools/spa-inspect.c
View file

@ -26,7 +26,8 @@
#include <spa/id-map.h>
#include <spa/log.h>
#include <spa/node.h>
#include <spa/debug.h>
#include <lib/debug.h>
#include <lib/mapper.h>
typedef struct {
uint32_t node;

3
spa/tools/spa-monitor.c
View file

@ -29,7 +29,8 @@
#include <spa/id-map.h>
#include <spa/monitor.h>
#include <spa/poll.h>
#include <spa/debug.h>
#include <lib/debug.h>
#include <lib/mapper.h>
typedef struct {
uint32_t monitor;