mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-16 07:00:00 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

more hacking

Browse source 
Move plugin API to separate directory for now
Add ringbuffer and way to get ringbuffer from a port
This commit is contained in:
Wim Taymans 2016-06-28 12:21:56 +02:00
parent b8f6e99537
commit 3c029cba53
56 changed files with 7055 additions and 1530 deletions
Download patch file Download diff file Expand all files Collapse all files

72
pinos/client/client-port.c
View file

@ -21,6 +21,7 @@
#include <gst/gst.h>
#include <gio/gio.h>
#include <gio/gunixfdlist.h>
#include "pinos/client/pinos.h"
#include "pinos/client/enumtypes.h"
@ -43,6 +44,74 @@ enum
PROP_PROXY,
};
static void
on_ringbuffer (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GTask *task = user_data;
PinosClientPort *port = g_task_get_source_object (task);
PinosClientPortPrivate *priv = port->priv;
GVariant *ret;
GError *error = NULL;
GUnixFDList *fdlist;
gint fd, semfd, fd_idx, sem_idx;
guint fdsize;
PinosRingbuffer *rbuf;
g_assert (priv->proxy == G_DBUS_PROXY (source_object));
ret = g_dbus_proxy_call_with_unix_fd_list_finish (priv->proxy, &fdlist, res, &error);
if (ret == NULL)
goto create_failed;
g_variant_get (ret, "(huh)", &fd_idx, &fdsize, &sem_idx);
g_variant_unref (ret);
fd = g_unix_fd_list_get (fdlist, fd_idx, &error);
semfd = g_unix_fd_list_get (fdlist, sem_idx, &error);
g_object_unref (fdlist);
if (fd == -1 || semfd == -1)
goto create_failed;
rbuf = pinos_ringbuffer_new_import (PINOS_RINGBUFFER_MODE_WRITE,
fd, fdsize, semfd);
g_task_return_pointer (task, rbuf, (GDestroyNotify) g_object_unref);
g_object_unref (task);
return;
/* ERRORS */
create_failed:
{
g_warning ("failed to get ringbuffer: %s", error->message);
g_task_return_error (task, error);
g_object_unref (task);
return;
}
}
static void
pinos_client_port_get_ringbuffer (PinosPort *port,
PinosProperties *props,
GTask *task)
{
PinosClientPortPrivate *priv = PINOS_CLIENT_PORT (port)->priv;
g_dbus_proxy_call (priv->proxy,
"GetRingbuffer",
g_variant_new ("(@a{sv})",
pinos_properties_to_variant (props)),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL, /* GCancellable *cancellable */
on_ringbuffer,
task);
}
static void
pinos_client_port_get_property (GObject *_object,
guint prop_id,
@ -205,6 +274,7 @@ static void
pinos_client_port_class_init (PinosClientPortClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
PinosPortClass *port_class = PINOS_PORT_CLASS (klass);
g_type_class_add_private (klass, sizeof (PinosClientPortPrivate));
@ -223,6 +293,8 @@ pinos_client_port_class_init (PinosClientPortClass * klass)
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
port_class->get_ringbuffer = pinos_client_port_get_ringbuffer;
}
static void

1
pinos/client/pinos.h
View file

@ -27,6 +27,7 @@
#include <pinos/client/introspect.h>
#include <pinos/client/mainloop.h>
#include <pinos/client/properties.h>
#include <pinos/client/ringbuffer.h>
#include <pinos/client/stream.h>
#include <pinos/client/subscribe.h>

393
pinos/client/ringbuffer.c Normal file
View file

@ -0,0 +1,393 @@
/* 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.
*/
#define _GNU_SOURCE
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/eventfd.h>
#include <sys/mman.h>
#include <gio/gio.h>
#include <glib-object.h>
#include <pinos/client/enumtypes.h>
#include <pinos/client/ringbuffer.h>
#include <spa/include/spa/ringbuffer.h>
#include <spa/lib/ringbuffer.c>
#define PINOS_RINGBUFFER_GET_PRIVATE(rb) \
(G_TYPE_INSTANCE_GET_PRIVATE ((rb), PINOS_TYPE_RINGBUFFER, PinosRingbufferPrivate))
typedef struct {
SpaRingbuffer rbuf;
/* ringbuffer starts here */
} PinosRingbufferData;
struct _PinosRingbufferPrivate
{
PinosRingbufferMode mode;
guint size;
guint fdsize;
int fd;
int semaphore;
PinosRingbufferData *data;
};
G_DEFINE_TYPE (PinosRingbuffer, pinos_ringbuffer, G_TYPE_OBJECT);
enum
{
PROP_0,
PROP_MODE,
PROP_SIZE,
PROP_FD,
PROP_FDSIZE,
PROP_SEMAPHORE,
};
enum
{
SIGNAL_NONE,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
static void
pinos_ringbuffer_get_property (GObject *_object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
PinosRingbuffer *rb = PINOS_RINGBUFFER (_object);
PinosRingbufferPrivate *priv = rb->priv;
switch (prop_id) {
case PROP_MODE:
g_value_set_enum (value, priv->mode);
break;
case PROP_SIZE:
g_value_set_uint (value, priv->size);
break;
case PROP_FD:
g_value_set_int (value, priv->fd);
break;
case PROP_FDSIZE:
g_value_set_uint (value, priv->fdsize);
break;
case PROP_SEMAPHORE:
g_value_set_int (value, priv->semaphore);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (rb, prop_id, pspec);
break;
}
}
static void
pinos_ringbuffer_set_property (GObject *_object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
PinosRingbuffer *rb = PINOS_RINGBUFFER (_object);
PinosRingbufferPrivate *priv = rb->priv;
switch (prop_id) {
case PROP_MODE:
priv->mode = g_value_get_enum (value);
break;
case PROP_SIZE:
priv->size = g_value_get_uint (value);
break;
case PROP_FD:
priv->fd = g_value_get_int (value);
break;
case PROP_FDSIZE:
priv->fdsize = g_value_get_uint (value);
break;
case PROP_SEMAPHORE:
priv->semaphore = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (rb, prop_id, pspec);
break;
}
}
static int
tmpfile_create (gsize size)
{
char filename[] = "/dev/shm/tmpfilepay.XXXXXX";
int fd, result;
fd = mkostemp (filename, O_CLOEXEC);
if (fd == -1)
return -1;
unlink (filename);
result = ftruncate (fd, size);
if (result == -1) {
close (fd);
return -1;
}
return fd;
}
static void
pinos_ringbuffer_constructed (GObject * obj)
{
PinosRingbuffer *rb = PINOS_RINGBUFFER (obj);
PinosRingbufferPrivate *priv = rb->priv;
g_debug ("ringbuffer %p: constructed", rb);
if (priv->fd == -1) {
priv->fdsize = priv->size + sizeof (PinosRingbufferData);
priv->fd = tmpfile_create (priv->fdsize);
priv->semaphore = eventfd (0, EFD_CLOEXEC);
}
priv->data = mmap (NULL, priv->fdsize, PROT_READ | PROT_WRITE, MAP_SHARED, priv->fd, 0);
spa_ringbuffer_init (&priv->data->rbuf, (guint8 *)priv->data + sizeof (PinosRingbufferData), priv->size);
G_OBJECT_CLASS (pinos_ringbuffer_parent_class)->constructed (obj);
}
static void
pinos_ringbuffer_dispose (GObject * obj)
{
PinosRingbuffer *rb = PINOS_RINGBUFFER (obj);
g_debug ("ringbuffer %p: dispose", rb);
G_OBJECT_CLASS (pinos_ringbuffer_parent_class)->dispose (obj);
}
static void
pinos_ringbuffer_finalize (GObject * obj)
{
PinosRingbuffer *rb = PINOS_RINGBUFFER (obj);
g_debug ("ringbuffer %p: finalize", rb);
G_OBJECT_CLASS (pinos_ringbuffer_parent_class)->finalize (obj);
}
static void
pinos_ringbuffer_class_init (PinosRingbufferClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (PinosRingbufferPrivate));
gobject_class->constructed = pinos_ringbuffer_constructed;
gobject_class->dispose = pinos_ringbuffer_dispose;
gobject_class->finalize = pinos_ringbuffer_finalize;
gobject_class->set_property = pinos_ringbuffer_set_property;
gobject_class->get_property = pinos_ringbuffer_get_property;
g_object_class_install_property (gobject_class,
PROP_MODE,
g_param_spec_enum ("mode",
"Mode",
"The mode of the ringbuffer",
PINOS_TYPE_RINGBUFFER_MODE,
PINOS_RINGBUFFER_MODE_READ,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_SIZE,
g_param_spec_uint ("size",
"Size",
"The size of the ringbuffer",
1,
G_MAXUINT,
64 * 1024,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_FD,
g_param_spec_int ("fd",
"Fd",
"The file descriptor with memory",
-1,
G_MAXINT,
-1,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_FDSIZE,
g_param_spec_uint ("fdsize",
"Fd Size",
"Size of the memory",
1,
G_MAXUINT,
-1,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_SEMAPHORE,
g_param_spec_int ("semaphore",
"Semaphore",
"Semaphore file desciptor",
-1,
G_MAXINT,
-1,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
}
static void
pinos_ringbuffer_init (PinosRingbuffer * rb)
{
PinosRingbufferPrivate *priv = rb->priv = PINOS_RINGBUFFER_GET_PRIVATE (rb);
g_debug ("ringbuffer %p: new %u", rb, priv->size);
priv->mode = PINOS_RINGBUFFER_MODE_READ;
priv->size = 0;
priv->fd = -1;
}
PinosRingbuffer *
pinos_ringbuffer_new (PinosRingbufferMode mode,
gsize size)
{
PinosRingbuffer *rb;
g_return_val_if_fail (size > 0, NULL);
rb = g_object_new (PINOS_TYPE_RINGBUFFER,
"size", size,
"mode", mode,
NULL);
return rb;
}
PinosRingbuffer *
pinos_ringbuffer_new_import (PinosRingbufferMode mode,
guint fdsize,
int fd,
int semaphore)
{
PinosRingbuffer *rb;
g_return_val_if_fail (fdsize > 0, NULL);
g_return_val_if_fail (fd >= 0, NULL);
rb = g_object_new (PINOS_TYPE_RINGBUFFER,
"mode", mode,
"fd", fd,
"fdsize", fdsize,
"semaphore", semaphore,
NULL);
return rb;
}
gboolean
pinos_ringbuffer_get_read_areas (PinosRingbuffer *rbuf,
PinosRingbufferArea areas[2])
{
PinosRingbufferPrivate *priv;
g_return_val_if_fail (PINOS_IS_RINGBUFFER (rbuf), FALSE);
priv = rbuf->priv;
spa_ringbuffer_get_read_areas (&priv->data->rbuf, (SpaRingbufferArea *)areas);
return TRUE;
}
gboolean
pinos_ringbuffer_get_write_areas (PinosRingbuffer *rbuf,
PinosRingbufferArea areas[2])
{
PinosRingbufferPrivate *priv;
g_return_val_if_fail (PINOS_IS_RINGBUFFER (rbuf), FALSE);
priv = rbuf->priv;
spa_ringbuffer_get_write_areas (&priv->data->rbuf, (SpaRingbufferArea *)areas);
return TRUE;
}
gboolean
pinos_ringbuffer_read_advance (PinosRingbuffer *rbuf,
gssize len)
{
PinosRingbufferPrivate *priv;
guint64 val;
g_return_val_if_fail (PINOS_IS_RINGBUFFER (rbuf), FALSE);
priv = rbuf->priv;
spa_ringbuffer_read_advance (&priv->data->rbuf, len);
if (priv->mode == PINOS_RINGBUFFER_MODE_READ) {
val = 1;
write (priv->semaphore, &val, 8);
}
return TRUE;
}
gboolean
pinos_ringbuffer_write_advance (PinosRingbuffer *rbuf,
gssize len)
{
PinosRingbufferPrivate *priv;
guint64 val;
g_return_val_if_fail (PINOS_IS_RINGBUFFER (rbuf), FALSE);
priv = rbuf->priv;
spa_ringbuffer_write_advance (&priv->data->rbuf, len);
if (priv->mode == PINOS_RINGBUFFER_MODE_WRITE) {
val = 1;
write (priv->semaphore, &val, 8);
}
return TRUE;
}

97
pinos/client/ringbuffer.h Normal file
View file

@ -0,0 +1,97 @@
/* 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_RINGBUFFER_H__
#define __PINOS_RINGBUFFER_H__
#include <glib-object.h>
G_BEGIN_DECLS
typedef struct _PinosRingbuffer PinosRingbuffer;
typedef struct _PinosRingbufferClass PinosRingbufferClass;
typedef struct _PinosRingbufferPrivate PinosRingbufferPrivate;
#include <pinos/client/introspect.h>
#include <pinos/client/buffer.h>
#define PINOS_TYPE_RINGBUFFER (pinos_ringbuffer_get_type ())
#define PINOS_IS_RINGBUFFER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PINOS_TYPE_RINGBUFFER))
#define PINOS_IS_RINGBUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PINOS_TYPE_RINGBUFFER))
#define PINOS_RINGBUFFER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PINOS_TYPE_RINGBUFFER, PinosRingbufferClass))
#define PINOS_RINGBUFFER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PINOS_TYPE_RINGBUFFER, PinosRingbuffer))
#define PINOS_RINGBUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PINOS_TYPE_RINGBUFFER, PinosRingbufferClass))
#define PINOS_RINGBUFFER_CAST(obj) ((PinosRingbuffer*)(obj))
#define PINOS_RINGBUFFER_CLASS_CAST(klass) ((PinosRingbufferClass*)(klass))
/**
* PinosRingbuffer:
*
* Pinos ringbuffer object class.
*/
struct _PinosRingbuffer {
GObject object;
PinosRingbufferPrivate *priv;
};
/**
* PinosRingbufferClass:
*
* Pinos ringbuffer object class.
*/
struct _PinosRingbufferClass {
GObjectClass parent_class;
};
typedef void (*PinosRingbufferCallback) (PinosRingbuffer *rb, gpointer user_data);
typedef enum {
PINOS_RINGBUFFER_MODE_READ,
PINOS_RINGBUFFER_MODE_WRITE,
} PinosRingbufferMode;
typedef struct {
gpointer data;
gsize len;
} PinosRingbufferArea;
/* normal GObject stuff */
GType pinos_ringbuffer_get_type (void);
PinosRingbuffer * pinos_ringbuffer_new (PinosRingbufferMode mode,
gsize size);
PinosRingbuffer * pinos_ringbuffer_new_import (PinosRingbufferMode mode,
guint fdsize,
int fd,
int semaphore);
gboolean pinos_ringbuffer_get_read_areas (PinosRingbuffer *rbuf,
PinosRingbufferArea areas[2]);
gboolean pinos_ringbuffer_read_advance (PinosRingbuffer *rbuf,
gssize len);
gboolean pinos_ringbuffer_get_write_areas (PinosRingbuffer *rbuf,
PinosRingbufferArea areas[2]);
gboolean pinos_ringbuffer_write_advance (PinosRingbuffer *rbuf,
gssize len);
G_END_DECLS
#endif /* __PINOS_RINGBUFFER_H__ */

33
pinos/client/stream.c
View file

@ -851,6 +851,38 @@ pinos_stream_connect (PinosStream *stream,
return TRUE;
}
static void
on_ringbuffer (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
PinosStream *stream = user_data;
PinosStreamPrivate *priv = stream->priv;
GError *error = NULL;
g_assert (priv->port == PINOS_PORT (source_object));
priv->ringbuffer = pinos_port_get_ringbuffer_finish (priv->port,
res,
&error);
if (priv->ringbuffer == NULL)
goto no_ringbuffer;
stream_set_state (stream, PINOS_STREAM_STATE_STREAMING, NULL);
g_object_unref (stream);
return;
/* ERRORS */
no_ringbuffer:
{
g_warning ("failed to get ringbuffer: %s", error->message);
stream_set_state (stream, PINOS_STREAM_STATE_ERROR, error);
g_object_unref (stream);
return;
}
}
static gboolean
do_start (PinosStream *stream)
{
@ -1110,7 +1142,6 @@ pinos_stream_send_buffer (PinosStream *stream,
g_return_val_if_fail (buffer != NULL, FALSE);
priv = stream->priv;
g_return_val_if_fail (priv->state == PINOS_STREAM_STATE_STREAMING, FALSE);
if (!pinos_io_write_buffer (priv->fd, buffer, &error)) {
g_warning ("stream %p: failed to read buffer: %s", stream, error->message);