diff options
Diffstat (limited to 'spa/examples')
| -rw-r--r-- | spa/examples/adapter-control.c | 771 | ||||
| -rw-r--r-- | spa/examples/example-control.c | 560 | ||||
| -rw-r--r-- | spa/examples/local-libcamera.c | 562 | ||||
| -rw-r--r-- | spa/examples/local-v4l2.c | 553 | ||||
| -rw-r--r-- | spa/examples/meson.build | 32 |
5 files changed, 2478 insertions, 0 deletions
diff --git a/spa/examples/adapter-control.c b/spa/examples/adapter-control.c new file mode 100644 index 0000000..7caf32f --- /dev/null +++ b/spa/examples/adapter-control.c @@ -0,0 +1,771 @@ +/* Spa + * + * Copyright © 2020 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +/* + [title] + Running audioadapter nodes. + [title] + [doc] + Runs an output audioadapter using audiotestsrc as follower + with an input audioadapter using alsa-pcm-sink as follower + for easy testing. + [doc] + */ + +#include "config.h" + +#include <math.h> +#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/control/control.h> +#include <spa/graph/graph.h> +#include <spa/support/plugin.h> +#include <spa/support/log-impl.h> +#include <spa/support/loop.h> +#include <spa/node/node.h> +#include <spa/node/io.h> +#include <spa/node/utils.h> +#include <spa/param/param.h> +#include <spa/param/props.h> +#include <spa/param/audio/format-utils.h> +#include <spa/utils/names.h> +#include <spa/utils/result.h> +#include <spa/utils/string.h> + +static SPA_LOG_IMPL(default_log); + +#define MIN_LATENCY 1024 +#define CONTROL_BUFFER_SIZE 32768 + + +struct buffer { + struct spa_buffer buffer; + struct spa_meta metas[1]; + struct spa_meta_header header; + struct spa_data datas[1]; + struct spa_chunk chunks[1]; +}; + +struct data { + const char *plugin_dir; + struct spa_log *log; + struct spa_system *system; + struct spa_loop *loop; + struct spa_loop_control *control; + struct spa_support support[5]; + uint32_t n_support; + + struct spa_graph graph; + struct spa_graph_state graph_state; + struct spa_graph_node graph_source_node; + struct spa_graph_node graph_sink_node; + struct spa_graph_state graph_source_state; + struct spa_graph_state graph_sink_state; + struct spa_graph_port graph_source_port_0; + struct spa_graph_port graph_sink_port_0; + + struct spa_node *source_follower_node; // audiotestsrc + struct spa_node *source_node; // adapter for audiotestsrc + struct spa_node *sink_follower_node; // alsa-pcm-sink + struct spa_node *sink_node; // adapter for alsa-pcm-sink + + struct spa_io_position position; + struct spa_io_buffers source_sink_io[1]; + struct spa_buffer *source_buffers[1]; + struct buffer source_buffer[1]; + + struct spa_io_buffers control_io; + struct spa_buffer *control_buffers[1]; + struct buffer control_buffer[1]; + + int buffer_count; + bool start_fade_in; + double volume_accum; + uint32_t volume_offs; + + bool running; + pthread_t thread; +}; + +static int load_handle(struct data *data, struct spa_handle **handle, const char *lib, const char *name) +{ + int res; + void *hnd; + spa_handle_factory_enum_func_t enum_func; + uint32_t i; + char *path; + + if ((path = spa_aprintf("%s/%s", data->plugin_dir, lib)) == NULL) + return -ENOMEM; + + hnd = dlopen(path, RTLD_NOW); + free(path); + + if (hnd == NULL) { + printf("can't load %s: %s\n", lib, dlerror()); + return -ENOENT; + } + if ((enum_func = dlsym(hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) { + printf("can't find enum function\n"); + res = -ENOENT; + goto exit_cleanup; + } + + for (i = 0;;) { + const struct spa_handle_factory *factory; + + if ((res = enum_func(&factory, &i)) <= 0) { + if (res != 0) + printf("can't enumerate factories: %s\n", spa_strerror(res)); + break; + } + if (factory->version < 1) + continue; + if (!spa_streq(factory->name, name)) + continue; + + *handle = calloc(1, spa_handle_factory_get_size(factory, NULL)); + if ((res = spa_handle_factory_init(factory, *handle, + NULL, data->support, + data->n_support)) < 0) { + printf("can't make factory instance: %d\n", res); + goto exit_cleanup; + } + return 0; + } + return -EBADF; + +exit_cleanup: + dlclose(hnd); + return res; +} + +int init_data(struct data *data) +{ + int res; + const char *str; + struct spa_handle *handle = NULL; + void *iface; + + if ((str = getenv("SPA_PLUGIN_DIR")) == NULL) + str = PLUGINDIR; + data->plugin_dir = str; + + /* start not doing fade-in */ + data->start_fade_in = true; + data->volume_accum = 0.0; + data->volume_offs = 0; + + /* init the graph */ + spa_graph_init(&data->graph, &data->graph_state); + + /* set the default log */ + data->log = &default_log.log; + data->support[data->n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Log, data->log); + + /* load and set support system */ + if ((res = load_handle(data, &handle, + "support/libspa-support.so", + SPA_NAME_SUPPORT_SYSTEM)) < 0) + return res; + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_System, &iface)) < 0) { + printf("can't get System interface %d\n", res); + return res; + } + data->system = iface; + data->support[data->n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_System, data->system); + data->support[data->n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_DataSystem, data->system); + + /* load and set support loop and loop control */ + if ((res = load_handle(data, &handle, + "support/libspa-support.so", + SPA_NAME_SUPPORT_LOOP)) < 0) + return res; + + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_Loop, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + data->loop = iface; + data->support[data->n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Loop, data->loop); + data->support[data->n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_DataLoop, data->loop); + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_LoopControl, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + data->control = iface; + + if ((str = getenv("SPA_DEBUG"))) + data->log->level = atoi(str); + + return 0; +} + +static int make_node(struct data *data, struct spa_node **node, const char *lib, + const char *name, const struct spa_dict *props) +{ + struct spa_handle *handle; + int res = 0; + void *hnd = NULL; + spa_handle_factory_enum_func_t enum_func; + uint32_t i; + char *path; + + if ((path = spa_aprintf("%s/%s", data->plugin_dir, lib)) == NULL) + return -ENOMEM; + + hnd = dlopen(path, RTLD_NOW); + free(path); + + if (hnd == NULL) { + printf("can't load %s: %s\n", lib, dlerror()); + return -ENOENT; + } + if ((enum_func = dlsym(hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) { + printf("can't find enum function\n"); + res = -ENOENT; + goto exit_cleanup; + } + + for (i = 0;;) { + const struct spa_handle_factory *factory; + void *iface; + + if ((res = enum_func(&factory, &i)) <= 0) { + if (res != 0) + printf("can't enumerate factories: %s\n", spa_strerror(res)); + break; + } + if (factory->version < 1) + continue; + if (!spa_streq(factory->name, name)) + continue; + + handle = calloc(1, spa_handle_factory_get_size(factory, NULL)); + if ((res = + spa_handle_factory_init(factory, handle, props, data->support, + data->n_support)) < 0) { + printf("can't make factory instance: %d\n", res); + goto exit_cleanup; + } + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_Node, &iface)) < 0) { + printf("can't get interface %d\n", res); + goto exit_cleanup; + } + *node = iface; + return 0; + } + return -EBADF; + +exit_cleanup: + dlclose(hnd); + return res; +} + +static int fade_in(struct data *data) +{ + struct spa_pod_builder b; + struct spa_pod_frame f[1]; + void *buffer = data->control_buffer->datas[0].data; + uint32_t buffer_size = data->control_buffer->datas[0].maxsize; + data->control_buffer->datas[0].chunk[0].size = buffer_size; + + printf ("fading in\n"); + + spa_pod_builder_init(&b, buffer, buffer_size); + spa_pod_builder_push_sequence(&b, &f[0], 0); + data->volume_offs = 0; + do { + spa_pod_builder_control(&b, data->volume_offs, SPA_CONTROL_Properties); + spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, 0, + SPA_PROP_volume, SPA_POD_Float(data->volume_accum)); + data->volume_accum += 0.003; + data->volume_offs += 200; + } while (data->volume_accum < 1.0); + spa_pod_builder_pop(&b, &f[0]); + + return 0; +} + +static int fade_out(struct data *data) +{ + struct spa_pod_builder b; + struct spa_pod_frame f[1]; + void *buffer = data->control_buffer->datas[0].data; + uint32_t buffer_size = data->control_buffer->datas[0].maxsize; + data->control_buffer->datas[0].chunk[0].size = buffer_size; + + printf ("fading out\n"); + + spa_pod_builder_init(&b, buffer, buffer_size); + spa_pod_builder_push_sequence(&b, &f[0], 0); + data->volume_offs = 200; + do { + spa_pod_builder_control(&b, data->volume_offs, SPA_CONTROL_Properties); + spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, 0, + SPA_PROP_volume, SPA_POD_Float(data->volume_accum)); + data->volume_accum -= 0.003; + data->volume_offs += 200; + } while (data->volume_accum > 0.0); + spa_pod_builder_pop(&b, &f[0]); + + return 0; +} + +static void do_fade(struct data *data) +{ + switch (data->control_io.status) { + case SPA_STATUS_OK: + case SPA_STATUS_NEED_DATA: + break; + case SPA_STATUS_HAVE_DATA: + case SPA_STATUS_STOPPED: + default: + return; + } + + /* fade */ + if (data->start_fade_in) + fade_in(data); + else + fade_out(data); + + data->control_io.status = SPA_STATUS_HAVE_DATA; + data->control_io.buffer_id = 0; + + /* alternate */ + data->start_fade_in = !data->start_fade_in; +} + +static int on_sink_node_ready(void *_data, int status) +{ + struct data *data = _data; + + /* only do fade in/out when buffer count is 0 */ + if (data->buffer_count == 0) + do_fade(data); + + /* update buffer count */ + data->buffer_count++; + if (data->buffer_count > 64) + data->buffer_count = 0; + + spa_graph_node_process(&data->graph_source_node); + spa_graph_node_process(&data->graph_sink_node); + return 0; +} + +static const struct spa_node_callbacks sink_node_callbacks = { + SPA_VERSION_NODE_CALLBACKS, + .ready = on_sink_node_ready, +}; + +static int make_nodes(struct data *data, const char *device) +{ + int res = 0; + struct spa_pod *props; + struct spa_pod_builder b = { 0 }; + uint8_t buffer[1024]; + char value[32]; + struct spa_dict_item items[2]; + struct spa_audio_info_raw info; + struct spa_pod *param; + + items[0] = SPA_DICT_ITEM_INIT("clock.quantum-limit", "8192"); + + /* make the source node (audiotestsrc) */ + if ((res = make_node(data, &data->source_follower_node, + "audiotestsrc/libspa-audiotestsrc.so", + "audiotestsrc", + &SPA_DICT_INIT(items, 1))) < 0) { + printf("can't create source follower node (audiotestsrc): %d\n", res); + return res; + } + + /* set the format on the source */ + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + param = spa_format_audio_raw_build(&b, 0, + &SPA_AUDIO_INFO_RAW_INIT( + .format = SPA_AUDIO_FORMAT_S16, + .rate = 48000, + .channels = 2 )); + if ((res = spa_node_port_set_param(data->source_follower_node, + SPA_DIRECTION_OUTPUT, 0, + SPA_PARAM_Format, 0, param)) < 0) { + printf("can't set format on follower node (audiotestsrc): %d\n", res); + return res; + } + + /* make the sink adapter node */ + snprintf(value, sizeof(value), "pointer:%p", data->source_follower_node); + items[1] = SPA_DICT_ITEM_INIT("audio.adapt.follower", value); + if ((res = make_node(data, &data->source_node, + "audioconvert/libspa-audioconvert.so", + SPA_NAME_AUDIO_ADAPT, + &SPA_DICT_INIT(items, 2))) < 0) { + printf("can't create source adapter node: %d\n", res); + return res; + } + + /* setup the source node props */ + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + props = spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, 0, + SPA_PROP_frequency, SPA_POD_Float(600.0), + SPA_PROP_volume, SPA_POD_Float(0.5), + SPA_PROP_live, SPA_POD_Bool(false)); + if ((res = spa_node_set_param(data->source_node, SPA_PARAM_Props, 0, props)) < 0) { + printf("can't setup source follower node %d\n", res); + return res; + } + + /* setup the source node port config */ + spa_zero(info); + info.format = SPA_AUDIO_FORMAT_F32P; + info.channels = 1; + info.rate = 48000; + info.position[0] = SPA_AUDIO_CHANNEL_MONO; + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + param = spa_format_audio_raw_build(&b, SPA_PARAM_Format, &info); + param = spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_ParamPortConfig, SPA_PARAM_PortConfig, + SPA_PARAM_PORT_CONFIG_direction, SPA_POD_Id(SPA_DIRECTION_OUTPUT), + SPA_PARAM_PORT_CONFIG_mode, SPA_POD_Id(SPA_PARAM_PORT_CONFIG_MODE_dsp), + SPA_PARAM_PORT_CONFIG_format, SPA_POD_Pod(param)); + if ((res = spa_node_set_param(data->source_node, SPA_PARAM_PortConfig, 0, param) < 0)) { + printf("can't setup source node %d\n", res); + return res; + } + + /* make the sink follower node (alsa-pcm-sink) */ + if ((res = make_node(data, &data->sink_follower_node, + "alsa/libspa-alsa.so", + SPA_NAME_API_ALSA_PCM_SINK, + &SPA_DICT_INIT(items, 1))) < 0) { + printf("can't create sink follower node (alsa-pcm-sink): %d\n", res); + return res; + } + + /* make the sink adapter node */ + snprintf(value, sizeof(value), "pointer:%p", data->sink_follower_node); + items[1] = SPA_DICT_ITEM_INIT("audio.adapt.follower", value); + if ((res = make_node(data, &data->sink_node, + "audioconvert/libspa-audioconvert.so", + SPA_NAME_AUDIO_ADAPT, + &SPA_DICT_INIT(items, 2))) < 0) { + printf("can't create sink adapter node: %d\n", res); + return res; + } + + /* add sink follower node callbacks */ + spa_node_set_callbacks(data->sink_node, &sink_node_callbacks, data); + + /* setup the sink node props */ + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + props = spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, 0, + SPA_PROP_device, SPA_POD_String(device ? device : "hw:0"), + SPA_PROP_minLatency, SPA_POD_Int(MIN_LATENCY)); + if ((res = spa_node_set_param(data->sink_follower_node, SPA_PARAM_Props, 0, props)) < 0) { + printf("can't setup sink follower node %d\n", res); + return res; + } + + /* setup the sink node port config */ + spa_zero(info); + info.format = SPA_AUDIO_FORMAT_F32P; + info.channels = 1; + info.rate = 48000; + info.position[0] = SPA_AUDIO_CHANNEL_MONO; + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + param = spa_format_audio_raw_build(&b, SPA_PARAM_Format, &info); + param = spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_ParamPortConfig, SPA_PARAM_PortConfig, + SPA_PARAM_PORT_CONFIG_direction, SPA_POD_Id(SPA_DIRECTION_INPUT), + SPA_PARAM_PORT_CONFIG_mode, SPA_POD_Id(SPA_PARAM_PORT_CONFIG_MODE_dsp), + SPA_PARAM_PORT_CONFIG_control, SPA_POD_Bool(true), + SPA_PARAM_PORT_CONFIG_format, SPA_POD_Pod(param)); + if ((res = spa_node_set_param(data->sink_node, SPA_PARAM_PortConfig, 0, param) < 0)) { + printf("can't setup sink node %d\n", res); + return res; + } + + /* set io buffers on source and sink nodes */ + data->source_sink_io[0] = SPA_IO_BUFFERS_INIT; + if ((res = spa_node_port_set_io(data->source_node, + SPA_DIRECTION_OUTPUT, 0, + SPA_IO_Buffers, + &data->source_sink_io[0], sizeof(data->source_sink_io[0]))) < 0) { + printf("can't set io buffers on port 0 of source node: %d\n", res); + return res; + } + if ((res = spa_node_port_set_io(data->sink_node, + SPA_DIRECTION_INPUT, 0, + SPA_IO_Buffers, + &data->source_sink_io[0], sizeof(data->source_sink_io[0]))) < 0) { + printf("can't set io buffers on port 0 of sink node: %d\n", res); + return res; + } + /* set io position and clock on source and sink nodes */ + data->position.clock.rate = SPA_FRACTION(1, 48000); + data->position.clock.duration = 1024; + if ((res = spa_node_set_io(data->source_node, + SPA_IO_Position, + &data->position, sizeof(data->position))) < 0) { + printf("can't set io position on source node: %d\n", res); + return res; + } + if ((res = spa_node_set_io(data->sink_node, + SPA_IO_Position, + &data->position, sizeof(data->position))) < 0) { + printf("can't set io position on sink node: %d\n", res); + return res; + } + if ((res = spa_node_set_io(data->source_node, + SPA_IO_Clock, + &data->position.clock, sizeof(data->position.clock))) < 0) { + printf("can't set io clock on source node: %d\n", res); + return res; + } + if ((res = spa_node_set_io(data->sink_node, + SPA_IO_Clock, + &data->position.clock, sizeof(data->position.clock))) < 0) { + printf("can't set io clock on sink node: %d\n", res); + return res; + } + + /* set io buffers on control port of sink node */ + if ((res = spa_node_port_set_io(data->sink_node, + SPA_DIRECTION_INPUT, 1, + SPA_IO_Buffers, + &data->control_io, sizeof(data->control_io))) < 0) { + printf("can't set io buffers on control port 1 of sink node\n"); + return res; + } + + /* add source node to the graph */ + spa_graph_node_init(&data->graph_source_node, &data->graph_source_state); + spa_graph_node_set_callbacks(&data->graph_source_node, &spa_graph_node_impl_default, data->source_node); + spa_graph_node_add(&data->graph, &data->graph_source_node); + spa_graph_port_init(&data->graph_source_port_0, SPA_DIRECTION_OUTPUT, 0, 0); + spa_graph_port_add(&data->graph_source_node, &data->graph_source_port_0); + + /* add sink node to the graph */ + spa_graph_node_init(&data->graph_sink_node, &data->graph_sink_state); + spa_graph_node_set_callbacks(&data->graph_sink_node, &spa_graph_node_impl_default, data->sink_node); + spa_graph_node_add(&data->graph, &data->graph_sink_node); + spa_graph_port_init(&data->graph_sink_port_0, SPA_DIRECTION_INPUT, 0, 0); + spa_graph_port_add(&data->graph_sink_node, &data->graph_sink_port_0); + + /* link source and sink nodes */ + spa_graph_port_link(&data->graph_source_port_0, &data->graph_sink_port_0); + + return res; +} + +static void +init_buffer(struct data *data, struct spa_buffer **bufs, struct buffer *ba, int n_buffers, + size_t size) +{ + int i; + + for (i = 0; i < n_buffers; i++) { + struct buffer *b = &ba[i]; + bufs[i] = &b->buffer; + + b->buffer.metas = b->metas; + b->buffer.n_metas = 1; + b->buffer.datas = b->datas; + b->buffer.n_datas = 1; + + b->header.flags = 0; + b->header.seq = 0; + b->header.pts = 0; + b->header.dts_offset = 0; + b->metas[0].type = SPA_META_Header; + b->metas[0].data = &b->header; + b->metas[0].size = sizeof(b->header); + + b->datas[0].type = SPA_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 = 0; + b->datas[0].chunk->stride = 0; + } +} + +static int negotiate_formats(struct data *data) +{ + int res; + struct spa_pod *filter = NULL, *param = NULL; + struct spa_pod_builder b = { 0 }; + uint8_t buffer[4096]; + uint32_t state = 0; + size_t buffer_size = 1024; + + /* set the sink and source formats */ + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + param = spa_format_audio_dsp_build(&b, 0, + &SPA_AUDIO_INFO_DSP_INIT( + .format = SPA_AUDIO_FORMAT_F32P)); + if ((res = spa_node_port_set_param(data->source_node, + SPA_DIRECTION_OUTPUT, 0, SPA_PARAM_Format, 0, param)) < 0) + return res; + if ((res = spa_node_port_set_param(data->sink_node, + SPA_DIRECTION_INPUT, 0, SPA_PARAM_Format, 0, param)) < 0) + return res; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + param = spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Format, SPA_PARAM_Format, + SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_application), + SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_control)); + if ((res = spa_node_port_set_param(data->sink_node, + SPA_DIRECTION_INPUT, 1, SPA_PARAM_Format, 0, param)) < 0) + return res; + + /* get the source node buffer size */ + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + if ((res = spa_node_port_enum_params_sync(data->source_node, + SPA_DIRECTION_OUTPUT, 0, + SPA_PARAM_Buffers, &state, filter, ¶m, &b)) != 1) + return res ? res : -ENOTSUP; + spa_pod_fixate(param); + if ((res = spa_pod_parse_object(param, SPA_TYPE_OBJECT_ParamBuffers, NULL, + SPA_PARAM_BUFFERS_size, SPA_POD_Int(&buffer_size))) < 0) + return res; + + /* use buffers on the source and sink */ + init_buffer(data, data->source_buffers, data->source_buffer, 1, buffer_size); + if ((res = spa_node_port_use_buffers(data->source_node, + SPA_DIRECTION_OUTPUT, 0, 0, data->source_buffers, 1)) < 0) + return res; + if ((res = spa_node_port_use_buffers(data->sink_node, + SPA_DIRECTION_INPUT, 0, 0, data->source_buffers, 1)) < 0) + return res; + + /* Set the control buffers */ + init_buffer(data, data->control_buffers, data->control_buffer, 1, CONTROL_BUFFER_SIZE); + if ((res = spa_node_port_use_buffers(data->sink_node, + SPA_DIRECTION_INPUT, 1, 0, data->control_buffers, 1)) < 0) + return res; + + return 0; +} + +static void *loop(void *user_data) +{ + struct data *data = user_data; + + printf("enter thread\n"); + spa_loop_control_enter(data->control); + + while (data->running) { + spa_loop_control_iterate(data->control, -1); + } + + printf("leave thread\n"); + spa_loop_control_leave(data->control); + return NULL; + + return NULL; +} + +static void run_async_sink(struct data *data) +{ + int res, err; + struct spa_command cmd; + + cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start); + if ((res = spa_node_send_command(data->source_node, &cmd)) < 0) + printf("got error %d\n", res); + if ((res = spa_node_send_command(data->sink_node, &cmd)) < 0) + printf("got error %d\n", res); + + spa_loop_control_leave(data->control); + + 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; + } + + printf("sleeping for 1000 seconds\n"); + sleep(1000); + + if (data->running) { + data->running = false; + pthread_join(data->thread, NULL); + } + + spa_loop_control_enter(data->control); + + cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause); + if ((res = spa_node_send_command(data->source_node, &cmd)) < 0) + printf("got error %d\n", res); + if ((res = spa_node_send_command(data->sink_node, &cmd)) < 0) + printf("got error %d\n", res); +} + +int main(int argc, char *argv[]) +{ + struct data data = { 0 }; + int res = 0; + + /* init data */ + if ((res = init_data(&data)) < 0) { + printf("can't init data: %d (%s)\n", res, spa_strerror(res)); + return -1; + } + + /* make the nodes (audiotestsrc and adapter with alsa-pcm-sink as follower) */ + if ((res = make_nodes(&data, argc > 1 ? argv[1] : NULL)) < 0) { + printf("can't make nodes: %d (%s)\n", res, spa_strerror(res)); + return -1; + } + + /* Negotiate format */ + if ((res = negotiate_formats(&data)) < 0) { + printf("can't negotiate nodes: %d (%s)\n", res, spa_strerror(res)); + return -1; + } + + spa_loop_control_enter(data.control); + run_async_sink(&data); + spa_loop_control_leave(data.control); +} diff --git a/spa/examples/example-control.c b/spa/examples/example-control.c new file mode 100644 index 0000000..f26960c --- /dev/null +++ b/spa/examples/example-control.c @@ -0,0 +1,560 @@ +/* Spa + * + * Copyright © 2018 Wim Taymans + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +/* + [title] + [title] + */ + +#include "config.h" + +#include <math.h> +#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/support/plugin.h> +#include <spa/support/log-impl.h> +#include <spa/support/loop.h> +#include <spa/node/node.h> +#include <spa/node/io.h> +#include <spa/node/utils.h> +#include <spa/param/param.h> +#include <spa/param/props.h> +#include <spa/param/audio/format-utils.h> +#include <spa/utils/names.h> +#include <spa/utils/result.h> +#include <spa/utils/string.h> + +#define M_PI_M2 ( M_PI + M_PI ) + +static SPA_LOG_IMPL(default_log); + +#define spa_debug(f,...) spa_log_trace(&default_log.log, f, __VA_ARGS__) + +#include <spa/graph/graph.h> + +#include <spa/debug/pod.h> + +struct buffer { + struct spa_buffer buffer; + struct spa_meta metas[1]; + struct spa_meta_header header; + struct spa_data datas[1]; + struct spa_chunk chunks[1]; +}; + +struct data { + const char *plugin_dir; + struct spa_log *log; + struct spa_system *system; + struct spa_loop *loop; + struct spa_loop_control *control; + struct spa_support support[5]; + uint32_t n_support; + + struct spa_graph graph; + struct spa_graph_state graph_state; + struct spa_graph_node source_node; + struct spa_graph_state source_state; + struct spa_graph_port source_out; + struct spa_graph_port sink_in; + struct spa_graph_node sink_node; + struct spa_graph_state sink_state; + + struct spa_node *sink; + + struct spa_node *source; + struct spa_io_buffers source_sink_io[1]; + struct spa_buffer *source_buffers[1]; + struct buffer source_buffer[1]; + + uint8_t ctrl[1024]; + double freq_accum; + double volume_accum; + + bool running; + pthread_t thread; +}; + +#define MIN_LATENCY 1024 + +#define BUFFER_SIZE 4096 + +static void +init_buffer(struct data *data, struct spa_buffer **bufs, struct buffer *ba, int n_buffers, + size_t size) +{ + int i; + + for (i = 0; i < n_buffers; i++) { + struct buffer *b = &ba[i]; + bufs[i] = &b->buffer; + + b->buffer.metas = b->metas; + b->buffer.n_metas = 1; + b->buffer.datas = b->datas; + b->buffer.n_datas = 1; + + b->header.flags = 0; + b->header.seq = 0; + b->header.pts = 0; + b->header.dts_offset = 0; + b->metas[0].type = SPA_META_Header; + b->metas[0].data = &b->header; + b->metas[0].size = sizeof(b->header); + + b->datas[0].type = SPA_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 = 0; + b->datas[0].chunk->stride = 0; + } +} + +static int make_node(struct data *data, struct spa_node **node, const char *lib, const char *name) +{ + struct spa_handle *handle; + int res; + void *hnd; + spa_handle_factory_enum_func_t enum_func; + uint32_t i; + char *path; + + if ((path = spa_aprintf("%s/%s", data->plugin_dir, lib)) == NULL) { + return -ENOMEM; + } + if ((hnd = dlopen(path, RTLD_NOW)) == NULL) { + printf("can't load %s: %s\n", lib, dlerror()); + free(path); + return -ENOENT; + } + free(path); + if ((enum_func = dlsym(hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) { + printf("can't find enum function\n"); + return -ENOENT; + } + + for (i = 0;;) { + const struct spa_handle_factory *factory; + void *iface; + + if ((res = enum_func(&factory, &i)) <= 0) { + if (res != 0) + printf("can't enumerate factories: %s\n", spa_strerror(res)); + break; + } + if (factory->version < 1) + continue; + if (!spa_streq(factory->name, name)) + continue; + + handle = calloc(1, spa_handle_factory_get_size(factory, NULL)); + 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, SPA_TYPE_INTERFACE_Node, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + *node = iface; + return 0; + } + return -EBADF; +} + +static void update_props(struct data *data) +{ + struct spa_pod_builder b; + struct spa_pod *pod; + struct spa_pod_frame f[2]; + + spa_pod_builder_init(&b, data->ctrl, sizeof(data->ctrl)); + +#if 0 + spa_pod_builder_push_sequence(&b, &f[0], 0); + spa_pod_builder_control(&b, 0, SPA_CONTROL_Properties); + spa_pod_builder_push_object(&b, &f[1], SPA_TYPE_OBJECT_Props, 0); + spa_pod_builder_prop(&b, SPA_PROP_frequency, 0); + spa_pod_builder_float(&b, ((sin(data->freq_accum) + 1.0) * 200.0) + 440.0); + spa_pod_builder_prop(&b, SPA_PROP_volume, 0); + spa_pod_builder_float(&b, (sin(data->volume_accum) / 2.0) + 0.5); + spa_pod_builder_pop(&b, &f[1]); + pod = spa_pod_builder_pop(&b, &f[0]); +#else + spa_pod_builder_push_sequence(&b, &f[0], 0); + spa_pod_builder_control(&b, 0, SPA_CONTROL_Properties); + spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, 0, + SPA_PROP_frequency, SPA_POD_Float(((sin(data->freq_accum) + 1.0) * 200.0) + 440.0), + SPA_PROP_volume, SPA_POD_Float((sin(data->volume_accum) / 2.0) + 0.5)); + pod = spa_pod_builder_pop(&b, &f[0]); +#endif + + spa_debug_pod(0, NULL, pod); + + data->freq_accum += M_PI_M2 / 880.0; + if (data->freq_accum >= M_PI_M2) + data->freq_accum -= M_PI_M2; + + data->volume_accum += M_PI_M2 / 2000.0; + if (data->volume_accum >= M_PI_M2) + data->volume_accum -= M_PI_M2; +} + +static int on_sink_ready(void *_data, int status) +{ + struct data *data = _data; + + update_props(data); + + spa_graph_node_process(&data->source_node); + spa_graph_node_process(&data->sink_node); + return 0; +} + +static int +on_sink_reuse_buffer(void *_data, uint32_t port_id, uint32_t buffer_id) +{ + struct data *data = _data; + + data->source_sink_io[0].buffer_id = buffer_id; + return 0; +} + +static const struct spa_node_callbacks sink_callbacks = { + SPA_VERSION_NODE_CALLBACKS, + .ready = on_sink_ready, + .reuse_buffer = on_sink_reuse_buffer +}; + +static int make_nodes(struct data *data, const char *device) +{ + int res; + struct spa_pod *props; + struct spa_pod_builder b = { 0 }; + uint8_t buffer[512]; + //uint32_t idx; + + if ((res = make_node(data, &data->sink, + "alsa/libspa-alsa.so", + SPA_NAME_API_ALSA_PCM_SINK)) < 0) { + printf("can't create alsa-sink: %d\n", res); + return res; + } + spa_node_set_callbacks(data->sink, &sink_callbacks, data); + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + props = spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, 0, + SPA_PROP_device, SPA_POD_String(device ? device : "hw:0"), + SPA_PROP_minLatency, SPA_POD_Int(MIN_LATENCY)); + + spa_debug_pod(0, NULL, props); + + if ((res = spa_node_set_param(data->sink, SPA_PARAM_Props, 0, props)) < 0) + printf("got set_props error %d\n", res); + + if ((res = make_node(data, &data->source, + "audiotestsrc/libspa-audiotestsrc.so", + "audiotestsrc")) < 0) { + printf("can't create audiotestsrc: %d\n", res); + return res; + } + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + props = spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, 0, + SPA_PROP_frequency, SPA_POD_Float(600.0), + SPA_PROP_volume, SPA_POD_Float(0.5), + SPA_PROP_live, SPA_POD_Bool(false)); + + if ((res = spa_node_set_param(data->source, SPA_PARAM_Props, 0, props)) < 0) + printf("got set_props error %d\n", res); + + if ((res = spa_node_port_set_io(data->source, + SPA_DIRECTION_OUTPUT, 0, + SPA_IO_Control, + &data->ctrl, sizeof(data->ctrl))) < 0) { + printf("can't set_io freq: %d\n", res); + return res; + } + + data->source_sink_io[0] = SPA_IO_BUFFERS_INIT; + + spa_node_port_set_io(data->source, + SPA_DIRECTION_OUTPUT, 0, + SPA_IO_Buffers, + &data->source_sink_io[0], sizeof(data->source_sink_io[0])); + spa_node_port_set_io(data->sink, + SPA_DIRECTION_INPUT, 0, + SPA_IO_Buffers, + &data->source_sink_io[0], sizeof(data->source_sink_io[0])); + + spa_graph_node_init(&data->source_node, &data->source_state); + spa_graph_node_set_callbacks(&data->source_node, &spa_graph_node_impl_default, data->source); + spa_graph_node_add(&data->graph, &data->source_node); + spa_graph_port_init(&data->source_out, SPA_DIRECTION_OUTPUT, 0, 0); + spa_graph_port_add(&data->source_node, &data->source_out); + + spa_graph_node_init(&data->sink_node, &data->sink_state); + spa_graph_node_set_callbacks(&data->sink_node, &spa_graph_node_impl_default, data->sink); + spa_graph_node_add(&data->graph, &data->sink_node); + spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0); + spa_graph_port_add(&data->sink_node, &data->sink_in); + + spa_graph_port_link(&data->source_out, &data->sink_in); + + return res; +} + +static int negotiate_formats(struct data *data) +{ + int res; + struct spa_pod *format; + struct spa_pod_builder b = { 0 }; + uint8_t buffer[4096]; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + format = spa_format_audio_raw_build(&b, 0, + &SPA_AUDIO_INFO_RAW_INIT( + .format = SPA_AUDIO_FORMAT_S16, + .rate = 48000, + .channels = 2 )); + + if ((res = spa_node_port_set_param(data->sink, + SPA_DIRECTION_INPUT, 0, + SPA_PARAM_Format, 0, format)) < 0) + return res; + + if ((res = spa_node_port_set_param(data->source, + SPA_DIRECTION_OUTPUT, 0, + SPA_PARAM_Format, 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, 0, + data->source_buffers, 1)) < 0) + return res; + if ((res = + spa_node_port_use_buffers(data->source, + SPA_DIRECTION_OUTPUT, 0, 0, + data->source_buffers, 1)) < 0) + return res; + + return 0; +} + +static void *loop(void *user_data) +{ + struct data *data = user_data; + + printf("enter thread\n"); + spa_loop_control_enter(data->control); + + while (data->running) { + spa_loop_control_iterate(data->control, -1); + } + + printf("leave thread\n"); + spa_loop_control_leave(data->control); + + return NULL; +} + +static void run_async_sink(struct data *data) +{ + int res, err; + struct spa_command cmd; + + cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start); + if ((res = spa_node_send_command(data->sink, &cmd)) < 0) + printf("got error %d\n", res); + + spa_loop_control_leave(data->control); + + 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; + } + + printf("sleeping for 1000 seconds\n"); + sleep(1000); + + if (data->running) { + data->running = false; + pthread_join(data->thread, NULL); + } + + spa_loop_control_enter(data->control); + + cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause); + if ((res = spa_node_send_command(data->sink, &cmd)) < 0) + printf("got error %d\n", res); +} + +static int load_handle(struct data *data, struct spa_handle **handle, const char *lib, const char *name) +{ + int res; + void *hnd; + spa_handle_factory_enum_func_t enum_func; + uint32_t i; + char *path; + + if ((path = spa_aprintf("%s/%s", data->plugin_dir, lib)) == NULL) { + return -ENOMEM; + } + if ((hnd = dlopen(path, RTLD_NOW)) == NULL) { + printf("can't load %s: %s\n", lib, dlerror()); + free(path); + return -ENOENT; + } + free(path); + if ((enum_func = dlsym(hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) { + printf("can't find enum function\n"); + return -ENOENT; + } + + for (i = 0;;) { + const struct spa_handle_factory *factory; + + if ((res = enum_func(&factory, &i)) <= 0) { + if (res != 0) + printf("can't enumerate factories: %s\n", spa_strerror(res)); + break; + } + if (factory->version < 1) + continue; + if (!spa_streq(factory->name, name)) + continue; + + *handle = calloc(1, spa_handle_factory_get_size(factory, NULL)); + 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; + } + return 0; + } + return -EBADF; +} + +int init_data(struct data *data) +{ + int res; + const char *str; + struct spa_handle *handle = NULL; + void *iface; + + if ((str = getenv("SPA_PLUGIN_DIR")) == NULL) + str = PLUGINDIR; + data->plugin_dir = str; + + /* init the graph */ + spa_graph_init(&data->graph, &data->graph_state); + + /* set the default log */ + data->log = &default_log.log; + data->support[data->n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Log, data->log); + + /* load and set support system */ + if ((res = load_handle(data, &handle, + "support/libspa-support.so", + SPA_NAME_SUPPORT_SYSTEM)) < 0) + return res; + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_System, &iface)) < 0) { + printf("can't get System interface %d\n", res); + return res; + } + data->system = iface; + data->support[data->n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_System, data->system); + data->support[data->n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_DataSystem, data->system); + + /* load and set support loop and loop control */ + if ((res = load_handle(data, &handle, + "support/libspa-support.so", + SPA_NAME_SUPPORT_LOOP)) < 0) + return res; + + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_Loop, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + data->loop = iface; + data->support[data->n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Loop, data->loop); + data->support[data->n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_DataLoop, data->loop); + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_LoopControl, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + data->control = iface; + + if ((str = getenv("SPA_DEBUG"))) + data->log->level = atoi(str); + + return 0; +} + +int main(int argc, char *argv[]) +{ + struct data data = { NULL }; + int res; + + if ((res = init_data(&data)) < 0) { + printf("can't init data: %d (%s)\n", res, spa_strerror(res)); + return -1; + } + + if ((res = make_nodes(&data, argc > 1 ? argv[1] : NULL)) < 0) { + printf("can't make nodes: %d (%s)\n", res, spa_strerror(res)); + return -1; + } + if ((res = negotiate_formats(&data)) < 0) { + printf("can't negotiate nodes: %d (%s)\n", res, spa_strerror(res)); + return -1; + } + + spa_loop_control_enter(data.control); + run_async_sink(&data); + spa_loop_control_leave(data.control); + + return 0; +} diff --git a/spa/examples/local-libcamera.c b/spa/examples/local-libcamera.c new file mode 100644 index 0000000..88ad02b --- /dev/null +++ b/spa/examples/local-libcamera.c @@ -0,0 +1,562 @@ +/* Spa + * + * Copyright (C) 2020, Collabora Ltd. + * Author: Raghavendra Rao Sidlagatta <raghavendra.rao@collabora.com> + * + * local-libcamera.c + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +/* + [title] + Example using libspa-libcamera, with only \ref api_spa + [title] + */ + +#include "config.h" + +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <dlfcn.h> +#include <poll.h> +#include <pthread.h> +#include <errno.h> +#include <sys/mman.h> + +#include <SDL2/SDL.h> + +#include <spa/support/plugin.h> +#include <spa/utils/names.h> +#include <spa/utils/result.h> +#include <spa/utils/string.h> +#include <spa/support/log-impl.h> +#include <spa/support/loop.h> +#include <spa/node/node.h> +#include <spa/node/io.h> +#include <spa/node/utils.h> +#include <spa/param/param.h> +#include <spa/param/props.h> +#include <spa/param/video/format-utils.h> +#include <spa/debug/pod.h> + +#define WIDTH 640 +#define HEIGHT 480 + +static SPA_LOG_IMPL(default_log); + +#define MAX_BUFFERS 8 + +#define USE_BUFFER false + +struct buffer { + struct spa_buffer buffer; + struct spa_meta metas[1]; + struct spa_meta_header header; + struct spa_data datas[1]; + struct spa_chunk chunks[1]; + SDL_Texture *texture; +}; + +struct data { + const char *plugin_dir; + struct spa_log *log; + struct spa_system *system; + struct spa_loop *loop; + struct spa_loop_control *control; + + struct spa_support support[5]; + uint32_t n_support; + + struct spa_node *source; + struct spa_hook listener; + struct spa_io_buffers source_output[1]; + + SDL_Renderer *renderer; + SDL_Window *window; + SDL_Texture *texture; + + bool use_buffer; + + bool running; + pthread_t thread; + + struct spa_buffer *bp[MAX_BUFFERS]; + struct buffer buffers[MAX_BUFFERS]; + unsigned int n_buffers; +}; + +static int load_handle(struct data *data, struct spa_handle **handle, const char *lib, const char *name) +{ + int res; + void *hnd; + spa_handle_factory_enum_func_t enum_func; + uint32_t i; + + char *path = NULL; + + if ((path = spa_aprintf("%s/%s", data->plugin_dir, lib)) == NULL) { + return -ENOMEM; + } + if ((hnd = dlopen(path, RTLD_NOW)) == NULL) { + printf("can't load %s: %s\n", path, dlerror()); + free(path); + return -errno; + } + free(path); + if ((enum_func = dlsym(hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) { + printf("can't find enum function\n"); + return -errno; + } + + for (i = 0;;) { + const struct spa_handle_factory *factory; + + if ((res = enum_func(&factory, &i)) <= 0) { + if (res != 0) + printf("can't enumerate factories: %s\n", spa_strerror(res)); + break; + } + if (!spa_streq(factory->name, name)) + continue; + + *handle = calloc(1, spa_handle_factory_get_size(factory, NULL)); + 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; + } + return 0; + } + return -EBADF; +} + +static int make_node(struct data *data, struct spa_node **node, const char *lib, const char *name) +{ + struct spa_handle *handle = NULL; + void *iface; + int res; + + if ((res = load_handle(data, &handle, lib, name)) < 0) + return res; + + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_Node, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + *node = iface; + return 0; +} + +static int on_source_ready(void *_data, int status) +{ + struct data *data = _data; + int res; + struct buffer *b; + void *sdata, *ddata; + int sstride, dstride; + int i; + uint8_t *src, *dst; + struct spa_data *datas; + struct spa_io_buffers *io = &data->source_output[0]; + + if (io->status != SPA_STATUS_HAVE_DATA || + io->buffer_id >= MAX_BUFFERS) + return -EINVAL; + + b = &data->buffers[io->buffer_id]; + io->status = SPA_STATUS_NEED_DATA; + + datas = b->buffer.datas; + + if (b->texture) { + SDL_Texture *texture = b->texture; + + SDL_UnlockTexture(texture); + + SDL_RenderClear(data->renderer); + SDL_RenderCopy(data->renderer, texture, NULL, NULL); + SDL_RenderPresent(data->renderer); + + if (SDL_LockTexture(texture, NULL, &sdata, &sstride) < 0) { + fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError()); + return -EIO; + } + } else { + uint8_t *map; + + if (SDL_LockTexture(data->texture, NULL, &ddata, &dstride) < 0) { + fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError()); + return -EIO; + } + sdata = datas[0].data; + if (datas[0].type == SPA_DATA_MemFd || + datas[0].type == SPA_DATA_DmaBuf) { + map = mmap(NULL, datas[0].maxsize + datas[0].mapoffset, PROT_READ, + MAP_PRIVATE, datas[0].fd, 0); + if (map == MAP_FAILED) + return -errno; + sdata = SPA_PTROFF(map, datas[0].mapoffset, uint8_t); + } else if (datas[0].type == SPA_DATA_MemPtr) { + map = NULL; + sdata = datas[0].data; + } else + return -EIO; + + sstride = datas[0].chunk->stride; + + for (i = 0; i < HEIGHT; i++) { + src = ((uint8_t *) sdata + i * sstride); + dst = ((uint8_t *) ddata + i * dstride); + memcpy(dst, src, SPA_MIN(sstride, dstride)); + } + SDL_UnlockTexture(data->texture); + + SDL_RenderClear(data->renderer); + SDL_RenderCopy(data->renderer, data->texture, NULL, NULL); + SDL_RenderPresent(data->renderer); + + if (map) + munmap(map, datas[0].maxsize + datas[0].mapoffset); + } + + if ((res = spa_node_process(data->source)) < 0) + printf("got process error %d\n", res); + + return 0; +} + +static const struct spa_node_callbacks source_callbacks = { + SPA_VERSION_NODE_CALLBACKS, + .ready = on_source_ready, +}; + +static int make_nodes(struct data *data, const char *device) +{ + int res; + struct spa_pod *props; + struct spa_pod_builder b = { 0 }; + uint8_t buffer[256]; + uint32_t index; + + if ((res = + make_node(data, &data->source, + "libcamera/libspa-libcamera.so", + SPA_NAME_API_LIBCAMERA_SOURCE)) < 0) { + printf("can't create libcamera-source: %d\n", res); + return res; + } + + spa_node_set_callbacks(data->source, &source_callbacks, data); + + index = 0; + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + if ((res = spa_node_enum_params_sync(data->source, SPA_PARAM_Props, + &index, NULL, &props, &b)) == 1) { + spa_debug_pod(0, NULL, props); + } + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + props = spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, 0, + SPA_PROP_device, SPA_POD_String(device ? device : "/dev/media0")); + + if ((res = spa_node_set_param(data->source, SPA_PARAM_Props, 0, props)) < 0) + printf("got set_props error %d\n", res); + + return res; +} + +static int setup_buffers(struct data *data) +{ + int i; + + for (i = 0; i < MAX_BUFFERS; i++) { + struct buffer *b = &data->buffers[i]; + + data->bp[i] = &b->buffer; + + b->texture = NULL; + + b->buffer.metas = b->metas; + b->buffer.n_metas = 1; + b->buffer.datas = b->datas; + b->buffer.n_datas = 1; + + b->header.flags = 0; + b->header.seq = 0; + b->header.pts = 0; + b->header.dts_offset = 0; + b->metas[0].type = SPA_META_Header; + b->metas[0].data = &b->header; + b->metas[0].size = sizeof(b->header); + + b->datas[0].type = SPA_DATA_DmaBuf; + b->datas[0].flags = 0; + b->datas[0].fd = -1; + b->datas[0].mapoffset = 0; + b->datas[0].maxsize = 0; + b->datas[0].data = NULL; + b->datas[0].chunk = &b->chunks[0]; + b->datas[0].chunk->offset = 0; + b->datas[0].chunk->size = 0; + b->datas[0].chunk->stride = 0; + } + data->n_buffers = MAX_BUFFERS; + return 0; +} + +static int sdl_alloc_buffers(struct data *data) +{ + int i; + + for (i = 0; i < MAX_BUFFERS; i++) { + struct buffer *b = &data->buffers[i]; + SDL_Texture *texture; + void *ptr; + int stride; + + texture = SDL_CreateTexture(data->renderer, + SDL_PIXELFORMAT_YUY2, + SDL_TEXTUREACCESS_STREAMING, WIDTH, HEIGHT); + if (!texture) { + printf("can't create texture: %s\n", SDL_GetError()); + return -ENOMEM; + } + if (SDL_LockTexture(texture, NULL, &ptr, &stride) < 0) { + fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError()); + return -EIO; + } + b->texture = texture; + + b->datas[0].type = SPA_DATA_DmaBuf; + b->datas[0].maxsize = stride * HEIGHT; + b->datas[0].data = ptr; + b->datas[0].chunk->offset = 0; + b->datas[0].chunk->size = stride * HEIGHT; + b->datas[0].chunk->stride = stride; + } + return 0; +} + +static int negotiate_formats(struct data *data) +{ + int res; + struct spa_pod *format; + uint8_t buffer[256]; + struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer)); + + data->source_output[0] = SPA_IO_BUFFERS_INIT; + + if ((res = + spa_node_port_set_io(data->source, + SPA_DIRECTION_OUTPUT, 0, + SPA_IO_Buffers, + &data->source_output[0], sizeof(data->source_output[0]))) < 0) + return res; + + format = spa_format_video_raw_build(&b, 0, + &SPA_VIDEO_INFO_RAW_INIT( + .format = SPA_VIDEO_FORMAT_YUY2, + .size = SPA_RECTANGLE(WIDTH, HEIGHT), + .framerate = SPA_FRACTION(25,1))); + + if ((res = spa_node_port_set_param(data->source, + SPA_DIRECTION_OUTPUT, 0, + SPA_PARAM_Format, 0, + format)) < 0) + return res; + + + setup_buffers(data); + + if (data->use_buffer) { + if ((res = sdl_alloc_buffers(data)) < 0) + return res; + + if ((res = spa_node_port_use_buffers(data->source, + SPA_DIRECTION_OUTPUT, 0, 0, + data->bp, data->n_buffers)) < 0) { + printf("can't allocate buffers: %s\n", spa_strerror(res)); + return -1; + } + } else { + unsigned int n_buffers; + + data->texture = SDL_CreateTexture(data->renderer, + SDL_PIXELFORMAT_YUY2, + SDL_TEXTUREACCESS_STREAMING, WIDTH, HEIGHT); + if (!data->texture) { + printf("can't create texture: %s\n", SDL_GetError()); + return -1; + } + n_buffers = MAX_BUFFERS; + if ((res = spa_node_port_use_buffers(data->source, + SPA_DIRECTION_OUTPUT, 0, + SPA_NODE_BUFFERS_FLAG_ALLOC, + data->bp, n_buffers)) < 0) { + printf("can't allocate buffers: %s\n", spa_strerror(res)); + return -1; + } + data->n_buffers = n_buffers; + } + return 0; +} + +static void *loop(void *user_data) +{ + struct data *data = user_data; + + printf("enter thread\n"); + spa_loop_control_enter(data->control); + + while (data->running) { + spa_loop_control_iterate(data->control, -1); + } + + printf("leave thread\n"); + spa_loop_control_leave(data->control); + return NULL; +} + +static void run_async_source(struct data *data) +{ + int res, err; + struct spa_command cmd; + SDL_Event event; + bool running = true; + + printf("starting...\n\n"); + cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start); + if ((res = spa_node_send_command(data->source, &cmd)) < 0) + printf("got error %d\n", res); + + spa_loop_control_leave(data->control); + + 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; + } + + while (running && SDL_WaitEvent(&event)) { + switch (event.type) { + case SDL_QUIT: + running = false; + break; + } + } + + if (data->running) { + data->running = false; + pthread_join(data->thread, NULL); + } + + spa_loop_control_enter(data->control); + + printf("pausing...\n\n"); + cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause); + if ((res = spa_node_send_command(data->source, &cmd)) < 0) + printf("got error %d\n", res); +} + +int main(int argc, char *argv[]) +{ + struct data data = { 0 }; + int res; + const char *str; + struct spa_handle *handle = NULL; + void *iface; + + if ((str = getenv("SPA_PLUGIN_DIR")) == NULL) + str = PLUGINDIR; + data.plugin_dir = str; + + if ((res = load_handle(&data, &handle, + "support/libspa-support.so", + SPA_NAME_SUPPORT_SYSTEM)) < 0) + return res; + + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_System, &iface)) < 0) { + printf("can't get System interface %d\n", res); + return res; + } + data.system = iface; + data.support[data.n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_System, data.system); + + if ((res = load_handle(&data, &handle, + "support/libspa-support.so", + SPA_NAME_SUPPORT_LOOP)) < 0) + return res; + + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_Loop, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + data.loop = iface; + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_LoopControl, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + data.control = iface; + + data.use_buffer = USE_BUFFER; + + data.log = &default_log.log; + + if ((str = getenv("SPA_DEBUG"))) + data.log->level = atoi(str); + + data.support[data.n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Log, data.log); + data.support[data.n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Loop, data.loop); + data.support[data.n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_DataLoop, data.loop); + + if (SDL_Init(SDL_INIT_VIDEO) < 0) { + printf("can't initialize SDL: %s\n", SDL_GetError()); + return -1; + } + + if (SDL_CreateWindowAndRenderer + (WIDTH, HEIGHT, SDL_WINDOW_RESIZABLE, &data.window, &data.renderer)) { + printf("can't create window: %s\n", SDL_GetError()); + return -1; + } + + if ((res = make_nodes(&data, argv[1])) < 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; + } + + spa_loop_control_enter(data.control); + run_async_source(&data); + spa_loop_control_leave(data.control); + + SDL_DestroyRenderer(data.renderer); + + return 0; +} diff --git a/spa/examples/local-v4l2.c b/spa/examples/local-v4l2.c new file mode 100644 index 0000000..bd6de7b --- /dev/null +++ b/spa/examples/local-v4l2.c @@ -0,0 +1,553 @@ +/* Spa + * + * Copyright © 2018 Wim Taymans + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +/* + [title] + Example using libspa-v4l2, with only \ref api_spa + [title] + */ + +#include "config.h" + +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <dlfcn.h> +#include <poll.h> +#include <pthread.h> +#include <errno.h> +#include <sys/mman.h> + +#include <SDL2/SDL.h> + +#include <spa/support/plugin.h> +#include <spa/utils/names.h> +#include <spa/utils/result.h> +#include <spa/utils/string.h> +#include <spa/support/log-impl.h> +#include <spa/support/loop.h> +#include <spa/node/node.h> +#include <spa/node/io.h> +#include <spa/node/utils.h> +#include <spa/param/param.h> +#include <spa/param/props.h> +#include <spa/param/video/format-utils.h> +#include <spa/debug/pod.h> + +static SPA_LOG_IMPL(default_log); + +#define MAX_BUFFERS 8 + +struct buffer { + struct spa_buffer buffer; + struct spa_meta metas[1]; + struct spa_meta_header header; + struct spa_data datas[1]; + struct spa_chunk chunks[1]; + SDL_Texture *texture; +}; + +struct data { + const char *plugin_dir; + struct spa_log *log; + struct spa_system *system; + struct spa_loop *loop; + struct spa_loop_control *control; + + struct spa_support support[5]; + uint32_t n_support; + + struct spa_node *source; + struct spa_hook listener; + struct spa_io_buffers source_output[1]; + + SDL_Renderer *renderer; + SDL_Window *window; + SDL_Texture *texture; + + bool use_buffer; + + bool running; + pthread_t thread; + + struct spa_buffer *bp[MAX_BUFFERS]; + struct buffer buffers[MAX_BUFFERS]; + unsigned int n_buffers; +}; + +static int load_handle(struct data *data, struct spa_handle **handle, const char *lib, const char *name) +{ + int res; + void *hnd; + spa_handle_factory_enum_func_t enum_func; + uint32_t i; + char *path = NULL; + + if ((path = spa_aprintf("%s/%s", data->plugin_dir, lib)) == NULL) { + return -ENOMEM; + } + if ((hnd = dlopen(path, RTLD_NOW)) == NULL) { + printf("can't load %s: %s\n", path, dlerror()); + free(path); + return -ENOENT; + } + free(path); + if ((enum_func = dlsym(hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) { + printf("can't find enum function\n"); + return -ENOENT; + } + + for (i = 0;;) { + const struct spa_handle_factory *factory; + + if ((res = enum_func(&factory, &i)) <= 0) { + if (res != 0) + printf("can't enumerate factories: %s\n", spa_strerror(res)); + break; + } + if (factory->version < 1) + continue; + if (!spa_streq(factory->name, name)) + continue; + + *handle = calloc(1, spa_handle_factory_get_size(factory, NULL)); + 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; + } + return 0; + } + return -EBADF; +} + +static int make_node(struct data *data, struct spa_node **node, const char *lib, const char *name) +{ + struct spa_handle *handle = NULL; + void *iface; + int res; + + if ((res = load_handle(data, &handle, lib, name)) < 0) + return res; + + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_Node, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + *node = iface; + return 0; +} + +static int on_source_ready(void *_data, int status) +{ + struct data *data = _data; + int res; + struct buffer *b; + void *sdata, *ddata; + int sstride, dstride; + int i; + uint8_t *src, *dst; + struct spa_data *datas; + struct spa_io_buffers *io = &data->source_output[0]; + + if (io->status != SPA_STATUS_HAVE_DATA || + io->buffer_id >= MAX_BUFFERS) + return -EINVAL; + + b = &data->buffers[io->buffer_id]; + io->status = SPA_STATUS_NEED_DATA; + + datas = b->buffer.datas; + + if (b->texture) { + SDL_Texture *texture = b->texture; + + SDL_UnlockTexture(texture); + + SDL_RenderClear(data->renderer); + SDL_RenderCopy(data->renderer, texture, NULL, NULL); + SDL_RenderPresent(data->renderer); + + if (SDL_LockTexture(texture, NULL, &sdata, &sstride) < 0) { + fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError()); + return -EIO; + } + } else { + uint8_t *map; + + if (SDL_LockTexture(data->texture, NULL, &ddata, &dstride) < 0) { + fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError()); + return -EIO; + } + sdata = datas[0].data; + if (datas[0].type == SPA_DATA_MemFd || + datas[0].type == SPA_DATA_DmaBuf) { + map = mmap(NULL, datas[0].maxsize + datas[0].mapoffset, PROT_READ, + MAP_PRIVATE, datas[0].fd, 0); + if (map == MAP_FAILED) + return -errno; + sdata = SPA_PTROFF(map, datas[0].mapoffset, uint8_t); + } else if (datas[0].type == SPA_DATA_MemPtr) { + map = NULL; + sdata = datas[0].data; + } else + return -EIO; + + sstride = datas[0].chunk->stride; + + for (i = 0; i < 240; i++) { + src = ((uint8_t *) sdata + i * sstride); + dst = ((uint8_t *) ddata + i * dstride); + memcpy(dst, src, SPA_MIN(sstride, dstride)); + } + SDL_UnlockTexture(data->texture); + + SDL_RenderClear(data->renderer); + SDL_RenderCopy(data->renderer, data->texture, NULL, NULL); + SDL_RenderPresent(data->renderer); + + if (map) + munmap(map, datas[0].maxsize + datas[0].mapoffset); + } + + if ((res = spa_node_process(data->source)) < 0) + printf("got process error %d\n", res); + + return 0; +} + +static const struct spa_node_callbacks source_callbacks = { + SPA_VERSION_NODE_CALLBACKS, + .ready = on_source_ready, +}; + +static int make_nodes(struct data *data, const char *device) +{ + int res; + struct spa_pod *props; + struct spa_pod_builder b = { 0 }; + uint8_t buffer[256]; + uint32_t index; + + if ((res = + make_node(data, &data->source, + "v4l2/libspa-v4l2.so", + SPA_NAME_API_V4L2_SOURCE)) < 0) { + printf("can't create v4l2-source: %d\n", res); + return res; + } + + spa_node_set_callbacks(data->source, &source_callbacks, data); + + index = 0; + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + if ((res = spa_node_enum_params_sync(data->source, SPA_PARAM_Props, + &index, NULL, &props, &b)) == 1) { + spa_debug_pod(0, NULL, props); + } + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + props = spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, 0, + SPA_PROP_device, SPA_POD_String(device ? device : "/dev/video0")); + + if ((res = spa_node_set_param(data->source, SPA_PARAM_Props, 0, props)) < 0) + printf("got set_props error %d\n", res); + + return res; +} + +static int setup_buffers(struct data *data) +{ + int i; + + for (i = 0; i < MAX_BUFFERS; i++) { + struct buffer *b = &data->buffers[i]; + + data->bp[i] = &b->buffer; + + b->texture = NULL; + + b->buffer.metas = b->metas; + b->buffer.n_metas = 1; + b->buffer.datas = b->datas; + b->buffer.n_datas = 1; + + b->header.flags = 0; + b->header.seq = 0; + b->header.pts = 0; + b->header.dts_offset = 0; + b->metas[0].type = SPA_META_Header; + b->metas[0].data = &b->header; + b->metas[0].size = sizeof(b->header); + + b->datas[0].type = 0; + b->datas[0].flags = 0; + b->datas[0].fd = -1; + b->datas[0].mapoffset = 0; + b->datas[0].maxsize = 0; + b->datas[0].data = NULL; + b->datas[0].chunk = &b->chunks[0]; + b->datas[0].chunk->offset = 0; + b->datas[0].chunk->size = 0; + b->datas[0].chunk->stride = 0; + } + data->n_buffers = MAX_BUFFERS; + return 0; +} + +static int sdl_alloc_buffers(struct data *data) +{ + int i; + + for (i = 0; i < MAX_BUFFERS; i++) { + struct buffer *b = &data->buffers[i]; + SDL_Texture *texture; + void *ptr; + int stride; + + texture = SDL_CreateTexture(data->renderer, + SDL_PIXELFORMAT_YUY2, + SDL_TEXTUREACCESS_STREAMING, 320, 240); + if (!texture) { + printf("can't create texture: %s\n", SDL_GetError()); + return -ENOMEM; + } + if (SDL_LockTexture(texture, NULL, &ptr, &stride) < 0) { + fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError()); + return -EIO; + } + b->texture = texture; + + b->datas[0].type = SPA_DATA_MemPtr; + b->datas[0].maxsize = stride * 240; + b->datas[0].data = ptr; + b->datas[0].chunk->offset = 0; + b->datas[0].chunk->size = stride * 240; + b->datas[0].chunk->stride = stride; + } + return 0; +} + +static int negotiate_formats(struct data *data) +{ + int res; + struct spa_pod *format; + uint8_t buffer[256]; + struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer)); + + data->source_output[0] = SPA_IO_BUFFERS_INIT; + + if ((res = + spa_node_port_set_io(data->source, + SPA_DIRECTION_OUTPUT, 0, + SPA_IO_Buffers, + &data->source_output[0], sizeof(data->source_output[0]))) < 0) + return res; + + format = spa_format_video_raw_build(&b, 0, + &SPA_VIDEO_INFO_RAW_INIT( + .format = SPA_VIDEO_FORMAT_YUY2, + .size = SPA_RECTANGLE(320, 240), + .framerate = SPA_FRACTION(25,1))); + + if ((res = spa_node_port_set_param(data->source, + SPA_DIRECTION_OUTPUT, 0, + SPA_PARAM_Format, 0, + format)) < 0) + return res; + + + setup_buffers(data); + + if (data->use_buffer) { + if ((res = sdl_alloc_buffers(data)) < 0) + return res; + + if ((res = spa_node_port_use_buffers(data->source, + SPA_DIRECTION_OUTPUT, 0, 0, + data->bp, data->n_buffers)) < 0) { + printf("can't allocate buffers: %s\n", spa_strerror(res)); + return -1; + } + } else { + unsigned int n_buffers; + + data->texture = SDL_CreateTexture(data->renderer, + SDL_PIXELFORMAT_YUY2, + SDL_TEXTUREACCESS_STREAMING, 320, 240); + if (!data->texture) { + printf("can't create texture: %s\n", SDL_GetError()); + return -1; + } + n_buffers = MAX_BUFFERS; + if ((res = spa_node_port_use_buffers(data->source, + SPA_DIRECTION_OUTPUT, 0, + SPA_NODE_BUFFERS_FLAG_ALLOC, + data->bp, n_buffers)) < 0) { + printf("can't allocate buffers: %s\n", spa_strerror(res)); + return -1; + } + data->n_buffers = n_buffers; + } + return 0; +} + +static void *loop(void *user_data) +{ + struct data *data = user_data; + + printf("enter thread\n"); + spa_loop_control_enter(data->control); + + while (data->running) { + spa_loop_control_iterate(data->control, -1); + } + + printf("leave thread\n"); + spa_loop_control_leave(data->control); + return NULL; +} + +static void run_async_source(struct data *data) +{ + int res, err; + struct spa_command cmd; + SDL_Event event; + bool running = true; + + cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Start); + if ((res = spa_node_send_command(data->source, &cmd)) < 0) + printf("got error %d\n", res); + + spa_loop_control_leave(data->control); + + 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; + } + + while (running && SDL_WaitEvent(&event)) { + switch (event.type) { + case SDL_QUIT: + running = false; + break; + } + } + + if (data->running) { + data->running = false; + pthread_join(data->thread, NULL); + } + + spa_loop_control_enter(data->control); + + cmd = SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Pause); + if ((res = spa_node_send_command(data->source, &cmd)) < 0) + printf("got error %d\n", res); +} + +int main(int argc, char *argv[]) +{ + struct data data = { 0 }; + int res; + const char *str; + struct spa_handle *handle = NULL; + void *iface; + + if ((str = getenv("SPA_PLUGIN_DIR")) == NULL) + str = PLUGINDIR; + data.plugin_dir = str; + + if ((res = load_handle(&data, &handle, + "support/libspa-support.so", + SPA_NAME_SUPPORT_SYSTEM)) < 0) + return res; + + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_System, &iface)) < 0) { + printf("can't get System interface %d\n", res); + return res; + } + data.system = iface; + data.support[data.n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_System, data.system); + + if ((res = load_handle(&data, &handle, + "support/libspa-support.so", + SPA_NAME_SUPPORT_LOOP)) < 0) + return res; + + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_Loop, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + data.loop = iface; + if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_LoopControl, &iface)) < 0) { + printf("can't get interface %d\n", res); + return res; + } + data.control = iface; + + data.use_buffer = true; + + data.log = &default_log.log; + + if ((str = getenv("SPA_DEBUG"))) + data.log->level = atoi(str); + + data.support[data.n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Log, data.log); + data.support[data.n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Loop, data.loop); + data.support[data.n_support++] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_DataLoop, data.loop); + + if (SDL_Init(SDL_INIT_VIDEO) < 0) { + printf("can't initialize SDL: %s\n", SDL_GetError()); + return -1; + } + + if (SDL_CreateWindowAndRenderer + (320, 240, SDL_WINDOW_RESIZABLE, &data.window, &data.renderer)) { + printf("can't create window: %s\n", SDL_GetError()); + return -1; + } + + + if ((res = make_nodes(&data, argv[1])) < 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; + } + + spa_loop_control_enter(data.control); + run_async_source(&data); + spa_loop_control_leave(data.control); + + SDL_DestroyRenderer(data.renderer); + + return 0; +} diff --git a/spa/examples/meson.build b/spa/examples/meson.build new file mode 100644 index 0000000..7064a06 --- /dev/null +++ b/spa/examples/meson.build @@ -0,0 +1,32 @@ +# Examples, in order from simple to complicated +spa_examples = [ + 'adapter-control', + 'example-control', + 'local-libcamera', + 'local-v4l2', +] + +spa_examples_extra_deps = { + 'local-v4l2': [sdl_dep], + 'local-libcamera': [sdl_dep, libcamera_dep], +} + +foreach c : spa_examples + deps = spa_examples_extra_deps.get(c, []) + + found = true + foreach dep : deps + found = found and dep.found() + endforeach + + if found + executable( + c, + c + '.c', + include_directories : [configinc], + dependencies : [spa_dep, dl_lib, pthread_lib, mathlib] + deps, + install : installed_tests_enabled, + install_dir : installed_tests_execdir / 'examples' / 'spa' + ) + endif +endforeach |