system/pipewire
system/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire synced 2024-09-06 00:40:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Cleanups

Browse source 
Remove old code
Only depend on GStreamer for the plugins
Rename STOP to PAUSE because that's what it really does
Start working on format_fixate.
Remove default property value from props
Fix framerate
This commit is contained in:
Wim Taymans 2016-08-25 14:10:38 +02:00
parent da5fb808e7
commit fbd6304663
43 changed files with 97 additions and 3631 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
pinos/Makefile.am
View file

@ -161,8 +161,6 @@ pinos_monitor_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
# Client library #
###################################
pinosgstsource = gst/gsttmpfileallocator.h gst/gsttmpfileallocator.c
pinosinclude_HEADERS = \
client/context.h \
client/enumtypes.h \
@ -189,13 +187,11 @@ libpinos_@PINOS_MAJORMINOR@_la_SOURCES = \
client/pinos.c client/pinos.h \
client/fdmanager.c client/fdmanager.h \
client/ringbuffer.c client/ringbuffer.h \
client/subscribe.c client/subscribe.h \
$(pinosgstsource)
client/subscribe.c client/subscribe.h
libpinos_@PINOS_MAJORMINOR@_la_CFLAGS = $(AM_CFLAGS) $(GST_CFLAGS)
libpinos_@PINOS_MAJORMINOR@_la_CFLAGS = $(AM_CFLAGS)
libpinos_@PINOS_MAJORMINOR@_la_LDFLAGS = $(AM_LDFLAGS) -avoid-version
libpinos_@PINOS_MAJORMINOR@_la_LIBADD = $(AM_LIBADD) $(LTLIBICONV) $(GST_LIBS) $(GST_BASE_LIBS) -lgstvideo-1.0 -lgstaudio-1.0
libpinos_@PINOS_MAJORMINOR@_la_LIBADD = $(AM_LIBADD) $(LTLIBICONV)
###################################
# Daemon core library #
@ -241,24 +237,16 @@ libgstpinos_la_SOURCES = \
gst/gstpinossrc.c \
gst/gstpinossink.c \
gst/gstpinospool.c
#gst/gstpinosdepay.c
#gst/gstpinosportsrc.c
#gst/gstpinosportsink.c
#gst/gstpinossocketsink.c
#gst/gstpinospay.c
libgstpinos_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS) $(GST_CFLAGS) $(GLIB_CFLAGS)
libgstpinos_la_LDFLAGS = $(AM_LDFLAGS) $(GST_PLUGIN_LDFLAGS)
libgstpinos_la_LIBADD = $(GST_BASE_LIBS) $(GST_LIBS) $(GLIB_LIBS) $(LIBM) -lgstvideo-1.0 \
libgstpinos_la_LIBADD = $(GST_BASE_LIBS) $(GST_LIBS) $(GLIB_LIBS) $(LIBM) -lgstvideo-1.0 -lgstaudio-1.0 \
libpinos-@PINOS_MAJORMINOR@.la libpinoscore-@PINOS_MAJORMINOR@.la $(AM_LIBADD)
libgstpinos_la_LIBTOOLFLAGS = $(GST_PLUGIN_LIBTOOLFLAGS)
noinst_HEADERS = gst/gstburstcache.h gst/gstpinossrc.h \
gst/gstpinossocketsink.h gst/gstpinosportsink.h \
gst/gstpinosportsrc.h \
gst/gstpinosformat.h \
gst/gstpinossink.h gst/gstpinospay.h \
gst/gstpinosdepay.h gst/gstpinosdeviceprovider.h
gst/gstpinossink.h gst/gstpinosdeviceprovider.h
###################################
# Some minor stuff #

3
pinos/client/pinos.c
View file

@ -17,7 +17,7 @@
* Boston, MA 02110-1301, USA.
*/
#include <gst/gst.h>
#include <glib.h>
#include "pinos/client/pinos.h"
#include "spa/include/spa/memory.h"
@ -33,7 +33,6 @@
void
pinos_init (int *argc, char **argv[])
{
gst_init (argc, argv);
spa_memory_init ();
}

4
pinos/client/stream.c
View file

@ -769,7 +769,7 @@ parse_control (PinosStream *stream,
stream_set_state (stream, PINOS_STREAM_STATE_STREAMING, NULL);
break;
}
case SPA_CONTROL_CMD_STOP:
case SPA_CONTROL_CMD_PAUSE:
{
SpaControlBuilder builder;
SpaControl control;
@ -1292,7 +1292,7 @@ do_stop (PinosStream *stream)
SpaControlBuilder builder;
control_builder_init (stream, &builder);
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_STOP, NULL);
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_PAUSE, NULL);
g_object_unref (stream);
return FALSE;

15
pinos/gst/gstpinos.c
View file

