mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-01 22:58:50 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add fakesrc ! fakesink test

Browse source 
Add fakesrc and fakesink and some performance test
Small cleanups
This commit is contained in:
Wim Taymans 2017-05-19 12:48:51 +02:00
parent 6691eb7845
commit 12effccb06
16 changed files with 2526 additions and 22 deletions
Download patch file Download diff file Expand all files Collapse all files

4
spa/include/spa/format-utils.h
View file

@ -34,6 +34,8 @@ typedef struct {
uint32_t audio;
uint32_t video;
uint32_t image;
uint32_t binary;
uint32_t stream;
} SpaTypeMediaType;
static inline void
@ -43,6 +45,8 @@ spa_type_media_type_map (SpaTypeMap *map, SpaTypeMediaType *type)
type->audio = spa_type_map_get_id (map, SPA_TYPE_MEDIA_TYPE__audio);
type->video = spa_type_map_get_id (map, SPA_TYPE_MEDIA_TYPE__video);
type->image = spa_type_map_get_id (map, SPA_TYPE_MEDIA_TYPE__image);
type->binary = spa_type_map_get_id (map, SPA_TYPE_MEDIA_TYPE__binary);
type->stream = spa_type_map_get_id (map, SPA_TYPE_MEDIA_TYPE__stream);
}
}

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

@ -38,6 +38,8 @@ typedef struct _SpaFormat SpaFormat;
#define SPA_TYPE_MEDIA_TYPE__audio SPA_TYPE_MEDIA_TYPE_BASE "audio"
#define SPA_TYPE_MEDIA_TYPE__video SPA_TYPE_MEDIA_TYPE_BASE "video"
#define SPA_TYPE_MEDIA_TYPE__image SPA_TYPE_MEDIA_TYPE_BASE "image"
#define SPA_TYPE_MEDIA_TYPE__binary SPA_TYPE_MEDIA_TYPE_BASE "binary"
#define SPA_TYPE_MEDIA_TYPE__stream SPA_TYPE_MEDIA_TYPE_BASE "stream"
#define SPA_TYPE__MediaSubtype SPA_TYPE_ENUM_BASE "MediaSubtype"
#define SPA_TYPE_MEDIA_SUBTYPE_BASE SPA_TYPE__MediaSubtype ":"

30
spa/include/spa/graph.h
View file

