From 12effccb06d7e1734ece3e03960264c00d9fb0e5 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Fri, 19 May 2017 12:48:51 +0200 Subject: [PATCH] Add fakesrc ! fakesink test Add fakesrc and fakesink and some performance test Small cleanups --- spa/include/spa/format-utils.h | 10 +- spa/include/spa/format.h | 2 + spa/include/spa/graph.h | 32 +- spa/include/spa/node.h | 3 +- spa/plugins/meson.build | 1 + spa/plugins/test/fakesink.c | 907 +++++++++++++++++++++++ spa/plugins/test/fakesrc.c | 940 ++++++++++++++++++++++++ spa/plugins/test/meson.build | 9 + spa/plugins/test/plugin.c | 43 ++ spa/plugins/videotestsrc/videotestsrc.c | 4 +- spa/tests/meson.build | 5 + spa/tests/test-graph.c | 7 +- spa/tests/test-mixer.c | 4 + spa/tests/test-perf.c | 577 +++++++++++++++ spa/tests/test-ringbuffer.c | 2 + spa/tests/test-v4l2.c | 2 + 16 files changed, 2526 insertions(+), 22 deletions(-) create mode 100644 spa/plugins/test/fakesink.c create mode 100644 spa/plugins/test/fakesrc.c create mode 100644 spa/plugins/test/meson.build create mode 100644 spa/plugins/test/plugin.c create mode 100644 spa/tests/test-perf.c diff --git a/spa/include/spa/format-utils.h b/spa/include/spa/format-utils.h index bacd1d64a..67ec61309 100644 --- a/spa/include/spa/format-utils.h +++ b/spa/include/spa/format-utils.h @@ -34,15 +34,19 @@ typedef struct { uint32_t audio; uint32_t video; uint32_t image; + uint32_t binary; + uint32_t stream; } SpaTypeMediaType; static inline void spa_type_media_type_map (SpaTypeMap *map, SpaTypeMediaType *type) { if (type->audio == 0) { - 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->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); } } diff --git a/spa/include/spa/format.h b/spa/include/spa/format.h index 57684c861..396ce4ad1 100644 --- a/spa/include/spa/format.h +++ b/spa/include/spa/format.h @@ -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 ":" diff --git a/spa/include/spa/graph.h b/spa/include/spa/graph.h index d598e82fb..50ca46dfe 100644 --- a/spa/include/spa/graph.h +++ b/spa/include/spa/graph.h @@ -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,21 +182,25 @@ 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; - spa_list_insert (graph->ready.prev, &pn->ready_link); + 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++; diff --git a/spa/include/spa/node.h b/spa/include/spa/node.h index 8e3a3076d..8c52aa2a4 100644 --- a/spa/include/spa/node.h +++ b/spa/include/spa/node.h @@ -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 diff --git a/spa/plugins/meson.build b/spa/plugins/meson.build index 89377a1b3..4e5ced214 100644 --- a/spa/plugins/meson.build +++ b/spa/plugins/meson.build @@ -2,6 +2,7 @@ subdir('alsa') subdir('audiomixer') subdir('audiotestsrc') subdir('ffmpeg') +subdir('test') #subdir('libva') subdir('videotestsrc') subdir('volume') diff --git a/spa/plugins/test/fakesink.c b/spa/plugins/test/fakesink.c new file mode 100644 index 000000000..ee41c690f --- /dev/null +++ b/spa/plugins/test/fakesink.c @@ -0,0 +1,907 @@ +/* Spa + * Copyright (C) 2017 Wim Taymans + * + * 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 +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +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, +}; diff --git a/spa/plugins/test/fakesrc.c b/spa/plugins/test/fakesrc.c new file mode 100644 index 000000000..4d04068e1 --- /dev/null +++ b/spa/plugins/test/fakesrc.c @@ -0,0 +1,940 @@ +/* Spa + * Copyright (C) 2017 Wim Taymans + * + * 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 +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +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, +}; diff --git a/spa/plugins/test/meson.build b/spa/plugins/test/meson.build new file mode 100644 index 000000000..31cef6b15 --- /dev/null +++ b/spa/plugins/test/meson.build @@ -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'))) diff --git a/spa/plugins/test/plugin.c b/spa/plugins/test/plugin.c new file mode 100644 index 000000000..5ec7df0dc --- /dev/null +++ b/spa/plugins/test/plugin.c @@ -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 +#include + +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; +} diff --git a/spa/plugins/videotestsrc/videotestsrc.c b/spa/plugins/videotestsrc/videotestsrc.c index c79485d28..51d3139e0 100644 --- a/spa/plugins/videotestsrc/videotestsrc.c +++ b/spa/plugins/videotestsrc/videotestsrc.c @@ -34,8 +34,8 @@ #include #include -#define FRAMES_TO_TIME(this,f) ((this->current_format.info.raw.framerate.denom * (f) * SPA_NSEC_PER_SEC) / \ - (this->current_format.info.raw.framerate.num)) +#define FRAMES_TO_TIME(this,f) ((this->current_format.info.raw.framerate.denom * (f) * SPA_NSEC_PER_SEC) / \ + (this->current_format.info.raw.framerate.num)) typedef struct { uint32_t node; diff --git a/spa/tests/meson.build b/spa/tests/meson.build index 65a6a728d..190c6c649 100644 --- a/spa/tests/meson.build +++ b/spa/tests/meson.build @@ -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], diff --git a/spa/tests/test-graph.c b/spa/tests/test-graph.c index e2d6c0eb5..8101efb16 100644 --- a/spa/tests/test-graph.c +++ b/spa/tests/test-graph.c @@ -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; diff --git a/spa/tests/test-mixer.c b/spa/tests/test-mixer.c index 99d84d655..211296770 100644 --- a/spa/tests/test-mixer.c +++ b/spa/tests/test-mixer.c @@ -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]); diff --git a/spa/tests/test-perf.c b/spa/tests/test-perf.c new file mode 100644 index 000000000..2bd1dbb9d --- /dev/null +++ b/spa/tests/test-perf.c @@ -0,0 +1,577 @@ +/* Spa + * Copyright (C) 2017 Wim Taymans + * + * 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#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); +} diff --git a/spa/tests/test-ringbuffer.c b/spa/tests/test-ringbuffer.c index bb48f46f6..c85868131 100644 --- a/spa/tests/test-ringbuffer.c +++ b/spa/tests/test-ringbuffer.c @@ -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]); diff --git a/spa/tests/test-v4l2.c b/spa/tests/test-v4l2.c index 48084d066..78ad981fc 100644 --- a/spa/tests/test-v4l2.c +++ b/spa/tests/test-v4l2.c @@ -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;