@ -32,14 +32,9 @@
#include "config.h"
#endif
//#include "gstpinossocketsink.h"
#include "gstpinosportsink.h"
#include "gstpinosportsrc.h"
#include "gstpinossrc.h"
#include "gstpinossink.h"
#include "gstpinosdeviceprovider.h"
#include "gstpinospay.h"
#include "gstpinosdepay.h"
GST_DEBUG_CATEGORY (pinos_debug);
@ -48,20 +43,10 @@ plugin_init (GstPlugin * plugin)
{
pinos_init (NULL, NULL);
// gst_element_register (plugin, "pinospay", GST_RANK_NONE,
// GST_TYPE_PINOS_PAY);
// gst_element_register (plugin, "pinosdepay", GST_RANK_NONE,
// GST_TYPE_PINOS_DEPAY);
gst_element_register (plugin, "pinossrc", GST_RANK_PRIMARY + 1,
GST_TYPE_PINOS_SRC);
gst_element_register (plugin, "pinossink", GST_RANK_NONE,
GST_TYPE_PINOS_SINK);
// gst_element_register (plugin, "pinossocketsink", GST_RANK_NONE,
// GST_TYPE_PINOS_SOCKET_SINK);
// gst_element_register (plugin, "pinosportsink", GST_RANK_NONE,
// GST_TYPE_PINOS_PORT_SINK);
// gst_element_register (plugin, "pinosportsrc", GST_RANK_NONE,
// GST_TYPE_PINOS_PORT_SRC);
if (!gst_device_provider_register (plugin, "pinosdeviceprovider",
GST_RANK_PRIMARY + 1, GST_TYPE_PINOS_DEVICE_PROVIDER))

409
pinos/gst/gstpinosdepay.c
View file

@ -1,409 +0,0 @@
/* GStreamer
* Copyright (C) 2014 William Manley <will@williammanley.net>
* (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 Street, Suite 500,
* Boston, MA 02110-1335, USA.
*/
/**
* SECTION:element-gstpinosdepay
*
* The pinosdepay element does FIXME stuff.
*
* <refsect2>
* <title>Example launch line</title>
* |[
* gst-launch -v fakesrc ! pinosdepay ! FIXME ! fakesink
* ]|
* FIXME Describe what the pipeline does.
* </refsect2>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstpinosdepay.h"
#include <gst/net/gstnetcontrolmessagemeta.h>
#include <gst/gst.h>
#include <gst/base/gstbasetransform.h>
#include <gst/allocators/gstfdmemory.h>
#include <gio/gunixfdmessage.h>
#include <fcntl.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
#include <client/pinos.h>
GST_DEBUG_CATEGORY_STATIC (gst_pinos_depay_debug_category);
#define GST_CAT_DEFAULT gst_pinos_depay_debug_category
static GQuark fdids_quark;
enum
{
PROP_0,
PROP_CAPS,
};
/* pad templates */
static GstStaticPadTemplate gst_pinos_depay_src_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY);
static GstStaticPadTemplate gst_pinos_depay_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("application/x-pinos"));
/* class initialization */
G_DEFINE_TYPE (GstPinosDepay, gst_pinos_depay, GST_TYPE_ELEMENT);
static gboolean
gst_pinos_depay_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
GstPinosDepay *depay = GST_PINOS_DEPAY (parent);
gboolean res = FALSE;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEGMENT:
{
GstSegment segment;
gst_segment_init (&segment, GST_FORMAT_TIME);
res = gst_pad_push_event (depay->srcpad, gst_event_new_segment (&segment));
break;
}
case GST_EVENT_CAPS:
{
GstCaps *caps;
GstStructure *str;
gst_event_parse_caps (event, &caps);
str = gst_caps_get_structure (caps, 0);
depay->pinos_input = gst_structure_has_name (str, "application/x-pinos");
gst_event_unref (event);
res = gst_pad_push_event (depay->srcpad, gst_event_new_caps (depay->caps));
break;
}
default:
res = gst_pad_event_default (pad, parent, event);
break;
}
return res;
}
static void
reuse_fds (GstPinosDepay *this, GstBuffer *buffer)
{
GArray *fdids;
guint i;
PinosBufferBuilder b;
PinosPacketReuseMem r;
PinosBuffer pbuf;
gsize size;
gpointer data;
GstBuffer *outbuf;
GstEvent *ev;
fdids = gst_mini_object_steal_qdata (GST_MINI_OBJECT_CAST (buffer),
fdids_quark);
if (fdids == NULL)
return;
pinos_buffer_builder_init (&b);
for (i = 0; i < fdids->len; i++) {
r.id = g_array_index (fdids, guint32, i);
GST_LOG ("reuse mem id %d", r.id);
pinos_buffer_builder_add_reuse_mem (&b, &r);
}
pinos_buffer_builder_end (&b, &pbuf);
g_array_unref (fdids);
data = pinos_buffer_steal_data (&pbuf, &size);
outbuf = gst_buffer_new_wrapped (data, size);
ev = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM,
gst_structure_new ("GstNetworkMessage",
"object", G_TYPE_OBJECT, this,
"buffer", GST_TYPE_BUFFER, outbuf, NULL));
gst_buffer_unref (outbuf);
gst_pad_push_event (this->sinkpad, ev);
g_object_unref (this);
}
static GstFlowReturn
gst_pinos_depay_chain (GstPad *pad, GstObject * parent, GstBuffer * buffer)
{
GstPinosDepay *depay = GST_PINOS_DEPAY (parent);
GstBuffer *outbuf = NULL;
GstMapInfo info;
PinosBuffer pbuf;
PinosBufferIter it;
GstNetControlMessageMeta * meta;
GError *err = NULL;
GArray *fdids = NULL;
GUnixFDList *fds = NULL;
meta = ((GstNetControlMessageMeta*) gst_buffer_get_meta (
buffer, GST_NET_CONTROL_MESSAGE_META_API_TYPE));
if (meta) {
if (G_IS_UNIX_FD_MESSAGE (meta->message)) {
fds = g_unix_fd_message_get_fd_list (G_UNIX_FD_MESSAGE (meta->message));
}
}
gst_buffer_map (buffer, &info, GST_MAP_READ);
pinos_buffer_init_data (&pbuf, info.data, info.size, NULL, 0);
pinos_buffer_iter_init (&it, &pbuf);
while (pinos_buffer_iter_next (&it)) {
switch (pinos_buffer_iter_get_type (&it)) {
case PINOS_PACKET_TYPE_HEADER:
{
PinosPacketHeader hdr;
if (!pinos_buffer_iter_parse_header (&it, &hdr))
goto error;
if (outbuf == NULL)
outbuf = gst_buffer_new ();
GST_INFO ("pts %" G_GUINT64_FORMAT ", dts_offset %"G_GUINT64_FORMAT, hdr.pts, hdr.dts_offset);
#if 0
if (GST_CLOCK_TIME_IS_VALID (hdr.pts)) {
GST_BUFFER_PTS (outbuf) = hdr.pts;
if (GST_BUFFER_PTS (outbuf) + hdr.dts_offset > 0)
GST_BUFFER_DTS (outbuf) = GST_BUFFER_PTS (outbuf) + hdr.dts_offset;
}
#endif
GST_BUFFER_OFFSET (outbuf) = hdr.seq;
break;
}
case PINOS_PACKET_TYPE_ADD_MEM:
{
GstMemory *fdmem = NULL;
PinosPacketAddMem p;
int fd;
if (!pinos_buffer_iter_parse_add_mem (&it, &p))
goto error;
fd = g_unix_fd_list_get (fds, p.fd_index, &err);
if (fd == -1)
goto error;
fdmem = gst_fd_allocator_alloc (depay->fd_allocator, fd,
p.offset + p.size, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (fdmem, p.offset, p.size);
g_hash_table_insert (depay->mem_ids, GINT_TO_POINTER (p.id), fdmem);
break;
}
case PINOS_PACKET_TYPE_REMOVE_MEM:
{
PinosPacketRemoveMem p;
if (!pinos_buffer_iter_parse_remove_mem (&it, &p))
goto error;
g_hash_table_remove (depay->mem_ids, GINT_TO_POINTER (p.id));
break;
}
case PINOS_PACKET_TYPE_PROCESS_MEM:
{
GstMemory *fdmem = NULL;
PinosPacketProcessMem p;
if (!pinos_buffer_iter_parse_process_mem (&it, &p))
goto error;
fdmem = g_hash_table_lookup (depay->mem_ids, GINT_TO_POINTER (p.id));
if (fdmem == NULL)
goto error;
if (outbuf == NULL)
outbuf = gst_buffer_new ();
fdmem = gst_memory_share (fdmem, p.offset, p.size);
gst_buffer_append_memory (outbuf, fdmem);
if (fdids == NULL)
fdids = g_array_new (FALSE, FALSE, sizeof (guint32));
GST_LOG ("track fd index %d", p.id);
g_array_append_val (fdids, p.id);
break;
}
case PINOS_PACKET_TYPE_FORMAT_CHANGE:
{
PinosPacketFormatChange change;
GstCaps *caps;
if (!pinos_buffer_iter_parse_format_change (&it, &change))
goto error;
GST_DEBUG ("got format change %d %s", change.id, change.format);
caps = gst_caps_from_string (change.format);
if (caps) {
gst_caps_take (&depay->caps, caps);
gst_pad_push_event (depay->srcpad, gst_event_new_caps (depay->caps));
}
break;
}
default:
break;
}
}
pinos_buffer_iter_init (&it, &pbuf);
pinos_buffer_unref (&pbuf);
gst_buffer_unmap (buffer, &info);
gst_buffer_unref (buffer);
if (outbuf) {
if (fdids != NULL) {
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (outbuf),
fdids_quark, fdids, NULL);
gst_mini_object_weak_ref (GST_MINI_OBJECT_CAST (outbuf),
(GstMiniObjectNotify) reuse_fds, g_object_ref (depay));
}
return gst_pad_push (depay->srcpad, outbuf);
}
else
return GST_FLOW_OK;
error:
{
GST_ELEMENT_ERROR (depay, RESOURCE, SETTINGS, (NULL),
("can't get fd: %s", err->message));
g_clear_error (&err);
gst_buffer_unref (outbuf);
return GST_FLOW_ERROR;
}
}
static void
gst_pinos_depay_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstPinosDepay *depay = GST_PINOS_DEPAY (object);
switch (prop_id) {
case PROP_CAPS:
{
const GstCaps *caps;
caps = gst_value_get_caps (value);
gst_caps_replace (&depay->caps, (GstCaps *)caps);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_pinos_depay_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstPinosDepay *depay = GST_PINOS_DEPAY (object);
switch (prop_id) {
case PROP_CAPS:
gst_value_set_caps (value, depay->caps);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_pinos_depay_finalize (GObject * object)
{
GstPinosDepay *depay = GST_PINOS_DEPAY (object);
GST_DEBUG_OBJECT (depay, "finalize");
gst_caps_replace (&depay->caps, NULL);
g_object_unref (depay->fd_allocator);
g_hash_table_unref (depay->mem_ids);
G_OBJECT_CLASS (gst_pinos_depay_parent_class)->finalize (object);
}
static void
gst_pinos_depay_class_init (GstPinosDepayClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class =
GST_ELEMENT_CLASS (klass);
gobject_class->finalize = gst_pinos_depay_finalize;
gobject_class->set_property = gst_pinos_depay_set_property;
gobject_class->get_property = gst_pinos_depay_get_property;
g_object_class_install_property (gobject_class, PROP_CAPS,
g_param_spec_boxed ("caps", "Caps",
"The caps of the source pad", GST_TYPE_CAPS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/* Setting up pads and setting metadata should be moved to
base_class_init if you intend to subclass this class. */
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_pinos_depay_src_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_pinos_depay_sink_template));
gst_element_class_set_static_metadata (element_class,
"Pinos Deplayloder", "Generic",
"Pinos Depayloader for zero-copy IPC via Pinos",
"Wim Taymans <wim.taymans@gmail.com>");
GST_DEBUG_CATEGORY_INIT (gst_pinos_depay_debug_category, "pinosdepay", 0,
"debug category for pinosdepay element");
fdids_quark = g_quark_from_static_string ("GstPinosDepayFDIds");
}
static void
gst_pinos_depay_init (GstPinosDepay * depay)
{
depay->srcpad = gst_pad_new_from_static_template (&gst_pinos_depay_src_template, "src");
gst_element_add_pad (GST_ELEMENT (depay), depay->srcpad);
depay->sinkpad = gst_pad_new_from_static_template (&gst_pinos_depay_sink_template, "sink");
gst_pad_set_chain_function (depay->sinkpad, gst_pinos_depay_chain);
gst_pad_set_event_function (depay->sinkpad, gst_pinos_depay_sink_event);
gst_element_add_pad (GST_ELEMENT (depay), depay->sinkpad);
depay->fd_allocator = gst_fd_allocator_new ();
depay->mem_ids = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) gst_memory_unref);
}

58
pinos/gst/gstpinosdepay.h
View file

@ -1,58 +0,0 @@
/* GStreamer
* Copyright (C) 2014 William Manley <will@williammanley.net>
* 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 _GST_PINOS_DEPAY_H_
#define _GST_PINOS_DEPAY_H_
#include <gst/gst.h>
G_BEGIN_DECLS
#define GST_TYPE_PINOS_DEPAY (gst_pinos_depay_get_type())
#define GST_PINOS_DEPAY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PINOS_DEPAY,GstPinosDepay))
#define GST_PINOS_DEPAY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PINOS_DEPAY,GstPinosDepayClass))
#define GST_IS_PINOS_DEPAY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PINOS_DEPAY))
#define GST_IS_PINOS_DEPAY_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PINOS_DEPAY))
typedef struct _GstPinosDepay GstPinosDepay;
typedef struct _GstPinosDepayClass GstPinosDepayClass;
struct _GstPinosDepay
{
GstElement parent;
GstCaps *caps;
gboolean pinos_input;
GstPad *srcpad, *sinkpad;
GstAllocator *fd_allocator;
GHashTable *mem_ids;
};
struct _GstPinosDepayClass
{
GstElementClass parent_class;
};
GType gst_pinos_depay_get_type (void);
G_END_DECLS
#endif

615
pinos/gst/gstpinospay.c
View file

@ -1,615 +0,0 @@
/* GStreamer
* Copyright (C) 2014 William Manley <will@williammanley.net>
*
* 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 Street, Suite 500,
* Boston, MA 02110-1335, USA.
*/
/**
* SECTION:element-gstpinospay
*
* The pinospay element converts regular GStreamer buffers into the format
* expected by Pinos.
*
* <refsect2>
* <title>Example launch line</title>
* |[
* gst-launch-1.0 -v videotestsrc ! video/x-raw,format=RGB,width=1920,height=1080 \
* ! pinospay ! fdsink fd=1 \
* | gst-launch-1.0 fdsrc fd=0 ! fddepay \
* ! video/x-raw,format=RGB,width=1920,height=1080 ! autovideosink
* ]|
* Video frames are created in the first gst-launch-1.0 process and displayed
* by the second with no copying.
* </refsect2>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gst/gst.h>
#include <gst/allocators/gstfdmemory.h>
#include <gst/base/gstbasetransform.h>
#include "gstpinospay.h"
#include "gsttmpfileallocator.h"
#include <gst/net/gstnetcontrolmessagemeta.h>
#include <gst/video/video.h>
#include <gio/gunixfdmessage.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
GST_DEBUG_CATEGORY_STATIC (gst_pinos_pay_debug_category);
#define GST_CAT_DEFAULT gst_pinos_pay_debug_category
static GQuark fdids_quark;
static GQuark orig_buffer_quark;
/* prototypes */
/* pad templates */
static GstStaticPadTemplate gst_pinos_pay_src_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("application/x-pinos"));
static GstStaticPadTemplate gst_pinos_pay_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY);
/* class initialization */
G_DEFINE_TYPE_WITH_CODE (GstPinosPay, gst_pinos_pay, GST_TYPE_ELEMENT,
GST_DEBUG_CATEGORY_INIT (gst_pinos_pay_debug_category, "pinospay", 0,
"debug category for pinospay element"));
/* propose allocation query parameters for input buffers */
static gboolean
gst_pinos_pay_query (GstPad * pad, GstObject * parent, GstQuery * query)
{
GstPinosPay *pay = GST_PINOS_PAY (parent);
gboolean res = FALSE;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_ALLOCATION:
{
GST_DEBUG_OBJECT (pay, "propose_allocation");
gst_query_add_allocation_param (query, pay->allocator, NULL);
res = TRUE;
break;
}
default:
res = gst_pad_query_default (pad, parent, query);
break;
}
return res;
}
static gboolean
do_allocation (GstPinosPay *pay, GstCaps *caps)
{
GstQuery *query;
GST_DEBUG_OBJECT (pay, "doing allocation query");
query = gst_query_new_allocation (caps, TRUE);
if (!gst_pad_peer_query (pay->srcpad, query)) {
/* not a problem, just debug a little */
GST_DEBUG_OBJECT (pay, "peer ALLOCATION query failed");
}
if (!gst_query_find_allocation_meta (query,
GST_NET_CONTROL_MESSAGE_META_API_TYPE, NULL))
goto no_meta;
gst_query_unref (query);
return TRUE;
/* ERRORS */
no_meta:
{
GST_ELEMENT_ERROR (pay, STREAM, FORMAT,
("Incompatible downstream element"),
("The downstream element does not handle control-message metadata API"));
gst_query_unref (query);
return FALSE;
}
}
static gboolean
gst_pinos_pay_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
GstPinosPay *pay = GST_PINOS_PAY (parent);
gboolean res = FALSE;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CAPS:
{
GstCaps *caps;
GstStructure *str;
gst_event_parse_caps (event, &caps);
str = gst_caps_get_structure (caps, 0);
pay->pinos_input = gst_structure_has_name (str, "application/x-pinos");
gst_event_unref (event);
caps = gst_caps_new_empty_simple ("application/x-pinos");
res = gst_pad_push_event (pay->srcpad, gst_event_new_caps (caps));
gst_caps_unref (caps);
if (res)
/* now negotiate the allocation */
res = do_allocation (pay, caps);
break;
}
default:
res = gst_pad_event_default (pad, parent, event);
break;
}
return res;
}
static void
client_buffer_sent (GstPinosPay *pay, GstBuffer *buffer,
GObject *obj)
{
GArray *fdids;
guint i;
const gchar *client_path;
fdids = gst_mini_object_get_qdata (GST_MINI_OBJECT_CAST (buffer), fdids_quark);
if (fdids == NULL)
return;
/* get the client path of this socket */
client_path = g_object_get_data (obj, "pinos-client-path");
if (client_path == NULL)
return;
for (i = 0; i < fdids->len; i++) {
gint id = g_array_index (fdids, guint32, i);
/* now store the id/client-path/buffer in the fdmanager */
GST_LOG ("fd index %d, client %s increment refcount of buffer %p", id, client_path, buffer);
pinos_fd_manager_add (pay->fdmanager,
client_path, id,
gst_buffer_ref (buffer),
(GDestroyNotify) gst_buffer_unref);
}
}
static void
client_buffer_received (GstPinosPay *pay, GstBuffer *buffer,
GObject *obj)
{
PinosBuffer pbuf;
PinosBufferIter it;
PinosBufferBuilder b;
GstMapInfo info;
const gchar *client_path;
gboolean have_out = FALSE;
client_path = g_object_get_data (obj, "pinos-client-path");
if (client_path == NULL)
return;
if (pay->pinos_input) {
pinos_buffer_builder_init (&b);
}
gst_buffer_map (buffer, &info, GST_MAP_READ);
pinos_buffer_init_data (&pbuf, info.data, info.size, NULL, 0);
pinos_buffer_iter_init (&it, &pbuf);
while (pinos_buffer_iter_next (&it)) {
switch (pinos_buffer_iter_get_type (&it)) {
case PINOS_PACKET_TYPE_REUSE_MEM:
{
PinosPacketReuseMem p;
gint id;
if (!pinos_buffer_iter_parse_reuse_mem (&it, &p))
continue;
id = p.id;
GST_LOG ("fd index %d for client %s is reused", id, client_path);
pinos_fd_manager_remove (pay->fdmanager, client_path, id);
break;
}
case PINOS_PACKET_TYPE_REFRESH_REQUEST:
{
PinosPacketRefreshRequest p;
if (!pinos_buffer_iter_parse_refresh_request (&it, &p))
continue;
GST_LOG ("refresh request");
if (!pay->pinos_input) {
gst_pad_push_event (pay->sinkpad,
gst_video_event_new_upstream_force_key_unit (p.pts,
p.request_type == 1, 0));
} else {
pinos_buffer_builder_add_refresh_request (&b, &p);
have_out = TRUE;
}
break;
}
default:
break;
}
}
pinos_buffer_iter_end (&it);
pinos_buffer_unref (&pbuf);
gst_buffer_unmap (buffer, &info);
if (pay->pinos_input) {
GstBuffer *outbuf;
GstEvent *ev;
gsize size;
gpointer data;
if (have_out) {
pinos_buffer_builder_end (&b, &pbuf);
data = pinos_buffer_steal_data (&pbuf, &size);
outbuf = gst_buffer_new_wrapped (data, size);
ev = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM,
gst_structure_new ("GstNetworkMessage",
"object", G_TYPE_OBJECT, pay,
"buffer", GST_TYPE_BUFFER, outbuf, NULL));
gst_buffer_unref (outbuf);
gst_pad_push_event (pay->sinkpad, ev);
} else {
pinos_buffer_builder_clear (&b);
}
}
}
static gboolean
gst_pinos_pay_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
GstPinosPay *pay = GST_PINOS_PAY (parent);
gboolean res = FALSE;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CUSTOM_UPSTREAM:
{
if (gst_event_has_name (event, "GstNetworkMessageDispatched")) {
const GstStructure *str = gst_event_get_structure (event);
GstBuffer *buf;
GObject *obj;
gst_structure_get (str, "object", G_TYPE_OBJECT, &obj,
"buffer", GST_TYPE_BUFFER, &buf, NULL);
client_buffer_sent (pay, buf, obj);
gst_buffer_unref (buf);
g_object_unref (obj);
}
else if (gst_event_has_name (event, "GstNetworkMessage")) {
const GstStructure *str = gst_event_get_structure (event);
GstBuffer *buf;
GObject *obj;
gst_structure_get (str, "object", G_TYPE_OBJECT, &obj,
"buffer", GST_TYPE_BUFFER, &buf, NULL);
client_buffer_received (pay, buf, obj);
gst_buffer_unref (buf);
g_object_unref (obj);
}
res = TRUE;
gst_event_unref (event);
break;
}
default:
res = gst_pad_event_default (pad, parent, event);
break;
}
return res;
}
static GstMemory *
gst_pinos_pay_get_fd_memory (GstPinosPay * tmpfilepay, GstBuffer * buffer, gboolean *tmpfile)
{
GstMemory *mem = NULL;
if (gst_buffer_n_memory (buffer) == 1
&& gst_is_fd_memory (gst_buffer_peek_memory (buffer, 0))) {
mem = gst_buffer_get_memory (buffer, 0);
*tmpfile = gst_is_tmpfile_memory (mem);
} else {
GstMapInfo info;
GstAllocationParams params = {0, 0, 0, 0, { NULL, }};
gsize size = gst_buffer_get_size (buffer);
GST_INFO_OBJECT (tmpfilepay, "Buffer cannot be payloaded without copying");
mem = gst_allocator_alloc (tmpfilepay->allocator, size, &params);
if (!gst_memory_map (mem, &info, GST_MAP_WRITE))
return NULL;
gst_buffer_extract (buffer, 0, info.data, size);
gst_memory_unmap (mem, &info);
*tmpfile = TRUE;
}
return mem;
}
static void
release_fds (GstPinosPay *pay, GstBuffer *buffer)
{
GArray *fdids;
guint i;
PinosBufferBuilder b;
PinosPacketReuseMem r;
PinosBuffer pbuf;
gsize size;
gpointer data;
GstBuffer *outbuf;
GstEvent *ev;
fdids = gst_mini_object_steal_qdata (GST_MINI_OBJECT_CAST (buffer),
fdids_quark);
if (fdids == NULL)
return;
pinos_buffer_builder_init (&b);
for (i = 0; i < fdids->len; i++) {
r.id = g_array_index (fdids, guint32, i);
GST_LOG ("release fd index %d", r.id);
pinos_buffer_builder_add_reuse_mem (&b, &r);
}
pinos_buffer_builder_end (&b, &pbuf);
g_array_unref (fdids);
data = pinos_buffer_steal_data (&pbuf, &size);
outbuf = gst_buffer_new_wrapped (data, size);
ev = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM,
gst_structure_new ("GstNetworkMessage",
"object", G_TYPE_OBJECT, pay,
"buffer", GST_TYPE_BUFFER, outbuf, NULL));
gst_buffer_unref (outbuf);
gst_pad_push_event (pay->sinkpad, ev);
g_object_unref (pay);
}
static GstFlowReturn
gst_pinos_pay_chain_pinos (GstPinosPay *pay, GstBuffer * buffer)
{
GstMapInfo info;
PinosBuffer pbuf;
PinosBufferIter it;
GArray *fdids = NULL;
gst_buffer_map (buffer, &info, GST_MAP_READ);
pinos_buffer_init_data (&pbuf, info.data, info.size, NULL, 0);
pinos_buffer_iter_init (&it, &pbuf);
while (pinos_buffer_iter_next (&it)) {
switch (pinos_buffer_iter_get_type (&it)) {
case PINOS_PACKET_TYPE_PROCESS_MEM:
{
PinosPacketProcessMem p;
if (!pinos_buffer_iter_parse_process_mem (&it, &p))
continue;
if (fdids == NULL)
fdids = g_array_new (FALSE, FALSE, sizeof (guint32));
GST_LOG ("track fd index %d", p.id);
g_array_append_val (fdids, p.id);
break;
}
case PINOS_PACKET_TYPE_FORMAT_CHANGE:
{
PinosPacketFormatChange p;
GstCaps * caps;
if (!pinos_buffer_iter_parse_format_change (&it, &p))
continue;
caps = gst_caps_from_string (p.format);
gst_element_post_message (GST_ELEMENT (pay),
gst_message_new_element (GST_OBJECT (pay),
gst_structure_new ("PinosPayloaderFormatChange",
"format", GST_TYPE_CAPS, caps, NULL)));
gst_caps_unref (caps);
break;
}
default:
break;
}
}
pinos_buffer_iter_end (&it);
pinos_buffer_unref (&pbuf);
gst_buffer_unmap (buffer, &info);
if (fdids != NULL) {
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (buffer),
fdids_quark, fdids, NULL);
gst_mini_object_weak_ref (GST_MINI_OBJECT_CAST (buffer),
(GstMiniObjectNotify) release_fds, g_object_ref (pay));
}
return gst_pad_push (pay->srcpad, buffer);
}
static GstFlowReturn
gst_pinos_pay_chain_other (GstPinosPay *pay, GstBuffer * buffer)
{
GstMemory *fdmem = NULL;
GError *err = NULL;
GstBuffer *outbuf;
PinosBuffer pbuf;
PinosBufferBuilder builder;
PinosPacketHeader hdr;
PinosPacketAddMem am;
PinosPacketProcessMem p;
PinosPacketRemoveMem rm;
gsize size;
gpointer data;
GSocketControlMessage *msg;
gboolean tmpfile = TRUE;
gint *fds, n_fds, i;
hdr.flags = 0;
hdr.seq = GST_BUFFER_OFFSET (buffer);
hdr.pts = GST_BUFFER_PTS (buffer) + GST_ELEMENT_CAST (pay)->base_time;
hdr.dts_offset = 0;
pinos_buffer_builder_init (&builder);
pinos_buffer_builder_add_header (&builder, &hdr);
msg = g_unix_fd_message_new ();
fdmem = gst_pinos_pay_get_fd_memory (pay, buffer, &tmpfile);
am.id = pinos_fd_manager_get_id (pay->fdmanager);
am.fd_index = pinos_buffer_builder_add_fd (&builder, gst_fd_memory_get_fd (fdmem));
am.offset = 0;
am.size = fdmem->size;
p.id = am.id;
p.offset = fdmem->offset;
p.size = fdmem->size;
rm.id = am.id;
pinos_buffer_builder_add_add_mem (&builder, &am);
pinos_buffer_builder_add_process_mem (&builder, &p);
pinos_buffer_builder_add_remove_mem (&builder, &rm);
pinos_buffer_builder_end (&builder, &pbuf);
data = pinos_buffer_steal_data (&pbuf, &size);
fds = pinos_buffer_steal_fds (&pbuf, &n_fds);
pinos_buffer_unref (&pbuf);
outbuf = gst_buffer_new_wrapped (data, size);
GST_BUFFER_PTS (outbuf) = GST_BUFFER_PTS (buffer);
GST_BUFFER_DTS (outbuf) = GST_BUFFER_DTS (buffer);
GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buffer);
GST_BUFFER_OFFSET (outbuf) = GST_BUFFER_OFFSET (buffer);
GST_BUFFER_OFFSET_END (outbuf) = GST_BUFFER_OFFSET_END (buffer);
msg = g_unix_fd_message_new ();
for (i = 0; i < n_fds; i++) {
if (!g_unix_fd_message_append_fd (G_UNIX_FD_MESSAGE (msg), fds[i], &err))
goto add_fd_failed;
}
gst_buffer_add_net_control_message_meta (outbuf, msg);
g_object_unref (msg);
g_free (fds);
gst_memory_unref(fdmem);
fdmem = NULL;
if (!tmpfile) {
GArray *fdids;
/* we are using the original buffer fd in the control message, we need
* to make sure it is not reused before everyone is finished with it.
* We tag the output buffer with the array of fds in it and the original
* buffer (to keep it alive). All clients that receive the fd will
* increment outbuf refcount, all clients that do release-fd on the fd
* will decrease the refcount again. */
fdids = g_array_new (FALSE, FALSE, sizeof (guint32));
g_array_append_val (fdids, p.id);
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (outbuf),
fdids_quark, fdids, (GDestroyNotify) g_array_unref);
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (outbuf),
orig_buffer_quark, buffer, (GDestroyNotify) gst_buffer_unref);
} else {
gst_buffer_unref (buffer);
}
return gst_pad_push (pay->srcpad, outbuf);
/* ERRORS */
add_fd_failed:
{
GST_WARNING_OBJECT (pay, "Adding fd failed: %s", err->message);
gst_object_unref(msg);
g_clear_error (&err);
return GST_FLOW_ERROR;
}
}
static GstFlowReturn
gst_pinos_pay_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstPinosPay *pay = GST_PINOS_PAY (parent);
if (pay->pinos_input)
return gst_pinos_pay_chain_pinos (pay, buffer);
else
return gst_pinos_pay_chain_other (pay, buffer);
}
static void
gst_pinos_pay_finalize (GObject * object)
{
GstPinosPay *pay = GST_PINOS_PAY (object);
GST_DEBUG_OBJECT (pay, "finalize");
g_object_unref (pay->allocator);
g_object_unref (pay->fdmanager);
G_OBJECT_CLASS (gst_pinos_pay_parent_class)->finalize (object);
}
static void
gst_pinos_pay_init (GstPinosPay * pay)
{
pay->srcpad = gst_pad_new_from_static_template (&gst_pinos_pay_src_template, "src");
gst_pad_set_event_function (pay->srcpad, gst_pinos_pay_src_event);
gst_element_add_pad (GST_ELEMENT (pay), pay->srcpad);
pay->sinkpad = gst_pad_new_from_static_template (&gst_pinos_pay_sink_template, "sink");
gst_pad_set_chain_function (pay->sinkpad, gst_pinos_pay_chain);
gst_pad_set_event_function (pay->sinkpad, gst_pinos_pay_sink_event);
gst_pad_set_query_function (pay->sinkpad, gst_pinos_pay_query);
gst_element_add_pad (GST_ELEMENT (pay), pay->sinkpad);
pay->allocator = gst_tmpfile_allocator_new ();
pay->fdmanager = pinos_fd_manager_get (PINOS_FD_MANAGER_DEFAULT);
}
static void
gst_pinos_pay_class_init (GstPinosPayClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_pinos_pay_src_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_pinos_pay_sink_template));
gst_element_class_set_static_metadata (element_class,
"Pinos Payloader", "Generic",
"Pinos Payloader for zero-copy IPC with Pinos",
"Wim Taymans <wim.taymans@gmail.com>");
gobject_class->finalize = gst_pinos_pay_finalize;
fdids_quark = g_quark_from_static_string ("GstPinosPayFDIds");
orig_buffer_quark = g_quark_from_static_string ("GstPinosPayOrigBuffer");
}

