mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-10-29 05:40:27 -04:00
More hacking
Add spa based v4l2 pinos module Add allocation params to port_alloc_buffers Let the app do allocation for handles.
This commit is contained in:
Wim Taymans
parent
4c7cee6b28
commit
6ab8af91e0
41 changed files with 4733 additions and 351 deletions
|
|
@ -223,6 +223,7 @@ libpinoscore_@PINOS_MAJORMINOR@_la_SOURCES = \
|
|||
modules/gst/gst-sink.c modules/gst/gst-sink.h \
|
||||
modules/gst/gst-node-factory.c modules/gst/gst-node-factory.h \
|
||||
modules/spa/spa-alsa-sink.c modules/spa/spa-alsa-sink.h \
|
||||
modules/spa/spa-v4l2-source.c modules/spa/spa-v4l2-source.h \
|
||||
dbus/org-pinos.c dbus/org-pinos.h
|
||||
|
||||
libpinoscore_@PINOS_MAJORMINOR@_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS)
|
||||
|
|
|
|||
|
|
@ -46,6 +46,7 @@ main (gint argc, gchar *argv[])
|
|||
pinos_daemon_add_node_factory (daemon, factory);
|
||||
|
||||
pinos_spa_alsa_sink_new (daemon, "alsa-sink", NULL);
|
||||
pinos_spa_v4l2_source_new (daemon, "v4l2-source", NULL);
|
||||
pinos_daemon_start (daemon);
|
||||
|
||||
g_main_loop_run (loop);
|
||||
|
|
|
|||
|
|
@ -146,7 +146,7 @@ on_sink_event (SpaHandle *handle, SpaEvent *event, void *user_data)
|
|||
iinfo.event = oinfo.event;
|
||||
|
||||
g_debug ("push sink %p", iinfo.buffer);
|
||||
if ((res = priv->sink_node->push_port_input (priv->sink, 1, &iinfo)) < 0)
|
||||
if ((res = priv->sink_node->port_push_input (priv->sink, 1, &iinfo)) < 0)
|
||||
g_debug ("got error %d", res);
|
||||
break;
|
||||
}
|
||||
|
|
@ -314,7 +314,7 @@ negotiate_formats (PinosSpaAlsaSink *this)
|
|||
uint32_t val;
|
||||
SpaPropValue value;
|
||||
|
||||
if ((res = priv->sink_node->enum_port_formats (priv->sink, 0, 0, &format)) < 0)
|
||||
if ((res = priv->sink_node->port_enum_formats (priv->sink, 0, 0, &format)) < 0)
|
||||
return res;
|
||||
|
||||
props = &format->props;
|
||||
|
|
@ -336,7 +336,7 @@ negotiate_formats (PinosSpaAlsaSink *this)
|
|||
if ((res = props->set_prop (props, spa_props_index_for_id (props, SPA_PROP_ID_AUDIO_CHANNELS), &value)) < 0)
|
||||
return res;
|
||||
|
||||
if ((res = priv->sink_node->set_port_format (priv->sink, 0, 0, format)) < 0)
|
||||
if ((res = priv->sink_node->port_set_format (priv->sink, 0, 0, format)) < 0)
|
||||
return res;
|
||||
|
||||
priv->ringbuffer = pinos_ringbuffer_new (PINOS_RINGBUFFER_MODE_READ, 64 * 1024);
|
||||
|
|
|
|||
645
pinos/modules/spa/spa-v4l2-source.c
Normal file
645
pinos/modules/spa/spa-v4l2-source.c
Normal file
|
|
@ -0,0 +1,645 @@
|
|||
/* Pinos
|
||||
* Copyright (C) 2015 Wim Taymans <wim.taymans@gmail.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <errno.h>
|
||||
#include <poll.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/mman.h>
|
||||
|
||||
#include <gio/gio.h>
|
||||
|
||||
#include <spa/include/spa/node.h>
|
||||
#include <spa/include/spa/video/format.h>
|
||||
|
||||
#include "spa-v4l2-source.h"
|
||||
|
||||
#define PINOS_SPA_V4L2_SOURCE_GET_PRIVATE(obj) \
|
||||
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), PINOS_TYPE_SPA_V4L2_SOURCE, PinosSpaV4l2SourcePrivate))
|
||||
|
||||
typedef struct {
|
||||
PinosSpaV4l2Source *source;
|
||||
|
||||
gboolean have_format;
|
||||
PinosServerPort *port;
|
||||
} SourcePortData;
|
||||
|
||||
struct _PinosSpaV4l2SourcePrivate
|
||||
{
|
||||
SpaHandle *source;
|
||||
const SpaNode *source_node;
|
||||
|
||||
SpaPollFd fds[16];
|
||||
unsigned int n_fds;
|
||||
SpaPollItem poll;
|
||||
|
||||
gboolean running;
|
||||
pthread_t thread;
|
||||
|
||||
const void *format;
|
||||
|
||||
GList *ports;
|
||||
PinosFdManager *fdmanager;
|
||||
};
|
||||
|
||||
enum {
|
||||
PROP_0,
|
||||
};
|
||||
|
||||
G_DEFINE_TYPE (PinosSpaV4l2Source, pinos_spa_v4l2_source, PINOS_TYPE_SERVER_NODE);
|
||||
|
||||
static SpaResult
|
||||
make_node (SpaHandle **handle, const SpaNode **node, const char *lib, const char *name)
|
||||
{
|
||||
SpaResult res;
|
||||
void *hnd;
|
||||
SpaEnumHandleFactoryFunc enum_func;
|
||||
unsigned int i;
|
||||
|
||||
if ((hnd = dlopen (lib, RTLD_NOW)) == NULL) {
|
||||
g_error ("can't load %s: %s", lib, dlerror());
|
||||
return SPA_RESULT_ERROR;
|
||||
}
|
||||
if ((enum_func = dlsym (hnd, "spa_enum_handle_factory")) == NULL) {
|
||||
g_error ("can't find enum function");
|
||||
return SPA_RESULT_ERROR;
|
||||
}
|
||||
|
||||
for (i = 0; ;i++) {
|
||||
const SpaHandleFactory *factory;
|
||||
const void *iface;
|
||||
|
||||
if ((res = enum_func (i, &factory)) < 0) {
|
||||
if (res != SPA_RESULT_ENUM_END)
|
||||
g_error ("can't enumerate factories: %d", res);
|
||||
break;
|
||||
}
|
||||
if (strcmp (factory->name, name))
|
||||
continue;
|
||||
|
||||
if ((res = factory->instantiate (factory, handle)) < 0) {
|
||||
g_error ("can't make factory instance: %d", res);
|
||||
return res;
|
||||
}
|
||||
if ((res = (*handle)->get_interface (*handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
|
||||
g_error ("can't get interface %d", res);
|
||||
return res;
|
||||
}
|
||||
*node = iface;
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
return SPA_RESULT_ERROR;
|
||||
}
|
||||
|
||||
static void
|
||||
send_format (PinosSpaV4l2Source *source, SourcePortData *data)
|
||||
{
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
GError *error = NULL;
|
||||
PinosBufferBuilder builder;
|
||||
PinosBuffer pbuf;
|
||||
PinosPacketFormatChange fc;
|
||||
guint8 buf[1024];
|
||||
|
||||
pinos_buffer_builder_init_into (&builder, buf, 1024, NULL, 0);
|
||||
fc.id = 0;
|
||||
fc.format = priv->format;
|
||||
pinos_buffer_builder_add_format_change (&builder, &fc);
|
||||
pinos_buffer_builder_end (&builder, &pbuf);
|
||||
|
||||
if (!pinos_port_send_buffer (PINOS_PORT (data->port), &pbuf, &error)) {
|
||||
g_debug ("format update failed: %s", error->message);
|
||||
g_clear_error (&error);
|
||||
}
|
||||
pinos_buffer_unref (&pbuf);
|
||||
|
||||
data->have_format = TRUE;
|
||||
}
|
||||
|
||||
static int
|
||||
tmpfile_create (PinosSpaV4l2Source * source, void *data, gsize size)
|
||||
{
|
||||
char filename[] = "/dev/shm/tmpfilepay.XXXXXX";
|
||||
int fd, result;
|
||||
void *p;
|
||||
|
||||
fd = mkostemp (filename, O_CLOEXEC);
|
||||
if (fd == -1) {
|
||||
g_debug ("Failed to create temporary file: %s", strerror (errno));
|
||||
return -1;
|
||||
}
|
||||
unlink (filename);
|
||||
|
||||
result = ftruncate (fd, size);
|
||||
if (result == -1) {
|
||||
g_debug ("Failed to resize temporary file: %s", strerror (errno));
|
||||
close (fd);
|
||||
return -1;
|
||||
}
|
||||
p = mmap (0, size, PROT_WRITE, MAP_SHARED, fd, 0);
|
||||
memcpy (p, data, size);
|
||||
munmap (p, size);
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
static void
|
||||
on_source_event (SpaHandle *handle, SpaEvent *event, void *user_data)
|
||||
{
|
||||
PinosSpaV4l2Source *source = user_data;
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
|
||||
switch (event->type) {
|
||||
case SPA_EVENT_TYPE_CAN_PULL_OUTPUT:
|
||||
{
|
||||
SpaOutputInfo info[1] = { 0, };
|
||||
SpaResult res;
|
||||
SpaBuffer *b;
|
||||
PinosBuffer pbuf;
|
||||
PinosBufferBuilder builder;
|
||||
PinosPacketHeader hdr;
|
||||
PinosPacketFDPayload p;
|
||||
GList *walk;
|
||||
gint fd;
|
||||
guint8 buf[1024];
|
||||
gint fdbuf[8];
|
||||
|
||||
if ((res = priv->source_node->port_pull_output (priv->source, 1, info)) < 0)
|
||||
g_debug ("spa-v4l2-source %p: got pull error %d", source, res);
|
||||
|
||||
b = info[0].buffer;
|
||||
|
||||
hdr.flags = 0;
|
||||
hdr.seq = 0;
|
||||
hdr.pts = 0;
|
||||
hdr.dts_offset = 0;
|
||||
|
||||
pinos_buffer_builder_init_into (&builder, buf, 1024, fdbuf, 8);
|
||||
pinos_buffer_builder_add_header (&builder, &hdr);
|
||||
|
||||
fd = tmpfile_create (source, b->datas[0].data, b->size);
|
||||
p.fd_index = pinos_buffer_builder_add_fd (&builder, fd);
|
||||
p.id = pinos_fd_manager_get_id (priv->fdmanager);
|
||||
p.offset = 0;
|
||||
p.size = b->size;
|
||||
pinos_buffer_builder_add_fd_payload (&builder, &p);
|
||||
pinos_buffer_builder_end (&builder, &pbuf);
|
||||
|
||||
for (walk = priv->ports; walk; walk = g_list_next (walk)) {
|
||||
SourcePortData *data = walk->data;
|
||||
GError *error = NULL;
|
||||
|
||||
if (!data->have_format)
|
||||
send_format (source, data);
|
||||
|
||||
if (!pinos_port_send_buffer (PINOS_PORT (data->port), &pbuf, &error)) {
|
||||
g_debug ("send failed: %s", error->message);
|
||||
g_clear_error (&error);
|
||||
}
|
||||
}
|
||||
pinos_buffer_unref (&pbuf);
|
||||
|
||||
spa_buffer_unref (b);
|
||||
break;
|
||||
}
|
||||
|
||||
case SPA_EVENT_TYPE_ADD_POLL:
|
||||
{
|
||||
SpaPollItem *poll = event->data;
|
||||
|
||||
priv->poll = *poll;
|
||||
priv->fds[0] = poll->fds[0];
|
||||
priv->n_fds = 1;
|
||||
priv->poll.fds = priv->fds;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
g_debug ("got event %d", event->type);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
create_pipeline (PinosSpaV4l2Source *this)
|
||||
{
|
||||
PinosSpaV4l2SourcePrivate *priv = this->priv;
|
||||
SpaResult res;
|
||||
SpaProps *props;
|
||||
SpaPropValue value;
|
||||
|
||||
if ((res = make_node (&priv->source,
|
||||
&priv->source_node,
|
||||
"spa/build/plugins/v4l2/libspa-v4l2.so",
|
||||
"v4l2-source")) < 0) {
|
||||
g_error ("can't create v4l2-source: %d", res);
|
||||
return;
|
||||
}
|
||||
priv->source_node->set_event_callback (priv->source, on_source_event, this);
|
||||
|
||||
if ((res = priv->source_node->get_props (priv->source, &props)) < 0)
|
||||
g_debug ("got get_props error %d", res);
|
||||
|
||||
value.type = SPA_PROP_TYPE_STRING;
|
||||
value.value = "/dev/video1";
|
||||
value.size = strlen (value.value)+1;
|
||||
props->set_prop (props, spa_props_index_for_name (props, "device"), &value);
|
||||
|
||||
if ((res = priv->source_node->set_props (priv->source, props)) < 0)
|
||||
g_debug ("got set_props error %d", res);
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
negotiate_formats (PinosSpaV4l2Source *this)
|
||||
{
|
||||
PinosSpaV4l2SourcePrivate *priv = this->priv;
|
||||
SpaResult res;
|
||||
SpaFormat *format;
|
||||
SpaProps *props;
|
||||
uint32_t val;
|
||||
SpaPropValue value;
|
||||
SpaFraction frac;
|
||||
|
||||
if ((res = priv->source_node->port_enum_formats (priv->source, 0, 0, &format)) < 0)
|
||||
return res;
|
||||
|
||||
props = &format->props;
|
||||
|
||||
value.type = SPA_PROP_TYPE_UINT32;
|
||||
value.size = sizeof (uint32_t);
|
||||
value.value = &val;
|
||||
|
||||
val = SPA_VIDEO_FORMAT_YUY2;
|
||||
if ((res = props->set_prop (props, spa_props_index_for_id (props, SPA_PROP_ID_VIDEO_FORMAT), &value)) < 0)
|
||||
return res;
|
||||
val = 320;
|
||||
if ((res = props->set_prop (props, spa_props_index_for_id (props, SPA_PROP_ID_VIDEO_WIDTH), &value)) < 0)
|
||||
return res;
|
||||
val = 240;
|
||||
if ((res = props->set_prop (props, spa_props_index_for_id (props, SPA_PROP_ID_VIDEO_HEIGHT), &value)) < 0)
|
||||
return res;
|
||||
|
||||
value.type = SPA_PROP_TYPE_FRACTION;
|
||||
value.size = sizeof (SpaFraction);
|
||||
value.value = &frac;
|
||||
|
||||
frac.num = 25;
|
||||
frac.denom = 1;
|
||||
if ((res = props->set_prop (props, spa_props_index_for_id (props, SPA_PROP_ID_VIDEO_FRAMERATE), &value)) < 0)
|
||||
return res;
|
||||
|
||||
if ((res = priv->source_node->port_set_format (priv->source, 0, 0, format)) < 0)
|
||||
return res;
|
||||
|
||||
priv->format = "video/x-raw,"
|
||||
" format=(string)YUY2,"
|
||||
" width=(int)320,"
|
||||
" height=(int)240,"
|
||||
" framerate=(fraction)30/1";
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static void *
|
||||
loop (void *user_data)
|
||||
{
|
||||
PinosSpaV4l2Source *this = user_data;
|
||||
PinosSpaV4l2SourcePrivate *priv = this->priv;
|
||||
int r;
|
||||
|
||||
g_debug ("spa-v4l2-source %p: enter thread", this);
|
||||
while (priv->running) {
|
||||
SpaPollNotifyData ndata;
|
||||
|
||||
r = poll ((struct pollfd *) priv->fds, priv->n_fds, -1);
|
||||
if (r < 0) {
|
||||
if (errno == EINTR)
|
||||
continue;
|
||||
break;
|
||||
}
|
||||
if (r == 0) {
|
||||
g_debug ("spa-v4l2-source %p: select timeout", this);
|
||||
break;
|
||||
}
|
||||
if (priv->poll.after_cb) {
|
||||
ndata.fds = priv->poll.fds;
|
||||
ndata.n_fds = priv->poll.n_fds;
|
||||
ndata.user_data = priv->poll.user_data;
|
||||
priv->poll.after_cb (&ndata);
|
||||
}
|
||||
}
|
||||
g_debug ("spa-v4l2-source %p: leave thread", this);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
start_pipeline (PinosSpaV4l2Source *source)
|
||||
{
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
SpaResult res;
|
||||
SpaCommand cmd;
|
||||
int err;
|
||||
|
||||
g_debug ("spa-v4l2-source %p: starting pipeline", source);
|
||||
negotiate_formats (source);
|
||||
|
||||
cmd.type = SPA_COMMAND_START;
|
||||
if ((res = priv->source_node->send_command (priv->source, &cmd)) < 0)
|
||||
g_debug ("got error %d", res);
|
||||
|
||||
priv->running = true;
|
||||
if ((err = pthread_create (&priv->thread, NULL, loop, source)) != 0) {
|
||||
g_debug ("spa-v4l2-source %p: can't create thread", strerror (err));
|
||||
priv->running = false;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
stop_pipeline (PinosSpaV4l2Source *source)
|
||||
{
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
SpaResult res;
|
||||
SpaCommand cmd;
|
||||
|
||||
g_debug ("spa-v4l2-source %p: stopping pipeline", source);
|
||||
|
||||
if (priv->running) {
|
||||
priv->running = false;
|
||||
pthread_join (priv->thread, NULL);
|
||||
}
|
||||
|
||||
cmd.type = SPA_COMMAND_STOP;
|
||||
if ((res = priv->source_node->send_command (priv->source, &cmd)) < 0)
|
||||
g_debug ("got error %d", res);
|
||||
}
|
||||
|
||||
static void
|
||||
destroy_pipeline (PinosSpaV4l2Source *source)
|
||||
{
|
||||
g_debug ("spa-v4l2-source %p: destroy pipeline", source);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
set_state (PinosNode *node,
|
||||
PinosNodeState state)
|
||||
{
|
||||
PinosSpaV4l2Source *this = PINOS_SPA_V4L2_SOURCE (node);
|
||||
PinosSpaV4l2SourcePrivate *priv = this->priv;
|
||||
|
||||
g_debug ("spa-source %p: set state %s", node, pinos_node_state_as_string (state));
|
||||
|
||||
switch (state) {
|
||||
case PINOS_NODE_STATE_SUSPENDED:
|
||||
break;
|
||||
|
||||
case PINOS_NODE_STATE_INITIALIZING:
|
||||
break;
|
||||
|
||||
case PINOS_NODE_STATE_IDLE:
|
||||
stop_pipeline (this);
|
||||
break;
|
||||
|
||||
case PINOS_NODE_STATE_RUNNING:
|
||||
start_pipeline (this);
|
||||
break;
|
||||
|
||||
case PINOS_NODE_STATE_ERROR:
|
||||
break;
|
||||
}
|
||||
pinos_node_update_state (node, state);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
get_property (GObject *object,
|
||||
guint prop_id,
|
||||
GValue *value,
|
||||
GParamSpec *pspec)
|
||||
{
|
||||
PinosSpaV4l2Source *source = PINOS_SPA_V4L2_SOURCE (object);
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
|
||||
switch (prop_id) {
|
||||
default:
|
||||
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
set_property (GObject *object,
|
||||
guint prop_id,
|
||||
const GValue *value,
|
||||
GParamSpec *pspec)
|
||||
{
|
||||
PinosSpaV4l2Source *source = PINOS_SPA_V4L2_SOURCE (object);
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
|
||||
switch (prop_id) {
|
||||
default:
|
||||
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean
|
||||
on_linked (PinosPort *port, PinosPort *peer, gpointer user_data)
|
||||
{
|
||||
SourcePortData *data = user_data;
|
||||
PinosSpaV4l2Source *source = data->source;
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
guint n_links;
|
||||
|
||||
pinos_port_get_links (port, &n_links);
|
||||
g_debug ("port %p: linked, now %d", port, n_links);
|
||||
if (n_links == 0)
|
||||
pinos_node_report_busy (PINOS_NODE (source));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
on_unlinked (PinosPort *port, PinosPort *peer, gpointer user_data)
|
||||
{
|
||||
SourcePortData *data = user_data;
|
||||
PinosSpaV4l2Source *source = data->source;
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
guint n_links;
|
||||
|
||||
pinos_port_get_links (port, &n_links);
|
||||
g_debug ("port %p: unlinked, now %d", port, n_links);
|
||||
if (n_links == 1)
|
||||
pinos_node_report_busy (PINOS_NODE (source));
|
||||
}
|
||||
|
||||
static void
|
||||
on_received_buffer (PinosPort *port,
|
||||
gpointer user_data)
|
||||
{
|
||||
PinosSpaV4l2Source *this = user_data;
|
||||
PinosSpaV4l2SourcePrivate *priv = this->priv;
|
||||
PinosBuffer *pbuf;
|
||||
PinosBufferIter it;
|
||||
|
||||
pbuf = pinos_port_peek_buffer (port);
|
||||
|
||||
pinos_buffer_iter_init (&it, pbuf);
|
||||
while (pinos_buffer_iter_next (&it)) {
|
||||
switch (pinos_buffer_iter_get_type (&it)) {
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
pinos_buffer_iter_end (&it);
|
||||
}
|
||||
|
||||
static void
|
||||
free_source_port_data (SourcePortData *data)
|
||||
{
|
||||
PinosSpaV4l2Source *source = data->source;
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
|
||||
g_slice_free (SourcePortData, data);
|
||||
}
|
||||
|
||||
static void
|
||||
remove_port (PinosNode *node,
|
||||
PinosPort *port)
|
||||
{
|
||||
PinosSpaV4l2Source *source = PINOS_SPA_V4L2_SOURCE (node);
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
GList *walk;
|
||||
|
||||
for (walk = priv->ports; walk; walk = g_list_next (walk)) {
|
||||
SourcePortData *data = walk->data;
|
||||
|
||||
if (data->port == PINOS_SERVER_PORT_CAST (port)) {
|
||||
free_source_port_data (data);
|
||||
priv->ports = g_list_delete_link (priv->ports, walk);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (priv->ports == NULL)
|
||||
pinos_node_report_idle (node);
|
||||
}
|
||||
|
||||
static void
|
||||
source_constructed (GObject * object)
|
||||
{
|
||||
PinosSpaV4l2Source *source = PINOS_SPA_V4L2_SOURCE (object);
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
|
||||
G_OBJECT_CLASS (pinos_spa_v4l2_source_parent_class)->constructed (object);
|
||||
|
||||
create_pipeline (source);
|
||||
}
|
||||
|
||||
static void
|
||||
source_finalize (GObject * object)
|
||||
{
|
||||
PinosSpaV4l2Source *source = PINOS_SPA_V4L2_SOURCE (object);
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
|
||||
g_debug ("spa-source %p: dispose", source);
|
||||
destroy_pipeline (source);
|
||||
|
||||
G_OBJECT_CLASS (pinos_spa_v4l2_source_parent_class)->finalize (object);
|
||||
}
|
||||
|
||||
static PinosServerPort *
|
||||
create_port_sync (PinosServerNode *node,
|
||||
PinosDirection direction,
|
||||
const gchar *name,
|
||||
GBytes *possible_formats,
|
||||
PinosProperties *props)
|
||||
{
|
||||
PinosSpaV4l2Source *source = PINOS_SPA_V4L2_SOURCE (node);
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv;
|
||||
SourcePortData *data;
|
||||
|
||||
data = g_slice_new0 (SourcePortData);
|
||||
data->source = source;
|
||||
data->have_format = FALSE;
|
||||
|
||||
data->port = PINOS_SERVER_NODE_CLASS (pinos_spa_v4l2_source_parent_class)
|
||||
->create_port_sync (node,
|
||||
direction,
|
||||
name,
|
||||
possible_formats,
|
||||
props);
|
||||
|
||||
pinos_port_set_received_buffer_cb (PINOS_PORT (data->port), on_received_buffer, source, NULL);
|
||||
|
||||
g_debug ("connecting signals");
|
||||
g_signal_connect (data->port, "linked", (GCallback) on_linked, data);
|
||||
g_signal_connect (data->port, "unlinked", (GCallback) on_unlinked, data);
|
||||
|
||||
priv->ports = g_list_append (priv->ports, data);
|
||||
|
||||
return data->port;
|
||||
}
|
||||
|
||||
static void
|
||||
pinos_spa_v4l2_source_class_init (PinosSpaV4l2SourceClass * klass)
|
||||
{
|
||||
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
||||
PinosNodeClass *node_class = PINOS_NODE_CLASS (klass);
|
||||
PinosServerNodeClass *server_node_class = PINOS_SERVER_NODE_CLASS (klass);
|
||||
|
||||
g_type_class_add_private (klass, sizeof (PinosSpaV4l2SourcePrivate));
|
||||
|
||||
gobject_class->constructed = source_constructed;
|
||||
gobject_class->finalize = source_finalize;
|
||||
gobject_class->get_property = get_property;
|
||||
gobject_class->set_property = set_property;
|
||||
|
||||
node_class->set_state = set_state;
|
||||
node_class->remove_port = remove_port;
|
||||
|
||||
server_node_class->create_port_sync = create_port_sync;
|
||||
}
|
||||
|
||||
static void
|
||||
pinos_spa_v4l2_source_init (PinosSpaV4l2Source * source)
|
||||
{
|
||||
PinosSpaV4l2SourcePrivate *priv = source->priv = PINOS_SPA_V4L2_SOURCE_GET_PRIVATE (source);
|
||||
|
||||
priv->fdmanager = pinos_fd_manager_get (PINOS_FD_MANAGER_DEFAULT);
|
||||
|
||||
}
|
||||
|
||||
PinosServerNode *
|
||||
pinos_spa_v4l2_source_new (PinosDaemon *daemon,
|
||||
const gchar *name,
|
||||
PinosProperties *properties)
|
||||
{
|
||||
PinosServerNode *node;
|
||||
|
||||
node = g_object_new (PINOS_TYPE_SPA_V4L2_SOURCE,
|
||||
"daemon", daemon,
|
||||
"name", name,
|
||||
"properties", properties,
|
||||
NULL);
|
||||
|
||||
return node;
|
||||
}
|
||||
61
pinos/modules/spa/spa-v4l2-source.h
Normal file
61
pinos/modules/spa/spa-v4l2-source.h
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
/* Pinos
|
||||
* Copyright (C) 2015 Wim Taymans <wim.taymans@gmail.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#ifndef __PINOS_SPA_V4L2_SOURCE_H__
|
||||
#define __PINOS_SPA_V4L2_SOURCE_H__
|
||||
|
||||
#include <glib-object.h>
|
||||
|
||||
#include <client/pinos.h>
|
||||
#include <server/server-node.h>
|
||||
|
||||
G_BEGIN_DECLS
|
||||
|
||||
#define PINOS_TYPE_SPA_V4L2_SOURCE (pinos_spa_v4l2_source_get_type ())
|
||||
#define PINOS_IS_SPA_V4L2_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PINOS_TYPE_SPA_V4L2_SOURCE))
|
||||
#define PINOS_IS_SPA_V4L2_SOURCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PINOS_TYPE_SPA_V4L2_SOURCE))
|
||||
#define PINOS_SPA_V4L2_SOURCE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PINOS_TYPE_SPA_V4L2_SOURCE, PinosSpaV4l2SourceClass))
|
||||
#define PINOS_SPA_V4L2_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PINOS_TYPE_SPA_V4L2_SOURCE, PinosSpaV4l2Source))
|
||||
#define PINOS_SPA_V4L2_SOURCE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PINOS_TYPE_SPA_V4L2_SOURCE, PinosSpaV4l2SourceClass))
|
||||
#define PINOS_SPA_V4L2_SOURCE_CAST(obj) ((PinosSpaV4l2Source*)(obj))
|
||||
#define PINOS_SPA_V4L2_SOURCE_CLASS_CAST(klass) ((PinosSpaV4l2SourceClass*)(klass))
|
||||
|
||||
typedef struct _PinosSpaV4l2Source PinosSpaV4l2Source;
|
||||
typedef struct _PinosSpaV4l2SourceClass PinosSpaV4l2SourceClass;
|
||||
typedef struct _PinosSpaV4l2SourcePrivate PinosSpaV4l2SourcePrivate;
|
||||
|
||||
struct _PinosSpaV4l2Source {
|
||||
PinosServerNode object;
|
||||
|
||||
PinosSpaV4l2SourcePrivate *priv;
|
||||
};
|
||||
|
||||
struct _PinosSpaV4l2SourceClass {
|
||||
PinosServerNodeClass parent_class;
|
||||
};
|
||||
|
||||
GType pinos_spa_v4l2_source_get_type (void);
|
||||
|
||||
PinosServerNode * pinos_spa_v4l2_source_new (PinosDaemon *daemon,
|
||||
const gchar *name,
|
||||
PinosProperties *properties);
|
||||
|
||||
G_END_DECLS
|
||||
|
||||
#endif /* __PINOS_SPA_V4L2_SOURCE_H__ */
|
||||
|
|
@ -25,6 +25,7 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
typedef struct _SpaBuffer SpaBuffer;
|
||||
typedef struct _SpaBufferGroup SpaBufferGroup;
|
||||
|
||||
#include <spa/defs.h>
|
||||
|
||||
|
|
@ -37,6 +38,7 @@ typedef enum {
|
|||
SPA_META_TYPE_INVALID = 0,
|
||||
SPA_META_TYPE_HEADER,
|
||||
SPA_META_TYPE_POINTER,
|
||||
SPA_META_TYPE_VIDEO_CROP,
|
||||
} SpaMetaType;
|
||||
|
||||
/**
|
||||
|
|
@ -72,6 +74,18 @@ typedef struct {
|
|||
void *ptr;
|
||||
} SpaMetaPointer;
|
||||
|
||||
/**
|
||||
* SpaMetaVideoCrop:
|
||||
* @x:
|
||||
* @y:
|
||||
* @width:
|
||||
* @height
|
||||
*/
|
||||
typedef struct {
|
||||
int x, y;
|
||||
int width, height;
|
||||
} SpaMetaVideoCrop;
|
||||
|
||||
/**
|
||||
* SpaMeta:
|
||||
* @type: metadata type
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ typedef struct _SpaEvent SpaEvent;
|
|||
* @SPA_EVENT_TYPE_STARTED: emited when the START command completes
|
||||
* @SPA_EVENT_TYPE_STOPPED: emited when the STOP command completes
|
||||
* @SPA_EVENT_TYPE_CAN_PULL_OUTPUT: emited when an async node has output that can be pulled
|
||||
* @SPA_EVENT_TYPE_CAN_PUSH_INTPUT: emited when more data can be pushed to an async node
|
||||
* @SPA_EVENT_TYPE_CAN_PUSH_INPUT: emited when more data can be pushed to an async node
|
||||
* @SPA_EVENT_TYPE_PULL_INPUT: emited when data needs to be provided on an input
|
||||
* @SPA_EVENT_TYPE_ALLOC_OUTPUT: emited when an output buffer needs to be allocated
|
||||
* @SPA_EVENT_TYPE_ADD_POLL: emited when a pollfd should be added
|
||||
|
|
@ -49,7 +49,7 @@ typedef enum {
|
|||
SPA_EVENT_TYPE_STARTED,
|
||||
SPA_EVENT_TYPE_STOPPED,
|
||||
SPA_EVENT_TYPE_CAN_PULL_OUTPUT,
|
||||
SPA_EVENT_TYPE_CAN_PUSH_INTPUT,
|
||||
SPA_EVENT_TYPE_CAN_PUSH_INPUT,
|
||||
SPA_EVENT_TYPE_PULL_INPUT,
|
||||
SPA_EVENT_TYPE_ALLOC_OUTPUT,
|
||||
SPA_EVENT_TYPE_ADD_POLL,
|
||||
|
|
|
|||
|
|
@ -320,6 +320,8 @@ struct _SpaNode {
|
|||
uint32_t n_buffers);
|
||||
SpaResult (*port_alloc_buffers) (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers);
|
||||
|
||||
|
|
|
|||
|
|
@ -78,20 +78,27 @@ struct _SpaHandleFactory {
|
|||
* Extra information about the handles of this factory.
|
||||
*/
|
||||
const SpaProps * info;
|
||||
/**
|
||||
* SpaHandleFactory::size
|
||||
*
|
||||
* The size of handles from this factory
|
||||
*/
|
||||
const size_t size;
|
||||
|
||||
/**
|
||||
* SpaHandleFactory::instantiate
|
||||
* SpaHandleFactory::init
|
||||
* @factory: a #SpaHandleFactory
|
||||
* @handle: a pointer to hold the result
|
||||
* @handle: a pointer to memory
|
||||
*
|
||||
* Make an instance of this factory.
|
||||
* Initialize an instance of this factory. The caller should allocate
|
||||
* memory at least SpaHandleFactory::size bytes and pass this as @handle.
|
||||
*
|
||||
* Returns: #SPA_RESULT_OK on success
|
||||
* #SPA_RESULT_NOT_IMPLEMENTED when an instance can't be made
|
||||
* #SPA_RESULT_INVALID_ARGUMENTS when factory or handle are %NULL
|
||||
*/
|
||||
SpaResult (*instantiate) (const SpaHandleFactory *factory,
|
||||
SpaHandle **handle);
|
||||
SpaResult (*init) (const SpaHandleFactory *factory,
|
||||
SpaHandle *handle);
|
||||
/**
|
||||
* SpaHandle::enum_interface_info:
|
||||
* @factory: a #SpaHandleFactory
|
||||
|
|
|
|||
|
|
@ -25,6 +25,48 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
#include <spa/defs.h>
|
||||
#include <spa/buffer.h>
|
||||
|
||||
/**
|
||||
* SpaAllocParamType:
|
||||
* @SPA_ALLOC_PARAM_TYPE_INVALID: invalid type, should be ignored
|
||||
* @SPA_ALLOC_PARAM_TYPE_META_ENABLE: enable a certain metadata on buffers
|
||||
* @SPA_ALLOC_PARAM_TYPE_VIDEO_PADDING: do specialized video padding
|
||||
*/
|
||||
typedef enum {
|
||||
SPA_ALLOC_PARAM_TYPE_INVALID,
|
||||
SPA_ALLOC_PARAM_TYPE_BUFFERS,
|
||||
SPA_ALLOC_PARAM_TYPE_META_ENABLE,
|
||||
SPA_ALLOC_PARAM_TYPE_VIDEO_PADDING,
|
||||
} SpaAllocParamType;
|
||||
|
||||
typedef struct {
|
||||
uint32_t type;
|
||||
size_t size;
|
||||
} SpaAllocParam;
|
||||
|
||||
typedef struct {
|
||||
SpaAllocParam param;
|
||||
size_t minsize;
|
||||
size_t stride;
|
||||
uint32_t min_buffers;
|
||||
uint32_t max_buffers;
|
||||
uint32_t align;
|
||||
} SpaAllocParamBuffers;
|
||||
|
||||
typedef struct {
|
||||
SpaAllocParam param;
|
||||
SpaMetaType type;
|
||||
} SpaAllocParamMetaEnable;
|
||||
|
||||
typedef struct {
|
||||
SpaAllocParam param;
|
||||
unsigned int padding_top;
|
||||
unsigned int padding_bottom;
|
||||
unsigned int padding_left;
|
||||
unsigned int padding_right;
|
||||
unsigned int stride_align[4];
|
||||
} SpaAllocParamVideoPadding;
|
||||
|
||||
/**
|
||||
* SpaPortInfoFlags:
|
||||
|
|
@ -58,18 +100,17 @@ typedef enum {
|
|||
* @maxbuffering: the maximum amount of bytes that the element will keep
|
||||
* around internally
|
||||
* @latency: latency on this port in nanoseconds
|
||||
* @params: extra allocation parameters
|
||||
* @n_params: number of elements in @params;
|
||||
* @features: NULL terminated array of extra port features
|
||||
*
|
||||
*/
|
||||
typedef struct {
|
||||
SpaPortInfoFlags flags;
|
||||
size_t minsize;
|
||||
size_t stride;
|
||||
uint32_t min_buffers;
|
||||
uint32_t max_buffers;
|
||||
uint32_t align;
|
||||
unsigned int maxbuffering;
|
||||
uint64_t latency;
|
||||
SpaAllocParam **params;
|
||||
uint32_t n_params;
|
||||
const char **features;
|
||||
} SpaPortInfo;
|
||||
|
||||
|
|
|
|||
80
spa/lib/debug.c
Normal file
80
spa/lib/debug.c
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
/* Simple Plugin API
|
||||
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "spa/debug.h"
|
||||
|
||||
SpaResult
|
||||
spa_debug_port_info (const SpaPortInfo *info)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (info == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
fprintf (stderr, "SpaPortInfo %p:\n", info);
|
||||
fprintf (stderr, " flags: \t%08x\n", info->flags);
|
||||
fprintf (stderr, " maxbuffering: \t%u\n", info->maxbuffering);
|
||||
fprintf (stderr, " latency: \t%" PRIu64 "\n", info->latency);
|
||||
fprintf (stderr, " n_params: \t%d\n", info->n_params);
|
||||
for (i = 0; i < info->n_params; i++) {
|
||||
SpaAllocParam *param = info->params[i];
|
||||
fprintf (stderr, " param %d, type %d, size %zd:\n", i, param->type, param->size);
|
||||
switch (param->type) {
|
||||
case SPA_ALLOC_PARAM_TYPE_INVALID:
|
||||
fprintf (stderr, " INVALID\n");
|
||||
break;
|
||||
case SPA_ALLOC_PARAM_TYPE_BUFFERS:
|
||||
{
|
||||
SpaAllocParamBuffers *p = (SpaAllocParamBuffers *)param;
|
||||
fprintf (stderr, " SpaAllocParamBuffers:\n");
|
||||
fprintf (stderr, " minsize: \t\t%zd\n", p->minsize);
|
||||
fprintf (stderr, " stride: \t\t%zd\n", p->stride);
|
||||
fprintf (stderr, " min_buffers: \t%d\n", p->min_buffers);
|
||||
fprintf (stderr, " max_buffers: \t%d\n", p->max_buffers);
|
||||
fprintf (stderr, " align: \t\t%d\n", p->align);
|
||||
break;
|
||||
}
|
||||
case SPA_ALLOC_PARAM_TYPE_META_ENABLE:
|
||||
{
|
||||
SpaAllocParamMetaEnable *p = (SpaAllocParamMetaEnable *)param;
|
||||
fprintf (stderr, " SpaAllocParamMetaEnable:\n");
|
||||
fprintf (stderr, " type: \t%d\n", p->type);
|
||||
break;
|
||||
}
|
||||
case SPA_ALLOC_PARAM_TYPE_VIDEO_PADDING:
|
||||
{
|
||||
SpaAllocParamVideoPadding *p = (SpaAllocParamVideoPadding *)param;
|
||||
fprintf (stderr, " SpaAllocParamVideoPadding:\n");
|
||||
fprintf (stderr, " padding_top: \t%d\n", p->padding_top);
|
||||
fprintf (stderr, " padding_bottom: \t%d\n", p->padding_bottom);
|
||||
fprintf (stderr, " padding_left: \t%d\n", p->padding_left);
|
||||
fprintf (stderr, " padding_right: \t%d\n", p->padding_right);
|
||||
fprintf (stderr, " stide_align: \t[%d, %d, %d, %d]\n",
|
||||
p->stride_align[0], p->stride_align[1], p->stride_align[2], p->stride_align[3]);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
fprintf (stderr, " UNKNOWN\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
|
@ -1,4 +1,5 @@
|
|||
spalib_sources = ['audio-raw.c',
|
||||
'debug.c',
|
||||
'props.c',
|
||||
'ringbuffer.c',
|
||||
'video-raw.c']
|
||||
|
|
|
|||
|
|
@ -4,6 +4,10 @@ alsa_dep = dependency('alsa')
|
|||
v4l2_dep = dependency('libv4l2')
|
||||
xv_dep = dependency('x11')
|
||||
sdl_dep = dependency('sdl2')
|
||||
avcodec_dep = dependency('libavcodec')
|
||||
avformat_dep = dependency('libavformat')
|
||||
avfilter_dep = dependency('libavfilter')
|
||||
libva_dep = dependency('libva')
|
||||
|
||||
cc = meson.get_compiler('c')
|
||||
|
||||
|
|
|
|||
|
|
@ -474,6 +474,8 @@ spa_alsa_sink_node_port_use_buffers (SpaHandle *handle,
|
|||
static SpaResult
|
||||
spa_alsa_sink_node_port_alloc_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers)
|
||||
{
|
||||
|
|
@ -572,13 +574,15 @@ spa_alsa_sink_get_interface (SpaHandle *handle,
|
|||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaHandle *
|
||||
spa_alsa_sink_new (void)
|
||||
static SpaResult
|
||||
alsa_sink_init (const SpaHandleFactory *factory,
|
||||
SpaHandle *handle)
|
||||
{
|
||||
SpaHandle *handle;
|
||||
SpaALSASink *this;
|
||||
|
||||
handle = calloc (1, sizeof (SpaALSASink));
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
handle->get_interface = spa_alsa_sink_get_interface;
|
||||
|
||||
this = (SpaALSASink *) handle;
|
||||
|
|
@ -590,5 +594,35 @@ spa_alsa_sink_new (void)
|
|||
|
||||
this->info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->status.flags = SPA_PORT_STATUS_FLAG_NEED_INPUT;
|
||||
return handle;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo alsa_sink_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
alsa_sink_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &alsa_sink_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
const SpaHandleFactory spa_alsa_sink_factory =
|
||||
{ "alsa-sink",
|
||||
NULL,
|
||||
sizeof (SpaALSASink),
|
||||
alsa_sink_init,
|
||||
alsa_sink_enum_interface_info,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -20,59 +20,21 @@
|
|||
#include <spa/plugin.h>
|
||||
#include <spa/node.h>
|
||||
|
||||
SpaHandle * spa_alsa_sink_new (void);
|
||||
|
||||
static SpaResult
|
||||
alsa_sink_instantiate (const SpaHandleFactory *factory,
|
||||
SpaHandle **handle)
|
||||
{
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
*handle = spa_alsa_sink_new ();
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo alsa_sink_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
alsa_sink_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &alsa_sink_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaHandleFactory factories[] =
|
||||
{
|
||||
{ "alsa-sink",
|
||||
NULL,
|
||||
alsa_sink_instantiate,
|
||||
alsa_sink_enum_interface_info,
|
||||
},
|
||||
};
|
||||
|
||||
extern const SpaHandleFactory spa_alsa_sink_factory;
|
||||
|
||||
SpaResult
|
||||
spa_enum_handle_factory (unsigned int index,
|
||||
const SpaHandleFactory **factory)
|
||||
{
|
||||
if (index >= 1)
|
||||
if (factory == NULL)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*factory = &factories[index];
|
||||
|
||||
switch (index) {
|
||||
case 0:
|
||||
*factory = &spa_alsa_sink_factory;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -440,6 +440,8 @@ spa_audiomixer_node_port_use_buffers (SpaHandle *handle,
|
|||
static SpaResult
|
||||
spa_audiomixer_node_port_alloc_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers)
|
||||
{
|
||||
|
|
@ -733,13 +735,15 @@ spa_audiomixer_get_interface (SpaHandle *handle,
|
|||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaHandle *
|
||||
spa_audiomixer_new (void)
|
||||
static SpaResult
|
||||
spa_audiomixer_init (const SpaHandleFactory *factory,
|
||||
SpaHandle *handle)
|
||||
{
|
||||
SpaHandle *handle;
|
||||
SpaAudioMixer *this;
|
||||
|
||||
handle = calloc (1, sizeof (SpaAudioMixer));
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
handle->get_interface = spa_audiomixer_get_interface;
|
||||
|
||||
this = (SpaAudioMixer *) handle;
|
||||
|
|
@ -753,5 +757,34 @@ spa_audiomixer_new (void)
|
|||
this->ports[0].info.flags = SPA_PORT_INFO_FLAG_CAN_GIVE_BUFFER |
|
||||
SPA_PORT_INFO_FLAG_CAN_USE_BUFFER |
|
||||
SPA_PORT_INFO_FLAG_NO_REF;
|
||||
return handle;
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo audiomixer_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
audiomixer_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &audiomixer_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
const SpaHandleFactory spa_audiomixer_factory =
|
||||
{ "audiomixer",
|
||||
NULL,
|
||||
sizeof (SpaAudioMixer),
|
||||
spa_audiomixer_init,
|
||||
audiomixer_enum_interface_info,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -20,59 +20,21 @@
|
|||
#include <spa/plugin.h>
|
||||
#include <spa/node.h>
|
||||
|
||||
SpaHandle * spa_audiomixer_new (void);
|
||||
|
||||
static SpaResult
|
||||
audiomixer_instantiate (const SpaHandleFactory *factory,
|
||||
SpaHandle **handle)
|
||||
{
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
*handle = spa_audiomixer_new ();
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo audiomixer_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
audiomixer_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &audiomixer_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaHandleFactory factories[] =
|
||||
{
|
||||
{ "audiomixer",
|
||||
NULL,
|
||||
audiomixer_instantiate,
|
||||
audiomixer_enum_interface_info,
|
||||
},
|
||||
};
|
||||
|
||||
extern const SpaHandleFactory spa_audiomixer_factory;
|
||||
|
||||
SpaResult
|
||||
spa_enum_handle_factory (unsigned int index,
|
||||
const SpaHandleFactory **factory)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*factory = &factories[index];
|
||||
if (factory == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (index) {
|
||||
case 0:
|
||||
*factory = &spa_audiomixer_factory;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -417,6 +417,8 @@ spa_audiotestsrc_node_port_use_buffers (SpaHandle *handle,
|
|||
static SpaResult
|
||||
spa_audiotestsrc_node_port_alloc_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers)
|
||||
{
|
||||
|
|
@ -520,13 +522,15 @@ spa_audiotestsrc_get_interface (SpaHandle *handle,
|
|||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaHandle *
|
||||
spa_audiotestsrc_new (void)
|
||||
static SpaResult
|
||||
audiotestsrc_init (const SpaHandleFactory *factory,
|
||||
SpaHandle *handle)
|
||||
{
|
||||
SpaHandle *handle;
|
||||
SpaAudioTestSrc *this;
|
||||
|
||||
handle = calloc (1, sizeof (SpaAudioTestSrc));
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
handle->get_interface = spa_audiotestsrc_get_interface;
|
||||
|
||||
this = (SpaAudioTestSrc *) handle;
|
||||
|
|
@ -540,5 +544,34 @@ spa_audiotestsrc_new (void)
|
|||
SPA_PORT_INFO_FLAG_NO_REF;
|
||||
this->status.flags = SPA_PORT_STATUS_FLAG_HAVE_OUTPUT;
|
||||
|
||||
return handle;
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo audiotestsrc_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
audiotestsrc_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &audiotestsrc_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
const SpaHandleFactory spa_audiotestsrc_factory =
|
||||
{ "audiotestsrc",
|
||||
NULL,
|
||||
sizeof (SpaAudioTestSrc),
|
||||
audiotestsrc_init,
|
||||
audiotestsrc_enum_interface_info,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -20,59 +20,21 @@
|
|||
#include <spa/plugin.h>
|
||||
#include <spa/node.h>
|
||||
|
||||
SpaHandle * spa_audiotestsrc_new (void);
|
||||
|
||||
static SpaResult
|
||||
audiotestsrc_instantiate (const SpaHandleFactory *factory,
|
||||
SpaHandle **handle)
|
||||
{
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
*handle = spa_audiotestsrc_new ();
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo audiotestsrc_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
audiotestsrc_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &audiotestsrc_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaHandleFactory factories[] =
|
||||
{
|
||||
{ "audiotestsrc",
|
||||
NULL,
|
||||
audiotestsrc_instantiate,
|
||||
audiotestsrc_enum_interface_info,
|
||||
},
|
||||
};
|
||||
|
||||
extern const SpaHandleFactory spa_audiotestsrc_factory;
|
||||
|
||||
SpaResult
|
||||
spa_enum_handle_factory (unsigned int index,
|
||||
const SpaHandleFactory **factory)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*factory = &factories[index];
|
||||
if (factory == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (index) {
|
||||
case 0:
|
||||
*factory = &spa_audiotestsrc_factory;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
|
|
|||
529
spa/plugins/ffmpeg/ffmpeg-dec.c
Normal file
529
spa/plugins/ffmpeg/ffmpeg-dec.c
Normal file
|
|
@ -0,0 +1,529 @@
|
|||
/* Spa FFMpeg Decoder
|
||||
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stddef.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#include <spa/node.h>
|
||||
#include <spa/video/format.h>
|
||||
|
||||
typedef struct _SpaFFMpegDec SpaFFMpegDec;
|
||||
|
||||
typedef struct {
|
||||
SpaProps props;
|
||||
} SpaFFMpegDecProps;
|
||||
|
||||
static void
|
||||
reset_ffmpeg_dec_props (SpaFFMpegDecProps *props)
|
||||
{
|
||||
}
|
||||
|
||||
#define INPUT_PORT_ID 0
|
||||
#define OUTPUT_PORT_ID 1
|
||||
#define IS_VALID_PORT(id) ((id) < 2)
|
||||
#define MAX_BUFFERS 32
|
||||
|
||||
typedef struct _FFMpegBuffer FFMpegBuffer;
|
||||
|
||||
struct _FFMpegBuffer {
|
||||
SpaBuffer buffer;
|
||||
SpaMeta metas[1];
|
||||
SpaMetaHeader header;
|
||||
SpaData datas[1];
|
||||
SpaFFMpegDec *dec;
|
||||
SpaBuffer *imported;
|
||||
bool outstanding;
|
||||
FFMpegBuffer *next;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
SpaVideoRawFormat raw_format[2];
|
||||
SpaFormat *current_format;
|
||||
bool have_buffers;
|
||||
FFMpegBuffer buffers[MAX_BUFFERS];
|
||||
SpaPortInfo info;
|
||||
SpaAllocParam *params[1];
|
||||
SpaAllocParamBuffers param_buffers;
|
||||
SpaPortStatus status;
|
||||
} SpaFFMpegState;
|
||||
|
||||
struct _SpaFFMpegDec {
|
||||
SpaHandle handle;
|
||||
|
||||
SpaFFMpegDecProps props[2];
|
||||
|
||||
SpaEventCallback event_cb;
|
||||
void *user_data;
|
||||
|
||||
SpaFFMpegState state[2];
|
||||
};
|
||||
|
||||
enum {
|
||||
PROP_ID_LAST,
|
||||
};
|
||||
|
||||
static const SpaPropInfo prop_info[] =
|
||||
{
|
||||
{ 0, },
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_get_props (SpaHandle *handle,
|
||||
SpaProps **props)
|
||||
{
|
||||
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
|
||||
|
||||
if (handle == NULL || props == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
memcpy (&this->props[0], &this->props[1], sizeof (this->props[1]));
|
||||
*props = &this->props[0].props;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_set_props (SpaHandle *handle,
|
||||
const SpaProps *props)
|
||||
{
|
||||
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
|
||||
SpaFFMpegDecProps *p = &this->props[1];
|
||||
SpaResult res;
|
||||
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (props == NULL) {
|
||||
reset_ffmpeg_dec_props (p);
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
res = spa_props_copy (props, &p->props);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_send_command (SpaHandle *handle,
|
||||
SpaCommand *command)
|
||||
{
|
||||
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
|
||||
|
||||
if (handle == NULL || command == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (command->type) {
|
||||
case SPA_COMMAND_INVALID:
|
||||
return SPA_RESULT_INVALID_COMMAND;
|
||||
|
||||
case SPA_COMMAND_START:
|
||||
if (this->event_cb) {
|
||||
SpaEvent event;
|
||||
|
||||
event.refcount = 1;
|
||||
event.notify = NULL;
|
||||
event.type = SPA_EVENT_TYPE_STARTED;
|
||||
event.port_id = -1;
|
||||
event.data = NULL;
|
||||
event.size = 0;
|
||||
|
||||
this->event_cb (handle, &event, this->user_data);
|
||||
}
|
||||
break;
|
||||
case SPA_COMMAND_STOP:
|
||||
if (this->event_cb) {
|
||||
SpaEvent event;
|
||||
|
||||
event.refcount = 1;
|
||||
event.notify = NULL;
|
||||
event.type = SPA_EVENT_TYPE_STOPPED;
|
||||
event.port_id = -1;
|
||||
event.data = NULL;
|
||||
event.size = 0;
|
||||
|
||||
this->event_cb (handle, &event, this->user_data);
|
||||
}
|
||||
break;
|
||||
|
||||
case SPA_COMMAND_FLUSH:
|
||||
case SPA_COMMAND_DRAIN:
|
||||
case SPA_COMMAND_MARKER:
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_set_event_callback (SpaHandle *handle,
|
||||
SpaEventCallback event,
|
||||
void *user_data)
|
||||
{
|
||||
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
|
||||
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
this->event_cb = event;
|
||||
this->user_data = user_data;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_get_n_ports (SpaHandle *handle,
|
||||
unsigned int *n_input_ports,
|
||||
unsigned int *max_input_ports,
|
||||
unsigned int *n_output_ports,
|
||||
unsigned int *max_output_ports)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (n_input_ports)
|
||||
*n_input_ports = 1;
|
||||
if (n_output_ports)
|
||||
*n_output_ports = 1;
|
||||
if (max_input_ports)
|
||||
*max_input_ports = 1;
|
||||
if (max_output_ports)
|
||||
*max_output_ports = 1;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_get_port_ids (SpaHandle *handle,
|
||||
unsigned int n_input_ports,
|
||||
uint32_t *input_ids,
|
||||
unsigned int n_output_ports,
|
||||
uint32_t *output_ids)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (n_input_ports > 0)
|
||||
input_ids[0] = 0;
|
||||
if (n_output_ports > 0)
|
||||
output_ids[0] = 1;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_add_port (SpaHandle *handle,
|
||||
SpaDirection direction,
|
||||
uint32_t *port_id)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_remove_port (SpaHandle *handle,
|
||||
uint32_t port_id)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_enum_formats (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
unsigned int index,
|
||||
SpaFormat **format)
|
||||
{
|
||||
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
|
||||
SpaFFMpegState *state;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
switch (index) {
|
||||
case 0:
|
||||
spa_video_raw_format_init (&state->raw_format[0]);
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
*format = &state->raw_format[0].format;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_set_format (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
bool test_only,
|
||||
const SpaFormat *format)
|
||||
{
|
||||
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
|
||||
SpaFFMpegState *state;
|
||||
SpaResult res;
|
||||
SpaFormat *f, *tf;
|
||||
size_t fs;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
if (format == NULL) {
|
||||
state->current_format = NULL;
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) {
|
||||
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
|
||||
if ((res = spa_video_raw_format_parse (format, &state->raw_format[0]) < 0))
|
||||
return res;
|
||||
|
||||
f = &state->raw_format[0].format;
|
||||
tf = &state->raw_format[1].format;
|
||||
fs = sizeof (SpaVideoRawFormat);
|
||||
} else
|
||||
return SPA_RESULT_INVALID_MEDIA_TYPE;
|
||||
} else
|
||||
return SPA_RESULT_INVALID_MEDIA_TYPE;
|
||||
|
||||
if (!test_only) {
|
||||
memcpy (tf, f, fs);
|
||||
state->current_format = tf;
|
||||
}
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_get_format (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaFormat **format)
|
||||
{
|
||||
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
|
||||
SpaFFMpegState *state;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
if (state->current_format == NULL)
|
||||
return SPA_RESULT_NO_FORMAT;
|
||||
|
||||
*format = state->current_format;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_get_info (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaPortInfo **info)
|
||||
{
|
||||
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
|
||||
|
||||
if (handle == NULL || info == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
*info = &this->state[port_id].info;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_get_props (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaProps **props)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_set_props (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaProps *props)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_get_status (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaPortStatus **status)
|
||||
{
|
||||
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
|
||||
|
||||
if (handle == NULL || status == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
*status = &this->state[port_id].status;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_use_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t n_buffers)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_alloc_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_push_input (SpaHandle *handle,
|
||||
unsigned int n_info,
|
||||
SpaInputInfo *info)
|
||||
{
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_node_port_pull_output (SpaHandle *handle,
|
||||
unsigned int n_info,
|
||||
SpaOutputInfo *info)
|
||||
{
|
||||
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
|
||||
SpaFFMpegState *state;
|
||||
unsigned int i;
|
||||
bool have_error = false;
|
||||
|
||||
if (handle == NULL || n_info == 0 || info == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
|
||||
for (i = 0; i < n_info; i++) {
|
||||
if (info[i].port_id != OUTPUT_PORT_ID) {
|
||||
info[i].status = SPA_RESULT_INVALID_PORT;
|
||||
have_error = true;
|
||||
continue;
|
||||
}
|
||||
state = &this->state[info[i].port_id];
|
||||
|
||||
if (state->current_format == NULL) {
|
||||
info[i].status = SPA_RESULT_NO_FORMAT;
|
||||
have_error = true;
|
||||
continue;
|
||||
}
|
||||
info[i].status = SPA_RESULT_OK;
|
||||
}
|
||||
if (have_error)
|
||||
return SPA_RESULT_ERROR;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaNode ffmpeg_dec_node = {
|
||||
sizeof (SpaNode),
|
||||
spa_ffmpeg_dec_node_get_props,
|
||||
spa_ffmpeg_dec_node_set_props,
|
||||
spa_ffmpeg_dec_node_send_command,
|
||||
spa_ffmpeg_dec_node_set_event_callback,
|
||||
spa_ffmpeg_dec_node_get_n_ports,
|
||||
spa_ffmpeg_dec_node_get_port_ids,
|
||||
spa_ffmpeg_dec_node_add_port,
|
||||
spa_ffmpeg_dec_node_remove_port,
|
||||
spa_ffmpeg_dec_node_port_enum_formats,
|
||||
spa_ffmpeg_dec_node_port_set_format,
|
||||
spa_ffmpeg_dec_node_port_get_format,
|
||||
spa_ffmpeg_dec_node_port_get_info,
|
||||
spa_ffmpeg_dec_node_port_get_props,
|
||||
spa_ffmpeg_dec_node_port_set_props,
|
||||
spa_ffmpeg_dec_node_port_use_buffers,
|
||||
spa_ffmpeg_dec_node_port_alloc_buffers,
|
||||
spa_ffmpeg_dec_node_port_get_status,
|
||||
spa_ffmpeg_dec_node_port_push_input,
|
||||
spa_ffmpeg_dec_node_port_pull_output,
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_dec_get_interface (SpaHandle *handle,
|
||||
uint32_t interface_id,
|
||||
const void **interface)
|
||||
{
|
||||
if (handle == NULL || interface == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (interface_id) {
|
||||
case SPA_INTERFACE_ID_NODE:
|
||||
*interface = &ffmpeg_dec_node;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_UNKNOWN_INTERFACE;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaResult
|
||||
spa_ffmpeg_dec_init (SpaHandle *handle)
|
||||
{
|
||||
SpaFFMpegDec *this;
|
||||
|
||||
handle->get_interface = spa_ffmpeg_dec_get_interface;
|
||||
|
||||
this = (SpaFFMpegDec *) handle;
|
||||
this->props[1].props.n_prop_info = PROP_ID_LAST;
|
||||
this->props[1].props.prop_info = prop_info;
|
||||
this->props[1].props.set_prop = spa_props_generic_set_prop;
|
||||
this->props[1].props.get_prop = spa_props_generic_get_prop;
|
||||
reset_ffmpeg_dec_props (&this->props[1]);
|
||||
|
||||
this->state[INPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->state[INPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
|
||||
this->state[OUTPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->state[OUTPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
529
spa/plugins/ffmpeg/ffmpeg-enc.c
Normal file
529
spa/plugins/ffmpeg/ffmpeg-enc.c
Normal file
|
|
@ -0,0 +1,529 @@
|
|||
/* Spa FFMpeg Encoder
|
||||
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stddef.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#include <spa/node.h>
|
||||
#include <spa/video/format.h>
|
||||
|
||||
typedef struct _SpaFFMpegEnc SpaFFMpegEnc;
|
||||
|
||||
typedef struct {
|
||||
SpaProps props;
|
||||
} SpaFFMpegEncProps;
|
||||
|
||||
static void
|
||||
reset_ffmpeg_enc_props (SpaFFMpegEncProps *props)
|
||||
{
|
||||
}
|
||||
|
||||
#define INPUT_PORT_ID 0
|
||||
#define OUTPUT_PORT_ID 1
|
||||
#define IS_VALID_PORT(id) ((id) < 2)
|
||||
#define MAX_BUFFERS 32
|
||||
|
||||
typedef struct _FFMpegBuffer FFMpegBuffer;
|
||||
|
||||
struct _FFMpegBuffer {
|
||||
SpaBuffer buffer;
|
||||
SpaMeta metas[1];
|
||||
SpaMetaHeader header;
|
||||
SpaData datas[1];
|
||||
SpaFFMpegEnc *enc;
|
||||
SpaBuffer *imported;
|
||||
bool outstanding;
|
||||
FFMpegBuffer *next;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
SpaVideoRawFormat raw_format[2];
|
||||
SpaFormat *current_format;
|
||||
bool have_buffers;
|
||||
FFMpegBuffer buffers[MAX_BUFFERS];
|
||||
SpaPortInfo info;
|
||||
SpaAllocParam *params[1];
|
||||
SpaAllocParamBuffers param_buffers;
|
||||
SpaPortStatus status;
|
||||
} SpaFFMpegState;
|
||||
|
||||
struct _SpaFFMpegEnc {
|
||||
SpaHandle handle;
|
||||
|
||||
SpaFFMpegEncProps props[2];
|
||||
|
||||
SpaEventCallback event_cb;
|
||||
void *user_data;
|
||||
|
||||
SpaFFMpegState state[2];
|
||||
};
|
||||
|
||||
enum {
|
||||
PROP_ID_LAST,
|
||||
};
|
||||
|
||||
static const SpaPropInfo prop_info[] =
|
||||
{
|
||||
{ 0, },
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_get_props (SpaHandle *handle,
|
||||
SpaProps **props)
|
||||
{
|
||||
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
|
||||
|
||||
if (handle == NULL || props == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
memcpy (&this->props[0], &this->props[1], sizeof (this->props[1]));
|
||||
*props = &this->props[0].props;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_set_props (SpaHandle *handle,
|
||||
const SpaProps *props)
|
||||
{
|
||||
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
|
||||
SpaFFMpegEncProps *p = &this->props[1];
|
||||
SpaResult res;
|
||||
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (props == NULL) {
|
||||
reset_ffmpeg_enc_props (p);
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
res = spa_props_copy (props, &p->props);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_send_command (SpaHandle *handle,
|
||||
SpaCommand *command)
|
||||
{
|
||||
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
|
||||
|
||||
if (handle == NULL || command == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (command->type) {
|
||||
case SPA_COMMAND_INVALID:
|
||||
return SPA_RESULT_INVALID_COMMAND;
|
||||
|
||||
case SPA_COMMAND_START:
|
||||
if (this->event_cb) {
|
||||
SpaEvent event;
|
||||
|
||||
event.refcount = 1;
|
||||
event.notify = NULL;
|
||||
event.type = SPA_EVENT_TYPE_STARTED;
|
||||
event.port_id = -1;
|
||||
event.data = NULL;
|
||||
event.size = 0;
|
||||
|
||||
this->event_cb (handle, &event, this->user_data);
|
||||
}
|
||||
break;
|
||||
case SPA_COMMAND_STOP:
|
||||
if (this->event_cb) {
|
||||
SpaEvent event;
|
||||
|
||||
event.refcount = 1;
|
||||
event.notify = NULL;
|
||||
event.type = SPA_EVENT_TYPE_STOPPED;
|
||||
event.port_id = -1;
|
||||
event.data = NULL;
|
||||
event.size = 0;
|
||||
|
||||
this->event_cb (handle, &event, this->user_data);
|
||||
}
|
||||
break;
|
||||
|
||||
case SPA_COMMAND_FLUSH:
|
||||
case SPA_COMMAND_DRAIN:
|
||||
case SPA_COMMAND_MARKER:
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_set_event_callback (SpaHandle *handle,
|
||||
SpaEventCallback event,
|
||||
void *user_data)
|
||||
{
|
||||
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
|
||||
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
this->event_cb = event;
|
||||
this->user_data = user_data;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_get_n_ports (SpaHandle *handle,
|
||||
unsigned int *n_input_ports,
|
||||
unsigned int *max_input_ports,
|
||||
unsigned int *n_output_ports,
|
||||
unsigned int *max_output_ports)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (n_input_ports)
|
||||
*n_input_ports = 1;
|
||||
if (n_output_ports)
|
||||
*n_output_ports = 1;
|
||||
if (max_input_ports)
|
||||
*max_input_ports = 1;
|
||||
if (max_output_ports)
|
||||
*max_output_ports = 1;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_get_port_ids (SpaHandle *handle,
|
||||
unsigned int n_input_ports,
|
||||
uint32_t *input_ids,
|
||||
unsigned int n_output_ports,
|
||||
uint32_t *output_ids)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (n_input_ports > 0)
|
||||
input_ids[0] = 0;
|
||||
if (n_output_ports > 0)
|
||||
output_ids[0] = 1;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_add_port (SpaHandle *handle,
|
||||
SpaDirection direction,
|
||||
uint32_t *port_id)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_remove_port (SpaHandle *handle,
|
||||
uint32_t port_id)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_enum_formats (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
unsigned int index,
|
||||
SpaFormat **format)
|
||||
{
|
||||
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
|
||||
SpaFFMpegState *state;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
switch (index) {
|
||||
case 0:
|
||||
spa_video_raw_format_init (&state->raw_format[0]);
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
*format = &state->raw_format[0].format;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_set_format (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
bool test_only,
|
||||
const SpaFormat *format)
|
||||
{
|
||||
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
|
||||
SpaFFMpegState *state;
|
||||
SpaResult res;
|
||||
SpaFormat *f, *tf;
|
||||
size_t fs;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
if (format == NULL) {
|
||||
state->current_format = NULL;
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) {
|
||||
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
|
||||
if ((res = spa_video_raw_format_parse (format, &state->raw_format[0]) < 0))
|
||||
return res;
|
||||
|
||||
f = &state->raw_format[0].format;
|
||||
tf = &state->raw_format[1].format;
|
||||
fs = sizeof (SpaVideoRawFormat);
|
||||
} else
|
||||
return SPA_RESULT_INVALID_MEDIA_TYPE;
|
||||
} else
|
||||
return SPA_RESULT_INVALID_MEDIA_TYPE;
|
||||
|
||||
if (!test_only) {
|
||||
memcpy (tf, f, fs);
|
||||
state->current_format = tf;
|
||||
}
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_get_format (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaFormat **format)
|
||||
{
|
||||
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
|
||||
SpaFFMpegState *state;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
if (state->current_format == NULL)
|
||||
return SPA_RESULT_NO_FORMAT;
|
||||
|
||||
*format = state->current_format;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_get_info (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaPortInfo **info)
|
||||
{
|
||||
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
|
||||
|
||||
if (handle == NULL || info == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
*info = &this->state[port_id].info;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_get_props (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaProps **props)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_set_props (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaProps *props)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_get_status (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaPortStatus **status)
|
||||
{
|
||||
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
|
||||
|
||||
if (handle == NULL || status == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
*status = &this->state[port_id].status;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_use_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t n_buffers)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_alloc_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_push_input (SpaHandle *handle,
|
||||
unsigned int n_info,
|
||||
SpaInputInfo *info)
|
||||
{
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_node_port_pull_output (SpaHandle *handle,
|
||||
unsigned int n_info,
|
||||
SpaOutputInfo *info)
|
||||
{
|
||||
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
|
||||
SpaFFMpegState *state;
|
||||
unsigned int i;
|
||||
bool have_error = false;
|
||||
|
||||
if (handle == NULL || n_info == 0 || info == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
|
||||
for (i = 0; i < n_info; i++) {
|
||||
if (info[i].port_id != OUTPUT_PORT_ID) {
|
||||
info[i].status = SPA_RESULT_INVALID_PORT;
|
||||
have_error = true;
|
||||
continue;
|
||||
}
|
||||
state = &this->state[info[i].port_id];
|
||||
|
||||
if (state->current_format == NULL) {
|
||||
info[i].status = SPA_RESULT_NO_FORMAT;
|
||||
have_error = true;
|
||||
continue;
|
||||
}
|
||||
info[i].status = SPA_RESULT_OK;
|
||||
}
|
||||
if (have_error)
|
||||
return SPA_RESULT_ERROR;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaNode ffmpeg_enc_node = {
|
||||
sizeof (SpaNode),
|
||||
spa_ffmpeg_enc_node_get_props,
|
||||
spa_ffmpeg_enc_node_set_props,
|
||||
spa_ffmpeg_enc_node_send_command,
|
||||
spa_ffmpeg_enc_node_set_event_callback,
|
||||
spa_ffmpeg_enc_node_get_n_ports,
|
||||
spa_ffmpeg_enc_node_get_port_ids,
|
||||
spa_ffmpeg_enc_node_add_port,
|
||||
spa_ffmpeg_enc_node_remove_port,
|
||||
spa_ffmpeg_enc_node_port_enum_formats,
|
||||
spa_ffmpeg_enc_node_port_set_format,
|
||||
spa_ffmpeg_enc_node_port_get_format,
|
||||
spa_ffmpeg_enc_node_port_get_info,
|
||||
spa_ffmpeg_enc_node_port_get_props,
|
||||
spa_ffmpeg_enc_node_port_set_props,
|
||||
spa_ffmpeg_enc_node_port_use_buffers,
|
||||
spa_ffmpeg_enc_node_port_alloc_buffers,
|
||||
spa_ffmpeg_enc_node_port_get_status,
|
||||
spa_ffmpeg_enc_node_port_push_input,
|
||||
spa_ffmpeg_enc_node_port_pull_output,
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
spa_ffmpeg_enc_get_interface (SpaHandle *handle,
|
||||
uint32_t interface_id,
|
||||
const void **interface)
|
||||
{
|
||||
if (handle == NULL || interface == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (interface_id) {
|
||||
case SPA_INTERFACE_ID_NODE:
|
||||
*interface = &ffmpeg_enc_node;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_UNKNOWN_INTERFACE;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaResult
|
||||
spa_ffmpeg_enc_init (SpaHandle *handle)
|
||||
{
|
||||
SpaFFMpegEnc *this;
|
||||
|
||||
handle->get_interface = spa_ffmpeg_enc_get_interface;
|
||||
|
||||
this = (SpaFFMpegEnc *) handle;
|
||||
this->props[1].props.n_prop_info = PROP_ID_LAST;
|
||||
this->props[1].props.prop_info = prop_info;
|
||||
this->props[1].props.set_prop = spa_props_generic_set_prop;
|
||||
this->props[1].props.get_prop = spa_props_generic_get_prop;
|
||||
reset_ffmpeg_enc_props (&this->props[1]);
|
||||
|
||||
this->state[INPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->state[INPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
|
||||
this->state[OUTPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->state[OUTPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
109
spa/plugins/ffmpeg/ffmpeg.c
Normal file
109
spa/plugins/ffmpeg/ffmpeg.c
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
/* Spa V4l2 support
|
||||
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include <spa/plugin.h>
|
||||
#include <spa/node.h>
|
||||
|
||||
#include <libavcodec/avcodec.h>
|
||||
#include <libavformat/avformat.h>
|
||||
|
||||
SpaResult spa_ffmpeg_dec_init (SpaHandle *handle);
|
||||
SpaResult spa_ffmpeg_enc_init (SpaHandle *handle);
|
||||
|
||||
static SpaResult
|
||||
ffmpeg_dec_init (const SpaHandleFactory *factory,
|
||||
SpaHandle *handle)
|
||||
{
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
return spa_ffmpeg_dec_init (handle);
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
ffmpeg_enc_init (const SpaHandleFactory *factory,
|
||||
SpaHandle *handle)
|
||||
{
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
return spa_ffmpeg_enc_init (handle);
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo ffmpeg_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
ffmpeg_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &ffmpeg_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaResult
|
||||
spa_enum_handle_factory (unsigned int index,
|
||||
const SpaHandleFactory **factory)
|
||||
{
|
||||
static const AVCodec *c = NULL;
|
||||
static int ci = 0;
|
||||
static SpaHandleFactory f;
|
||||
static char name[128];
|
||||
|
||||
av_register_all();
|
||||
|
||||
if (index == 0 || index < ci) {
|
||||
c = av_codec_next (NULL);
|
||||
ci = 0;
|
||||
}
|
||||
while (index > ci && c) {
|
||||
c = av_codec_next (c);
|
||||
ci++;
|
||||
}
|
||||
if (c == NULL)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
if (av_codec_is_encoder (c)) {
|
||||
snprintf (name, 128, "ffenc_%s", c->name);
|
||||
f.init = ffmpeg_enc_init;
|
||||
}
|
||||
else {
|
||||
snprintf (name, 128, "ffdec_%s", c->name);
|
||||
f.init = ffmpeg_dec_init;
|
||||
}
|
||||
f.name = name;
|
||||
f.info = NULL;
|
||||
f.enum_interface_info = ffmpeg_enum_interface_info;
|
||||
|
||||
*factory = &f;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
10
spa/plugins/ffmpeg/meson.build
Normal file
10
spa/plugins/ffmpeg/meson.build
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
ffmpeg_sources = ['ffmpeg.c',
|
||||
'ffmpeg-dec.c',
|
||||
'ffmpeg-enc.c']
|
||||
|
||||
ffmpeglib = shared_library('spa-ffmpeg',
|
||||
ffmpeg_sources,
|
||||
include_directories : inc,
|
||||
dependencies : [ avcodec_dep, avformat_dep ],
|
||||
link_with : spalib,
|
||||
install : true)
|
||||
530
spa/plugins/libva/libva-dec.c
Normal file
530
spa/plugins/libva/libva-dec.c
Normal file
|
|
@ -0,0 +1,530 @@
|
|||
/* Spa Libva Decoder
|
||||
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stddef.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#include <spa/node.h>
|
||||
#include <spa/video/format.h>
|
||||
|
||||
typedef struct _SpaLibvaDec SpaLibvaDec;
|
||||
|
||||
typedef struct {
|
||||
SpaProps props;
|
||||
} SpaLibvaDecProps;
|
||||
|
||||
static void
|
||||
reset_libva_dec_props (SpaLibvaDecProps *props)
|
||||
{
|
||||
}
|
||||
|
||||
#define INPUT_PORT_ID 0
|
||||
#define OUTPUT_PORT_ID 1
|
||||
#define IS_VALID_PORT(id) ((id) < 2)
|
||||
#define MAX_BUFFERS 32
|
||||
|
||||
typedef struct _LibvaBuffer LibvaBuffer;
|
||||
|
||||
struct _LibvaBuffer {
|
||||
SpaBuffer buffer;
|
||||
SpaMeta metas[1];
|
||||
SpaMetaHeader header;
|
||||
SpaData datas[1];
|
||||
SpaLibvaDec *dec;
|
||||
SpaBuffer *imported;
|
||||
bool outstanding;
|
||||
LibvaBuffer *next;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
SpaVideoRawFormat raw_format[2];
|
||||
SpaFormat *current_format;
|
||||
bool have_buffers;
|
||||
LibvaBuffer buffers[MAX_BUFFERS];
|
||||
SpaPortInfo info;
|
||||
SpaAllocParam *params[1];
|
||||
SpaAllocParamBuffers param_buffers;
|
||||
SpaPortStatus status;
|
||||
} SpaLibvaState;
|
||||
|
||||
struct _SpaLibvaDec {
|
||||
SpaHandle handle;
|
||||
|
||||
SpaLibvaDecProps props[2];
|
||||
|
||||
SpaEventCallback event_cb;
|
||||
void *user_data;
|
||||
|
||||
SpaLibvaState state[2];
|
||||
};
|
||||
|
||||
enum {
|
||||
PROP_ID_LAST,
|
||||
};
|
||||
|
||||
static const SpaPropInfo prop_info[] =
|
||||
{
|
||||
{ 0, },
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_get_props (SpaHandle *handle,
|
||||
SpaProps **props)
|
||||
{
|
||||
SpaLibvaDec *this = (SpaLibvaDec *) handle;
|
||||
|
||||
if (handle == NULL || props == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
memcpy (&this->props[0], &this->props[1], sizeof (this->props[1]));
|
||||
*props = &this->props[0].props;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_set_props (SpaHandle *handle,
|
||||
const SpaProps *props)
|
||||
{
|
||||
SpaLibvaDec *this = (SpaLibvaDec *) handle;
|
||||
SpaLibvaDecProps *p = &this->props[1];
|
||||
SpaResult res;
|
||||
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (props == NULL) {
|
||||
reset_libva_dec_props (p);
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
res = spa_props_copy (props, &p->props);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_send_command (SpaHandle *handle,
|
||||
SpaCommand *command)
|
||||
{
|
||||
SpaLibvaDec *this = (SpaLibvaDec *) handle;
|
||||
|
||||
if (handle == NULL || command == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (command->type) {
|
||||
case SPA_COMMAND_INVALID:
|
||||
return SPA_RESULT_INVALID_COMMAND;
|
||||
|
||||
case SPA_COMMAND_START:
|
||||
if (this->event_cb) {
|
||||
SpaEvent event;
|
||||
|
||||
event.refcount = 1;
|
||||
event.notify = NULL;
|
||||
event.type = SPA_EVENT_TYPE_STARTED;
|
||||
event.port_id = -1;
|
||||
event.data = NULL;
|
||||
event.size = 0;
|
||||
|
||||
this->event_cb (handle, &event, this->user_data);
|
||||
}
|
||||
break;
|
||||
case SPA_COMMAND_STOP:
|
||||
if (this->event_cb) {
|
||||
SpaEvent event;
|
||||
|
||||
event.refcount = 1;
|
||||
event.notify = NULL;
|
||||
event.type = SPA_EVENT_TYPE_STOPPED;
|
||||
event.port_id = -1;
|
||||
event.data = NULL;
|
||||
event.size = 0;
|
||||
|
||||
this->event_cb (handle, &event, this->user_data);
|
||||
}
|
||||
break;
|
||||
|
||||
case SPA_COMMAND_FLUSH:
|
||||
case SPA_COMMAND_DRAIN:
|
||||
case SPA_COMMAND_MARKER:
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_set_event_callback (SpaHandle *handle,
|
||||
SpaEventCallback event,
|
||||
void *user_data)
|
||||
{
|
||||
SpaLibvaDec *this = (SpaLibvaDec *) handle;
|
||||
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
this->event_cb = event;
|
||||
this->user_data = user_data;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_get_n_ports (SpaHandle *handle,
|
||||
unsigned int *n_input_ports,
|
||||
unsigned int *max_input_ports,
|
||||
unsigned int *n_output_ports,
|
||||
unsigned int *max_output_ports)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (n_input_ports)
|
||||
*n_input_ports = 1;
|
||||
if (n_output_ports)
|
||||
*n_output_ports = 1;
|
||||
if (max_input_ports)
|
||||
*max_input_ports = 1;
|
||||
if (max_output_ports)
|
||||
*max_output_ports = 1;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_get_port_ids (SpaHandle *handle,
|
||||
unsigned int n_input_ports,
|
||||
uint32_t *input_ids,
|
||||
unsigned int n_output_ports,
|
||||
uint32_t *output_ids)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (n_input_ports > 0)
|
||||
input_ids[0] = 0;
|
||||
if (n_output_ports > 0)
|
||||
output_ids[0] = 1;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_add_port (SpaHandle *handle,
|
||||
SpaDirection direction,
|
||||
uint32_t *port_id)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_remove_port (SpaHandle *handle,
|
||||
uint32_t port_id)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_enum_formats (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
unsigned int index,
|
||||
SpaFormat **format)
|
||||
{
|
||||
SpaLibvaDec *this = (SpaLibvaDec *) handle;
|
||||
SpaLibvaState *state;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
switch (index) {
|
||||
case 0:
|
||||
spa_video_raw_format_init (&state->raw_format[0]);
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
*format = &state->raw_format[0].format;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_set_format (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
bool test_only,
|
||||
const SpaFormat *format)
|
||||
{
|
||||
SpaLibvaDec *this = (SpaLibvaDec *) handle;
|
||||
SpaLibvaState *state;
|
||||
SpaResult res;
|
||||
SpaFormat *f, *tf;
|
||||
size_t fs;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
if (format == NULL) {
|
||||
state->current_format = NULL;
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) {
|
||||
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
|
||||
if ((res = spa_video_raw_format_parse (format, &state->raw_format[0]) < 0))
|
||||
return res;
|
||||
|
||||
f = &state->raw_format[0].format;
|
||||
tf = &state->raw_format[1].format;
|
||||
fs = sizeof (SpaVideoRawFormat);
|
||||
} else
|
||||
return SPA_RESULT_INVALID_MEDIA_TYPE;
|
||||
} else
|
||||
return SPA_RESULT_INVALID_MEDIA_TYPE;
|
||||
|
||||
if (!test_only) {
|
||||
memcpy (tf, f, fs);
|
||||
state->current_format = tf;
|
||||
}
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_get_format (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaFormat **format)
|
||||
{
|
||||
SpaLibvaDec *this = (SpaLibvaDec *) handle;
|
||||
SpaLibvaState *state;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
if (state->current_format == NULL)
|
||||
return SPA_RESULT_NO_FORMAT;
|
||||
|
||||
*format = state->current_format;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_get_info (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaPortInfo **info)
|
||||
{
|
||||
SpaLibvaDec *this = (SpaLibvaDec *) handle;
|
||||
|
||||
if (handle == NULL || info == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
*info = &this->state[port_id].info;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_get_props (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaProps **props)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_set_props (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaProps *props)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_get_status (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaPortStatus **status)
|
||||
{
|
||||
SpaLibvaDec *this = (SpaLibvaDec *) handle;
|
||||
|
||||
if (handle == NULL || status == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
*status = &this->state[port_id].status;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_use_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t n_buffers)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_alloc_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_push_input (SpaHandle *handle,
|
||||
unsigned int n_info,
|
||||
SpaInputInfo *info)
|
||||
{
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_node_port_pull_output (SpaHandle *handle,
|
||||
unsigned int n_info,
|
||||
SpaOutputInfo *info)
|
||||
{
|
||||
SpaLibvaDec *this = (SpaLibvaDec *) handle;
|
||||
SpaLibvaState *state;
|
||||
unsigned int i;
|
||||
bool have_error = false;
|
||||
|
||||
if (handle == NULL || n_info == 0 || info == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
|
||||
for (i = 0; i < n_info; i++) {
|
||||
if (info[i].port_id != OUTPUT_PORT_ID) {
|
||||
info[i].status = SPA_RESULT_INVALID_PORT;
|
||||
have_error = true;
|
||||
continue;
|
||||
}
|
||||
state = &this->state[info[i].port_id];
|
||||
|
||||
if (state->current_format == NULL) {
|
||||
info[i].status = SPA_RESULT_NO_FORMAT;
|
||||
have_error = true;
|
||||
continue;
|
||||
}
|
||||
info[i].status = SPA_RESULT_OK;
|
||||
}
|
||||
if (have_error)
|
||||
return SPA_RESULT_ERROR;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaNode libva_dec_node = {
|
||||
sizeof (SpaNode),
|
||||
spa_libva_dec_node_get_props,
|
||||
spa_libva_dec_node_set_props,
|
||||
spa_libva_dec_node_send_command,
|
||||
spa_libva_dec_node_set_event_callback,
|
||||
spa_libva_dec_node_get_n_ports,
|
||||
spa_libva_dec_node_get_port_ids,
|
||||
spa_libva_dec_node_add_port,
|
||||
spa_libva_dec_node_remove_port,
|
||||
spa_libva_dec_node_port_enum_formats,
|
||||
spa_libva_dec_node_port_set_format,
|
||||
spa_libva_dec_node_port_get_format,
|
||||
spa_libva_dec_node_port_get_info,
|
||||
spa_libva_dec_node_port_get_props,
|
||||
spa_libva_dec_node_port_set_props,
|
||||
spa_libva_dec_node_port_use_buffers,
|
||||
spa_libva_dec_node_port_alloc_buffers,
|
||||
spa_libva_dec_node_port_get_status,
|
||||
spa_libva_dec_node_port_push_input,
|
||||
spa_libva_dec_node_port_pull_output,
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
spa_libva_dec_get_interface (SpaHandle *handle,
|
||||
uint32_t interface_id,
|
||||
const void **interface)
|
||||
{
|
||||
if (handle == NULL || interface == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (interface_id) {
|
||||
case SPA_INTERFACE_ID_NODE:
|
||||
*interface = &libva_dec_node;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_UNKNOWN_INTERFACE;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaHandle *
|
||||
spa_libva_dec_new (void)
|
||||
{
|
||||
SpaHandle *handle;
|
||||
SpaLibvaDec *this;
|
||||
|
||||
handle = calloc (1, sizeof (SpaLibvaDec));
|
||||
handle->get_interface = spa_libva_dec_get_interface;
|
||||
|
||||
this = (SpaLibvaDec *) handle;
|
||||
this->props[1].props.n_prop_info = PROP_ID_LAST;
|
||||
this->props[1].props.prop_info = prop_info;
|
||||
this->props[1].props.set_prop = spa_props_generic_set_prop;
|
||||
this->props[1].props.get_prop = spa_props_generic_get_prop;
|
||||
reset_libva_dec_props (&this->props[1]);
|
||||
|
||||
this->state[INPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->state[INPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
|
||||
this->state[OUTPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->state[OUTPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
return handle;
|
||||
}
|
||||
530
spa/plugins/libva/libva-enc.c
Normal file
530
spa/plugins/libva/libva-enc.c
Normal file
|
|
@ -0,0 +1,530 @@
|
|||
/* Spa Libva Encoder
|
||||
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stddef.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#include <spa/node.h>
|
||||
#include <spa/video/format.h>
|
||||
|
||||
typedef struct _SpaLibvaEnc SpaLibvaEnc;
|
||||
|
||||
typedef struct {
|
||||
SpaProps props;
|
||||
} SpaLibvaEncProps;
|
||||
|
||||
static void
|
||||
reset_libva_enc_props (SpaLibvaEncProps *props)
|
||||
{
|
||||
}
|
||||
|
||||
#define INPUT_PORT_ID 0
|
||||
#define OUTPUT_PORT_ID 1
|
||||
#define IS_VALID_PORT(id) ((id) < 2)
|
||||
#define MAX_BUFFERS 32
|
||||
|
||||
typedef struct _LibvaBuffer LibvaBuffer;
|
||||
|
||||
struct _LibvaBuffer {
|
||||
SpaBuffer buffer;
|
||||
SpaMeta metas[1];
|
||||
SpaMetaHeader header;
|
||||
SpaData datas[1];
|
||||
SpaLibvaEnc *enc;
|
||||
SpaBuffer *imported;
|
||||
bool outstanding;
|
||||
LibvaBuffer *next;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
SpaVideoRawFormat raw_format[2];
|
||||
SpaFormat *current_format;
|
||||
bool have_buffers;
|
||||
LibvaBuffer buffers[MAX_BUFFERS];
|
||||
SpaPortInfo info;
|
||||
SpaAllocParam *params[1];
|
||||
SpaAllocParamBuffers param_buffers;
|
||||
SpaPortStatus status;
|
||||
} SpaLibvaState;
|
||||
|
||||
struct _SpaLibvaEnc {
|
||||
SpaHandle handle;
|
||||
|
||||
SpaLibvaEncProps props[2];
|
||||
|
||||
SpaEventCallback event_cb;
|
||||
void *user_data;
|
||||
|
||||
SpaLibvaState state[2];
|
||||
};
|
||||
|
||||
enum {
|
||||
PROP_ID_LAST,
|
||||
};
|
||||
|
||||
static const SpaPropInfo prop_info[] =
|
||||
{
|
||||
{ 0, },
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_get_props (SpaHandle *handle,
|
||||
SpaProps **props)
|
||||
{
|
||||
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
|
||||
|
||||
if (handle == NULL || props == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
memcpy (&this->props[0], &this->props[1], sizeof (this->props[1]));
|
||||
*props = &this->props[0].props;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_set_props (SpaHandle *handle,
|
||||
const SpaProps *props)
|
||||
{
|
||||
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
|
||||
SpaLibvaEncProps *p = &this->props[1];
|
||||
SpaResult res;
|
||||
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (props == NULL) {
|
||||
reset_libva_enc_props (p);
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
res = spa_props_copy (props, &p->props);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_send_command (SpaHandle *handle,
|
||||
SpaCommand *command)
|
||||
{
|
||||
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
|
||||
|
||||
if (handle == NULL || command == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (command->type) {
|
||||
case SPA_COMMAND_INVALID:
|
||||
return SPA_RESULT_INVALID_COMMAND;
|
||||
|
||||
case SPA_COMMAND_START:
|
||||
if (this->event_cb) {
|
||||
SpaEvent event;
|
||||
|
||||
event.refcount = 1;
|
||||
event.notify = NULL;
|
||||
event.type = SPA_EVENT_TYPE_STARTED;
|
||||
event.port_id = -1;
|
||||
event.data = NULL;
|
||||
event.size = 0;
|
||||
|
||||
this->event_cb (handle, &event, this->user_data);
|
||||
}
|
||||
break;
|
||||
case SPA_COMMAND_STOP:
|
||||
if (this->event_cb) {
|
||||
SpaEvent event;
|
||||
|
||||
event.refcount = 1;
|
||||
event.notify = NULL;
|
||||
event.type = SPA_EVENT_TYPE_STOPPED;
|
||||
event.port_id = -1;
|
||||
event.data = NULL;
|
||||
event.size = 0;
|
||||
|
||||
this->event_cb (handle, &event, this->user_data);
|
||||
}
|
||||
break;
|
||||
|
||||
case SPA_COMMAND_FLUSH:
|
||||
case SPA_COMMAND_DRAIN:
|
||||
case SPA_COMMAND_MARKER:
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_set_event_callback (SpaHandle *handle,
|
||||
SpaEventCallback event,
|
||||
void *user_data)
|
||||
{
|
||||
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
|
||||
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
this->event_cb = event;
|
||||
this->user_data = user_data;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_get_n_ports (SpaHandle *handle,
|
||||
unsigned int *n_input_ports,
|
||||
unsigned int *max_input_ports,
|
||||
unsigned int *n_output_ports,
|
||||
unsigned int *max_output_ports)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (n_input_ports)
|
||||
*n_input_ports = 1;
|
||||
if (n_output_ports)
|
||||
*n_output_ports = 1;
|
||||
if (max_input_ports)
|
||||
*max_input_ports = 1;
|
||||
if (max_output_ports)
|
||||
*max_output_ports = 1;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_get_port_ids (SpaHandle *handle,
|
||||
unsigned int n_input_ports,
|
||||
uint32_t *input_ids,
|
||||
unsigned int n_output_ports,
|
||||
uint32_t *output_ids)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (n_input_ports > 0)
|
||||
input_ids[0] = 0;
|
||||
if (n_output_ports > 0)
|
||||
output_ids[0] = 1;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_add_port (SpaHandle *handle,
|
||||
SpaDirection direction,
|
||||
uint32_t *port_id)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_remove_port (SpaHandle *handle,
|
||||
uint32_t port_id)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_enum_formats (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
unsigned int index,
|
||||
SpaFormat **format)
|
||||
{
|
||||
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
|
||||
SpaLibvaState *state;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
switch (index) {
|
||||
case 0:
|
||||
spa_video_raw_format_init (&state->raw_format[0]);
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
*format = &state->raw_format[0].format;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_set_format (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
bool test_only,
|
||||
const SpaFormat *format)
|
||||
{
|
||||
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
|
||||
SpaLibvaState *state;
|
||||
SpaResult res;
|
||||
SpaFormat *f, *tf;
|
||||
size_t fs;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
if (format == NULL) {
|
||||
state->current_format = NULL;
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) {
|
||||
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
|
||||
if ((res = spa_video_raw_format_parse (format, &state->raw_format[0]) < 0))
|
||||
return res;
|
||||
|
||||
f = &state->raw_format[0].format;
|
||||
tf = &state->raw_format[1].format;
|
||||
fs = sizeof (SpaVideoRawFormat);
|
||||
} else
|
||||
return SPA_RESULT_INVALID_MEDIA_TYPE;
|
||||
} else
|
||||
return SPA_RESULT_INVALID_MEDIA_TYPE;
|
||||
|
||||
if (!test_only) {
|
||||
memcpy (tf, f, fs);
|
||||
state->current_format = tf;
|
||||
}
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_get_format (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaFormat **format)
|
||||
{
|
||||
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
|
||||
SpaLibvaState *state;
|
||||
|
||||
if (handle == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
state = &this->state[port_id];
|
||||
|
||||
if (state->current_format == NULL)
|
||||
return SPA_RESULT_NO_FORMAT;
|
||||
|
||||
*format = state->current_format;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_get_info (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaPortInfo **info)
|
||||
{
|
||||
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
|
||||
|
||||
if (handle == NULL || info == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
*info = &this->state[port_id].info;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_get_props (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaProps **props)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_set_props (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaProps *props)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_get_status (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
const SpaPortStatus **status)
|
||||
{
|
||||
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
|
||||
|
||||
if (handle == NULL || status == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
*status = &this->state[port_id].status;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_use_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t n_buffers)
|
||||
{
|
||||
if (handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
if (!IS_VALID_PORT (port_id))
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_alloc_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers)
|
||||
{
|
||||
return SPA_RESULT_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_push_input (SpaHandle *handle,
|
||||
unsigned int n_info,
|
||||
SpaInputInfo *info)
|
||||
{
|
||||
return SPA_RESULT_INVALID_PORT;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_node_port_pull_output (SpaHandle *handle,
|
||||
unsigned int n_info,
|
||||
SpaOutputInfo *info)
|
||||
{
|
||||
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
|
||||
SpaLibvaState *state;
|
||||
unsigned int i;
|
||||
bool have_error = false;
|
||||
|
||||
if (handle == NULL || n_info == 0 || info == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
|
||||
for (i = 0; i < n_info; i++) {
|
||||
if (info[i].port_id != OUTPUT_PORT_ID) {
|
||||
info[i].status = SPA_RESULT_INVALID_PORT;
|
||||
have_error = true;
|
||||
continue;
|
||||
}
|
||||
state = &this->state[info[i].port_id];
|
||||
|
||||
if (state->current_format == NULL) {
|
||||
info[i].status = SPA_RESULT_NO_FORMAT;
|
||||
have_error = true;
|
||||
continue;
|
||||
}
|
||||
info[i].status = SPA_RESULT_OK;
|
||||
}
|
||||
if (have_error)
|
||||
return SPA_RESULT_ERROR;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaNode libva_enc_node = {
|
||||
sizeof (SpaNode),
|
||||
spa_libva_enc_node_get_props,
|
||||
spa_libva_enc_node_set_props,
|
||||
spa_libva_enc_node_send_command,
|
||||
spa_libva_enc_node_set_event_callback,
|
||||
spa_libva_enc_node_get_n_ports,
|
||||
spa_libva_enc_node_get_port_ids,
|
||||
spa_libva_enc_node_add_port,
|
||||
spa_libva_enc_node_remove_port,
|
||||
spa_libva_enc_node_port_enum_formats,
|
||||
spa_libva_enc_node_port_set_format,
|
||||
spa_libva_enc_node_port_get_format,
|
||||
spa_libva_enc_node_port_get_info,
|
||||
spa_libva_enc_node_port_get_props,
|
||||
spa_libva_enc_node_port_set_props,
|
||||
spa_libva_enc_node_port_use_buffers,
|
||||
spa_libva_enc_node_port_alloc_buffers,
|
||||
spa_libva_enc_node_port_get_status,
|
||||
spa_libva_enc_node_port_push_input,
|
||||
spa_libva_enc_node_port_pull_output,
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
spa_libva_enc_get_interface (SpaHandle *handle,
|
||||
uint32_t interface_id,
|
||||
const void **interface)
|
||||
{
|
||||
if (handle == NULL || interface == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (interface_id) {
|
||||
case SPA_INTERFACE_ID_NODE:
|
||||
*interface = &libva_enc_node;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_UNKNOWN_INTERFACE;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaHandle *
|
||||
spa_libva_enc_new (void)
|
||||
{
|
||||
SpaHandle *handle;
|
||||
SpaLibvaEnc *this;
|
||||
|
||||
handle = calloc (1, sizeof (SpaLibvaEnc));
|
||||
handle->get_interface = spa_libva_enc_get_interface;
|
||||
|
||||
this = (SpaLibvaEnc *) handle;
|
||||
this->props[1].props.n_prop_info = PROP_ID_LAST;
|
||||
this->props[1].props.prop_info = prop_info;
|
||||
this->props[1].props.set_prop = spa_props_generic_set_prop;
|
||||
this->props[1].props.get_prop = spa_props_generic_get_prop;
|
||||
reset_libva_enc_props (&this->props[1]);
|
||||
|
||||
this->state[INPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->state[INPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
|
||||
this->state[OUTPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->state[OUTPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
return handle;
|
||||
}
|
||||
96
spa/plugins/libva/libva.c
Normal file
96
spa/plugins/libva/libva.c
Normal file
|
|
@ -0,0 +1,96 @@
|
|||
/* Spa V4l2 support
|
||||
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <spa/plugin.h>
|
||||
#include <spa/node.h>
|
||||
|
||||
SpaHandle * spa_libva_dec_new (void);
|
||||
SpaHandle * spa_libva_enc_new (void);
|
||||
|
||||
static SpaResult
|
||||
libva_dec_instantiate (const SpaHandleFactory *factory,
|
||||
SpaHandle **handle)
|
||||
{
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
*handle = spa_libva_dec_new ();
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static SpaResult
|
||||
libva_enc_instantiate (const SpaHandleFactory *factory,
|
||||
SpaHandle **handle)
|
||||
{
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
*handle = spa_libva_enc_new ();
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
|
||||
static const SpaInterfaceInfo libva_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
libva_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &libva_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaHandleFactory factories[] =
|
||||
{
|
||||
{ "libva-dec",
|
||||
NULL,
|
||||
libva_dec_instantiate,
|
||||
libva_enum_interface_info,
|
||||
},
|
||||
{ "libva-enc",
|
||||
NULL,
|
||||
libva_enc_instantiate,
|
||||
libva_enum_interface_info,
|
||||
}
|
||||
};
|
||||
|
||||
SpaResult
|
||||
spa_enum_handle_factory (unsigned int index,
|
||||
const SpaHandleFactory **factory)
|
||||
{
|
||||
if (index >= 2)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*factory = &factories[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
10
spa/plugins/libva/meson.build
Normal file
10
spa/plugins/libva/meson.build
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
libva_sources = ['libva.c',
|
||||
'libva-dec.c',
|
||||
'libva-enc.c']
|
||||
|
||||
libvalib = shared_library('spa-libva',
|
||||
libva_sources,
|
||||
include_directories : inc,
|
||||
dependencies : libva_dep,
|
||||
link_with : spalib,
|
||||
install : true)
|
||||
1161
spa/plugins/libva/vaapi-recorder.c
Normal file
1161
spa/plugins/libva/vaapi-recorder.c
Normal file
File diff suppressed because it is too large
Load diff
38
spa/plugins/libva/vaapi-recorder.h
Normal file
38
spa/plugins/libva/vaapi-recorder.h
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
/*
|
||||
* Copyright © 2013 Intel Corporation
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the
|
||||
* next paragraph) shall be included in all copies or substantial
|
||||
* portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef _VAAPI_RECORDER_H_
|
||||
#define _VAAPI_RECORDER_H_
|
||||
|
||||
struct vaapi_recorder;
|
||||
|
||||
struct vaapi_recorder *
|
||||
vaapi_recorder_create(int drm_fd, int width, int height, const char *filename);
|
||||
void
|
||||
vaapi_recorder_destroy(struct vaapi_recorder *r);
|
||||
int
|
||||
vaapi_recorder_frame(struct vaapi_recorder *r, int fd, int stride);
|
||||
|
||||
#endif /* _VAAPI_RECORDER_H_ */
|
||||
|
|
@ -1,6 +1,8 @@
|
|||
subdir('alsa')
|
||||
subdir('audiomixer')
|
||||
subdir('audiotestsrc')
|
||||
subdir('ffmpeg')
|
||||
#subdir('libva')
|
||||
subdir('volume')
|
||||
subdir('v4l2')
|
||||
subdir('xv')
|
||||
|
|
|
|||
|
|
@ -77,6 +77,8 @@ typedef struct {
|
|||
SpaPollFd fds[1];
|
||||
SpaPollItem poll;
|
||||
SpaPortInfo info;
|
||||
SpaAllocParam *params[1];
|
||||
SpaAllocParamBuffers param_buffers;
|
||||
SpaPortStatus status;
|
||||
} SpaV4l2State;
|
||||
|
||||
|
|
@ -467,6 +469,8 @@ spa_v4l2_source_node_port_use_buffers (SpaHandle *handle,
|
|||
static SpaResult
|
||||
spa_v4l2_source_node_port_alloc_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers)
|
||||
{
|
||||
|
|
@ -573,13 +577,15 @@ spa_v4l2_source_get_interface (SpaHandle *handle,
|
|||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaHandle *
|
||||
spa_v4l2_source_new (void)
|
||||
static SpaResult
|
||||
v4l2_source_init (const SpaHandleFactory *factory,
|
||||
SpaHandle *handle)
|
||||
{
|
||||
SpaHandle *handle;
|
||||
SpaV4l2Source *this;
|
||||
|
||||
handle = calloc (1, sizeof (SpaV4l2Source));
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
handle->get_interface = spa_v4l2_source_get_interface;
|
||||
|
||||
this = (SpaV4l2Source *) handle;
|
||||
|
|
@ -591,5 +597,35 @@ spa_v4l2_source_new (void)
|
|||
|
||||
this->state[0].info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->state[0].status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
return handle;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo v4l2_source_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
v4l2_source_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &v4l2_source_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
const SpaHandleFactory spa_v4l2_source_factory =
|
||||
{ "v4l2-source",
|
||||
NULL,
|
||||
sizeof (SpaV4l2Source),
|
||||
v4l2_source_init,
|
||||
v4l2_source_enum_interface_info,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -314,13 +314,19 @@ spa_v4l2_set_format (SpaV4l2Source *this, SpaFormat *format, bool try_only)
|
|||
|
||||
state->fmt = fmt;
|
||||
state->info.flags = SPA_PORT_INFO_FLAG_CAN_GIVE_BUFFER;
|
||||
state->info.minsize = fmt.fmt.pix.sizeimage;
|
||||
state->info.stride = fmt.fmt.pix.bytesperline;
|
||||
state->info.min_buffers = 2;
|
||||
state->info.max_buffers = MAX_BUFFERS;
|
||||
state->info.align = 16;
|
||||
state->info.maxbuffering = -1;
|
||||
state->info.latency = -1;
|
||||
|
||||
state->info.n_params = 1;
|
||||
state->info.params = state->params;
|
||||
state->params[0] = &state->param_buffers.param;
|
||||
state->param_buffers.param.type = SPA_ALLOC_PARAM_TYPE_BUFFERS;
|
||||
state->param_buffers.param.size = sizeof (&state->buffers);
|
||||
state->param_buffers.minsize = fmt.fmt.pix.sizeimage;
|
||||
state->param_buffers.stride = fmt.fmt.pix.bytesperline;
|
||||
state->param_buffers.min_buffers = 2;
|
||||
state->param_buffers.max_buffers = MAX_BUFFERS;
|
||||
state->param_buffers.align = 16;
|
||||
state->info.features = NULL;
|
||||
|
||||
return 0;
|
||||
|
|
@ -334,6 +340,7 @@ spa_v4l2_close (SpaV4l2Source *this)
|
|||
if (!state->opened)
|
||||
return 0;
|
||||
|
||||
fprintf (stderr, "close\n");
|
||||
if (close(state->fd))
|
||||
perror ("close");
|
||||
|
||||
|
|
|
|||
|
|
@ -20,59 +20,21 @@
|
|||
#include <spa/plugin.h>
|
||||
#include <spa/node.h>
|
||||
|
||||
SpaHandle * spa_v4l2_source_new (void);
|
||||
|
||||
static SpaResult
|
||||
v4l2_source_instantiate (const SpaHandleFactory *factory,
|
||||
SpaHandle **handle)
|
||||
{
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
*handle = spa_v4l2_source_new ();
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo v4l2_source_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
v4l2_source_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &v4l2_source_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaHandleFactory factories[] =
|
||||
{
|
||||
{ "v4l2-source",
|
||||
NULL,
|
||||
v4l2_source_instantiate,
|
||||
v4l2_source_enum_interface_info,
|
||||
},
|
||||
};
|
||||
|
||||
extern const SpaHandleFactory spa_v4l2_source_factory;
|
||||
|
||||
SpaResult
|
||||
spa_enum_handle_factory (unsigned int index,
|
||||
const SpaHandleFactory **factory)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*factory = &factories[index];
|
||||
if (factory == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (index) {
|
||||
case 0:
|
||||
*factory = &spa_v4l2_source_factory;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,59 +20,21 @@
|
|||
#include <spa/plugin.h>
|
||||
#include <spa/node.h>
|
||||
|
||||
SpaHandle * spa_volume_new (void);
|
||||
|
||||
static SpaResult
|
||||
volume_instantiate (const SpaHandleFactory *factory,
|
||||
SpaHandle **handle)
|
||||
{
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
*handle = spa_volume_new ();
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo volume_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
volume_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &volume_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaHandleFactory factories[] =
|
||||
{
|
||||
{ "volume",
|
||||
NULL,
|
||||
volume_instantiate,
|
||||
volume_enum_interface_info,
|
||||
},
|
||||
};
|
||||
|
||||
extern const SpaHandleFactory spa_volume_factory;
|
||||
|
||||
SpaResult
|
||||
spa_enum_handle_factory (unsigned int index,
|
||||
const SpaHandleFactory **factory)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*factory = &factories[index];
|
||||
if (factory == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (index) {
|
||||
case 0:
|
||||
*factory = &spa_volume_factory;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -398,6 +398,8 @@ spa_volume_node_port_use_buffers (SpaHandle *handle,
|
|||
static SpaResult
|
||||
spa_volume_node_port_alloc_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers)
|
||||
{
|
||||
|
|
@ -594,13 +596,15 @@ spa_volume_get_interface (SpaHandle *handle,
|
|||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaHandle *
|
||||
spa_volume_new (void)
|
||||
static SpaResult
|
||||
volume_instantiate (const SpaHandleFactory *factory,
|
||||
SpaHandle *handle)
|
||||
{
|
||||
SpaHandle *handle;
|
||||
SpaVolume *this;
|
||||
|
||||
handle = calloc (1, sizeof (SpaVolume));
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
handle->get_interface = spa_volume_get_interface;
|
||||
|
||||
this = (SpaVolume *) handle;
|
||||
|
|
@ -619,5 +623,34 @@ spa_volume_new (void)
|
|||
this->ports[0].status.flags = SPA_PORT_STATUS_FLAG_NEED_INPUT;
|
||||
this->ports[1].status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
|
||||
return handle;
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo volume_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
volume_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &volume_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
const SpaHandleFactory spa_volume_factory =
|
||||
{ "volume",
|
||||
NULL,
|
||||
sizeof (SpaVolume),
|
||||
volume_instantiate,
|
||||
volume_enum_interface_info,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -442,6 +442,8 @@ spa_xv_sink_node_port_use_buffers (SpaHandle *handle,
|
|||
static SpaResult
|
||||
spa_xv_sink_node_port_alloc_buffers (SpaHandle *handle,
|
||||
uint32_t port_id,
|
||||
SpaAllocParam **params,
|
||||
uint32_t n_params,
|
||||
SpaBuffer **buffers,
|
||||
uint32_t *n_buffers)
|
||||
{
|
||||
|
|
@ -546,13 +548,15 @@ spa_xv_sink_get_interface (SpaHandle *handle,
|
|||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
SpaHandle *
|
||||
spa_xv_sink_new (void)
|
||||
static SpaResult
|
||||
xv_sink_init (const SpaHandleFactory *factory,
|
||||
SpaHandle *handle)
|
||||
{
|
||||
SpaHandle *handle;
|
||||
SpaXvSink *this;
|
||||
|
||||
handle = calloc (1, sizeof (SpaXvSink));
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
handle->get_interface = spa_xv_sink_get_interface;
|
||||
|
||||
this = (SpaXvSink *) handle;
|
||||
|
|
@ -564,5 +568,35 @@ spa_xv_sink_new (void)
|
|||
|
||||
this->info.flags = SPA_PORT_INFO_FLAG_NONE;
|
||||
this->status.flags = SPA_PORT_STATUS_FLAG_NONE;
|
||||
return handle;
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo xv_sink_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
xv_sink_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &xv_sink_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
const SpaHandleFactory spa_xv_sink_factory =
|
||||
{ "xv-sink",
|
||||
NULL,
|
||||
sizeof (SpaXvSink),
|
||||
xv_sink_init,
|
||||
xv_sink_enum_interface_info,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -20,59 +20,21 @@
|
|||
#include <spa/plugin.h>
|
||||
#include <spa/node.h>
|
||||
|
||||
SpaHandle * spa_xv_sink_new (void);
|
||||
|
||||
static SpaResult
|
||||
xv_sink_instantiate (const SpaHandleFactory *factory,
|
||||
SpaHandle **handle)
|
||||
{
|
||||
if (factory == NULL || handle == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
*handle = spa_xv_sink_new ();
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaInterfaceInfo xv_sink_interfaces[] =
|
||||
{
|
||||
{ SPA_INTERFACE_ID_NODE,
|
||||
SPA_INTERFACE_ID_NODE_NAME,
|
||||
SPA_INTERFACE_ID_NODE_DESCRIPTION,
|
||||
},
|
||||
};
|
||||
|
||||
static SpaResult
|
||||
xv_sink_enum_interface_info (const SpaHandleFactory *factory,
|
||||
unsigned int index,
|
||||
const SpaInterfaceInfo **info)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*info = &xv_sink_interfaces[index];
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
||||
static const SpaHandleFactory factories[] =
|
||||
{
|
||||
{ "xv-sink",
|
||||
NULL,
|
||||
xv_sink_instantiate,
|
||||
xv_sink_enum_interface_info,
|
||||
},
|
||||
};
|
||||
|
||||
extern const SpaHandleFactory spa_xv_sink_factory;
|
||||
|
||||
SpaResult
|
||||
spa_enum_handle_factory (unsigned int index,
|
||||
const SpaHandleFactory **factory)
|
||||
{
|
||||
if (index >= 1)
|
||||
return SPA_RESULT_ENUM_END;
|
||||
|
||||
*factory = &factories[index];
|
||||
if (factory == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
||||
switch (index) {
|
||||
case 0:
|
||||
*factory = &spa_xv_sink_factory;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,11 @@
|
|||
executable('test-mixer', 'test-mixer.c',
|
||||
include_directories : inc,
|
||||
dependencies : [dl_lib, pthread_lib],
|
||||
link_with : spalib,
|
||||
install : false)
|
||||
|
||||
executable('test-v4l2', 'test-v4l2.c',
|
||||
include_directories : inc,
|
||||
dependencies : [dl_lib, sdl_dep, pthread_lib],
|
||||
link_with : spalib,
|
||||
install : false)
|
||||
|
|
|
|||
|
|
@ -75,7 +75,8 @@ make_node (SpaHandle **handle, const SpaNode **node, const char *lib, const char
|
|||
if (strcmp (factory->name, name))
|
||||
continue;
|
||||
|
||||
if ((res = factory->instantiate (factory, handle)) < 0) {
|
||||
*handle = calloc (1, factory->size);
|
||||
if ((res = factory->init (factory, *handle)) < 0) {
|
||||
printf ("can't make factory instance: %d\n", res);
|
||||
return res;
|
||||
}
|
||||
|
|
@ -200,8 +201,8 @@ make_nodes (AppData *data)
|
|||
printf ("got get_props error %d\n", res);
|
||||
|
||||
value.type = SPA_PROP_TYPE_STRING;
|
||||
value.size = strlen ("hw:1")+1;
|
||||
value.value = "hw:1";
|
||||
value.value = "hw:0";
|
||||
value.size = strlen (value.value)+1;
|
||||
props->set_prop (props, spa_props_index_for_name (props, "device"), &value);
|
||||
|
||||
if ((res = data->sink_node->set_props (data->sink, props)) < 0)
|
||||
|
|
|
|||
|
|
@ -29,9 +29,10 @@
|
|||
#include <SDL2/SDL.h>
|
||||
|
||||
#include <spa/node.h>
|
||||
#include <spa/debug.h>
|
||||
#include <spa/video/format.h>
|
||||
|
||||
#define USE_BUFFER
|
||||
#undef USE_BUFFER
|
||||
|
||||
#define MAX_BUFFERS 8
|
||||
|
||||
|
|
@ -87,7 +88,8 @@ make_node (SpaHandle **handle, const SpaNode **node, const char *lib, const char
|
|||
if (strcmp (factory->name, name))
|
||||
continue;
|
||||
|
||||
if ((res = factory->instantiate (factory, handle)) < 0) {
|
||||
*handle = calloc (1, factory->size);
|
||||
if ((res = factory->init (factory, *handle)) < 0) {
|
||||
printf ("can't make factory instance: %d\n", res);
|
||||
return res;
|
||||
}
|
||||
|
|
@ -309,14 +311,7 @@ negotiate_formats (AppData *data)
|
|||
if ((res = data->source_node->port_get_info (data->source, 0, &info)) < 0)
|
||||
return res;
|
||||
|
||||
printf ("flags: %d\n", info->flags);
|
||||
printf ("minsize: %zd\n", info->minsize);
|
||||
printf ("stride: %zd\n", info->stride);
|
||||
printf ("min_buffers: %d\n", info->min_buffers);
|
||||
printf ("max_buffers: %d\n", info->max_buffers);
|
||||
printf ("align: %d\n", info->align);
|
||||
printf ("maxbuffering: %d\n", info->maxbuffering);
|
||||
printf ("latency: %lu\n", info->latency);
|
||||
spa_debug_port_info (info);
|
||||
|
||||
#ifdef USE_BUFFER
|
||||
alloc_buffers (data);
|
||||
|
|
|
|||
|
|
@ -188,7 +188,8 @@ inspect_factory (const SpaHandleFactory *factory)
|
|||
else
|
||||
printf (" none\n");
|
||||
|
||||
if ((res = factory->instantiate (factory, &handle)) < 0) {
|
||||
handle = calloc (1, factory->size);
|
||||
if ((res = factory->init (factory, handle)) < 0) {
|
||||
printf ("can't make factory instance: %d\n", res);
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue