#include "config.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
#include <errno.h>
#include <pthread.h>
#include <poll.h>
#define MIN_LATENCY 1024
struct buffer {
};
struct data {
const char *plugin_dir;
uint32_t n_support;
struct buffer source_buffer[1];
uint8_t ctrl[1024];
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;
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;
}
printf("can't find enum function\n");
res = -ENOENT;
goto exit_cleanup;
}
for (i = 0;;) {
if ((res = enum_func(&factory, &i)) <= 0) {
if (res != 0)
printf(
"can't enumerate factories: %s\n",
spa_strerror(res));
break;
}
continue;
continue;
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;
void *iface;
if ((str = getenv("SPA_PLUGIN_DIR")) == NULL)
str = PLUGINDIR;
data->plugin_dir = str;
data->log = &default_log.log;
if ((res = load_handle(data, &handle,
"support/libspa-support.so",
return res;
printf("can't get System interface %d\n", res);
return res;
}
data->system = iface;
if ((res = load_handle(data, &handle,
"support/libspa-support.so",
return res;
printf("can't get interface %d\n", res);
return res;
}
data->loop = iface;
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)
{
int res = 0;
void *hnd = NULL;
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;
}
printf("can't find enum function\n");
res = -ENOENT;
goto exit_cleanup;
}
for (i = 0;;) {
void *iface;
if ((res = enum_func(&factory, &i)) <= 0) {
if (res != 0)
printf(
"can't enumerate factories: %s\n",
spa_strerror(res));
break;
}
continue;
continue;
if ((res =
data->n_support)) < 0) {
printf("can't make factory instance: %d\n", res);
goto exit_cleanup;
}
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 on_sink_node_ready(void *_data, int status)
{
struct data *data = _data;
return 0;
}
static int
on_sink_node_reuse_buffer(void *_data, uint32_t port_id, uint32_t buffer_id)
{
struct data *data = _data;
printf ("reuse_buffer: port_id=%d\n", port_id);
data->source_sink_io[0].buffer_id = buffer_id;
return 0;
}
.ready = on_sink_node_ready,
.reuse_buffer = on_sink_node_reuse_buffer
};
static int make_nodes(struct data *data, const char *device)
{
int res = 0;
uint8_t buffer[1024];
char value[32];
if ((res = make_node(data, &data->source_follower_node,
"audiotestsrc/libspa-audiotestsrc.so",
"audiotestsrc",
NULL)) < 0) {
printf("can't create source follower node (audiotestsrc): %d\n", res);
return res;
}
.rate = 48000,
.channels = 2 ));
printf("can't set format on follower node (audiotestsrc): %d\n", res);
return res;
}
snprintf(value, sizeof(value), "pointer:%p", data->source_follower_node);
if ((res = make_node(data, &data->source_node,
"audioconvert/libspa-audioconvert.so",
printf("can't create source adapter node: %d\n", res);
return res;
}
printf("can't setup source follower node %d\n", res);
return res;
}
info.channels = 1;
info.rate = 48000;
printf("can't setup source node %d\n", res);
return res;
}
if ((res = make_node(data, &data->sink_follower_node,
"alsa/libspa-alsa.so",
NULL)) < 0) {
printf("can't create sink follower node (alsa-pcm-sink): %d\n", res);
return res;
}
snprintf(value, sizeof(value), "pointer:%p", data->sink_follower_node);
if ((res = make_node(data, &data->sink_node,
"audioconvert/libspa-audioconvert.so",
printf("can't create sink adapter node: %d\n", res);
return res;
}
printf("can't setup sink follower node %d\n", res);
return res;
}
info.channels = 1;
info.rate = 48000;
printf("can't setup sink node %d\n", res);
return res;
}
&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;
}
&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;
}
return res;
}
static void
init_buffer(
struct data *data,
struct spa_buffer **bufs,
struct buffer *ba,
int n_buffers,
{
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].data = &b->header;
b->metas[0].size = sizeof(b->header);
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;
uint8_t buffer[4096];
size_t buffer_size = 1024;
return -ENOTSUP;
return res;
return res;
return res;
init_buffer(
data,
data->source_buffers,
data->source_buffer, 1, buffer_size);
return res;
return res;
return 0;
}
static void *loop(void *user_data)
{
struct data *data = user_data;
printf("enter thread\n");
while (data->running) {
}
printf("leave thread\n");
return NULL;
return NULL;
}
static void run_async_sink(struct data *data)
{
int res, err;
printf("got error %d\n", res);
printf("got error %d\n", res);
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);
}
printf("got error %d\n", res);
printf("got error %d\n", res);
}
int main(int argc, char *argv[])
{
struct data data = { 0 };
int res = 0;
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;
}
run_async_sink(&data);
}