60
pinos/gst/gstpinospay.h
View file

@ -1,60 +0,0 @@
/* GStreamer
* Copyright (C) 2014 William Manley <will@williammanley.net>
* (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 _GST_PINOS_PAY_H_
#define _GST_PINOS_PAY_H_
#include <gst/gst.h>
#include <client/pinos.h>
G_BEGIN_DECLS
#define GST_TYPE_PINOS_PAY (gst_pinos_pay_get_type())
#define GST_PINOS_PAY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PINOS_PAY,GstPinosPay))
#define GST_PINOS_PAY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PINOS_PAY,GstPinosPayClass))
#define GST_IS_PINOS_PAY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PINOS_PAY))
#define GST_IS_PINOS_PAY_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PINOS_PAY))
typedef struct _GstPinosPay GstPinosPay;
typedef struct _GstPinosPayClass GstPinosPayClass;
struct _GstPinosPay
{
GstElement parent;
gboolean pinos_input;
GstPad *srcpad, *sinkpad;
GstAllocator *allocator;
PinosFdManager *fdmanager;
};
struct _GstPinosPayClass
{
GstElementClass parent_class;
};
GType gst_pinos_pay_get_type (void);
G_END_DECLS
#endif /* _GST_PINOS_PAY_H_ */

402
pinos/gst/gstpinosportsink.c
View file

@ -1,402 +0,0 @@
/* GStreamer
* 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.
*/
/**
* SECTION:element-pinosportsink
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <unistd.h>
#include <gio/gunixfdmessage.h>
#include <gst/allocators/gstfdmemory.h>
#include <gst/net/gstnetcontrolmessagemeta.h>
#include <gst/video/video.h>
#include "gstpinosportsink.h"
#include "gsttmpfileallocator.h"
GST_DEBUG_CATEGORY_STATIC (pinos_port_sink_debug);
#define GST_CAT_DEFAULT pinos_port_sink_debug
static GstStaticPadTemplate gst_pinos_port_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY
);
enum
{
PROP_0,
PROP_PORT,
};
#define gst_pinos_port_sink_parent_class parent_class
G_DEFINE_TYPE (GstPinosPortSink, gst_pinos_port_sink, GST_TYPE_BASE_SINK);
static gboolean
gst_pinos_port_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
{
GstPinosPortSink *this = GST_PINOS_PORT_SINK (bsink);
gst_query_add_allocation_param (query, this->allocator, NULL);
gst_query_add_allocation_meta (query, GST_NET_CONTROL_MESSAGE_META_API_TYPE,
NULL);
return TRUE;
}
static gboolean
on_received_buffer (PinosPort *port, PinosBuffer *pbuf, GError **error, gpointer user_data)
{
GstPinosPortSink *this = user_data;
GstEvent *ev;
PinosBufferIter it;
PinosBufferBuilder b;
gboolean have_out = FALSE;
guint8 buffer[1024];
gint fds[8];
if (this->pinos_input) {
pinos_buffer_builder_init_into (&b, buffer, 1024, fds, 8);
}
pinos_buffer_iter_init (&it, pbuf);
while (pinos_buffer_iter_next (&it)) {
switch (pinos_buffer_iter_get_type (&it)) {
case PINOS_PACKET_TYPE_REFRESH_REQUEST:
{
PinosPacketRefreshRequest p;
if (!pinos_buffer_iter_parse_refresh_request (&it, &p))
continue;
GST_LOG ("refresh request");
if (!this->pinos_input) {
gst_pad_push_event (GST_BASE_SINK_PAD (this),
gst_video_event_new_upstream_force_key_unit (p.pts,
p.request_type == 1, 0));
} else {
pinos_buffer_builder_add_refresh_request (&b, &p);
have_out = TRUE;
}
break;
}
default:
break;
}
}
pinos_buffer_iter_end (&it);
if (this->pinos_input) {
GstBuffer *outbuf;
gsize size;
gpointer data;
if (have_out) {
pinos_buffer_builder_end (&b, pbuf);
data = pinos_buffer_steal_data (pbuf, &size);
outbuf = gst_buffer_new_wrapped (data, size);
ev = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM,
gst_structure_new ("GstNetworkMessage",
"object", G_TYPE_OBJECT, this,
"buffer", GST_TYPE_BUFFER, outbuf, NULL));
gst_buffer_unref (outbuf);
gst_pad_push_event (GST_BASE_SINK_PAD (this), ev);
} else {
pinos_buffer_builder_clear (&b);
}
}
return TRUE;
}
static void
set_port (GstPinosPortSink *this, PinosPort *port)
{
if (this->port)
g_object_unref (this->port);
this->port = port;
pinos_port_set_received_buffer_cb (port, on_received_buffer, this, NULL);
}
static void
gst_pinos_port_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstPinosPortSink *this = GST_PINOS_PORT_SINK (object);
switch (prop_id) {
case PROP_PORT:
set_port (this, g_value_dup_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_pinos_port_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstPinosPortSink *this = GST_PINOS_PORT_SINK (object);
switch (prop_id) {
case PROP_PORT:
g_value_set_object (value, this->port);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GstCaps *
gst_pinos_port_sink_getcaps (GstBaseSink * bsink, GstCaps * filter)
{
GstPinosPortSink *this = GST_PINOS_PORT_SINK (bsink);
GBytes *filt, *formats;
gchar *cstr;
GstCaps *result;
if (filter) {
cstr = gst_caps_to_string (filter);
filt = g_bytes_new_take (cstr, strlen (cstr) + 1);
} else {
filt = NULL;
}
formats = pinos_port_filter_formats (this->port, filt, NULL);
if (filt)
g_bytes_unref (filt);
if (formats) {
result = gst_caps_from_string (g_bytes_get_data (formats, NULL));
g_bytes_unref (formats);
} else {
result = gst_caps_new_empty ();
}
return result;
}
static gboolean
gst_pinos_port_sink_setcaps (GstBaseSink * bsink, GstCaps * caps)
{
GstPinosPortSink *this = GST_PINOS_PORT_SINK (bsink);
GstStructure *str;
gchar *cstr;
str = gst_caps_get_structure (caps, 0);
this->pinos_input = gst_structure_has_name (str, "application/x-pinos");
if (!this->pinos_input) {
GError *error = NULL;
PinosBufferBuilder builder;
PinosBuffer pbuf;
PinosPacketFormatChange fc;
guint8 buffer[1024];
pinos_buffer_builder_init_into (&builder, buffer, 1024, NULL, 0);
fc.id = 0;
fc.format = cstr = gst_caps_to_string (caps);
pinos_buffer_builder_add_format_change (&builder, &fc);
pinos_buffer_builder_end (&builder, &pbuf);
g_free (cstr);
if (!pinos_port_send_buffer (this->port, &pbuf, &error)) {
GST_WARNING ("format update failed: %s", error->message);
g_clear_error (&error);
}
pinos_buffer_unref (&pbuf);
}
return GST_BASE_SINK_CLASS (parent_class)->set_caps (bsink, caps);
}
static GstFlowReturn
gst_pinos_port_sink_render_pinos (GstPinosPortSink * this, GstBuffer * buffer)
{
GstMapInfo info;
PinosBuffer pbuf;
GError *error = NULL;
gst_buffer_map (buffer, &info, GST_MAP_READ);
pinos_buffer_init_data (&pbuf, info.data, info.size, NULL, 0);
if (!pinos_port_send_buffer (this->port, &pbuf, &error)) {
GST_WARNING ("send failed: %s", error->message);
g_clear_error (&error);
}
gst_buffer_unmap (buffer, &info);
pinos_buffer_unref (&pbuf);
return GST_FLOW_OK;
}
static GstMemory *
gst_pinos_port_sink_get_fd_memory (GstPinosPortSink * this, GstBuffer * buffer, gboolean *tmpfile)
{
GstMemory *mem = NULL;
if (gst_buffer_n_memory (buffer) == 1
&& gst_is_fd_memory (gst_buffer_peek_memory (buffer, 0))) {
mem = gst_buffer_get_memory (buffer, 0);
*tmpfile = gst_is_tmpfile_memory (mem);
} else {
GstMapInfo info;
GstAllocationParams params = {0, 0, 0, 0, { NULL, }};
gsize size = gst_buffer_get_size (buffer);
GST_INFO_OBJECT (this, "Buffer cannot be sent without copying");
mem = gst_allocator_alloc (this->allocator, size, &params);
if (!gst_memory_map (mem, &info, GST_MAP_WRITE))
return NULL;
gst_buffer_extract (buffer, 0, info.data, size);
gst_memory_unmap (mem, &info);
*tmpfile = TRUE;
}
return mem;
}
static GstFlowReturn
gst_pinos_port_sink_render_other (GstPinosPortSink * this, GstBuffer * buffer)
{
GstMemory *fdmem = NULL;
GError *error = NULL;
PinosBuffer pbuf;
PinosBufferBuilder builder;
PinosPacketHeader hdr;
PinosPacketAddMem am;
PinosPacketProcessMem p;
PinosPacketRemoveMem rm;
gboolean tmpfile = TRUE;
guint8 send_buffer[1024];
gint send_fds[8];
hdr.flags = 0;
hdr.seq = GST_BUFFER_OFFSET (buffer);
hdr.pts = GST_BUFFER_PTS (buffer) + GST_ELEMENT_CAST (this)->base_time;
hdr.dts_offset = 0;
pinos_buffer_builder_init_into (&builder, send_buffer, 1024, send_fds, 8);
pinos_buffer_builder_add_header (&builder, &hdr);
fdmem = gst_pinos_port_sink_get_fd_memory (this, buffer, &tmpfile);
am.id = pinos_fd_manager_get_id (this->fdmanager);
am.fd_index = pinos_buffer_builder_add_fd (&builder, gst_fd_memory_get_fd (fdmem));
am.offset = 0;
am.size = fdmem->size + fdmem->offset;
p.id = am.id;
p.offset = fdmem->offset;
p.size = fdmem->size;
rm.id = am.id;
pinos_buffer_builder_add_add_mem (&builder, &am);
pinos_buffer_builder_add_process_mem (&builder, &p);
pinos_buffer_builder_add_remove_mem (&builder, &rm);
pinos_buffer_builder_end (&builder, &pbuf);
GST_LOG ("send %d %"G_GUINT64_FORMAT" %"G_GUINT64_FORMAT" %"G_GUINT64_FORMAT,
p.id, hdr.pts, GST_BUFFER_PTS (buffer), GST_ELEMENT_CAST (this)->base_time);
if (!pinos_port_send_buffer (this->port, &pbuf, &error)) {
GST_WARNING ("send failed: %s", error->message);
g_clear_error (&error);
}
pinos_buffer_steal_fds (&pbuf, NULL);
pinos_buffer_unref (&pbuf);
gst_memory_unref(fdmem);
return GST_FLOW_OK;
}
static GstFlowReturn
gst_pinos_port_sink_render (GstBaseSink * bsink, GstBuffer * buffer)
{
GstPinosPortSink *this = GST_PINOS_PORT_SINK (bsink);
if (this->pinos_input)
return gst_pinos_port_sink_render_pinos (this, buffer);
else
return gst_pinos_port_sink_render_other (this, buffer);
}
static void
gst_pinos_port_sink_finalize (GObject * object)
{
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_pinos_port_sink_class_init (GstPinosPortSinkClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstBaseSinkClass *gstbasesink_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gstbasesink_class = (GstBaseSinkClass *) klass;
gobject_class->finalize = gst_pinos_port_sink_finalize;
gobject_class->set_property = gst_pinos_port_sink_set_property;
gobject_class->get_property = gst_pinos_port_sink_get_property;
g_object_class_install_property (gobject_class, PROP_PORT,
g_param_spec_object ("port", "Port",
"The pinos port object", PINOS_TYPE_PORT,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
gst_element_class_set_static_metadata (gstelement_class,
"Pinos Port sink", "Sink/Video",
"Send data to pinos port", "Wim Taymans <wim.taymans@gmail.com>");
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&gst_pinos_port_sink_template));
gstbasesink_class->get_caps = gst_pinos_port_sink_getcaps;
gstbasesink_class->set_caps = gst_pinos_port_sink_setcaps;
gstbasesink_class->propose_allocation = gst_pinos_port_sink_propose_allocation;
gstbasesink_class->render = gst_pinos_port_sink_render;
GST_DEBUG_CATEGORY_INIT (pinos_port_sink_debug, "pinosportsink", 0,
"Pinos Socket Sink");
}
static void
gst_pinos_port_sink_init (GstPinosPortSink * this)
{
this->allocator = gst_tmpfile_allocator_new ();
this->fdmanager = pinos_fd_manager_get (PINOS_FD_MANAGER_DEFAULT);
}

66
pinos/gst/gstpinosportsink.h
View file

@ -1,66 +0,0 @@
/* GStreamer
* 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 __GST_PINOS_PORT_SINK_H__
#define __GST_PINOS_PORT_SINK_H__
#include <gio/gio.h>
#include <client/pinos.h>
#include <server/port.h>
#include <gst/gst.h>
#include <gst/base/gstbasesink.h>
G_BEGIN_DECLS
#define GST_TYPE_PINOS_PORT_SINK (gst_pinos_port_sink_get_type())
#define GST_PINOS_PORT_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PINOS_PORT_SINK,GstPinosPortSink))
#define GST_PINOS_PORT_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PINOS_PORT_SINK,GstPinosPortSinkClass))
#define GST_IS_PINOS_PORT_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PINOS_PORT_SINK))
#define GST_IS_PINOS_PORT_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PINOS_PORT_SINK))
#define GST_PINOS_PORT_SINK_CAST(obj) ((GstPinosPortSink *) (obj))
typedef struct _GstPinosPortSink GstPinosPortSink;
typedef struct _GstPinosPortSinkClass GstPinosPortSinkClass;
/**
* GstPinosPortSink:
*
* Opaque data structure.
*/
struct _GstPinosPortSink {
GstBaseSink element;
gboolean pinos_input;
GstAllocator *allocator;
PinosPort *port;
PinosFdManager *fdmanager;
};
struct _GstPinosPortSinkClass {
GstBaseSinkClass parent_class;
};
GType gst_pinos_port_sink_get_type (void);
G_END_DECLS
#endif /* __GST_PINOS_PORT_SINK_H__ */

649
pinos/gst/gstpinosportsrc.c
View file

@ -1,649 +0,0 @@
/* GStreamer
* 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.
*/
/**
* SECTION:element-pinosportsrc
*
* <refsect2>
* <title>Example launch line</title>
* |[
* gst-launch -v pinosportsrc ! videoconvert ! ximagesink
* ]| Shows pinos output in an X window.
* </refsect2>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstpinosportsrc.h"
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <unistd.h>
#include <gio/gunixfdmessage.h>
#include <gst/net/gstnetclientclock.h>
#include <gst/allocators/gstfdmemory.h>
#include <gst/video/video.h>
static GQuark process_mem_data_quark;
GST_DEBUG_CATEGORY_STATIC (pinos_port_src_debug);
#define GST_CAT_DEFAULT pinos_port_src_debug
enum
{
PROP_0,
PROP_PORT,
};
#define PINOSS_VIDEO_CAPS GST_VIDEO_CAPS_MAKE (GST_VIDEO_FORMATS_ALL)
static GstStaticPadTemplate gst_pinos_port_src_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY
);
#define gst_pinos_port_src_parent_class parent_class
G_DEFINE_TYPE (GstPinosPortSrc, gst_pinos_port_src, GST_TYPE_PUSH_SRC);
static GstStateChangeReturn
gst_pinos_port_src_change_state (GstElement * element, GstStateChange transition);
static GstCaps *gst_pinos_port_src_getcaps (GstBaseSrc * bsrc, GstCaps * filter);
static GstFlowReturn gst_pinos_port_src_create (GstPushSrc * psrc,
GstBuffer ** buffer);
static gboolean gst_pinos_port_src_start (GstBaseSrc * basesrc);
static gboolean gst_pinos_port_src_stop (GstBaseSrc * basesrc);
static gboolean gst_pinos_port_src_event (GstBaseSrc * src, GstEvent * event);
static gboolean gst_pinos_port_src_query (GstBaseSrc * src, GstQuery * query);
typedef struct {
GstPinosPortSrc *src;
PinosPacketProcessMem p;
} ProcessMemData;
static void
process_mem_data_destroy (gpointer user_data)
{
ProcessMemData *data = user_data;
GstPinosPortSrc *this = data->src;
PinosBufferBuilder b;
PinosPacketReuseMem r;
PinosBuffer pbuf;
r.id = data->p.id;
GST_DEBUG_OBJECT (this, "destroy %d", r.id);
pinos_buffer_builder_init (&b);
pinos_buffer_builder_add_reuse_mem (&b, &r);
pinos_buffer_builder_end (&b, &pbuf);
pinos_port_send_buffer (this->port, &pbuf, NULL);
pinos_buffer_unref (&pbuf);
gst_object_unref (this);
g_slice_free (ProcessMemData, data);
}
static gboolean
on_received_buffer (PinosPort *port,
PinosBuffer *pbuf,
GError **error,
gpointer user_data)
{
GstPinosPortSrc *this = user_data;
PinosBufferIter it;
GstBuffer *buf = NULL;
GST_LOG_OBJECT (this, "got new buffer");
pinos_buffer_iter_init (&it, pbuf);
while (pinos_buffer_iter_next (&it)) {
switch (pinos_buffer_iter_get_type (&it)) {
case PINOS_PACKET_TYPE_HEADER:
{
PinosPacketHeader hdr;
if (!pinos_buffer_iter_parse_header (&it, &hdr))
break;
if (buf == NULL)
buf = gst_buffer_new ();
GST_INFO ("pts %" G_GUINT64_FORMAT ", dts_offset %"G_GUINT64_FORMAT, hdr.pts, hdr.dts_offset);
if (GST_CLOCK_TIME_IS_VALID (hdr.pts)) {
GST_BUFFER_PTS (buf) = hdr.pts;
if (GST_BUFFER_PTS (buf) + hdr.dts_offset > 0)
GST_BUFFER_DTS (buf) = GST_BUFFER_PTS (buf) + hdr.dts_offset;
}
GST_BUFFER_OFFSET (buf) = hdr.seq;
break;
}
case PINOS_PACKET_TYPE_ADD_MEM:
{
GstMemory *fdmem = NULL;
PinosPacketAddMem p;
int fd;
if (!pinos_buffer_iter_parse_add_mem (&it, &p))
break;
fd = pinos_buffer_get_fd (pbuf, p.fd_index);
if (fd == -1)
break;
fdmem = gst_fd_allocator_alloc (this->fd_allocator, dup (fd),
p.offset + p.size, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (fdmem, p.offset, p.size);
g_hash_table_insert (this->mem_ids, GINT_TO_POINTER (p.id), fdmem);
break;
}
case PINOS_PACKET_TYPE_REMOVE_MEM:
{
PinosPacketRemoveMem p;
if (!pinos_buffer_iter_parse_remove_mem (&it, &p))
break;
g_hash_table_remove (this->mem_ids, GINT_TO_POINTER (p.id));
break;
}
case PINOS_PACKET_TYPE_PROCESS_MEM:
{
GstMemory *fdmem = NULL;
ProcessMemData data;
if (!pinos_buffer_iter_parse_process_mem (&it, &data.p))
break;
if (!(fdmem = g_hash_table_lookup (this->mem_ids, GINT_TO_POINTER (data.p.id))))
break;
if (buf == NULL)
buf = gst_buffer_new ();
fdmem = gst_memory_share (fdmem, data.p.offset, data.p.size);
gst_buffer_append_memory (buf, fdmem);
data.src = gst_object_ref (this);
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (fdmem),
process_mem_data_quark,
g_slice_dup (ProcessMemData, &data),
process_mem_data_destroy);
break;
}
case PINOS_PACKET_TYPE_FORMAT_CHANGE:
{
PinosPacketFormatChange change;
GstCaps *caps;
if (!pinos_buffer_iter_parse_format_change (&it, &change))
break;
GST_DEBUG ("got format change %d %s", change.id, change.format);
caps = gst_caps_from_string (change.format);
gst_base_src_set_caps (GST_BASE_SRC (this), caps);
gst_caps_unref (caps);
break;
}
default:
break;
}
}
pinos_buffer_iter_end (&it);
if (buf) {
g_queue_push_tail (&this->queue, buf);
g_cond_signal (&this->cond);
}
return TRUE;
}
static void
set_port (GstPinosPortSrc *this, PinosPort *port)
{
g_debug ("set port %p", port);
if (this->port)
g_object_unref (this->port);
this->port = port;
pinos_port_set_received_buffer_cb (port, on_received_buffer, this, NULL);
}
static void
gst_pinos_port_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstPinosPortSrc *this = GST_PINOS_PORT_SRC (object);
switch (prop_id) {
case PROP_PORT:
set_port (this, g_value_dup_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_pinos_port_src_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstPinosPortSrc *this = GST_PINOS_PORT_SRC (object);
switch (prop_id) {
case PROP_PORT:
g_value_set_object (value, this->port);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GstClock *
gst_pinos_port_src_provide_clock (GstElement * elem)
{
GstPinosPortSrc *this = GST_PINOS_PORT_SRC (elem);
GstClock *clock;
GST_OBJECT_LOCK (this);
if (!GST_OBJECT_FLAG_IS_SET (this, GST_ELEMENT_FLAG_PROVIDE_CLOCK))
goto clock_disabled;
if (this->clock)
clock = GST_CLOCK_CAST (gst_object_ref (this->clock));
else
clock = NULL;
GST_OBJECT_UNLOCK (this);
return clock;
/* ERRORS */
clock_disabled:
{
GST_DEBUG_OBJECT (this, "clock provide disabled");
GST_OBJECT_UNLOCK (this);
return NULL;
}
}
static gboolean
gst_pinos_port_src_unlock (GstBaseSrc * basesrc)
{
GstPinosPortSrc *this = GST_PINOS_PORT_SRC (basesrc);
GST_DEBUG_OBJECT (this, "setting flushing");
GST_OBJECT_LOCK (this);
this->flushing = TRUE;
g_cond_signal (&this->cond);
GST_OBJECT_UNLOCK (this);
return TRUE;
}
static gboolean
gst_pinos_port_src_unlock_stop (GstBaseSrc * basesrc)
{
GstPinosPortSrc *this = GST_PINOS_PORT_SRC (basesrc);
GST_DEBUG_OBJECT (this, "unsetting flushing");
this->flushing = FALSE;
return TRUE;
}
static void
gst_pinos_port_src_finalize (GObject * object)
{
GstPinosPortSrc *this = GST_PINOS_PORT_SRC (object);
g_queue_foreach (&this->queue, (GFunc) gst_mini_object_unref, NULL);
g_queue_clear (&this->queue);
g_cond_clear (&this->cond);
g_object_unref (this->fd_allocator);
g_object_unref (this->port);
if (this->clock)
gst_object_unref (this->clock);
g_hash_table_unref (this->mem_ids);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_pinos_port_src_class_init (GstPinosPortSrcClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstBaseSrcClass *gstbasesrc_class;
GstPushSrcClass *gstpushsrc_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gstbasesrc_class = (GstBaseSrcClass *) klass;
gstpushsrc_class = (GstPushSrcClass *) klass;
gobject_class->finalize = gst_pinos_port_src_finalize;
gobject_class->set_property = gst_pinos_port_src_set_property;
gobject_class->get_property = gst_pinos_port_src_get_property;
g_object_class_install_property (gobject_class, PROP_PORT,
g_param_spec_object ("port", "Port",
"The pinos port object",
PINOS_TYPE_PORT,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
gstelement_class->provide_clock = gst_pinos_port_src_provide_clock;
gstelement_class->change_state = gst_pinos_port_src_change_state;
gst_element_class_set_static_metadata (gstelement_class,
"Pinos source", "Source/Video",
"Uses pinos to create video", "Wim Taymans <wim.taymans@gmail.com>");
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&gst_pinos_port_src_template));
gstbasesrc_class->get_caps = gst_pinos_port_src_getcaps;
gstbasesrc_class->unlock = gst_pinos_port_src_unlock;
gstbasesrc_class->unlock_stop = gst_pinos_port_src_unlock_stop;
gstbasesrc_class->start = gst_pinos_port_src_start;
gstbasesrc_class->stop = gst_pinos_port_src_stop;
gstbasesrc_class->event = gst_pinos_port_src_event;
gstbasesrc_class->query = gst_pinos_port_src_query;
gstpushsrc_class->create = gst_pinos_port_src_create;
GST_DEBUG_CATEGORY_INIT (pinos_port_src_debug, "pinosportsrc", 0,
"Pinos Source");
process_mem_data_quark = g_quark_from_static_string ("GstPinosPortSrcProcessMemQuark");
}
static void
gst_pinos_port_src_init (GstPinosPortSrc * src)
{
/* we operate in time */
gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);
GST_OBJECT_FLAG_SET (src, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
g_cond_init (&src->cond);
g_queue_init (&src->queue);
src->fd_allocator = gst_fd_allocator_new ();
src->mem_ids = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) gst_memory_unref);
}
static void
parse_stream_properties (GstPinosPortSrc *this, PinosProperties *props)
{
const gchar *var;
var = pinos_properties_get (props, "pinos.latency.is-live");
this->is_live = var ? (atoi (var) == 1) : FALSE;
gst_base_src_set_live (GST_BASE_SRC (this), this->is_live);
var = pinos_properties_get (props, "pinos.latency.min");
this->min_latency = var ? (GstClockTime) atoi (var) : 0;
var = pinos_properties_get (props, "pinos.latency.max");
this->max_latency = var ? (GstClockTime) atoi (var) : GST_CLOCK_TIME_NONE;
var = pinos_properties_get (props, "pinos.clock.type");
if (var != NULL) {
GST_DEBUG_OBJECT (this, "got clock type %s", var);
if (strcmp (var, "gst.net.time.provider") == 0) {
const gchar *address;
gint port;
GstClockTime base_time;
address = pinos_properties_get (props, "pinos.clock.address");
port = atoi (pinos_properties_get (props, "pinos.clock.port"));
base_time = atoll (pinos_properties_get (props, "pinos.clock.base-time"));
GST_DEBUG_OBJECT (this, "making net clock for %s:%d %" G_GUINT64_FORMAT, address, port, base_time);
if (this->clock)
gst_object_unref (this->clock);
this->clock = gst_net_client_clock_new ("pinosclock", address, port, base_time);
gst_element_post_message (GST_ELEMENT_CAST (this),
gst_message_new_clock_provide (GST_OBJECT_CAST (this),
this->clock, TRUE));
}
}
}
static GstCaps *
gst_pinos_port_src_getcaps (GstBaseSrc * bsrc, GstCaps * filter)
{
GstPinosPortSrc *this = GST_PINOS_PORT_SRC (bsrc);
GBytes *format;
GstCaps *caps = NULL;
GST_DEBUG ("getting caps");
g_object_get (this->port, "format", &format, NULL);
if (format) {
GST_DEBUG ("have format %s", (gchar *)g_bytes_get_data (format, NULL));
caps = gst_caps_from_string (g_bytes_get_data (format, NULL));
g_bytes_unref (format);
}
return caps;
}
static gboolean
gst_pinos_port_src_event (GstBaseSrc * src, GstEvent * event)
{
gboolean res = FALSE;
GstPinosPortSrc *this;
this = GST_PINOS_PORT_SRC (src);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CUSTOM_UPSTREAM:
if (gst_video_event_is_force_key_unit (event)) {
GstClockTime running_time;
gboolean all_headers;
guint count;
PinosPacketRefreshRequest refresh;
PinosBufferBuilder b;
PinosBuffer pbuf;
gst_video_event_parse_upstream_force_key_unit (event,
&running_time, &all_headers, &count);
refresh.last_id = 0;
refresh.request_type = all_headers ? 1 : 0;
refresh.pts = running_time;
pinos_buffer_builder_init (&b);
pinos_buffer_builder_add_refresh_request (&b, &refresh);
pinos_buffer_builder_end (&b, &pbuf);
GST_DEBUG_OBJECT (this, "send refresh request");
pinos_port_send_buffer (this->port, &pbuf, NULL);
pinos_buffer_unref (&pbuf);
res = TRUE;
} else {
res = GST_BASE_SRC_CLASS (parent_class)->event (src, event);
}
break;
default:
res = GST_BASE_SRC_CLASS (parent_class)->event (src, event);
break;
}
return res;
}
static gboolean
gst_pinos_port_src_query (GstBaseSrc * src, GstQuery * query)
{
gboolean res = FALSE;
GstPinosPortSrc *this;
this = GST_PINOS_PORT_SRC (src);
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_LATENCY:
gst_query_set_latency (query, this->is_live, this->min_latency, this->max_latency);
res = TRUE;
break;
default:
res = GST_BASE_SRC_CLASS (parent_class)->query (src, query);
break;
}
return res;
}
static GstFlowReturn
gst_pinos_port_src_create (GstPushSrc * psrc, GstBuffer ** buffer)
{
GstPinosPortSrc *this;
GstClockTime pts, dts, base_time;
this = GST_PINOS_PORT_SRC (psrc);
GST_OBJECT_LOCK (this);
while (TRUE) {
if (this->flushing)
goto streaming_stopped;
*buffer = g_queue_pop_head (&this->queue);
if (*buffer != NULL)
break;
g_cond_wait (&this->cond, GST_OBJECT_GET_LOCK (this));
}
GST_OBJECT_UNLOCK (this);
base_time = GST_ELEMENT_CAST (psrc)->base_time;
pts = GST_BUFFER_PTS (*buffer);
dts = GST_BUFFER_DTS (*buffer);
if (GST_CLOCK_TIME_IS_VALID (pts))
pts = (pts >= base_time ? pts - base_time : 0);
if (GST_CLOCK_TIME_IS_VALID (dts))
dts = (dts >= base_time ? dts - base_time : 0);
GST_INFO ("pts %" G_GUINT64_FORMAT ", dts %"G_GUINT64_FORMAT
", base-time %"GST_TIME_FORMAT" -> %"GST_TIME_FORMAT", %"GST_TIME_FORMAT,
GST_BUFFER_PTS (*buffer), GST_BUFFER_DTS (*buffer), GST_TIME_ARGS (base_time),
GST_TIME_ARGS (pts), GST_TIME_ARGS (dts));
GST_BUFFER_PTS (*buffer) = pts;
GST_BUFFER_DTS (*buffer) = dts;
return GST_FLOW_OK;
streaming_stopped:
{
GST_OBJECT_UNLOCK (this);
return GST_FLOW_FLUSHING;
}
}
static gboolean
gst_pinos_port_src_start (GstBaseSrc * basesrc)
{
PinosProperties *props;
GstPinosPortSrc *this;
this = GST_PINOS_PORT_SRC (basesrc);
props = pinos_port_get_properties (this->port);
if (props)
parse_stream_properties (this, props);
return TRUE;
}
static void
clear_queue (GstPinosPortSrc *this)
{
g_queue_foreach (&this->queue, (GFunc) gst_mini_object_unref, NULL);
g_queue_clear (&this->queue);
}
static gboolean
gst_pinos_port_src_stop (GstBaseSrc * basesrc)
{
GstPinosPortSrc *this;
this = GST_PINOS_PORT_SRC (basesrc);
clear_queue (this);
return TRUE;
}
static GstStateChangeReturn
gst_pinos_port_src_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
/* uncork and start recording */
break;
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
/* stop recording ASAP by corking */
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
if (gst_base_src_is_live (GST_BASE_SRC (element)))
ret = GST_STATE_CHANGE_NO_PREROLL;
break;
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_NULL:
break;
default:
break;
}
return ret;
}