@ -36,10 +36,6 @@ struct SpaGraph {
SpaList ready;
};
#define PROCESS_CHECK 0
#define PROCESS_IN 1
#define PROCESS_OUT 2
typedef SpaResult (*SpaGraphNodeFunc) (SpaGraphNode *node);
struct SpaGraphNode {
@ -49,6 +45,9 @@ struct SpaGraphNode {
#define SPA_GRAPH_NODE_FLAG_ASYNC (1 << 0)
uint32_t flags;
SpaResult state;
#define SPA_GRAPH_ACTION_CHECK 0
#define SPA_GRAPH_ACTION_IN 1
#define SPA_GRAPH_ACTION_OUT 2
uint32_t action;
SpaGraphNodeFunc schedule;
void *user_data;
@ -78,9 +77,10 @@ static inline SpaResult
spa_graph_node_schedule_default (SpaGraphNode *node)
{
SpaNode *n = node->user_data;
if (node->action == PROCESS_IN)
if (node->action == SPA_GRAPH_ACTION_IN)
return spa_node_process_input (n);
else if (node->action == PROCESS_OUT)
else if (node->action == SPA_GRAPH_ACTION_OUT)
return spa_node_process_output (n);
else
return SPA_RESULT_ERROR;
@ -93,7 +93,7 @@ spa_graph_node_add (SpaGraph *graph, SpaGraphNode *node, SpaGraphNodeFunc schedu
spa_list_init (&node->ports[SPA_DIRECTION_OUTPUT]);
node->flags = 0;
node->state = SPA_RESULT_OK;
node->action = PROCESS_OUT;
node->action = SPA_GRAPH_ACTION_OUT;
node->schedule = schedule;
node->user_data = user_data;
spa_list_insert (graph->nodes.prev, &node->link);
@ -110,7 +110,7 @@ spa_graph_port_check (SpaGraph *graph,
node->ready_in++;
if (node->required_in > 0 && node->ready_in == node->required_in) {
node->action = PROCESS_IN;
node->action = SPA_GRAPH_ACTION_IN;
if (node->ready_link.next == NULL)
spa_list_insert (graph->ready.prev, &node->ready_link);
} else if (node->ready_link.next) {
@ -182,22 +182,26 @@ spa_graph_node_schedule (SpaGraph *graph, SpaGraphNode *node)
n->ready_link.next = NULL;
switch (n->action) {
case PROCESS_IN:
case PROCESS_OUT:
case SPA_GRAPH_ACTION_IN:
case SPA_GRAPH_ACTION_OUT:
n->state = n->schedule (n);
n->action = PROCESS_CHECK;
if (n->action == SPA_GRAPH_ACTION_IN && n == node)
continue;
n->action = SPA_GRAPH_ACTION_CHECK;
spa_list_insert (graph->ready.prev, &n->ready_link);
break;
case PROCESS_CHECK:
case SPA_GRAPH_ACTION_CHECK:
if (n->state == SPA_RESULT_NEED_BUFFER) {
n->ready_in = 0;
spa_list_for_each (p, &n->ports[SPA_DIRECTION_INPUT], link) {
SpaGraphNode *pn = p->peer->node;
if (p->io->status == SPA_RESULT_NEED_BUFFER) {
pn->action = PROCESS_OUT;
if (pn != node || pn->flags & SPA_GRAPH_NODE_FLAG_ASYNC) {
pn->action = SPA_GRAPH_ACTION_OUT;
spa_list_insert (graph->ready.prev, &pn->ready_link);
}
}
else if (p->io->status == SPA_RESULT_OK)
n->ready_in++;
}

3
spa/include/spa/node.h
View file

@ -49,7 +49,6 @@ typedef struct {
* @status: the status
* @buffer_id: a buffer id
* @range: requested range
* @event: event
*
* IO information for a port on a node. This is allocated
* by the host and configured on all ports for which IO is requested.
@ -60,6 +59,8 @@ typedef struct {
SpaRange range;
} SpaPortIO;
#define SPA_PORT_IO_INIT (SpaPortIO) { SPA_RESULT_NEED_BUFFER, SPA_ID_INVALID, }
/**
* SpaPortInfo
* @flags: extra port flags

1
spa/plugins/meson.build
View file

@ -2,6 +2,7 @@ subdir('alsa')
subdir('audiomixer')
subdir('audiotestsrc')
subdir('ffmpeg')
subdir('test')
#subdir('libva')
subdir('videotestsrc')
subdir('volume')

907
spa/plugins/test/fakesink.c Normal file
View file

@ -0,0 +1,907 @@
/* Spa
* Copyright (C) 2017 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 <unistd.h>
#include <string.h>
#include <stdio.h>
#include <sys/timerfd.h>
#include <spa/type-map.h>
#include <spa/clock.h>
#include <spa/log.h>
#include <spa/loop.h>
#include <spa/node.h>
#include <spa/list.h>
#include <spa/format-builder.h>
#include <lib/props.h>
typedef struct {
uint32_t node;
uint32_t clock;
uint32_t format;
uint32_t props;
uint32_t prop_live;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
SpaTypeAllocParamBuffers alloc_param_buffers;
SpaTypeAllocParamMetaEnable alloc_param_meta_enable;
} Type;
static inline void
init_type (Type *type, SpaTypeMap *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->clock = spa_type_map_get_id (map, SPA_TYPE__Clock);
type->format = spa_type_map_get_id (map, SPA_TYPE__Format);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
type->prop_live = spa_type_map_get_id (map, SPA_TYPE_PROPS__live);
spa_type_meta_map (map, &type->meta);
spa_type_data_map (map, &type->data);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
spa_type_alloc_param_buffers_map (map, &type->alloc_param_buffers);
spa_type_alloc_param_meta_enable_map (map, &type->alloc_param_meta_enable);
}
typedef struct _SpaFakeSink SpaFakeSink;
typedef struct {
bool live;
} SpaFakeSinkProps;
#define MAX_BUFFERS 16
#define MAX_PORTS 1
typedef struct _Buffer Buffer;
struct _Buffer {
SpaBuffer *outbuf;
bool outstanding;
SpaMetaHeader *h;
SpaList link;
};
struct _SpaFakeSink {
SpaHandle handle;
SpaNode node;
SpaClock clock;
Type type;
SpaTypeMap *map;
SpaLog *log;
SpaLoop *data_loop;
uint8_t props_buffer[512];
SpaFakeSinkProps props;
SpaNodeCallbacks callbacks;
void *user_data;
SpaSource timer_source;
struct itimerspec timerspec;
SpaPortInfo info;
SpaAllocParam *params[2];
uint8_t params_buffer[1024];
SpaPortIO *io;
bool have_format;
uint8_t format_buffer[1024];
Buffer buffers[MAX_BUFFERS];
uint32_t n_buffers;
bool started;
uint64_t start_time;
uint64_t elapsed_time;
uint64_t buffer_count;
SpaList ready;
};
#define CHECK_PORT_NUM(this,d,p) ((d) == SPA_DIRECTION_INPUT && (p) < MAX_PORTS)
#define CHECK_PORT(this,d,p) (CHECK_PORT_NUM(this,d,p) && this->io)
#define DEFAULT_LIVE false
static void
reset_fakesink_props (SpaFakeSink *this, SpaFakeSinkProps *props)
{
props->live = DEFAULT_LIVE;
}
#define PROP(f,key,type,...) \
SPA_POD_PROP (f,key,0,type,1,__VA_ARGS__)
#define PROP_MM(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_RANGE_MIN_MAX,type,3,__VA_ARGS__)
#define PROP_U_MM(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_UNSET | \
SPA_POD_PROP_RANGE_MIN_MAX,type,3,__VA_ARGS__)
#define PROP_EN(f,key,type,n,...) \
SPA_POD_PROP (f,key, SPA_POD_PROP_RANGE_ENUM,type,n,__VA_ARGS__)
#define PROP_U_EN(f,key,type,n,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_UNSET | \
SPA_POD_PROP_RANGE_ENUM,type,n,__VA_ARGS__)
static SpaResult
spa_fakesink_node_get_props (SpaNode *node,
SpaProps **props)
{
SpaFakeSink *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f[2];
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (props != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP (&f[1], this->type.prop_live, SPA_POD_TYPE_BOOL, this->props.live));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_set_props (SpaNode *node,
const SpaProps *props)
{
SpaFakeSink *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
if (props == NULL) {
reset_fakesink_props (this, &this->props);
} else {
spa_props_query (props,
this->type.prop_live, SPA_POD_TYPE_BOOL, &this->props.live,
0);
}
if (this->props.live)
this->info.flags |= SPA_PORT_INFO_FLAG_LIVE;
else
this->info.flags &= ~SPA_PORT_INFO_FLAG_LIVE;
return SPA_RESULT_OK;
}
static void
set_timer (SpaFakeSink *this, bool enabled)
{
if (this->callbacks.need_input || this->props.live) {
if (enabled) {
if (this->props.live) {
uint64_t next_time = this->start_time + this->elapsed_time;
this->timerspec.it_value.tv_sec = next_time / SPA_NSEC_PER_SEC;
this->timerspec.it_value.tv_nsec = next_time % SPA_NSEC_PER_SEC;
} else {
this->timerspec.it_value.tv_sec = 0;
this->timerspec.it_value.tv_nsec = 1;
}
} else {
this->timerspec.it_value.tv_sec = 0;
this->timerspec.it_value.tv_nsec = 0;
}
timerfd_settime (this->timer_source.fd, TFD_TIMER_ABSTIME, &this->timerspec, NULL);
}
}
static inline void
read_timer (SpaFakeSink *this)
{
uint64_t expirations;
if (this->callbacks.need_input || this->props.live) {
if (read (this->timer_source.fd, &expirations, sizeof (uint64_t)) < sizeof (uint64_t))
perror ("read timerfd");
}
}
static void
render_buffer (SpaFakeSink *this, Buffer *b)
{
}
static SpaResult
fakesink_consume_buffer (SpaFakeSink *this)
{
Buffer *b;
SpaPortIO *io = this->io;
int n_bytes;
read_timer (this);
if (spa_list_is_empty (&this->ready)) {
io->status = SPA_RESULT_NEED_BUFFER;
if (this->callbacks.need_input)
this->callbacks.need_input (&this->node, this->user_data);
}
if (spa_list_is_empty (&this->ready)) {
spa_log_error (this->log, "fakesink %p: no buffers", this);
return SPA_RESULT_NEED_BUFFER;
}
b = spa_list_first (&this->ready, Buffer, link);
spa_list_remove (&b->link);
n_bytes = b->outbuf->datas[0].maxsize;
spa_log_trace (this->log, "fakesink %p: dequeue buffer %d", this, b->outbuf->id);
render_buffer (this, b);
b->outbuf->datas[0].chunk->offset = 0;
b->outbuf->datas[0].chunk->size = n_bytes;
b->outbuf->datas[0].chunk->stride = n_bytes;
if (b->h) {
b->h->seq = this->buffer_count;
b->h->pts = this->start_time + this->elapsed_time;
b->h->dts_offset = 0;
}
this->buffer_count++;
this->elapsed_time = this->buffer_count;
set_timer (this, true);
io->buffer_id = b->outbuf->id;
io->status = SPA_RESULT_NEED_BUFFER;
b->outstanding = true;
return SPA_RESULT_NEED_BUFFER;
}
static void
fakesink_on_input (SpaSource *source)
{
SpaFakeSink *this = source->data;
fakesink_consume_buffer (this);
}
static SpaResult
spa_fakesink_node_send_command (SpaNode *node,
SpaCommand *command)
{
SpaFakeSink *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (command != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
struct timespec now;
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
if (this->n_buffers == 0)
return SPA_RESULT_NO_BUFFERS;
if (this->started)
return SPA_RESULT_OK;
clock_gettime (CLOCK_MONOTONIC, &now);
if (this->props.live)
this->start_time = SPA_TIMESPEC_TO_TIME (&now);
else
this->start_time = 0;
this->buffer_count = 0;
this->elapsed_time = 0;
this->started = true;
set_timer (this, true);
}
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
if (this->n_buffers == 0)
return SPA_RESULT_NO_BUFFERS;
if (!this->started)
return SPA_RESULT_OK;
this->started = false;
set_timer (this, false);
}
else
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_set_callbacks (SpaNode *node,
const SpaNodeCallbacks *callbacks,
size_t callbacks_size,
void *user_data)
{
SpaFakeSink *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
if (this->data_loop == NULL && callbacks->need_input != NULL) {
spa_log_error (this->log, "a data_loop is needed for async operation");
return SPA_RESULT_ERROR;
}
this->callbacks = *callbacks;
this->user_data = user_data;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_get_n_ports (SpaNode *node,
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
if (n_input_ports)
*n_input_ports = 0;
if (n_output_ports)
*n_output_ports = 1;
if (max_input_ports)
*max_input_ports = 0;
if (max_output_ports)
*max_output_ports = 1;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_get_port_ids (SpaNode *node,
uint32_t n_input_ports,
uint32_t *input_ids,
uint32_t n_output_ports,
uint32_t *output_ids)
{
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
if (n_output_ports > 0 && output_ids != NULL)
output_ids[0] = 0;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_add_port (SpaNode *node,
SpaDirection direction,
uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesink_node_remove_port (SpaNode *node,
SpaDirection direction,
uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesink_node_port_enum_formats (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
uint32_t index)
{
SpaFakeSink *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (format != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
return SPA_RESULT_ENUM_END;
}
static SpaResult
clear_buffers (SpaFakeSink *this)
{
if (this->n_buffers > 0) {
spa_log_info (this->log, "fakesink %p: clear buffers", this);
this->n_buffers = 0;
spa_list_init (&this->ready);
this->started = false;
set_timer (this, false);
}
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_port_set_format (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
uint32_t flags,
const SpaFormat *format)
{
SpaFakeSink *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
if (format == NULL) {
this->have_format = false;
clear_buffers (this);
} else {
if (SPA_POD_SIZE (format) > sizeof (this->format_buffer))
return SPA_RESULT_ERROR;
memcpy (this->format_buffer, format, SPA_POD_SIZE (format));
this->have_format = true;
}
if (this->have_format) {
SpaPODBuilder b = { NULL };
SpaPODFrame f[2];
this->info.latency = 0;
this->info.maxbuffering = -1;
this->info.n_params = 2;
this->info.params = this->params;
spa_pod_builder_init (&b, this->params_buffer, sizeof (this->params_buffer));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_buffers.Buffers,
PROP (&f[1], this->type.alloc_param_buffers.size, SPA_POD_TYPE_INT, 128),
PROP (&f[1], this->type.alloc_param_buffers.stride, SPA_POD_TYPE_INT, 1),
PROP_U_MM (&f[1], this->type.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, 32, 2, 32),
PROP (&f[1], this->type.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
this->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, this->type.meta.Header),
PROP (&f[1], this->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader)));
this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL;
}
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_port_get_format (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
const SpaFormat **format)
{
SpaFakeSink *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (format != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
*format = (const SpaFormat *) this->format_buffer;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_port_get_info (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
const SpaPortInfo **info)
{
SpaFakeSink *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (info != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
*info = &this->info;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_port_get_props (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaProps **props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesink_node_port_set_props (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
const SpaProps *props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesink_node_port_use_buffers (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaBuffer **buffers,
uint32_t n_buffers)
{
SpaFakeSink *this;
uint32_t i;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
clear_buffers (this);
for (i = 0; i < n_buffers; i++) {
Buffer *b;
SpaData *d = buffers[i]->datas;
b = &this->buffers[i];
b->outbuf = buffers[i];
b->outstanding = true;
b->h = spa_buffer_find_meta (buffers[i], this->type.meta.Header);
if ((d[0].type == this->type.data.MemPtr ||
d[0].type == this->type.data.MemFd ||
d[0].type == this->type.data.DmaBuf) &&
d[0].data == NULL) {
spa_log_error (this->log, "fakesink %p: invalid memory on buffer %p", this, buffers[i]);
}
}
this->n_buffers = n_buffers;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_port_alloc_buffers (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
SpaFakeSink *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesink_node_port_set_io (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaPortIO *io)
{
SpaFakeSink *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
spa_return_val_if_fail (CHECK_PORT_NUM (this, direction, port_id), SPA_RESULT_INVALID_PORT);
this->io = io;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_port_reuse_buffer (SpaNode *node,
uint32_t port_id,
uint32_t buffer_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesink_node_port_send_command (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaCommand *command)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesink_node_process_input (SpaNode *node)
{
SpaFakeSink *this;
SpaPortIO *input;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSink, node);
input = this->io;
spa_return_val_if_fail (input != NULL, SPA_RESULT_WRONG_STATE);
if (input->status == SPA_RESULT_HAVE_BUFFER &&
input->buffer_id != SPA_ID_INVALID) {
Buffer *b = &this->buffers[input->buffer_id];
if (!b->outstanding) {
spa_log_warn (this->log, "fakesink %p: buffer %u in use", this, input->buffer_id);
input->status = SPA_RESULT_INVALID_BUFFER_ID;
return SPA_RESULT_ERROR;
}
spa_log_trace (this->log, "fakesink %p: queue buffer %u", this, input->buffer_id);
spa_list_insert (this->ready.prev, &b->link);
b->outstanding = false;
input->buffer_id = SPA_ID_INVALID;
input->status = SPA_RESULT_OK;
}
if (this->callbacks.need_input == NULL)
return fakesink_consume_buffer (this);
else
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesink_node_process_output (SpaNode *node)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static const SpaNode fakesink_node = {
sizeof (SpaNode),
NULL,
spa_fakesink_node_get_props,
spa_fakesink_node_set_props,
spa_fakesink_node_send_command,
spa_fakesink_node_set_callbacks,
spa_fakesink_node_get_n_ports,
spa_fakesink_node_get_port_ids,
spa_fakesink_node_add_port,
spa_fakesink_node_remove_port,
spa_fakesink_node_port_enum_formats,
spa_fakesink_node_port_set_format,
spa_fakesink_node_port_get_format,
spa_fakesink_node_port_get_info,
spa_fakesink_node_port_get_props,
spa_fakesink_node_port_set_props,
spa_fakesink_node_port_use_buffers,
spa_fakesink_node_port_alloc_buffers,
spa_fakesink_node_port_set_io,
spa_fakesink_node_port_reuse_buffer,
spa_fakesink_node_port_send_command,
spa_fakesink_node_process_input,
spa_fakesink_node_process_output,
};
static SpaResult
spa_fakesink_clock_get_props (SpaClock *clock,
SpaProps **props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesink_clock_set_props (SpaClock *clock,
const SpaProps *props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesink_clock_get_time (SpaClock *clock,
int32_t *rate,
int64_t *ticks,
int64_t *monotonic_time)
{
struct timespec now;
uint64_t tnow;
spa_return_val_if_fail (clock != NULL, SPA_RESULT_INVALID_ARGUMENTS);
if (rate)
*rate = SPA_NSEC_PER_SEC;
clock_gettime (CLOCK_MONOTONIC, &now);
tnow = SPA_TIMESPEC_TO_TIME (&now);
if (ticks)
*ticks = tnow;
if (monotonic_time)
*monotonic_time = tnow;
return SPA_RESULT_OK;
}
static const SpaClock fakesink_clock = {
sizeof (SpaClock),
NULL,
SPA_CLOCK_STATE_STOPPED,
spa_fakesink_clock_get_props,
spa_fakesink_clock_set_props,
spa_fakesink_clock_get_time,
};
static SpaResult
spa_fakesink_get_interface (SpaHandle *handle,
uint32_t interface_id,
void **interface)
{
SpaFakeSink *this;
spa_return_val_if_fail (handle != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (interface != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = (SpaFakeSink *) handle;
if (interface_id == this->type.node)
*interface = &this->node;
else if (interface_id == this->type.clock)
*interface = &this->clock;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
return SPA_RESULT_OK;
}
static SpaResult
fakesink_clear (SpaHandle *handle)
{
SpaFakeSink *this;
spa_return_val_if_fail (handle != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = (SpaFakeSink *) handle;
if (this->data_loop)
spa_loop_remove_source (this->data_loop, &this->timer_source);
close (this->timer_source.fd);
return SPA_RESULT_OK;
}
static SpaResult
fakesink_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
uint32_t n_support)
{
SpaFakeSink *this;
uint32_t i;
spa_return_val_if_fail (factory != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (handle != NULL, SPA_RESULT_INVALID_ARGUMENTS);
handle->get_interface = spa_fakesink_get_interface;
handle->clear = fakesink_clear;
this = (SpaFakeSink *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
else if (strcmp (support[i].type, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
init_type (&this->type, this->map);
this->node = fakesink_node;
this->clock = fakesink_clock;
reset_fakesink_props (this, &this->props);
spa_list_init (&this->ready);
this->timer_source.func = fakesink_on_input;
this->timer_source.data = this;
this->timer_source.fd = timerfd_create (CLOCK_MONOTONIC, TFD_CLOEXEC);
this->timer_source.mask = SPA_IO_IN;
this->timer_source.rmask = 0;
this->timerspec.it_value.tv_sec = 0;
this->timerspec.it_value.tv_nsec = 0;
this->timerspec.it_interval.tv_sec = 0;
this->timerspec.it_interval.tv_nsec = 0;
if (this->data_loop)
spa_loop_add_source (this->data_loop, &this->timer_source);
this->info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS |
SPA_PORT_INFO_FLAG_NO_REF;
if (this->props.live)
this->info.flags |= SPA_PORT_INFO_FLAG_LIVE;
spa_log_info (this->log, "fakesink %p: initialized", this);
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo fakesink_interfaces[] =
{
{ SPA_TYPE__Node, },
{ SPA_TYPE__Clock, },
};
static SpaResult
fakesink_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
uint32_t index)
{
spa_return_val_if_fail (factory != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (info != NULL, SPA_RESULT_INVALID_ARGUMENTS);
switch (index) {
case 0:
*info = &fakesink_interfaces[index];
break;
default:
return SPA_RESULT_ENUM_END;
}
return SPA_RESULT_OK;
}
const SpaHandleFactory spa_fakesink_factory =
{ "fakesink",
NULL,
sizeof (SpaFakeSink),
fakesink_init,
fakesink_enum_interface_info,
};

940
spa/plugins/test/fakesrc.c Normal file
View file

@ -0,0 +1,940 @@
/* Spa
* Copyright (C) 2017 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 <unistd.h>
#include <string.h>
#include <stdio.h>
#include <sys/timerfd.h>
#include <spa/type-map.h>
#include <spa/clock.h>
#include <spa/log.h>
#include <spa/loop.h>
#include <spa/node.h>
#include <spa/list.h>
#include <spa/format-builder.h>
#include <lib/props.h>
typedef struct {
uint32_t node;
uint32_t clock;
uint32_t format;
uint32_t props;
uint32_t prop_live;
uint32_t prop_pattern;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
SpaTypeAllocParamBuffers alloc_param_buffers;
SpaTypeAllocParamMetaEnable alloc_param_meta_enable;
} Type;
static inline void
init_type (Type *type, SpaTypeMap *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->clock = spa_type_map_get_id (map, SPA_TYPE__Clock);
type->format = spa_type_map_get_id (map, SPA_TYPE__Format);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
type->prop_live = spa_type_map_get_id (map, SPA_TYPE_PROPS__live);
type->prop_pattern = spa_type_map_get_id (map, SPA_TYPE_PROPS__patternType);
spa_type_meta_map (map, &type->meta);
spa_type_data_map (map, &type->data);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
spa_type_alloc_param_buffers_map (map, &type->alloc_param_buffers);
spa_type_alloc_param_meta_enable_map (map, &type->alloc_param_meta_enable);
}
typedef struct _SpaFakeSrc SpaFakeSrc;
typedef struct {
bool live;
uint32_t pattern;
} SpaFakeSrcProps;
#define MAX_BUFFERS 16
#define MAX_PORTS 1
typedef struct _Buffer Buffer;
struct _Buffer {
SpaBuffer *outbuf;
bool outstanding;
SpaMetaHeader *h;
SpaList link;
};
struct _SpaFakeSrc {
SpaHandle handle;
SpaNode node;
SpaClock clock;
Type type;
SpaTypeMap *map;
SpaLog *log;
SpaLoop *data_loop;
uint8_t props_buffer[512];
SpaFakeSrcProps props;
SpaNodeCallbacks callbacks;
void *user_data;
SpaSource timer_source;
struct itimerspec timerspec;
SpaPortInfo info;
SpaAllocParam *params[2];
uint8_t params_buffer[1024];
SpaPortIO *io;
bool have_format;
uint8_t format_buffer[1024];
Buffer buffers[MAX_BUFFERS];
uint32_t n_buffers;
bool started;
uint64_t start_time;
uint64_t elapsed_time;
uint64_t buffer_count;
SpaList empty;
bool underrun;
};
#define CHECK_PORT_NUM(this,d,p) ((d) == SPA_DIRECTION_OUTPUT && (p) < MAX_PORTS)
#define CHECK_PORT(this,d,p) (CHECK_PORT_NUM(this,d,p) && this->io)
#define DEFAULT_LIVE false
#define DEFAULT_PATTERN 0
static void
reset_fakesrc_props (SpaFakeSrc *this, SpaFakeSrcProps *props)
{
props->live = DEFAULT_LIVE;
props->pattern = DEFAULT_PATTERN;
}
#define PROP(f,key,type,...) \
SPA_POD_PROP (f,key,0,type,1,__VA_ARGS__)
#define PROP_MM(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_RANGE_MIN_MAX,type,3,__VA_ARGS__)
#define PROP_U_MM(f,key,type,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_UNSET | \
SPA_POD_PROP_RANGE_MIN_MAX,type,3,__VA_ARGS__)
#define PROP_EN(f,key,type,n,...) \
SPA_POD_PROP (f,key, SPA_POD_PROP_RANGE_ENUM,type,n,__VA_ARGS__)
#define PROP_U_EN(f,key,type,n,...) \
SPA_POD_PROP (f,key,SPA_POD_PROP_FLAG_UNSET | \
SPA_POD_PROP_RANGE_ENUM,type,n,__VA_ARGS__)
static SpaResult
spa_fakesrc_node_get_props (SpaNode *node,
SpaProps **props)
{
SpaFakeSrc *this;
SpaPODBuilder b = { NULL, };
SpaPODFrame f[2];
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (props != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP (&f[1], this->type.prop_live, SPA_POD_TYPE_BOOL, this->props.live),
PROP_EN (&f[1], this->type.prop_pattern, SPA_POD_TYPE_ID, 1,
this->props.pattern,
this->props.pattern));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_set_props (SpaNode *node,
const SpaProps *props)
{
SpaFakeSrc *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
if (props == NULL) {
reset_fakesrc_props (this, &this->props);
} else {
spa_props_query (props,
this->type.prop_live, SPA_POD_TYPE_BOOL, &this->props.live,
this->type.prop_pattern, SPA_POD_TYPE_ID, &this->props.pattern,
0);
}
if (this->props.live)
this->info.flags |= SPA_PORT_INFO_FLAG_LIVE;
else
this->info.flags &= ~SPA_PORT_INFO_FLAG_LIVE;
return SPA_RESULT_OK;
}
static SpaResult
fill_buffer (SpaFakeSrc *this, Buffer *b)
{
return SPA_RESULT_OK;
}
static void
set_timer (SpaFakeSrc *this, bool enabled)
{
if (this->callbacks.have_output || this->props.live) {
if (enabled) {
if (this->props.live) {
uint64_t next_time = this->start_time + this->elapsed_time;
this->timerspec.it_value.tv_sec = next_time / SPA_NSEC_PER_SEC;
this->timerspec.it_value.tv_nsec = next_time % SPA_NSEC_PER_SEC;
} else {
this->timerspec.it_value.tv_sec = 0;
this->timerspec.it_value.tv_nsec = 1;
}
} else {
this->timerspec.it_value.tv_sec = 0;
this->timerspec.it_value.tv_nsec = 0;
}
timerfd_settime (this->timer_source.fd, TFD_TIMER_ABSTIME, &this->timerspec, NULL);
}
}
static inline void
read_timer (SpaFakeSrc *this)
{
uint64_t expirations;
if (this->callbacks.have_output || this->props.live) {
if (read (this->timer_source.fd, &expirations, sizeof (uint64_t)) < sizeof (uint64_t))
perror ("read timerfd");
}
}
static SpaResult
fakesrc_make_buffer (SpaFakeSrc *this)
{
Buffer *b;
SpaPortIO *io = this->io;
int n_bytes;
read_timer (this);
if (spa_list_is_empty (&this->empty)) {
set_timer (this, false);
this->underrun = true;
spa_log_error (this->log, "fakesrc %p: out of buffers", this);
return SPA_RESULT_OUT_OF_BUFFERS;
}
b = spa_list_first (&this->empty, Buffer, link);
spa_list_remove (&b->link);
b->outstanding = true;
n_bytes = b->outbuf->datas[0].maxsize;
spa_log_trace (this->log, "fakesrc %p: dequeue buffer %d", this, b->outbuf->id);
fill_buffer (this, b);
b->outbuf->datas[0].chunk->offset = 0;
b->outbuf->datas[0].chunk->size = n_bytes;
b->outbuf->datas[0].chunk->stride = n_bytes;
if (b->h) {
b->h->seq = this->buffer_count;
b->h->pts = this->start_time + this->elapsed_time;
b->h->dts_offset = 0;
}
this->buffer_count++;
this->elapsed_time = this->buffer_count;
set_timer (this, true);
io->buffer_id = b->outbuf->id;
io->status = SPA_RESULT_HAVE_BUFFER;
return SPA_RESULT_HAVE_BUFFER;
}
static void
fakesrc_on_output (SpaSource *source)
{
SpaFakeSrc *this = source->data;
SpaResult res;
res = fakesrc_make_buffer (this);
if (res == SPA_RESULT_HAVE_BUFFER && this->callbacks.have_output)
this->callbacks.have_output (&this->node, this->user_data);
}
static SpaResult
spa_fakesrc_node_send_command (SpaNode *node,
SpaCommand *command)
{
SpaFakeSrc *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (command != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
struct timespec now;
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
if (this->n_buffers == 0)
return SPA_RESULT_NO_BUFFERS;
if (this->started)
return SPA_RESULT_OK;
clock_gettime (CLOCK_MONOTONIC, &now);
if (this->props.live)
this->start_time = SPA_TIMESPEC_TO_TIME (&now);
else
this->start_time = 0;
this->buffer_count = 0;
this->elapsed_time = 0;
this->started = true;
set_timer (this, true);
}
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
if (this->n_buffers == 0)
return SPA_RESULT_NO_BUFFERS;
if (!this->started)
return SPA_RESULT_OK;
this->started = false;
set_timer (this, false);
}
else
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_set_callbacks (SpaNode *node,
const SpaNodeCallbacks *callbacks,
size_t callbacks_size,
void *user_data)
{
SpaFakeSrc *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
if (this->data_loop == NULL && callbacks->have_output != NULL) {
spa_log_error (this->log, "a data_loop is needed for async operation");
return SPA_RESULT_ERROR;
}
this->callbacks = *callbacks;
this->user_data = user_data;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_get_n_ports (SpaNode *node,
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
if (n_input_ports)
*n_input_ports = 0;
if (n_output_ports)
*n_output_ports = 1;
if (max_input_ports)
*max_input_ports = 0;
if (max_output_ports)
*max_output_ports = 1;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_get_port_ids (SpaNode *node,
uint32_t n_input_ports,
uint32_t *input_ids,
uint32_t n_output_ports,
uint32_t *output_ids)
{
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
if (n_output_ports > 0 && output_ids != NULL)
output_ids[0] = 0;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_add_port (SpaNode *node,
SpaDirection direction,
uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesrc_node_remove_port (SpaNode *node,
SpaDirection direction,
uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesrc_node_port_enum_formats (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
uint32_t index)
{
SpaFakeSrc *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (format != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
return SPA_RESULT_ENUM_END;
}
static SpaResult
clear_buffers (SpaFakeSrc *this)
{
if (this->n_buffers > 0) {
spa_log_info (this->log, "fakesrc %p: clear buffers", this);
this->n_buffers = 0;
spa_list_init (&this->empty);
this->started = false;
set_timer (this, false);
}
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_port_set_format (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
uint32_t flags,
const SpaFormat *format)
{
SpaFakeSrc *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
if (format == NULL) {
this->have_format = false;
clear_buffers (this);
} else {
if (SPA_POD_SIZE (format) > sizeof (this->format_buffer))
return SPA_RESULT_ERROR;
memcpy (this->format_buffer, format, SPA_POD_SIZE (format));
this->have_format = true;
}
if (this->have_format) {
SpaPODBuilder b = { NULL };
SpaPODFrame f[2];
this->info.latency = 0;
this->info.maxbuffering = -1;
this->info.n_params = 2;
this->info.params = this->params;
spa_pod_builder_init (&b, this->params_buffer, sizeof (this->params_buffer));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_buffers.Buffers,
PROP (&f[1], this->type.alloc_param_buffers.size, SPA_POD_TYPE_INT, 128),
PROP (&f[1], this->type.alloc_param_buffers.stride, SPA_POD_TYPE_INT, 1),
PROP_U_MM (&f[1], this->type.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, 32, 2, 32),
PROP (&f[1], this->type.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
this->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_ID, this->type.meta.Header),
PROP (&f[1], this->type.alloc_param_meta_enable.size, SPA_POD_TYPE_INT, sizeof (SpaMetaHeader)));
this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL;
}
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_port_get_format (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
const SpaFormat **format)
{
SpaFakeSrc *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (format != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
*format = (const SpaFormat *) this->format_buffer;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_port_get_info (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
const SpaPortInfo **info)
{
SpaFakeSrc *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (info != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
*info = &this->info;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_port_get_props (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaProps **props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesrc_node_port_set_props (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
const SpaProps *props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesrc_node_port_use_buffers (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaBuffer **buffers,
uint32_t n_buffers)
{
SpaFakeSrc *this;
uint32_t i;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
clear_buffers (this);
for (i = 0; i < n_buffers; i++) {
Buffer *b;
SpaData *d = buffers[i]->datas;
b = &this->buffers[i];
b->outbuf = buffers[i];
b->outstanding = false;
b->h = spa_buffer_find_meta (buffers[i], this->type.meta.Header);
if ((d[0].type == this->type.data.MemPtr ||
d[0].type == this->type.data.MemFd ||
d[0].type == this->type.data.DmaBuf) &&
d[0].data == NULL) {
spa_log_error (this->log, "fakesrc %p: invalid memory on buffer %p", this, buffers[i]);
}
spa_list_insert (this->empty.prev, &b->link);
}
this->n_buffers = n_buffers;
this->underrun = false;
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_port_alloc_buffers (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
SpaFakeSrc *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
spa_return_val_if_fail (CHECK_PORT (this, direction, port_id), SPA_RESULT_INVALID_PORT);
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesrc_node_port_set_io (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaPortIO *io)
{
SpaFakeSrc *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
spa_return_val_if_fail (CHECK_PORT_NUM (this, direction, port_id), SPA_RESULT_INVALID_PORT);
this->io = io;
return SPA_RESULT_OK;
}
static inline void
reuse_buffer (SpaFakeSrc *this, uint32_t id)
{
Buffer *b = &this->buffers[id];
spa_return_if_fail (b->outstanding);
spa_log_trace (this->log, "fakesrc %p: reuse buffer %d", this, id);
b->outstanding = false;
spa_list_insert (this->empty.prev, &b->link);
if (this->underrun) {
set_timer (this, true);
this->underrun = false;
}
}
static SpaResult
spa_fakesrc_node_port_reuse_buffer (SpaNode *node,
uint32_t port_id,
uint32_t buffer_id)
{
SpaFakeSrc *this;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
spa_return_val_if_fail (port_id == 0, SPA_RESULT_INVALID_PORT);
spa_return_val_if_fail (this->n_buffers > 0, SPA_RESULT_NO_BUFFERS);
spa_return_val_if_fail (buffer_id < this->n_buffers, SPA_RESULT_INVALID_BUFFER_ID);
reuse_buffer (this, buffer_id);
return SPA_RESULT_OK;
}
static SpaResult
spa_fakesrc_node_port_send_command (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaCommand *command)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesrc_node_process_input (SpaNode *node)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesrc_node_process_output (SpaNode *node)
{
SpaFakeSrc *this;
SpaPortIO *io;
spa_return_val_if_fail (node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = SPA_CONTAINER_OF (node, SpaFakeSrc, node);
io = this->io;
spa_return_val_if_fail (io != NULL, SPA_RESULT_WRONG_STATE);
if (io->status == SPA_RESULT_HAVE_BUFFER)
return SPA_RESULT_HAVE_BUFFER;
if (io->buffer_id != SPA_ID_INVALID) {
reuse_buffer (this, this->io->buffer_id);
this->io->buffer_id = SPA_ID_INVALID;
}
if (this->callbacks.have_output == NULL && (io->status == SPA_RESULT_NEED_BUFFER))
return fakesrc_make_buffer (this);
else
return SPA_RESULT_OK;
}
static const SpaNode fakesrc_node = {
sizeof (SpaNode),
NULL,
spa_fakesrc_node_get_props,
spa_fakesrc_node_set_props,
spa_fakesrc_node_send_command,
spa_fakesrc_node_set_callbacks,
spa_fakesrc_node_get_n_ports,
spa_fakesrc_node_get_port_ids,
spa_fakesrc_node_add_port,
spa_fakesrc_node_remove_port,
spa_fakesrc_node_port_enum_formats,
spa_fakesrc_node_port_set_format,
spa_fakesrc_node_port_get_format,
spa_fakesrc_node_port_get_info,
spa_fakesrc_node_port_get_props,
spa_fakesrc_node_port_set_props,
spa_fakesrc_node_port_use_buffers,
spa_fakesrc_node_port_alloc_buffers,
spa_fakesrc_node_port_set_io,
spa_fakesrc_node_port_reuse_buffer,
spa_fakesrc_node_port_send_command,
spa_fakesrc_node_process_input,
spa_fakesrc_node_process_output,
};
static SpaResult
spa_fakesrc_clock_get_props (SpaClock *clock,
SpaProps **props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesrc_clock_set_props (SpaClock *clock,
const SpaProps *props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_fakesrc_clock_get_time (SpaClock *clock,
int32_t *rate,
int64_t *ticks,
int64_t *monotonic_time)
{
struct timespec now;
uint64_t tnow;
spa_return_val_if_fail (clock != NULL, SPA_RESULT_INVALID_ARGUMENTS);
if (rate)
*rate = SPA_NSEC_PER_SEC;
clock_gettime (CLOCK_MONOTONIC, &now);
tnow = SPA_TIMESPEC_TO_TIME (&now);
if (ticks)
*ticks = tnow;
if (monotonic_time)
*monotonic_time = tnow;
return SPA_RESULT_OK;
}
static const SpaClock fakesrc_clock = {
sizeof (SpaClock),
NULL,
SPA_CLOCK_STATE_STOPPED,
spa_fakesrc_clock_get_props,
spa_fakesrc_clock_set_props,
spa_fakesrc_clock_get_time,
};
static SpaResult
spa_fakesrc_get_interface (SpaHandle *handle,
uint32_t interface_id,
void **interface)
{
SpaFakeSrc *this;
spa_return_val_if_fail (handle != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (interface != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = (SpaFakeSrc *) handle;
if (interface_id == this->type.node)
*interface = &this->node;
else if (interface_id == this->type.clock)
*interface = &this->clock;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
return SPA_RESULT_OK;
}
static SpaResult
fakesrc_clear (SpaHandle *handle)
{
SpaFakeSrc *this;
spa_return_val_if_fail (handle != NULL, SPA_RESULT_INVALID_ARGUMENTS);
this = (SpaFakeSrc *) handle;
if (this->data_loop)
spa_loop_remove_source (this->data_loop, &this->timer_source);
close (this->timer_source.fd);
return SPA_RESULT_OK;
}
static SpaResult
fakesrc_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
uint32_t n_support)
{
SpaFakeSrc *this;
uint32_t i;
spa_return_val_if_fail (factory != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (handle != NULL, SPA_RESULT_INVALID_ARGUMENTS);
handle->get_interface = spa_fakesrc_get_interface;
handle->clear = fakesrc_clear;
this = (SpaFakeSrc *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
else if (strcmp (support[i].type, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
init_type (&this->type, this->map);
this->node = fakesrc_node;
this->clock = fakesrc_clock;
reset_fakesrc_props (this, &this->props);
spa_list_init (&this->empty);
this->timer_source.func = fakesrc_on_output;
this->timer_source.data = this;
this->timer_source.fd = timerfd_create (CLOCK_MONOTONIC, TFD_CLOEXEC);
this->timer_source.mask = SPA_IO_IN;
this->timer_source.rmask = 0;
this->timerspec.it_value.tv_sec = 0;
this->timerspec.it_value.tv_nsec = 0;
this->timerspec.it_interval.tv_sec = 0;
this->timerspec.it_interval.tv_nsec = 0;
if (this->data_loop)
spa_loop_add_source (this->data_loop, &this->timer_source);
this->info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS |
SPA_PORT_INFO_FLAG_NO_REF;
if (this->props.live)
this->info.flags |= SPA_PORT_INFO_FLAG_LIVE;
spa_log_info (this->log, "fakesrc %p: initialized", this);
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo fakesrc_interfaces[] =
{
{ SPA_TYPE__Node, },
{ SPA_TYPE__Clock, },
};
static SpaResult
fakesrc_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
uint32_t index)
{
spa_return_val_if_fail (factory != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail (info != NULL, SPA_RESULT_INVALID_ARGUMENTS);
switch (index) {
case 0:
*info = &fakesrc_interfaces[index];
break;
default:
return SPA_RESULT_ENUM_END;
}
return SPA_RESULT_OK;
}
const SpaHandleFactory spa_fakesrc_factory =
{ "fakesrc",
NULL,
sizeof (SpaFakeSrc),
fakesrc_init,
fakesrc_enum_interface_info,
};

9
spa/plugins/test/meson.build Normal file
View file

@ -0,0 +1,9 @@
test_sources = ['fakesrc.c', 'fakesink.c', 'plugin.c']
testlib = shared_library('spa-test',
test_sources,
include_directories : [ spa_inc, spa_libinc],
dependencies : threads_dep,
link_with : spalib,
install : true,
install_dir : '@0@/spa'.format(get_option('libdir')))

43
spa/plugins/test/plugin.c Normal file
View file

@ -0,0 +1,43 @@
/* Spa Video Test Source plugin
* Copyright (C) 2016 Axis Communications AB
*
* 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>
extern const SpaHandleFactory spa_fakesrc_factory;
extern const SpaHandleFactory spa_fakesink_factory;
SpaResult
spa_enum_handle_factory (const SpaHandleFactory **factory,
uint32_t index)
{
spa_return_val_if_fail (factory != NULL, SPA_RESULT_INVALID_ARGUMENTS);
switch (index) {
case 0:
*factory = &spa_fakesrc_factory;
break;
case 1:
*factory = &spa_fakesink_factory;
break;
default:
return SPA_RESULT_ENUM_END;
}
return SPA_RESULT_OK;
}

5
spa/tests/meson.build
View file

@ -13,6 +13,11 @@ executable('test-graph', 'test-graph.c',
dependencies : [dl_lib, pthread_lib],
link_with : spalib,
install : false)
executable('test-perf', 'test-perf.c',
include_directories : [spa_inc, spa_libinc ],
dependencies : [dl_lib, pthread_lib],
link_with : spalib,
install : false)
executable('stress-ringbuffer', 'stress-ringbuffer.c',
include_directories : [spa_inc, spa_libinc ],
dependencies : [dl_lib, pthread_lib],

7
spa/tests/test-graph.c
View file

@ -225,7 +225,7 @@ on_sink_need_input (SpaNode *node, void *user_data)
{
AppData *data = user_data;
data->sink_node.action = PROCESS_CHECK;
data->sink_node.action = SPA_GRAPH_ACTION_CHECK;
data->sink_node.state = SPA_RESULT_NEED_BUFFER;
spa_graph_node_schedule (&data->graph, &data->sink_node);
@ -332,6 +332,9 @@ make_nodes (AppData *data, const char *device)
if ((res = spa_node_set_props (data->source, props)) < 0)
printf ("got set_props error %d\n", res);
data->source_volume_io[0] = SPA_PORT_IO_INIT;
data->volume_sink_io[0] = SPA_PORT_IO_INIT;
spa_node_port_set_io (data->source, SPA_DIRECTION_OUTPUT, 0, &data->source_volume_io[0]);
spa_node_port_set_io (data->volume, SPA_DIRECTION_INPUT, 0, &data->source_volume_io[0]);
spa_node_port_set_io (data->volume, SPA_DIRECTION_OUTPUT, 0, &data->volume_sink_io[0]);
@ -440,7 +443,7 @@ loop (void *user_data)
data->rebuild_fds = false;
}
r = poll ((struct pollfd *) data->fds, data->n_fds, -1);
r = poll (data->fds, data->n_fds, -1);
if (r < 0) {
if (errno == EINTR)
continue;

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

@ -398,6 +398,10 @@ make_nodes (AppData *data, const char *device)
if ((res = spa_node_add_port (data->mix, SPA_DIRECTION_INPUT, 1)) < 0)
return res;
data->source1_mix_io[0] = SPA_PORT_IO_INIT;
data->source2_mix_io[0] = SPA_PORT_IO_INIT;
data->mix_sink_io[0] = SPA_PORT_IO_INIT;
spa_node_port_set_io (data->source1, SPA_DIRECTION_OUTPUT, 0, &data->source1_mix_io[0]);
spa_node_port_set_io (data->source2, SPA_DIRECTION_OUTPUT, 0, &data->source2_mix_io[0]);
spa_node_port_set_io (data->mix, SPA_DIRECTION_INPUT, 0, &data->source1_mix_io[0]);

577
spa/tests/test-perf.c Normal file
View file

@ -0,0 +1,577 @@
/* Spa
* Copyright (C) 2017 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
#include <errno.h>
#include <pthread.h>
#include <poll.h>
#include <spa/node.h>
#include <spa/log.h>
#include <spa/loop.h>
#include <spa/type-map.h>
#include <spa/audio/format-utils.h>
#include <spa/format-utils.h>
#include <spa/format-builder.h>
#include <spa/graph.h>
#include <lib/mapper.h>
#include <lib/debug.h>
#include <lib/props.h>
#define MODE_SYNC_PUSH (1<<0)
#define MODE_SYNC_PULL (1<<1)
#define MODE_ASYNC_PUSH (1<<2)
#define MODE_ASYNC_PULL (1<<3)
#define MODE_ASYNC_BOTH (MODE_ASYNC_PUSH|MODE_ASYNC_PULL)
#define MODE_DIRECT (1<<4)
typedef struct {
uint32_t node;
uint32_t props;
uint32_t format;
uint32_t props_device;
uint32_t props_freq;
uint32_t props_volume;
uint32_t props_min_latency;
uint32_t props_live;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
} Type;
static inline void
init_type (Type *type, SpaTypeMap *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
type->format = spa_type_map_get_id (map, SPA_TYPE__Format);
type->props_device = spa_type_map_get_id (map, SPA_TYPE_PROPS__device);
type->props_freq = spa_type_map_get_id (map, SPA_TYPE_PROPS__frequency);
type->props_volume = spa_type_map_get_id (map, SPA_TYPE_PROPS__volume);
type->props_min_latency = spa_type_map_get_id (map, SPA_TYPE_PROPS__minLatency);
type->props_live = spa_type_map_get_id (map, SPA_TYPE_PROPS__live);
spa_type_meta_map (map, &type->meta);
spa_type_data_map (map, &type->data);
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
}
typedef struct {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaChunk chunks[1];
} Buffer;
typedef struct {
SpaTypeMap *map;
SpaLog *log;
SpaLoop data_loop;
Type type;
int mode;
SpaSupport support[4];
uint32_t n_support;
int iterations;
SpaGraph graph;
SpaGraphNode source_node;
SpaGraphPort source_out;
SpaGraphPort sink_in;
SpaGraphNode sink_node;
SpaNode *sink;
SpaPortIO source_sink_io[1];
SpaNode *source;
SpaBuffer *source_buffers[1];
Buffer source_buffer[1];
bool running;
pthread_t thread;
SpaSource sources[16];
unsigned int n_sources;
bool rebuild_fds;
struct pollfd fds[16];
unsigned int n_fds;
void *hnd;
} AppData;
#define MIN_LATENCY 64
#define BUFFER_SIZE MIN_LATENCY
static void
init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t size)
{
int i;
for (i = 0; i < n_buffers; i++) {
Buffer *b = &ba[i];
bufs[i] = &b->buffer;
b->buffer.id = i;
b->buffer.n_metas = 1;
b->buffer.metas = b->metas;
b->buffer.n_datas = 1;
b->buffer.datas = b->datas;
b->header.flags = 0;
b->header.seq = 0;
b->header.pts = 0;
b->header.dts_offset = 0;
b->metas[0].type = data->type.meta.Header;
b->metas[0].data = &b->header;
b->metas[0].size = sizeof (b->header);
b->datas[0].type = data->type.data.MemPtr;
b->datas[0].flags = 0;
b->datas[0].fd = -1;
b->datas[0].mapoffset = 0;
b->datas[0].maxsize = size;
b->datas[0].data = malloc (size);
b->datas[0].chunk = &b->chunks[0];
b->datas[0].chunk->offset = 0;
b->datas[0].chunk->size = size;
b->datas[0].chunk->stride = 0;
}
}
static SpaResult
make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
{
SpaHandle *handle;
SpaResult res;
SpaEnumHandleFactoryFunc enum_func;
unsigned int i;
uint32_t state = 0;
if (data->hnd == NULL) {
if ((data->hnd = dlopen (lib, RTLD_NOW)) == NULL) {
printf ("can't load %s: %s\n", lib, dlerror());
return SPA_RESULT_ERROR;
}
}
if ((enum_func = dlsym (data->hnd, "spa_enum_handle_factory")) == NULL) {
printf ("can't find enum function\n");
return SPA_RESULT_ERROR;
}
for (i = 0; ;i++) {
const SpaHandleFactory *factory;
void *iface;
if ((res = enum_func (&factory, state++)) < 0) {
if (res != SPA_RESULT_ENUM_END)
printf ("can't enumerate factories: %d\n", res);
break;
}
if (strcmp (factory->name, name))
continue;
handle = calloc (1, factory->size);
if ((res = spa_handle_factory_init (factory, handle, NULL, data->support, data->n_support)) < 0) {
printf ("can't make factory instance: %d\n", res);
return res;
}
if ((res = spa_handle_get_interface (handle, data->type.node, &iface)) < 0) {
printf ("can't get interface %d\n", res);
return res;
}
*node = iface;
return SPA_RESULT_OK;
}
return SPA_RESULT_ERROR;
}
static void
on_sink_pull (AppData *data)
{
spa_log_trace (data->log, "do sink pull");
data->sink_node.state = SPA_RESULT_NEED_BUFFER;
if (data->mode & MODE_DIRECT) {
spa_node_process_output (data->source);
spa_node_process_input (data->sink);
}
else {
data->sink_node.action = SPA_GRAPH_ACTION_CHECK;
spa_graph_node_schedule (&data->graph, &data->sink_node);
}
}
static void
on_source_push (AppData *data)
{
spa_log_trace (data->log, "do source push");
if (data->mode & MODE_DIRECT) {
spa_node_process_output (data->source);
spa_node_process_input (data->sink);
}
else {
data->source_node.action = SPA_GRAPH_ACTION_OUT;
spa_graph_node_schedule (&data->graph, &data->source_node);
}
}
static void
on_sink_event (SpaNode *node, SpaEvent *event, void *user_data)
{
AppData *data = user_data;
spa_log_trace (data->log, "got sink event %d", SPA_EVENT_TYPE (event));
}
static void
on_sink_need_input (SpaNode *node, void *user_data)
{
AppData *data = user_data;
spa_log_trace (data->log, "need input");
on_sink_pull (data);
if (--data->iterations == 0)
data->running = false;
}
static void
on_sink_reuse_buffer (SpaNode *node, uint32_t port_id, uint32_t buffer_id, void *user_data)
{
AppData *data = user_data;
data->source_sink_io[0].buffer_id = buffer_id;
}
static const SpaNodeCallbacks sink_callbacks =
{
&on_sink_event,
&on_sink_need_input,
NULL,
&on_sink_reuse_buffer
};
static void
on_source_event (SpaNode *node, SpaEvent *event, void *user_data)
{
AppData *data = user_data;
spa_log_trace (data->log, "got source event %d", SPA_EVENT_TYPE (event));
}
static void
on_source_have_output (SpaNode *node, void *user_data)
{
AppData *data = user_data;
spa_log_trace (data->log, "have_output");
on_source_push (data);
if (--data->iterations == 0)
data->running = false;
}
static const SpaNodeCallbacks source_callbacks =
{
&on_source_event,
NULL,
&on_source_have_output,
NULL
};
static SpaResult
do_add_source (SpaLoop *loop,
SpaSource *source)
{
AppData *data = SPA_CONTAINER_OF (loop, AppData, data_loop);
data->sources[data->n_sources] = *source;
data->n_sources++;
data->rebuild_fds = true;
return SPA_RESULT_OK;
}
static SpaResult
do_update_source (SpaSource *source)
{
return SPA_RESULT_OK;
}
static void
do_remove_source (SpaSource *source)
{
}
static SpaResult
do_invoke (SpaLoop *loop,
SpaInvokeFunc func,
uint32_t seq,
size_t size,
void *data,
void *user_data)
{
return func (loop, false, seq, size, data, user_data);
}
static SpaResult
make_nodes (AppData *data)
{
SpaResult res;
if ((res = make_node (data, &data->sink,
"build/spa/plugins/test/libspa-test.so",
"fakesink")) < 0) {
printf ("can't create fakesink: %d\n", res);
return res;
}
if (data->mode & MODE_ASYNC_PULL)
spa_node_set_callbacks (data->sink, &sink_callbacks, sizeof (sink_callbacks), data);
if ((res = make_node (data, &data->source,
"build/spa/plugins/test/libspa-test.so",
"fakesrc")) < 0) {
printf ("can't create fakesrc: %d\n", res);
return res;
}
if (data->mode & MODE_ASYNC_PUSH)
spa_node_set_callbacks (data->source, &source_callbacks, sizeof (source_callbacks), data);
data->source_sink_io[0] = SPA_PORT_IO_INIT;
data->source_sink_io[0].status = SPA_RESULT_NEED_BUFFER;
spa_node_port_set_io (data->source, SPA_DIRECTION_OUTPUT, 0, &data->source_sink_io[0]);
spa_node_port_set_io (data->sink, SPA_DIRECTION_INPUT, 0, &data->source_sink_io[0]);
spa_graph_node_add (&data->graph, &data->source_node,
spa_graph_node_schedule_default, data->source);
data->source_node.flags = (data->mode & MODE_ASYNC_PUSH) ? SPA_GRAPH_NODE_FLAG_ASYNC : 0;
spa_graph_port_add (&data->graph, &data->source_node,
&data->source_out, SPA_DIRECTION_OUTPUT, 0,
0, &data->source_sink_io[0]);
spa_graph_node_add (&data->graph, &data->sink_node, spa_graph_node_schedule_default, data->sink);
data->sink_node.flags = (data->mode & MODE_ASYNC_PULL) ? SPA_GRAPH_NODE_FLAG_ASYNC : 0;
spa_graph_port_add (&data->graph, &data->sink_node,
&data->sink_in, SPA_DIRECTION_INPUT, 0,
0, &data->source_sink_io[0]);
spa_graph_port_link (&data->graph, &data->source_out, &data->sink_in);
return res;
}
static SpaResult
negotiate_formats (AppData *data)
{
SpaResult res;
SpaFormat *format;
SpaPODBuilder b = { 0 };
SpaPODFrame f[2];
uint8_t buffer[256];
spa_pod_builder_init (&b, buffer, sizeof (buffer));
spa_pod_builder_format (&b, &f[0], data->type.format,
data->type.media_type.binary, data->type.media_subtype.raw, 0);
format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
if ((res = spa_node_port_set_format (data->sink, SPA_DIRECTION_INPUT, 0, 0, format)) < 0)
return res;
if ((res = spa_node_port_set_format (data->source, SPA_DIRECTION_OUTPUT, 0, 0, format)) < 0)
return res;
init_buffer (data, data->source_buffers, data->source_buffer, 1, BUFFER_SIZE);
if ((res = spa_node_port_use_buffers (data->sink, SPA_DIRECTION_INPUT, 0, data->source_buffers, 1)) < 0)
return res;
if ((res = spa_node_port_use_buffers (data->source, SPA_DIRECTION_OUTPUT, 0, data->source_buffers, 1)) < 0)
return res;
return SPA_RESULT_OK;
}
static void *
loop (void *user_data)
{
AppData *data = user_data;
printf ("enter thread %d\n", data->n_sources);
while (data->running) {
int i, r;
/* rebuild */
if (data->rebuild_fds) {
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
data->fds[i].fd = p->fd;
data->fds[i].events = p->mask;
}
data->n_fds = data->n_sources;
data->rebuild_fds = false;
}
r = poll (data->fds, data->n_fds, -1);
if (r < 0) {
if (errno == EINTR)
continue;
break;
}
if (r == 0) {
fprintf (stderr, "select timeout");
break;
}
/* after */
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
p->rmask = 0;
if (data->fds[i].revents & POLLIN)
p->rmask |= SPA_IO_IN;
if (data->fds[i].revents & POLLOUT)
p->rmask |= SPA_IO_OUT;
if (data->fds[i].revents & POLLHUP)
p->rmask |= SPA_IO_HUP;
if (data->fds[i].revents & POLLERR)
p->rmask |= SPA_IO_ERR;
}
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
if (p->rmask)
p->func (p);
}
}
printf ("leave thread\n");
return NULL;
}
static void
run_graph (AppData *data)
{
SpaResult res;
int err, i;
struct timespec now;
int64_t start, stop;
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
if ((res = spa_node_send_command (data->source, &cmd)) < 0)
printf ("got source error %d\n", res);
if ((res = spa_node_send_command (data->sink, &cmd)) < 0)
printf ("got sink error %d\n", res);
}
clock_gettime (CLOCK_MONOTONIC, &now);
start = SPA_TIMESPEC_TO_TIME (&now);
printf ("running\n");
if (data->mode & MODE_SYNC_PUSH) {
for (i = 0; i < data->iterations; i++)
on_source_push (data);
}
else if (data->mode & MODE_SYNC_PULL) {
for (i = 0; i < data->iterations; i++)
on_sink_pull (data);
}
else {
data->running = true;
if ((err = pthread_create (&data->thread, NULL, loop, data)) != 0) {
printf ("can't create thread: %d %s", err, strerror (err));
data->running = false;
}
if (data->running) {
pthread_join (data->thread, NULL);
}
}
clock_gettime (CLOCK_MONOTONIC, &now);
stop = SPA_TIMESPEC_TO_TIME (&now);
printf ("stopping, elapsed %"PRIi64"\n", stop - start);
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
if ((res = spa_node_send_command (data->sink, &cmd)) < 0)
printf ("got error %d\n", res);
if ((res = spa_node_send_command (data->source, &cmd)) < 0)
printf ("got source error %d\n", res);
}
}
int
main (int argc, char *argv[])
{
AppData data = { NULL };
SpaResult res;
const char *str;
spa_graph_init (&data.graph);
data.map = spa_type_map_get_default();
data.log = spa_log_get_default();
data.data_loop.size = sizeof (SpaLoop);
data.data_loop.add_source = do_add_source;
data.data_loop.update_source = do_update_source;
data.data_loop.remove_source = do_remove_source;
data.data_loop.invoke = do_invoke;
if ((str = getenv ("PINOS_DEBUG")))
data.log->level = atoi (str);
data.mode = argc > 1 ? atoi (argv[1]) : MODE_SYNC_PUSH;
data.iterations = argc > 2 ? atoi (argv[2]) : 100000;
printf ("mode %08x\n", data.mode);
data.support[0].type = SPA_TYPE__TypeMap;
data.support[0].data = data.map;
data.support[1].type = SPA_TYPE__Log;
data.support[1].data = data.log;
data.support[2].type = SPA_TYPE_LOOP__DataLoop;
data.support[2].data = &data.data_loop;
data.support[3].type = SPA_TYPE_LOOP__MainLoop;
data.support[3].data = &data.data_loop;
data.n_support = 4;
init_type (&data.type, data.map);
if ((res = make_nodes (&data)) < 0) {
printf ("can't make nodes: %d\n", res);
return -1;
}
if ((res = negotiate_formats (&data)) < 0) {
printf ("can't negotiate nodes: %d\n", res);
return -1;
}
run_graph (&data);
}

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

@ -348,6 +348,8 @@ negotiate_formats (AppData *data)
if ((res = spa_node_port_set_format (data->sink, SPA_DIRECTION_INPUT, 0, 0, format)) < 0)
return res;
data->source_sink_io[0] = SPA_PORT_IO_INIT;
spa_node_port_set_io (data->source, SPA_DIRECTION_OUTPUT, 0, &data->source_sink_io[0]);
spa_node_port_set_io (data->sink, SPA_DIRECTION_INPUT, 0, &data->source_sink_io[0]);

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

@ -399,6 +399,8 @@ negotiate_formats (AppData *data)
uint8_t buffer[256];
SpaPODBuilder b = SPA_POD_BUILDER_INIT (buffer, sizeof (buffer));
data->source_output[0] = SPA_PORT_IO_INIT;
if ((res = spa_node_port_set_io (data->source, SPA_DIRECTION_OUTPUT, 0, &data->source_output[0])) < 0)
return res;