82
pinos/gst/gstpinosportsrc.h
View file

@ -1,82 +0,0 @@
/* GStreamer
* 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 __GST_PINOS_PORT_SRC_H__
#define __GST_PINOS_PORT_SRC_H__
#include <gst/gst.h>
#include <gst/base/gstpushsrc.h>
#include <client/pinos.h>
#include <server/port.h>
G_BEGIN_DECLS
#define GST_TYPE_PINOS_PORT_SRC \
(gst_pinos_port_src_get_type())
#define GST_PINOS_PORT_SRC(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PINOS_PORT_SRC,GstPinosPortSrc))
#define GST_PINOS_PORT_SRC_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PINOS_PORT_SRC,GstPinosPortSrcClass))
#define GST_IS_PINOS_PORT_SRC(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PINOS_PORT_SRC))
#define GST_IS_PINOS_PORT_SRC_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PINOS_PORT_SRC))
#define GST_PINOS_PORT_SRC_CAST(obj) \
((GstPinosPortSrc *) (obj))
typedef struct _GstPinosPortSrc GstPinosPortSrc;
typedef struct _GstPinosPortSrcClass GstPinosPortSrcClass;
/**
* GstPinosPortSrc:
*
* Opaque data structure.
*/
struct _GstPinosPortSrc {
GstPushSrc element;
/*< private >*/
PinosPort *port;
gboolean negotiated;
gboolean flushing;
gboolean started;
gboolean is_live;
GstClockTime min_latency;
GstClockTime max_latency;
GstClock *clock;
GstAllocator *fd_allocator;
GHashTable *mem_ids;
GQueue queue;
GCond cond;
};
struct _GstPinosPortSrcClass {
GstPushSrcClass parent_class;
};
GType gst_pinos_port_src_get_type (void);
G_END_DECLS
#endif /* __GST_PINOS_PORT_SRC_H__ */

3
pinos/gst/gstpinossink.c
View file

@ -45,7 +45,6 @@
#include <spa/include/spa/buffer.h>
#include "gsttmpfileallocator.h"
#include "gstpinosformat.h"
static GQuark process_mem_data_quark;
@ -216,7 +215,7 @@ gst_pinos_sink_class_init (GstPinosSinkClass * klass)
static void
gst_pinos_sink_init (GstPinosSink * sink)
{
sink->allocator = gst_tmpfile_allocator_new ();
sink->allocator = gst_fd_allocator_new ();
sink->pool = gst_pinos_pool_new ();
sink->client_name = pinos_client_name();
sink->mode = DEFAULT_PROP_MODE;

904
pinos/gst/gstpinossocketsink.c
View file

@ -1,904 +0,0 @@
/* GStreamer
* 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.
*/
/**
* SECTION:element-pinossocketsink
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <unistd.h>
#include <gio/gunixfdmessage.h>
#include <gst/allocators/gstfdmemory.h>
#include <gst/net/gstnetcontrolmessagemeta.h>
#include <gst/video/video.h>
#include "gstpinossocketsink.h"
#include "gsttmpfileallocator.h"
typedef struct _MyReader MyReader;
typedef struct _MySource MySource;
struct _MyReader {
GstBurstCacheReader reader;
GSocket *socket;
MySource *source;
guint id;
};
struct _MySource {
GSource source;
GIOCondition condition;
gpointer tag;
MyReader *reader;
};
typedef gboolean (*MyReaderSourceFunc) (MyReader *reader, GIOCondition condition, gpointer user_data);
static gboolean
mysource_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
MyReaderSourceFunc func = (MyReaderSourceFunc)callback;
MySource *mysource = (MySource *)source;
MyReader *myreader = mysource->reader;
guint events;
gboolean ret;
events = g_source_query_unix_fd (source, mysource->tag);
ret = (*func) (myreader, events, user_data);
return ret;
}
static GSourceFuncs mysource_funcs =
{
NULL, NULL, /* check, prepare */
mysource_dispatch,
NULL, /* finalize */
NULL,
NULL,
};
static GQuark fdids_quark;
static GQuark orig_buffer_quark;
GST_DEBUG_CATEGORY_STATIC (pinos_socket_sink_debug);
#define GST_CAT_DEFAULT pinos_socket_sink_debug
static GstStaticPadTemplate gst_pinos_socket_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY
);
enum
{
PROP_0,
PROP_NUM_HANDLES,
};
/* PinosSocketSink signals and args */
enum
{
/* methods */
SIGNAL_ADD,
SIGNAL_REMOVE,
LAST_SIGNAL
};
static guint gst_pinos_socket_sink_signals[LAST_SIGNAL] = { 0 };
#define gst_pinos_socket_sink_parent_class parent_class
G_DEFINE_TYPE (GstPinosSocketSink, gst_pinos_socket_sink, GST_TYPE_BASE_SINK);
static gboolean
gst_pinos_socket_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
{
GstPinosSocketSink *this = GST_PINOS_SOCKET_SINK (bsink);
gst_query_add_allocation_param (query, this->allocator, NULL);
gst_query_add_allocation_meta (query, GST_NET_CONTROL_MESSAGE_META_API_TYPE,
NULL);
return TRUE;
}
static void
gst_pinos_socket_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_pinos_socket_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstPinosSocketSink *this = GST_PINOS_SOCKET_SINK (object);
switch (prop_id) {
case PROP_NUM_HANDLES:
g_value_set_uint (value, g_hash_table_size (this->hash));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_pinos_socket_sink_setcaps (GstBaseSink * bsink, GstCaps * caps)
{
GstPinosSocketSink *this = GST_PINOS_SOCKET_SINK (bsink);
GstStructure *str;
str = gst_caps_get_structure (caps, 0);
this->pinos_input = gst_structure_has_name (str, "application/x-pinos");
return GST_BASE_SINK_CLASS (parent_class)->set_caps (bsink, caps);
}
static void
reuse_fds (GstPinosSocketSink *this, GstBuffer *buffer)
{
GArray *fdids;
guint i;
PinosBufferBuilder b;
PinosPacketReuseMem r;
PinosBuffer pbuf;
gsize size;
gpointer data;
GstBuffer *outbuf;
GstEvent *ev;
fdids = gst_mini_object_steal_qdata (GST_MINI_OBJECT_CAST (buffer),
fdids_quark);
if (fdids == NULL)
return;
pinos_buffer_builder_init (&b);
for (i = 0; i < fdids->len; i++) {
r.id = g_array_index (fdids, guint32, i);
GST_LOG ("reuse fd index %d", r.id);
pinos_buffer_builder_add_reuse_mem (&b, &r);
}
pinos_buffer_builder_end (&b, &pbuf);
g_array_unref (fdids);
data = pinos_buffer_steal_data (&pbuf, &size);
outbuf = gst_buffer_new_wrapped (data, size);
ev = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM,
gst_structure_new ("GstNetworkMessage",
"object", G_TYPE_OBJECT, this,
"buffer", GST_TYPE_BUFFER, outbuf, NULL));
gst_buffer_unref (outbuf);
gst_pad_push_event (GST_BASE_SINK_PAD (this), ev);
g_object_unref (this);
}
static GstFlowReturn
gst_pinos_socket_sink_render_pinos (GstPinosSocketSink * this, GstBuffer * buffer)
{
GstMapInfo info;
PinosBuffer pbuf;
PinosBufferIter it;
GArray *fdids = NULL;
gst_buffer_map (buffer, &info, GST_MAP_READ);
pinos_buffer_init_data (&pbuf, info.data, info.size, NULL, 0);
pinos_buffer_iter_init (&it, &pbuf);
while (pinos_buffer_iter_next (&it)) {
switch (pinos_buffer_iter_get_type (&it)) {
case PINOS_PACKET_TYPE_PROCESS_MEM:
{
PinosPacketProcessMem p;
if (!pinos_buffer_iter_parse_process_mem (&it, &p))
continue;
if (fdids == NULL)
fdids = g_array_new (FALSE, FALSE, sizeof (guint32));
GST_LOG ("track fd id %d", p.id);
g_array_append_val (fdids, p.id);
break;
}
case PINOS_PACKET_TYPE_FORMAT_CHANGE:
{
PinosPacketFormatChange p;
GstCaps * caps;
if (!pinos_buffer_iter_parse_format_change (&it, &p))
continue;
caps = gst_caps_from_string (p.format);
gst_element_post_message (GST_ELEMENT (this),
gst_message_new_element (GST_OBJECT (this),
gst_structure_new ("PinosPayloaderFormatChange",
"format", GST_TYPE_CAPS, caps, NULL)));
gst_caps_unref (caps);
break;
}
default:
break;
}
}
pinos_buffer_iter_end (&it);
pinos_buffer_unref (&pbuf);
gst_buffer_unmap (buffer, &info);
if (fdids != NULL) {
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (buffer),
fdids_quark, fdids, NULL);
gst_mini_object_weak_ref (GST_MINI_OBJECT_CAST (buffer),
(GstMiniObjectNotify) reuse_fds, g_object_ref (this));
}
gst_burst_cache_queue_buffer (this->cache, gst_buffer_ref (buffer));
return GST_FLOW_OK;
}
static GstMemory *
gst_pinos_socket_sink_get_fd_memory (GstPinosSocketSink * this, GstBuffer * buffer, gboolean *tmpfile)
{
GstMemory *mem = NULL;
if (gst_buffer_n_memory (buffer) == 1
&& gst_is_fd_memory (gst_buffer_peek_memory (buffer, 0))) {
mem = gst_buffer_get_memory (buffer, 0);
*tmpfile = gst_is_tmpfile_memory (mem);
} else {
GstMapInfo info;
GstAllocationParams params = {0, 0, 0, 0, { NULL, }};
gsize size = gst_buffer_get_size (buffer);
GST_INFO_OBJECT (this, "Buffer cannot be sent without copying");
mem = gst_allocator_alloc (this->allocator, size, &params);
if (!gst_memory_map (mem, &info, GST_MAP_WRITE))
return NULL;
gst_buffer_extract (buffer, 0, info.data, size);
gst_memory_unmap (mem, &info);
*tmpfile = TRUE;
}
return mem;
}
static GstFlowReturn
gst_pinos_socket_sink_render_other (GstPinosSocketSink * this, GstBuffer * buffer)
{
GstMemory *fdmem = NULL;
GError *err = NULL;
GstBuffer *outbuf;
PinosBuffer pbuf;
PinosBufferBuilder builder;
PinosPacketHeader hdr;
PinosPacketAddMem am;
PinosPacketProcessMem p;
PinosPacketRemoveMem rm;
gsize size;
gpointer data;
GSocketControlMessage *msg;
gboolean tmpfile = TRUE;
gint *fds, n_fds, i;
hdr.flags = 0;
hdr.seq = GST_BUFFER_OFFSET (buffer);
hdr.pts = GST_BUFFER_PTS (buffer) + GST_ELEMENT_CAST (this)->base_time;
hdr.dts_offset = 0;
pinos_buffer_builder_init (&builder);
pinos_buffer_builder_add_header (&builder, &hdr);
fdmem = gst_pinos_socket_sink_get_fd_memory (this, buffer, &tmpfile);
am.id = pinos_fd_manager_get_id (this->fdmanager);
am.fd_index = pinos_buffer_builder_add_fd (&builder, gst_fd_memory_get_fd (fdmem));
am.offset = 0;
am.size = fdmem->size;
p.id = am.id;
p.offset = fdmem->offset;
p.size = fdmem->size;
rm.id = am.id;
pinos_buffer_builder_add_add_mem (&builder, &am);
pinos_buffer_builder_add_process_mem (&builder, &p);
pinos_buffer_builder_add_remove_mem (&builder, &rm);
pinos_buffer_builder_end (&builder, &pbuf);
GST_LOG ("send %d %"G_GUINT64_FORMAT" %"G_GUINT64_FORMAT" %"G_GUINT64_FORMAT,
p.id, hdr.pts, GST_BUFFER_PTS (buffer), GST_ELEMENT_CAST (this)->base_time);
data = pinos_buffer_steal_data (&pbuf, &size);
fds = pinos_buffer_steal_fds (&pbuf, &n_fds);
pinos_buffer_unref (&pbuf);
outbuf = gst_buffer_new_wrapped (data, size);
GST_BUFFER_PTS (outbuf) = GST_BUFFER_PTS (buffer);
GST_BUFFER_DTS (outbuf) = GST_BUFFER_DTS (buffer);
GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buffer);
GST_BUFFER_OFFSET (outbuf) = GST_BUFFER_OFFSET (buffer);
GST_BUFFER_OFFSET_END (outbuf) = GST_BUFFER_OFFSET_END (buffer);
msg = g_unix_fd_message_new ();
for (i = 0; i < n_fds; i++) {
if (!g_unix_fd_message_append_fd (G_UNIX_FD_MESSAGE (msg), fds[i], &err))
goto add_fd_failed;
}
gst_buffer_add_net_control_message_meta (outbuf, msg);
g_object_unref (msg);
g_free (fds);
gst_memory_unref(fdmem);
fdmem = NULL;
if (!tmpfile) {
GArray *fdids;
/* we are using the original buffer fd in the control message, we need
* to make sure it is not reused before everyone is finished with it.
* We tag the output buffer with the array of fds in it and the original
* buffer (to keep it alive). All clients that receive the fd will
* increment outbuf refcount, all clients that do release-fd on the fd
* will decrease the refcount again. */
fdids = g_array_new (FALSE, FALSE, sizeof (guint32));
g_array_append_val (fdids, p.id);
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (outbuf),
fdids_quark, fdids, (GDestroyNotify) g_array_unref);
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (outbuf),
orig_buffer_quark, gst_buffer_ref (buffer), (GDestroyNotify) gst_buffer_unref);
}
gst_burst_cache_queue_buffer (this->cache, outbuf);
return GST_FLOW_OK;
/* ERRORS */
add_fd_failed:
{
GST_WARNING_OBJECT (this, "Adding fd failed: %s", err->message);
gst_memory_unref(fdmem);
g_clear_error (&err);
return GST_FLOW_ERROR;
}
}
static GstFlowReturn
gst_pinos_socket_sink_render (GstBaseSink * bsink, GstBuffer * buffer)
{
GstPinosSocketSink *this = GST_PINOS_SOCKET_SINK (bsink);
if (this->pinos_input)
return gst_pinos_socket_sink_render_pinos (this, buffer);
else
return gst_pinos_socket_sink_render_other (this, buffer);
}
static gboolean
gst_pinos_socket_sink_start (GstBaseSink * basesink)
{
return TRUE;
}
static gboolean
gst_pinos_socket_sink_stop (GstBaseSink * basesink)
{
return TRUE;
}
static gpointer
socketsink_loop (GstPinosSocketSink * this)
{
g_main_loop_run (this->loop);
return NULL;
}
static gboolean
gst_pinos_socket_sink_open (GstPinosSocketSink * this)
{
GError *error = NULL;
this->context = g_main_context_new ();
this->loop = g_main_loop_new (this->context, TRUE);
GST_DEBUG ("context %p, loop %p", this->context, this->loop);
this->thread = g_thread_try_new ("PinosSocketSink",
(GThreadFunc) socketsink_loop,
this,
&error);
if (this->thread == NULL)
goto thread_error;
return TRUE;
/* ERRORS */
thread_error:
{
GST_ELEMENT_ERROR (this, RESOURCE, FAILED,
("Failed to start mainloop thread: %s", error->message), (NULL));
g_clear_error (&error);
g_clear_pointer (&this->loop, g_main_loop_unref);
g_clear_pointer (&this->context, g_main_context_unref);
return FALSE;
}
}
static gboolean
gst_pinos_socket_sink_close (GstPinosSocketSink * this)
{
gst_burst_cache_remove_buffers (this->cache);
GST_DEBUG ("context %p, loop %p", this->context, this->loop);
g_main_loop_quit (this->loop);
g_thread_join (this->thread);
this->thread = NULL;
g_clear_pointer (&this->loop, g_main_loop_unref);
g_clear_pointer (&this->context, g_main_context_unref);
g_hash_table_remove_all (this->hash);
return TRUE;
}
static GstStateChangeReturn
gst_pinos_socket_sink_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret;
GstPinosSocketSink *this = GST_PINOS_SOCKET_SINK_CAST (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
if (!gst_pinos_socket_sink_open (this))
goto open_failed;
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_NULL:
gst_pinos_socket_sink_close (this);
break;
default:
break;
}
return ret;
/* ERRORS */
open_failed:
{
return GST_STATE_CHANGE_FAILURE;
}
}
static void
myreader_receive_buffer (GstPinosSocketSink *this, MyReader *myreader)
{
MySource *mysource = myreader->source;
gssize navail, nread, maxmem;
GstEvent *ev;
gchar *mem;
PinosBuffer pbuf;
PinosBufferIter it;
PinosBufferBuilder b;
const gchar *client_path;
gboolean have_out = FALSE;
navail = g_socket_get_available_bytes (myreader->socket);
maxmem = MAX (navail, 1);
mem = g_malloc (maxmem);
nread = g_socket_receive (myreader->socket, mem, maxmem, NULL, NULL);
if (nread <= 0) {
GST_DEBUG ("client closed");
mysource->condition &= ~G_IO_IN;
g_source_modify_unix_fd ((GSource *)mysource, mysource->tag, mysource->condition);
g_free (mem);
return;
}
client_path = g_object_get_data (G_OBJECT (myreader->socket), "pinos-client-path");
if (client_path == NULL)
return;
if (this->pinos_input) {
pinos_buffer_builder_init (&b);
}
pinos_buffer_init_data (&pbuf, mem, maxmem, NULL, 0);
pinos_buffer_iter_init (&it, &pbuf);
while (pinos_buffer_iter_next (&it)) {
switch (pinos_buffer_iter_get_type (&it)) {
case PINOS_PACKET_TYPE_REUSE_MEM:
{
PinosPacketReuseMem p;
gint id;
if (!pinos_buffer_iter_parse_reuse_mem (&it, &p))
continue;
id = p.id;
GST_LOG ("fd id %d for client %s is reused", id, client_path);
pinos_fd_manager_remove (this->fdmanager, client_path, id);
break;
}
case PINOS_PACKET_TYPE_REFRESH_REQUEST:
{
PinosPacketRefreshRequest p;
if (!pinos_buffer_iter_parse_refresh_request (&it, &p))
continue;
GST_LOG ("refresh request");
if (!this->pinos_input) {
gst_pad_push_event (GST_BASE_SINK_PAD (this),
gst_video_event_new_upstream_force_key_unit (p.pts,
p.request_type == 1, 0));
} else {
pinos_buffer_builder_add_refresh_request (&b, &p);
have_out = TRUE;
}
break;
}
default:
break;
}
}
pinos_buffer_iter_end (&it);
pinos_buffer_unref (&pbuf);
g_free (mem);
if (this->pinos_input) {
GstBuffer *outbuf;
gsize size;
gpointer data;
if (have_out) {
pinos_buffer_builder_end (&b, &pbuf);
data = pinos_buffer_steal_data (&pbuf, &size);
outbuf = gst_buffer_new_wrapped (data, size);
ev = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM,
gst_structure_new ("GstNetworkMessage",
"object", G_TYPE_OBJECT, this,
"buffer", GST_TYPE_BUFFER, outbuf, NULL));
gst_buffer_unref (outbuf);
gst_pad_push_event (GST_BASE_SINK_PAD (this), ev);
} else {
pinos_buffer_builder_clear (&b);
}
}
}
static void
myreader_callback (GstBurstCache *cache,
GstBurstCacheReader *reader,
gpointer user_data)
{
MyReader *myreader = (MyReader *) reader;
MySource *mysource = myreader->source;
GST_LOG ("%p: callback", reader);
mysource->condition |= G_IO_OUT;
g_source_modify_unix_fd ((GSource *)mysource, mysource->tag, mysource->condition);
}
#define VEC_MAX 8
#define CMSG_MAX 255
static void
myreader_send_buffer (GstPinosSocketSink *this, MyReader *myreader, GstBuffer *buf)
{
GstMapInfo maps[VEC_MAX];
GOutputVector vec[VEC_MAX];
GSocketControlMessage *cmsgs[CMSG_MAX];
guint i, mem_len;
gpointer iter_state = NULL;
GstMeta *meta;
gsize msg_count = 0;
gssize wrote;
mem_len = MIN (gst_buffer_n_memory (buf), VEC_MAX);
for (i = 0; i < mem_len; i++) {
GstMapInfo map = { 0 };
GstMemory *mem = gst_buffer_peek_memory (buf, i);
if (!gst_memory_map (mem, &map, GST_MAP_READ))
g_error ("Unable to map memory %p. This should never happen.", mem);
vec[i].buffer = map.data;
vec[i].size = map.size;
maps[i] = map;
}
while ((meta = gst_buffer_iterate_meta (buf, &iter_state)) != NULL
&& msg_count < CMSG_MAX) {
if (meta->info->api == GST_NET_CONTROL_MESSAGE_META_API_TYPE)
cmsgs[msg_count++] = ((GstNetControlMessageMeta *) meta)->message;
}
wrote = g_socket_send_message (myreader->socket, NULL, vec, mem_len, cmsgs, msg_count, 0,
NULL, NULL);
for (i = 0; i < mem_len; i++)
gst_memory_unmap (maps[i].memory, &maps[i]);
if (wrote < 0) {
GST_DEBUG_OBJECT (this, "error sending to reader");
} else {
GArray *fdids;
const gchar *client_path;
fdids = gst_mini_object_get_qdata (GST_MINI_OBJECT_CAST (buf), fdids_quark);
if (fdids == NULL)
return;
/* get the client path of this socket */
client_path = g_object_get_data (G_OBJECT (myreader->socket), "pinos-client-path");
if (client_path == NULL)
return;
for (i = 0; i < fdids->len; i++) {
gint id = g_array_index (fdids, guint32, i);
/* now store the id/client-path/buffer in the fdmanager */
GST_LOG ("fd index %d, client %s increment refcount of buffer %p", id, client_path, buf);
pinos_fd_manager_add (this->fdmanager,
client_path, id,
gst_buffer_ref (buf),
(GDestroyNotify) gst_buffer_unref);
}
}
}
static gboolean
myreader_source_func (GstBurstCacheReader *reader, GIOCondition condition, gpointer user_data)
{
GstPinosSocketSink *this = user_data;
MyReader *myreader = (MyReader *) reader;
MySource *mysource = myreader->source;
GST_LOG ("%p: io condition %d", reader, condition);
if (condition & (G_IO_HUP | G_IO_ERR)) {
GST_DEBUG ("client error");
return FALSE;
}
if (condition & G_IO_IN) {
myreader_receive_buffer (this, myreader);
}
if (condition & G_IO_OUT) {
GstBuffer *buf = NULL;
GstBurstCacheResult res;
res = gst_burst_cache_get_buffer (this->cache, reader, &buf);
switch (res) {
case GST_BURST_CACHE_RESULT_ERROR:
break;
case GST_BURST_CACHE_RESULT_OK:
break;
case GST_BURST_CACHE_RESULT_WAIT:
mysource->condition &= ~G_IO_OUT;
g_source_modify_unix_fd ((GSource *)mysource, mysource->tag, mysource->condition);
break;
case GST_BURST_CACHE_RESULT_EOS:
gst_burst_cache_remove_reader (this->cache, reader, FALSE);
break;
}
if (buf) {
myreader_send_buffer (this, myreader, buf);
gst_buffer_unref (buf);
}
}
return TRUE;
}
static void
myreader_destroy (MyReader *myreader)
{
gst_burst_cache_reader_destroy ((GstBurstCacheReader *)myreader);
g_clear_object (&myreader->socket);
g_source_destroy ((GSource*) myreader->source);
myreader->id = 0;
}
static void
gst_pinos_socket_sink_add (GstPinosSocketSink * this, GSocket *socket)
{
GstBurstCacheReader *reader;
MyReader *myreader;
MySource *mysource;
int fd;
fd = g_socket_get_fd (socket);
if (g_hash_table_lookup (this->hash, GINT_TO_POINTER (fd)))
return;
reader = gst_burst_cache_reader_new (this->cache,
(GstBurstCacheReaderCallback) myreader_callback,
this,
NULL);
reader->hook.destroy = (GDestroyNotify) myreader_destroy;
myreader = (MyReader *)reader;
myreader->socket = g_object_ref (socket);
mysource = (MySource*) g_source_new (&mysource_funcs, sizeof (MySource));
mysource->reader = myreader;
mysource->condition = G_IO_IN;
mysource->tag = g_source_add_unix_fd ((GSource*)mysource, fd, mysource->condition);
myreader->source = mysource;
g_source_set_callback ((GSource*)mysource,
(GSourceFunc) myreader_source_func,
this, NULL);
myreader->id = g_source_attach ((GSource*)mysource, this->context);
g_hash_table_insert (this->hash, GINT_TO_POINTER (fd), reader);
gst_burst_cache_add_reader (this->cache, reader);
}
static void
gst_pinos_socket_sink_remove (GstPinosSocketSink * this, GSocket *socket, gboolean drain)
{
GstBurstCacheReader *reader;
MyReader *myreader;
int fd;
fd = g_socket_get_fd (socket);
myreader = g_hash_table_lookup (this->hash, GINT_TO_POINTER (fd));
if (myreader == NULL)
return;
g_hash_table_remove (this->hash, GINT_TO_POINTER (fd));
reader = (GstBurstCacheReader *) myreader;
gst_burst_cache_remove_reader (this->cache, reader, drain);
}
static void
gst_pinos_socket_sink_finalize (GObject * object)
{
GstPinosSocketSink *this = GST_PINOS_SOCKET_SINK (object);
g_clear_pointer (&this->hash, g_hash_table_unref);
g_clear_pointer (&this->cache, g_object_unref);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_pinos_socket_sink_class_init (GstPinosSocketSinkClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstBaseSinkClass *gstbasesink_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gstbasesink_class = (GstBaseSinkClass *) klass;
gobject_class->finalize = gst_pinos_socket_sink_finalize;
gobject_class->set_property = gst_pinos_socket_sink_set_property;
gobject_class->get_property = gst_pinos_socket_sink_get_property;
g_object_class_install_property (gobject_class, PROP_NUM_HANDLES,
g_param_spec_uint ("num-handles", "Number of handles",
"The current number of client handles",
0, G_MAXUINT, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
gstelement_class->change_state = gst_pinos_socket_sink_change_state;
/**
* GstPinosSocketSink::add:
* @gstpinossocketsink: the pinossocketsink element to emit this signal on
* @socket: the socket to add to pinossocketsink
*
* Hand the given open file descriptor to pinossocketsink to write to.
*/
gst_pinos_socket_sink_signals[SIGNAL_ADD] =
g_signal_new ("add", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GstPinosSocketSinkClass, add), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 1, G_TYPE_SOCKET);
/**
* GstPinosSocketSink::remove:
* @gstpinossocketsink: the pinossocketsink element to emit this signal on
* @socket: the socket to remove from pinossocketsink
* @drain: if pending data should be written first.
*
* Remove the given open file descriptor from pinossocketsink.
*/
gst_pinos_socket_sink_signals[SIGNAL_REMOVE] =
g_signal_new ("remove", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GstPinosSocketSinkClass, remove), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 2, G_TYPE_SOCKET, G_TYPE_BOOLEAN);
gst_element_class_set_static_metadata (gstelement_class,
"Pinos FD sink", "Sink/Video",
"Send data to pinos clients", "Wim Taymans <wim.taymans@gmail.com>");
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&gst_pinos_socket_sink_template));
gstbasesink_class->set_caps = gst_pinos_socket_sink_setcaps;
gstbasesink_class->propose_allocation = gst_pinos_socket_sink_propose_allocation;
gstbasesink_class->start = gst_pinos_socket_sink_start;
gstbasesink_class->stop = gst_pinos_socket_sink_stop;
gstbasesink_class->render = gst_pinos_socket_sink_render;
klass->add = GST_DEBUG_FUNCPTR (gst_pinos_socket_sink_add);
klass->remove = GST_DEBUG_FUNCPTR (gst_pinos_socket_sink_remove);
fdids_quark = g_quark_from_static_string ("GstPinosSocketSinkFDIds");
orig_buffer_quark = g_quark_from_static_string ("GstPinosSocketSinkOrigBuffer");
GST_DEBUG_CATEGORY_INIT (pinos_socket_sink_debug, "pinossocketsink", 0,
"Pinos Socket Sink");
}
static void
gst_pinos_socket_sink_init (GstPinosSocketSink * this)
{
this->hash = g_hash_table_new (g_direct_hash, g_direct_equal);
this->cache = gst_burst_cache_new (sizeof (MyReader));
this->allocator = gst_tmpfile_allocator_new ();
this->fdmanager = pinos_fd_manager_get (PINOS_FD_MANAGER_DEFAULT);
}

74
pinos/gst/gstpinossocketsink.h
View file

@ -1,74 +0,0 @@
/* GStreamer
* 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 __GST_PINOS_SOCKET_SINK_H__
#define __GST_PINOS_SOCKET_SINK_H__
#include <gio/gio.h>
#include <client/pinos.h>
#include <gst/gst.h>
#include <gst/base/gstbasesink.h>
#include <gst/gstburstcache.h>
G_BEGIN_DECLS
#define GST_TYPE_PINOS_SOCKET_SINK (gst_pinos_socket_sink_get_type())
#define GST_PINOS_SOCKET_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PINOS_SOCKET_SINK,GstPinosSocketSink))
#define GST_PINOS_SOCKET_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PINOS_SOCKET_SINK,GstPinosSocketSinkClass))
#define GST_IS_PINOS_SOCKET_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PINOS_SOCKET_SINK))
#define GST_IS_PINOS_SOCKET_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PINOS_SOCKET_SINK))
#define GST_PINOS_SOCKET_SINK_CAST(obj) ((GstPinosSocketSink *) (obj))
typedef struct _GstPinosSocketSink GstPinosSocketSink;
typedef struct _GstPinosSocketSinkClass GstPinosSocketSinkClass;
/**
* GstPinosSocketSink:
*
* Opaque data structure.
*/
struct _GstPinosSocketSink {
GstBaseSink element;
gboolean pinos_input;
GstAllocator *allocator;
GstBurstCache *cache;
GHashTable *hash;
GThread *thread;
GMainLoop *loop;
GMainContext *context;
PinosFdManager *fdmanager;
};
struct _GstPinosSocketSinkClass {
GstBaseSinkClass parent_class;
void (*add) (GstPinosSocketSink *sink, GSocket *socket);
void (*remove) (GstPinosSocketSink *sink, GSocket *socket, gboolean drain);
};
GType gst_pinos_socket_sink_get_type (void);
G_END_DECLS
#endif /* __GST_PINOS_SOCKET_SINK_H__ */

144
pinos/gst/gsttmpfileallocator.c
View file

@ -1,144 +0,0 @@
/* GStreamer
* Copyright (C) 2014 William Manley <will@williammanley.net>
*
* 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 "gsttmpfileallocator.h"
#include <gst/allocators/gstfdmemory.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define PAGE_ALIGN 4095
#define GST_TYPE_TMPFILE_ALLOCATOR (gst_tmpfile_allocator_get_type ())
typedef struct
{
GstFdAllocator parent;
} GstTmpFileAllocator;
typedef struct
{
GstFdAllocatorClass parent_class;
} GstTmpFileAllocatorClass;
GType gst_tmpfile_allocator_get_type (void);
G_DEFINE_TYPE (GstTmpFileAllocator, gst_tmpfile_allocator, GST_TYPE_FD_ALLOCATOR);
static int
tmpfile_create (GstTmpFileAllocator * allocator, gsize size)
{
char filename[] = "/dev/shm/tmpfilepay.XXXXXX";
int fd, result;
GST_DEBUG_OBJECT (allocator, "tmpfile_create");
fd = mkostemp (filename, O_CLOEXEC);
if (fd == -1) {
GST_WARNING_OBJECT (allocator, "Failed to create temporary file: %s",
strerror (errno));
return -1;
}
unlink (filename);
result = ftruncate (fd, size);
if (result == -1) {
GST_WARNING_OBJECT (allocator, "Failed to resize temporary file: %s",
strerror (errno));
close (fd);
return -1;
}
return fd;
}
inline static gsize
pad (gsize off, gsize align)
{
return (off + align) / (align + 1) * (align + 1);
}
static GstMemory *
gst_tmpfile_allocator_alloc (GstAllocator * allocator, gsize size,
GstAllocationParams * params)
{
GstTmpFileAllocator *alloc = (GstTmpFileAllocator *) allocator;
GstMemory *mem;
int fd;
gsize maxsize;
g_return_val_if_fail (params != NULL, NULL);
maxsize =
pad (size + pad (params->prefix, params->align) + params->padding,
PAGE_ALIGN);
fd = tmpfile_create (alloc, maxsize);
if (fd < 0)
return NULL;
mem = gst_fd_allocator_alloc (allocator, fd, maxsize, GST_FD_MEMORY_FLAG_NONE);
gst_memory_resize (mem, pad (params->prefix, params->align), size);
return mem;
}
static void
gst_tmpfile_allocator_class_init (GstTmpFileAllocatorClass * klass)
{
GstAllocatorClass *allocator_class;
allocator_class = (GstAllocatorClass *) klass;
allocator_class->alloc = gst_tmpfile_allocator_alloc;
}
static void
gst_tmpfile_allocator_init (GstTmpFileAllocator * allocator)
{
GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator);
alloc->mem_type = GST_ALLOCATOR_TMPFILE;
GST_OBJECT_FLAG_UNSET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);
}
GstAllocator *
gst_tmpfile_allocator_new (void)
{
return g_object_new (GST_TYPE_TMPFILE_ALLOCATOR, NULL);
}
gint
gst_tmpfile_memory_get_fd (GstMemory * mem)
{
g_return_val_if_fail (gst_is_tmpfile_memory (mem), -1);
return gst_fd_memory_get_fd (mem);
}
gboolean
gst_is_tmpfile_memory (GstMemory * mem)
{
return gst_memory_is_type (mem, GST_ALLOCATOR_TMPFILE);
}

37
pinos/gst/gsttmpfileallocator.h
View file

@ -1,37 +0,0 @@
/* GStreamer
* Copyright (C) 2014 William Manley <will@williammanley.net>
*
* 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 _GST_TMPFILE_ALLOCATOR_H_
#define _GST_TMPFILE_ALLOCATOR_H_
#include <gst/gst.h>
G_BEGIN_DECLS
#define GST_ALLOCATOR_TMPFILE "tmpfile"
/* Allocator that allocates memory from a file stored on a tmpfs */
GstAllocator* gst_tmpfile_allocator_new (void);
gint gst_tmpfile_memory_get_fd (GstMemory * mem);
gboolean gst_is_tmpfile_memory (GstMemory * mem);
G_END_DECLS
#endif /* _GST_TMPFILE_ALLOCATOR_H_ */

2
pinos/modules/spa/spa-alsa-sink.c
View file

@ -266,7 +266,7 @@ stop_pipeline (PinosSpaAlsaSink *sink)
pthread_join (priv->thread, NULL);
}
cmd.type = SPA_COMMAND_STOP;
cmd.type = SPA_COMMAND_PAUSE;
if ((res = spa_node_send_command (node->node, &cmd)) < 0)
g_debug ("got error %d", res);
}

2
pinos/modules/spa/spa-v4l2-source.c
View file

@ -238,7 +238,7 @@ stop_pipeline (PinosSpaV4l2Source *this)
pthread_join (priv->thread, NULL);
}
cmd.type = SPA_COMMAND_STOP;
cmd.type = SPA_COMMAND_PAUSE;
if ((res = spa_node_send_command (node->node, &cmd)) < 0)
g_debug ("got error %d", res);
}

8
pinos/server/link.c
View file

@ -252,6 +252,8 @@ again:
}
spa_debug_format (format);
spa_format_fixate (format);
if ((res = spa_node_port_set_format (priv->output_node, priv->output_port, 0, format)) < 0) {
g_warning ("error set format output: %d", res);
return res;
@ -383,13 +385,13 @@ do_start (PinosLink *this)
}
static SpaResult
do_stop (PinosLink *this)
do_pause (PinosLink *this)
{
PinosLinkPrivate *priv = this->priv;
SpaCommand cmd;
SpaResult res;
cmd.type = SPA_COMMAND_STOP;
cmd.type = SPA_COMMAND_PAUSE;
if ((res = spa_node_send_command (priv->input_node, &cmd)) < 0)
g_warning ("got error %d", res);
if ((res = spa_node_send_command (priv->output_node, &cmd)) < 0)
@ -476,7 +478,7 @@ on_deactivate (PinosPort *port, gpointer user_data)
else
pinos_port_deactivate (priv->input);
do_stop (this);
do_pause (this);
return TRUE;
}

2
pinos/tools/pinos-monitor.c
View file

@ -17,8 +17,6 @@
* Boston, MA 02110-1301, USA.
*/
#include <gst/gst.h>
#include <client/pinos.h>
static GMainLoop *loop;

2
spa/include/spa/command.h
View file

@ -30,8 +30,8 @@ typedef struct _SpaCommand SpaCommand;
typedef enum {
SPA_COMMAND_INVALID = 0,
SPA_COMMAND_PAUSE,
SPA_COMMAND_START,
SPA_COMMAND_STOP,
SPA_COMMAND_FLUSH,
SPA_COMMAND_DRAIN,
SPA_COMMAND_MARKER,

2
spa/include/spa/control.h
View file

@ -75,7 +75,7 @@ typedef enum {
SPA_CONTROL_CMD_SET_PROPERTY = 35,
SPA_CONTROL_CMD_START = 36,
SPA_CONTROL_CMD_STOP = 37,
SPA_CONTROL_CMD_PAUSE = 37,
/* both */
SPA_CONTROL_CMD_ADD_MEM = 64,

2
spa/include/spa/format.h
View file

@ -89,6 +89,8 @@ typedef enum {
SPA_PROP_ID_MEDIA_CUSTOM_START = 200,
} SpaFormatProps;
SpaResult spa_format_fixate (SpaFormat *format);
#ifdef __cplusplus
} /* extern "C" */
#endif

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

@ -119,8 +119,6 @@ typedef struct {
* @flags: property flags
* @type: property type
* @max_size: maximum size of property value
* @default_size: size of default value
* @default_value: default value of property
* @range_type: type of the range values
* @n_range_values: number of elements in @range_values
* @range_values: array of possible values
@ -134,8 +132,6 @@ typedef struct {
SpaPropFlags flags;
SpaPropType type;
size_t maxsize;
size_t default_size;
const void *default_value;
SpaPropRangeType range_type;
unsigned int n_range_values;
const SpaPropRangeInfo *range_values;

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

@ -140,49 +140,42 @@ static const SpaPropInfo raw_format_prop_info[] =
{ SPA_PROP_ID_AUDIO_FORMAT, "format", "The media format",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.format,
SPA_PROP_RANGE_TYPE_ENUM, SPA_N_ELEMENTS (format_format_range), format_format_range,
NULL,
offsetof (SpaAudioRawFormat, info.format) },
{ SPA_PROP_ID_AUDIO_FLAGS, "flags", "Sample Flags",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.flags,
SPA_PROP_RANGE_TYPE_FLAGS, SPA_N_ELEMENTS (flags_range), flags_range,
NULL,
offsetof (SpaAudioRawFormat, info.flags) },
{ SPA_PROP_ID_AUDIO_LAYOUT, "layout", "Sample Layout",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.layout,
SPA_PROP_RANGE_TYPE_ENUM, SPA_N_ELEMENTS (layouts_range), layouts_range,
NULL,
offsetof (SpaAudioRawFormat, info.layout) },
{ SPA_PROP_ID_AUDIO_RATE, "rate", "Audio sample rate",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.rate,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, uint32_range,
NULL,
offsetof (SpaAudioRawFormat, info.rate) },
{ SPA_PROP_ID_AUDIO_CHANNELS, "channels", "Audio channels",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.channels,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, uint32_range,
NULL,
offsetof (SpaAudioRawFormat, info.channels) },
{ SPA_PROP_ID_AUDIO_CHANNEL_MASK, "channel-mask", "Audio channel mask",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_BITMASK, sizeof (uint32_t),
sizeof (uint32_t), &default_info.channel_mask,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaAudioRawFormat, info.channel_mask) },
{ SPA_PROP_ID_AUDIO_RAW_INFO, "info", "the SpaAudioRawInfo structure",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_POINTER, sizeof (SpaAudioRawInfo),
0, NULL,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaAudioRawFormat, info) },

17
spa/lib/control.c
View file

@ -358,8 +358,6 @@ parse_props (SpaMemory *mem, void *p, off_t offset)
pi->name = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->name), char);
if (pi->description)
pi->description = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->description), char);
if (pi->default_value)
pi->default_value = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->default_value), void);
if (pi->range_values)
pi->range_values = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->range_values), SpaPropRangeInfo);
@ -528,7 +526,7 @@ spa_control_iter_parse_cmd (SpaControlIter *iter,
break;
case SPA_CONTROL_CMD_START:
case SPA_CONTROL_CMD_STOP:
case SPA_CONTROL_CMD_PAUSE:
break;
/* bidirectional */
@ -814,8 +812,8 @@ calc_props_len (const SpaProps *props)
len += sizeof (SpaPropInfo);
len += pi->name ? strlen (pi->name) + 1 : 0;
len += pi->description ? strlen (pi->description) + 1 : 0;
/* for the value and the default value */
len += pi->maxsize + pi->default_size;
/* for the value */
len += pi->maxsize;
for (j = 0; j < pi->n_range_values; j++) {
ri = (SpaPropRangeInfo *)&pi->range_values[j];
len += sizeof (SpaPropRangeInfo);
@ -879,13 +877,6 @@ write_props (void *p, const SpaProps *props, off_t offset)
} else {
pi->description = 0;
}
if (pi->default_value) {
memcpy (p, pi->default_value, pi->default_size);
pi->default_value = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tp));
p += pi->default_size;
} else {
pi->default_value = 0;
}
for (j = 0; j < pi->n_range_values; j++) {
if (ri->name) {
slen = strlen (ri->name) + 1;
@ -1157,7 +1148,7 @@ spa_control_builder_add_cmd (SpaControlBuilder *builder,
break;
case SPA_CONTROL_CMD_START:
case SPA_CONTROL_CMD_STOP:
case SPA_CONTROL_CMD_PAUSE:
p = builder_add_cmd (sb, cmd, 0);
break;

6
spa/lib/debug.c
View file

@ -328,12 +328,6 @@ spa_debug_props (const SpaProps *props, bool print_ranges)
fprintf (stderr, "%-23.23s %s. ", "", prop_type_names[info->type].CCName);
fprintf (stderr, "Default: ");
if (info->default_value)
print_value (info, info->default_size, info->default_value);
else
fprintf (stderr, "None");
res = spa_props_get_prop (props, i, &value);
fprintf (stderr, ". Current: ");

47
spa/lib/format.c
View file

@ -27,10 +27,53 @@
SpaResult
spa_format_to_string (const SpaFormat *format, char **result)
{
SpaResult res;
if (format == NULL || result == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return SPA_RESULT_OK;
}
SpaResult
spa_format_fixate (SpaFormat *format)
{
unsigned int i, j;
SpaProps *props;
uint32_t mask;
if (format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
props = &format->props;
mask = props->unset_mask;
for (i = 0; i < props->n_prop_info; i++) {
if (mask & 1) {
const SpaPropInfo *pi = &props->prop_info[i];
switch (pi->range_type) {
case SPA_PROP_RANGE_TYPE_NONE:
break;
case SPA_PROP_RANGE_TYPE_MIN_MAX:
break;
case SPA_PROP_RANGE_TYPE_STEP:
break;
case SPA_PROP_RANGE_TYPE_ENUM:
{
for (j = 0; j < pi->n_range_values; j++) {
const SpaPropRangeInfo *ri = &pi->range_values[j];
memcpy (SPA_MEMBER (props, pi->offset, void), ri->value, ri->size);
props->unset_mask &= ~(1 << i);
break;
}
break;
}
case SPA_PROP_RANGE_TYPE_FLAGS:
break;
default:
break;
}
}
mask >>= 1;
}
return SPA_RESULT_OK;
}

1
spa/lib/meson.build
View file

@ -2,6 +2,7 @@ spalib_sources = ['audio-raw.c',
'buffer.c',
'control.c',
'debug.c',
'format.c',
'memory.c',
'props.c',
'ringbuffer.c',

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

@ -376,105 +376,90 @@ static const SpaPropInfo raw_format_prop_info[] =
{ SPA_PROP_ID_VIDEO_FORMAT, "format", "The media format",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.format,
SPA_PROP_RANGE_TYPE_ENUM, SPA_N_ELEMENTS (format_range), format_range,
NULL,
offsetof (SpaVideoRawFormat, info.format) },
{ SPA_PROP_ID_VIDEO_SIZE, "size", "Video size",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_RECTANGLE, sizeof (SpaRectangle),
sizeof (SpaRectangle), &default_info.size,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, size_range,
NULL,
offsetof (SpaVideoRawFormat, info.size) },
{ SPA_PROP_ID_VIDEO_FRAMERATE, "framerate", "Video framerate",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_FRACTION, sizeof (SpaFraction),
sizeof (SpaFraction), &default_info.framerate,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, framerate_range,
NULL,
offsetof (SpaVideoRawFormat, info.framerate) },
{ SPA_PROP_ID_VIDEO_MAX_FRAMERATE, "max-framerate", "Video max framerate",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_FRACTION, sizeof (SpaFraction),
sizeof (SpaFraction), &default_info.max_framerate,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, framerate_range,
NULL,
offsetof (SpaVideoRawFormat, info.max_framerate) },
{ SPA_PROP_ID_VIDEO_VIEWS, "views", "Video number of views",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.views,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, uint32_range,
NULL,
offsetof (SpaVideoRawFormat, info.views) },
{ SPA_PROP_ID_VIDEO_INTERLACE_MODE, "interlace-mode", "Interlace mode",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.interlace_mode,
SPA_PROP_RANGE_TYPE_ENUM, SPA_N_ELEMENTS (interlace_mode_range), interlace_mode_range,
NULL,
offsetof (SpaVideoRawFormat, info.interlace_mode) },
{ SPA_PROP_ID_VIDEO_PIXEL_ASPECT_RATIO, "pixel-aspect-ratio", "Video pixel aspect ratio",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_FRACTION, sizeof (SpaFraction),
sizeof (SpaFraction), &default_info.pixel_aspect_ratio,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, framerate_range,
NULL,
offsetof (SpaVideoRawFormat, info.pixel_aspect_ratio) },
{ SPA_PROP_ID_VIDEO_MULTIVIEW_MODE, "multiview-mode", "Multiview mode",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.multiview_mode,
SPA_PROP_RANGE_TYPE_ENUM, SPA_N_ELEMENTS (multiview_mode_range), multiview_mode_range,
NULL,
offsetof (SpaVideoRawFormat, info.multiview_mode) },
{ SPA_PROP_ID_VIDEO_MULTIVIEW_FLAGS, "multiview-flags", "Multiview flags",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.multiview_flags,
SPA_PROP_RANGE_TYPE_FLAGS, SPA_N_ELEMENTS (multiview_flags_range), multiview_flags_range,
NULL,
offsetof (SpaVideoRawFormat, info.multiview_flags) },
{ SPA_PROP_ID_VIDEO_CHROMA_SITE, "chroma-site", "Chroma site",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.chroma_site,
SPA_PROP_RANGE_TYPE_FLAGS, SPA_N_ELEMENTS (chroma_site_range), chroma_site_range,
NULL,
offsetof (SpaVideoRawFormat, info.chroma_site) },
{ SPA_PROP_ID_VIDEO_COLOR_RANGE, "color-range", "Color range",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.color_range,
SPA_PROP_RANGE_TYPE_ENUM, SPA_N_ELEMENTS (color_range_range), color_range_range,
NULL,
offsetof (SpaVideoRawFormat, info.color_range) },
{ SPA_PROP_ID_VIDEO_COLOR_MATRIX, "color-matrix", "Color matrix",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.color_matrix,
SPA_PROP_RANGE_TYPE_ENUM, SPA_N_ELEMENTS (color_matrix_range), color_matrix_range,
NULL,
offsetof (SpaVideoRawFormat, info.color_matrix) },
{ SPA_PROP_ID_VIDEO_TRANSFER_FUNCTION, "transfer-function", "Transfer function",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.transfer_function,
SPA_PROP_RANGE_TYPE_ENUM, SPA_N_ELEMENTS (transfer_function_range), transfer_function_range,
NULL,
offsetof (SpaVideoRawFormat, info.transfer_function) },
{ SPA_PROP_ID_VIDEO_COLOR_PRIMARIES, "color-primaries", "Color primaries",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_info.color_primaries,
SPA_PROP_RANGE_TYPE_ENUM, SPA_N_ELEMENTS (color_primaries_range), color_primaries_range,
NULL,
offsetof (SpaVideoRawFormat, info.color_primaries) },
{ SPA_PROP_ID_VIDEO_RAW_INFO, "info", "the SpaVideoRawInfo structure",
SPA_PROP_FLAG_READWRITE | SPA_PROP_FLAG_OPTIONAL,
SPA_PROP_TYPE_POINTER, sizeof (SpaVideoRawInfo),
0, NULL,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaVideoRawFormat, info) },

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

@ -126,42 +126,36 @@ static const SpaPropInfo prop_info[] =
{ PROP_ID_DEVICE, "device", "ALSA device, as defined in an asound configuration file",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_STRING, 63,
strlen (default_device)+1, default_device,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaALSASinkProps, device) },
{ PROP_ID_DEVICE_NAME, "device-name", "Human-readable name of the sound device",
SPA_PROP_FLAG_READABLE,
SPA_PROP_TYPE_STRING, 127,
0, NULL,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaALSASinkProps, device_name) },
{ PROP_ID_CARD_NAME, "card-name", "Human-readable name of the sound card",
SPA_PROP_FLAG_READABLE,
SPA_PROP_TYPE_STRING, 127,
0, NULL,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaALSASinkProps, card_name) },
{ PROP_ID_BUFFER_TIME, "buffer-time", "The total size of the buffer in time",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_buffer_time,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, uint32_range,
NULL,
offsetof (SpaALSASinkProps, buffer_time) },
{ PROP_ID_PERIOD_TIME, "period-time", "The size of a period in time",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_period_time,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, uint32_range,
NULL,
offsetof (SpaALSASinkProps, period_time) },
{ PROP_ID_PERIOD_EVENT, "period-event", "Generate an event each period",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_BOOL, sizeof (bool),
sizeof (bool), &default_period_event,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaALSASinkProps, period_event) },
@ -239,7 +233,7 @@ spa_alsa_sink_node_send_command (SpaNode *node,
this->event_cb (node, &event, this->user_data);
}
break;
case SPA_COMMAND_STOP:
case SPA_COMMAND_PAUSE:
spa_alsa_stop (this);
if (this->event_cb) {
@ -250,7 +244,7 @@ spa_alsa_sink_node_send_command (SpaNode *node,
event.port_id = -1;
event.data = &sc;
event.size = sizeof (sc);
sc.state = SPA_NODE_STATE_STREAMING;
sc.state = SPA_NODE_STATE_PAUSED;
this->event_cb (node, &event, this->user_data);
}

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

@ -161,7 +161,7 @@ spa_audiomixer_node_send_command (SpaNode *node,
}
break;
case SPA_COMMAND_STOP:
case SPA_COMMAND_PAUSE:
if (this->event_cb) {
SpaEvent event;
SpaEventStateChange sc;

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

@ -87,21 +87,18 @@ static const SpaPropInfo prop_info[] =
{ PROP_ID_WAVE, "wave", "Oscillator waveform",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
sizeof (uint32_t), &default_wave,
SPA_PROP_RANGE_TYPE_ENUM, SPA_N_ELEMENTS (wave_range), wave_range,
NULL,
offsetof (SpaAudioTestSrcProps, wave) },
{ PROP_ID_FREQ, "freq", "Frequency of test signal. The sample rate needs to be at least 4 times higher",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_DOUBLE, sizeof (double),
sizeof (double), &default_freq,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, freq_range,
NULL,
offsetof (SpaAudioTestSrcProps, freq) },
{ PROP_ID_VOLUME, "volume", "The Volume factor",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_DOUBLE, sizeof (double),
sizeof (double), &default_volume,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, volume_range,
NULL,
offsetof (SpaAudioTestSrcProps, volume) },
@ -185,7 +182,7 @@ spa_audiotestsrc_node_send_command (SpaNode *node,
}
break;
case SPA_COMMAND_STOP:
case SPA_COMMAND_PAUSE:
if (this->event_cb) {
SpaEvent event;
SpaEventStateChange sc;

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

@ -156,7 +156,7 @@ spa_ffmpeg_dec_node_send_command (SpaNode *node,
this->event_cb (node, &event, this->user_data);
}
break;
case SPA_COMMAND_STOP:
case SPA_COMMAND_PAUSE:
if (this->event_cb) {
SpaEvent event;
SpaEventStateChange sc;

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

@ -156,7 +156,7 @@ spa_ffmpeg_enc_node_send_command (SpaNode *node,
this->event_cb (node, &event, this->user_data);
}
break;
case SPA_COMMAND_STOP:
case SPA_COMMAND_PAUSE:
if (this->event_cb) {
SpaEvent event;
SpaEventStateChange sc;

12
spa/plugins/remote/proxy.c
View file

@ -91,7 +91,6 @@ static const SpaPropInfo prop_info[PROP_ID_LAST] =
{ PROP_ID_SOCKET, "socket", "The Socket factor",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_INT, sizeof (int),
sizeof (int), NULL,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaProxyProps, socketfd) },
@ -234,7 +233,7 @@ spa_proxy_node_send_command (SpaNode *node,
break;
}
case SPA_COMMAND_STOP:
case SPA_COMMAND_PAUSE:
{
SpaControlBuilder builder;
SpaControl control;
@ -242,7 +241,7 @@ spa_proxy_node_send_command (SpaNode *node,
/* send start */
spa_control_builder_init_into (&builder, buf, sizeof (buf), NULL, 0);
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_STOP, NULL);
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_PAUSE, NULL);
spa_control_builder_end (&builder, &control);
if ((res = spa_control_write (&control, this->fds[0].fd)) < 0)
@ -342,13 +341,16 @@ do_update_port (SpaProxy *this,
SpaEvent event;
SpaProxyPort *port;
SpaEventPortAdded pa;
unsigned int i;
port = &this->ports[pu->port_id];
if (pu->change_mask & SPA_CONTROL_CMD_PORT_UPDATE_POSSIBLE_FORMATS) {
port->n_formats = pu->n_possible_formats;
port->formats = pu->possible_formats;
for (i = 0; i < port->n_formats; i++)
spa_debug_format (port->formats[i]);
}
if (pu->change_mask & SPA_CONTROL_CMD_PORT_UPDATE_PROPS) {
@ -969,7 +971,7 @@ parse_control (SpaProxy *this,
case SPA_CONTROL_CMD_SET_FORMAT:
case SPA_CONTROL_CMD_SET_PROPERTY:
case SPA_CONTROL_CMD_START:
case SPA_CONTROL_CMD_STOP:
case SPA_CONTROL_CMD_PAUSE:
fprintf (stderr, "proxy %p: got unexpected control %d\n", this, cmd);
break;

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

@ -142,21 +142,18 @@ static const SpaPropInfo prop_info[] =
{ PROP_ID_DEVICE, "device", "V4l2 device location",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_STRING, 63,
strlen (default_device)+1, default_device,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaV4l2SourceProps, device) },
{ PROP_ID_DEVICE_NAME, "device-name", "Human-readable name of the device",
SPA_PROP_FLAG_READABLE,
SPA_PROP_TYPE_STRING, 127,
0, NULL,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaV4l2SourceProps, device_name) },
{ PROP_ID_DEVICE_FD, "device-fd", "Device file descriptor",
SPA_PROP_FLAG_READABLE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
0, NULL,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaV4l2SourceProps, device_fd) },
@ -237,7 +234,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
send_state_change (this, SPA_NODE_STATE_STREAMING);
break;
case SPA_COMMAND_STOP:
case SPA_COMMAND_PAUSE:
spa_v4l2_stop (this);
send_state_change (this, SPA_NODE_STATE_PAUSED);

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

@ -385,13 +385,13 @@ spa_v4l2_set_format (SpaV4l2Source *this, V4l2Format *f, bool try_only)
fmt.fmt.pix.field = V4L2_FIELD_ANY;
fmt.fmt.pix.width = f->size.width;
fmt.fmt.pix.height = f->size.height;
streamparm.parm.capture.timeperframe.numerator = f->framerate.denom;
streamparm.parm.capture.timeperframe.denominator = f->framerate.num;
streamparm.parm.capture.timeperframe.numerator = f->framerate.num;
streamparm.parm.capture.timeperframe.denominator = f->framerate.denom;
fprintf (stderr, "set %08x %dx%d %d/%d\n", fmt.fmt.pix.pixelformat,
fmt.fmt.pix.width, fmt.fmt.pix.height,
streamparm.parm.capture.timeperframe.denominator,
streamparm.parm.capture.timeperframe.numerator);
streamparm.parm.capture.timeperframe.numerator,
streamparm.parm.capture.timeperframe.denominator);
reqfmt = fmt;
@ -407,6 +407,11 @@ spa_v4l2_set_format (SpaV4l2Source *this, V4l2Format *f, bool try_only)
if (xioctl (state->fd, VIDIOC_S_PARM, &streamparm) < 0)
perror ("VIDIOC_S_PARM");
fprintf (stderr, "got %08x %dx%d %d/%d\n", fmt.fmt.pix.pixelformat,
fmt.fmt.pix.width, fmt.fmt.pix.height,
streamparm.parm.capture.timeperframe.numerator,
streamparm.parm.capture.timeperframe.denominator);
if (reqfmt.fmt.pix.pixelformat != fmt.fmt.pix.pixelformat ||
reqfmt.fmt.pix.width != fmt.fmt.pix.width ||
reqfmt.fmt.pix.height != fmt.fmt.pix.height)

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

@ -78,14 +78,12 @@ static const SpaPropInfo prop_info[] =
{ PROP_ID_VOLUME, "volume", "The Volume factor",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_DOUBLE, sizeof (double),
sizeof (double), &default_volume,
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, volume_range,
NULL,
offsetof (SpaVolumeProps, volume) },
{ PROP_ID_MUTE, "mute", "Mute",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_BOOL, sizeof (bool),
sizeof (bool), &default_mute,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaVolumeProps, mute) },
@ -168,7 +166,7 @@ spa_volume_node_send_command (SpaNode *node,
}
break;
case SPA_COMMAND_STOP:
case SPA_COMMAND_PAUSE:
if (this->event_cb) {
SpaEvent event;
SpaEventStateChange sc;

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

@ -100,21 +100,18 @@ static const SpaPropInfo prop_info[] =
{ PROP_ID_DEVICE, "device", "Xv device location",
SPA_PROP_FLAG_READWRITE,
SPA_PROP_TYPE_STRING, 63,
strlen (default_device)+1, default_device,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaXvSinkProps, device) },
{ PROP_ID_DEVICE_NAME, "device-name", "Human-readable name of the device",
SPA_PROP_FLAG_READABLE,
SPA_PROP_TYPE_STRING, 127,
0, NULL,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaXvSinkProps, device_name) },
{ PROP_ID_DEVICE_FD, "device-fd", "Device file descriptor",
SPA_PROP_FLAG_READABLE,
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
0, NULL,
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
NULL,
offsetof (SpaXvSinkProps, device_fd) },
@ -192,7 +189,7 @@ spa_xv_sink_node_send_command (SpaNode *node,
this->event_cb (node, &event, this->user_data);
}
break;
case SPA_COMMAND_STOP:
case SPA_COMMAND_PAUSE:
spa_xv_stop (this);
if (this->event_cb) {

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

@ -331,7 +331,7 @@ run_async_sink (AppData *data)
pthread_join (data->thread, NULL);
}
cmd.type = SPA_COMMAND_STOP;
cmd.type = SPA_COMMAND_PAUSE;
if ((res = spa_node_send_command (data->sink, &cmd)) < 0)
printf ("got error %d\n", res);
}

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

@ -439,7 +439,7 @@ run_async_source (AppData *data)
pthread_join (data->thread, NULL);
}
cmd.type = SPA_COMMAND_STOP;
cmd.type = SPA_COMMAND_PAUSE;
if ((res = spa_node_send_command (data->source, &cmd)) < 0)
printf ("got error %d\n", res);
}