mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-07 13:30:09 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Use errno for result errors

Browse source 
Make new enumeration for data transport status and use errno
style error numbers for errors.
This commit is contained in:
Wim Taymans 2017-11-13 09:41:41 +01:00
parent dda28b1589
commit 6fb0f580ea
86 changed files with 2019 additions and 1988 deletions
Download patch file Download diff file Expand all files Collapse all files

49
src/examples/export-sink.c
View file

@ -17,6 +17,7 @@
* Boston, MA 02110-1301, USA.
*/
#include <errno.h>
#include <stdio.h>
#include <sys/mman.h>
@ -179,7 +180,7 @@ static Uint32 id_to_sdl_format(struct data *data, uint32_t id)
static int impl_send_command(struct spa_node *node, const struct spa_command *command)
{
return SPA_RESULT_OK;
return 0;
}
static int impl_set_callbacks(struct spa_node *node,
@ -188,7 +189,7 @@ static int impl_set_callbacks(struct spa_node *node,
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
d->callbacks = callbacks;
d->callbacks_data = data;
return SPA_RESULT_OK;
return 0;
}
static int impl_get_n_ports(struct spa_node *node,
@ -199,7 +200,7 @@ static int impl_get_n_ports(struct spa_node *node,
{
*n_input_ports = *max_input_ports = 1;
*n_output_ports = *max_output_ports = 0;
return SPA_RESULT_OK;
return 0;
}
static int impl_get_port_ids(struct spa_node *node,
@ -210,7 +211,7 @@ static int impl_get_port_ids(struct spa_node *node,
{
if (n_input_ports > 0)
input_ids[0] = 0;
return SPA_RESULT_OK;
return 0;
}
static int impl_port_set_io(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -218,7 +219,7 @@ static int impl_port_set_io(struct spa_node *node, enum spa_direction direction,
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
d->io = io;
return SPA_RESULT_OK;
return 0;
}
static int impl_port_get_info(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -232,7 +233,7 @@ static int impl_port_get_info(struct spa_node *node, enum spa_direction directio
*info = &d->port_info;
return SPA_RESULT_OK;
return 0;
}
static int port_enum_formats(struct spa_node *node,
@ -246,7 +247,7 @@ static int port_enum_formats(struct spa_node *node,
int i, c;
if (*index != 0)
return SPA_RESULT_ENUM_END;
return 0;
SDL_GetRendererInfo(d->renderer, &info);
@ -287,7 +288,7 @@ static int port_enum_formats(struct spa_node *node,
(*index)++;
return SPA_RESULT_OK;
return 1;
}
static int port_get_format(struct spa_node *node,
@ -299,7 +300,7 @@ static int port_get_format(struct spa_node *node,
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (*index != 0 || d->format.format == 0)
return SPA_RESULT_ENUM_END;
return 0;
spa_pod_builder_object(builder,
d->t->param.idFormat, d->type.format,
@ -311,7 +312,7 @@ static int port_get_format(struct spa_node *node,
(*index)++;
return SPA_RESULT_OK;
return 1;
}
static int impl_port_enum_params(struct spa_node *node,
@ -334,7 +335,7 @@ static int impl_port_enum_params(struct spa_node *node,
id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return SPA_RESULT_ENUM_END;
return 0;
}
else if (id == t->param.idEnumFormat) {
return port_enum_formats(node, direction, port_id, index, filter, builder);
@ -344,7 +345,7 @@ static int impl_port_enum_params(struct spa_node *node,
}
else if (id == t->param.idBuffers) {
if (*index != 0)
return SPA_RESULT_ENUM_END;
return 0;
spa_pod_builder_object(builder,
id, t->param_buffers.Buffers,
@ -356,7 +357,7 @@ static int impl_port_enum_params(struct spa_node *node,
}
else if (id == t->param.idMeta) {
if (*index != 0)
return SPA_RESULT_ENUM_END;
return 0;
spa_pod_builder_object(builder,
id, t->param_meta.Meta,
@ -364,11 +365,11 @@ static int impl_port_enum_params(struct spa_node *node,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
}
else
return SPA_RESULT_UNKNOWN_PARAM;
return -ENOENT;
(*index)++;
return SPA_RESULT_OK;
return 1;
}
static int port_set_format(struct spa_node *node,
@ -380,7 +381,7 @@ static int port_set_format(struct spa_node *node,
void *dest;
if (format == NULL)
return SPA_RESULT_OK;
return 0;
spa_debug_pod(&format->pod, SPA_DEBUG_FLAG_FORMAT);
@ -388,7 +389,7 @@ static int port_set_format(struct spa_node *node,
sdl_format = id_to_sdl_format(d, d->format.format);
if (sdl_format == SDL_PIXELFORMAT_UNKNOWN)
return SPA_RESULT_ERROR;
return -EINVAL;
d->texture = SDL_CreateTexture(d->renderer,
sdl_format,
@ -398,7 +399,7 @@ static int port_set_format(struct spa_node *node,
SDL_LockTexture(d->texture, NULL, &dest, &d->stride);
SDL_UnlockTexture(d->texture);
return SPA_RESULT_OK;
return 0;
}
static int impl_port_set_param(struct spa_node *node,
@ -413,7 +414,7 @@ static int impl_port_set_param(struct spa_node *node,
return port_set_format(node, direction, port_id, flags, param);
}
else
return SPA_RESULT_UNKNOWN_PARAM;
return -ENOENT;
}
static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -424,7 +425,7 @@ static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direc
for (i = 0; i < n_buffers; i++)
d->buffers[i] = buffers[i];
d->n_buffers = n_buffers;
return SPA_RESULT_OK;
return 0;
}
static int impl_node_process_input(struct spa_node *node)
@ -437,7 +438,7 @@ static int impl_node_process_input(struct spa_node *node)
int i;
uint8_t *src, *dst;
if (d->io->status != SPA_RESULT_HAVE_BUFFER)
if (d->io->status != SPA_STATUS_HAVE_BUFFER)
goto done;
if (d->io->buffer_id > d->n_buffers)
@ -454,11 +455,11 @@ static int impl_node_process_input(struct spa_node *node)
map = NULL;
sdata = buf->datas[0].data;
} else
return SPA_RESULT_ERROR;
return -EINVAL;
if (SDL_LockTexture(d->texture, NULL, &ddata, &dstride) < 0) {
fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError());
return SPA_RESULT_ERROR;
return -EIO;
}
sstride = buf->datas[0].chunk->stride;
ostride = SPA_MIN(sstride, dstride);
@ -482,7 +483,7 @@ static int impl_node_process_input(struct spa_node *node)
done:
handle_events(d);
return d->io->status = SPA_RESULT_NEED_BUFFER;
return d->io->status = SPA_STATUS_NEED_BUFFER;
}
static const struct spa_node impl_node = {

57
src/examples/export-source.c
View file

@ -17,6 +17,7 @@
* Boston, MA 02110-1301, USA.
*/
#include <errno.h>
#include <stdio.h>
#include <math.h>
#include <sys/mman.h>
@ -96,7 +97,7 @@ struct data {
static int impl_send_command(struct spa_node *node, const struct spa_command *command)
{
return SPA_RESULT_OK;
return 0;
}
static int impl_set_callbacks(struct spa_node *node,
@ -105,7 +106,7 @@ static int impl_set_callbacks(struct spa_node *node,
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
d->callbacks = callbacks;
d->callbacks_data = data;
return SPA_RESULT_OK;
return 0;
}
static int impl_get_n_ports(struct spa_node *node,
@ -116,7 +117,7 @@ static int impl_get_n_ports(struct spa_node *node,
{
*n_input_ports = *max_input_ports = 0;
*n_output_ports = *max_output_ports = 1;
return SPA_RESULT_OK;
return 0;
}
static int impl_get_port_ids(struct spa_node *node,
@ -127,7 +128,7 @@ static int impl_get_port_ids(struct spa_node *node,
{
if (n_output_ports > 0)
output_ids[0] = 0;
return SPA_RESULT_OK;
return 0;
}
static int impl_port_set_io(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -135,7 +136,7 @@ static int impl_port_set_io(struct spa_node *node, enum spa_direction direction,
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
d->io = io;
return SPA_RESULT_OK;
return 0;
}
static int impl_port_get_info(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -149,7 +150,7 @@ static int impl_port_get_info(struct spa_node *node, enum spa_direction directio
*info = &d->port_info;
return SPA_RESULT_OK;
return 0;
}
static int port_enum_formats(struct spa_node *node,
@ -161,7 +162,7 @@ static int port_enum_formats(struct spa_node *node,
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (*index != 0)
return SPA_RESULT_ENUM_END;
return 0;
spa_pod_builder_object(builder,
d->t->param.idEnumFormat, d->type.format,
@ -173,7 +174,7 @@ static int port_enum_formats(struct spa_node *node,
(*index)++;
return SPA_RESULT_OK;
return 1;
}
static int port_get_format(struct spa_node *node,
@ -185,10 +186,10 @@ static int port_get_format(struct spa_node *node,
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (*index != 0)
return SPA_RESULT_ENUM_END;
return 0;
if (d->format.format == 0)
return SPA_RESULT_ENUM_END;
return 0;
spa_pod_builder_object(builder,
d->t->param.idFormat, d->type.format,
@ -200,7 +201,7 @@ static int port_get_format(struct spa_node *node,
(*index)++;
return SPA_RESULT_OK;
return 1;
}
static int impl_port_enum_params(struct spa_node *node,
@ -223,7 +224,7 @@ static int impl_port_enum_params(struct spa_node *node,
id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return SPA_RESULT_ENUM_END;
return 0;
}
else if (id == t->param.idEnumFormat) {
return port_enum_formats(node, direction, port_id, index, filter, builder);
@ -233,7 +234,7 @@ static int impl_port_enum_params(struct spa_node *node,
}
else if (id == t->param.idBuffers) {
if (*index > 0)
return SPA_RESULT_ENUM_END;
return 0;
spa_pod_builder_object(builder,
id, t->param_buffers.Buffers,
@ -264,15 +265,15 @@ static int impl_port_enum_params(struct spa_node *node,
":", t->param_meta.ringbufferAlign, "i", 16);
break;
default:
return SPA_RESULT_ENUM_END;
return 0;
}
}
else
return SPA_RESULT_UNKNOWN_PARAM;
return -ENOENT;
(*index)++;
return SPA_RESULT_OK;
return 1;
}
static int port_set_format(struct spa_node *node,
@ -283,18 +284,18 @@ static int port_set_format(struct spa_node *node,
if (format == NULL) {
d->format.format = 0;
return SPA_RESULT_OK;
return 0;
}
spa_debug_pod(&format->pod, SPA_DEBUG_FLAG_FORMAT);
if (spa_format_audio_raw_parse(format, &d->format, &d->type.format_audio) < 0)
return SPA_RESULT_INVALID_MEDIA_TYPE;
return -EINVAL;
if (d->format.format != d->type.audio_format.S16)
return SPA_RESULT_ERROR;
return -EINVAL;
return SPA_RESULT_OK;
return 0;
}
static int impl_port_set_param(struct spa_node *node,
@ -309,7 +310,7 @@ static int impl_port_set_param(struct spa_node *node,
return port_set_format(node, direction, port_id, flags, param);
}
else
return SPA_RESULT_UNKNOWN_PARAM;
return -ENOENT;
}
static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -331,7 +332,7 @@ static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direc
MAP_SHARED, datas[0].fd, 0);
if (b->ptr == MAP_FAILED) {
pw_log_error("failed to buffer mem");
return SPA_RESULT_ERROR;
return -errno;
}
b->ptr = SPA_MEMBER(b->ptr, datas[0].mapoffset, void);
@ -339,7 +340,7 @@ static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direc
}
else {
pw_log_error("invalid buffer mem");
return SPA_RESULT_ERROR;
return -EINVAL;
}
b->buffer = buffers[i];
b->rb = spa_buffer_find_meta(buffers[i], d->type.meta.Ringbuffer);
@ -347,7 +348,7 @@ static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direc
spa_list_append(&d->empty, &b->link);
}
d->n_buffers = n_buffers;
return SPA_RESULT_OK;
return 0;
}
static inline void reuse_buffer(struct data *d, uint32_t id)
@ -360,7 +361,7 @@ static int impl_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint3
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
reuse_buffer(d, buffer_id);
return SPA_RESULT_OK;
return 0;
}
static int impl_node_process_output(struct spa_node *node)
@ -378,7 +379,7 @@ static int impl_node_process_output(struct spa_node *node)
}
if (spa_list_is_empty(&d->empty)) {
pw_log_error("sine-source %p: out of buffers", d);
return SPA_RESULT_OUT_OF_BUFFERS;
return -EPIPE;
}
b = spa_list_first(&d->empty, struct buffer, link);
spa_list_remove(&b->link);
@ -424,9 +425,9 @@ static int impl_node_process_output(struct spa_node *node)
}
io->buffer_id = b->buffer->id;
io->status = SPA_RESULT_HAVE_BUFFER;
io->status = SPA_STATUS_HAVE_BUFFER;
return SPA_RESULT_HAVE_BUFFER;
return SPA_STATUS_HAVE_BUFFER;
}
static const struct spa_node impl_node = {

42
src/examples/local-v4l2.c
View file

@ -175,7 +175,7 @@ static Uint32 id_to_sdl_format(struct data *data, uint32_t id)
static int impl_send_command(struct spa_node *node, const struct spa_command *command)
{
return SPA_RESULT_OK;
return 0;
}
static int impl_set_callbacks(struct spa_node *node,
@ -184,7 +184,7 @@ static int impl_set_callbacks(struct spa_node *node,
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
d->callbacks = callbacks;
d->callbacks_data = data;
return SPA_RESULT_OK;
return 0;
}
static int impl_get_n_ports(struct spa_node *node,
@ -195,7 +195,7 @@ static int impl_get_n_ports(struct spa_node *node,
{
*n_input_ports = *max_input_ports = 1;
*n_output_ports = *max_output_ports = 0;
return SPA_RESULT_OK;
return 0;
}
static int impl_get_port_ids(struct spa_node *node,
@ -206,7 +206,7 @@ static int impl_get_port_ids(struct spa_node *node,
{
if (n_input_ports > 0)
input_ids[0] = 0;
return SPA_RESULT_OK;
return 0;
}
static int impl_port_set_io(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -214,7 +214,7 @@ static int impl_port_set_io(struct spa_node *node, enum spa_direction direction,
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
d->io = io;
return SPA_RESULT_OK;
return 0;
}
static int impl_port_get_info(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -228,7 +228,7 @@ static int impl_port_get_info(struct spa_node *node, enum spa_direction directio
*info = &d->port_info;
return SPA_RESULT_OK;
return 0;
}
static int port_enum_formats(struct spa_node *node,
@ -242,7 +242,7 @@ static int port_enum_formats(struct spa_node *node,
int i, c;
if (*index != 0)
return SPA_RESULT_ENUM_END;
return 0;
SDL_GetRendererInfo(d->renderer, &info);
@ -284,7 +284,7 @@ static int port_enum_formats(struct spa_node *node,
(*index)++;
return SPA_RESULT_OK;
return 1;
}
static int impl_port_enum_params(struct spa_node *node,
@ -301,7 +301,7 @@ static int impl_port_enum_params(struct spa_node *node,
}
else if (id == t->param.idBuffers) {
if (*index > 0)
return SPA_RESULT_ENUM_END;
return 0;
spa_pod_builder_object(builder,
id, t->param_buffers.Buffers,
@ -313,7 +313,7 @@ static int impl_port_enum_params(struct spa_node *node,
}
else if (id == t->param.idMeta) {
if (*index > 0)
return SPA_RESULT_ENUM_END;
return 0;
spa_pod_builder_object(builder,
id, t->param_meta.Meta,
@ -321,10 +321,10 @@ static int impl_port_enum_params(struct spa_node *node,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
}
else
return SPA_RESULT_UNKNOWN_PARAM;
return -ENOENT;
(*index)++;
return SPA_RESULT_OK;
return 1;
}
static int port_set_format(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -335,7 +335,7 @@ static int port_set_format(struct spa_node *node, enum spa_direction direction,
void *dest;
if (format == NULL)
return SPA_RESULT_OK;
return 0;
spa_debug_pod(&format->pod, SPA_DEBUG_FLAG_FORMAT);
@ -343,7 +343,7 @@ static int port_set_format(struct spa_node *node, enum spa_direction direction,
sdl_format = id_to_sdl_format(d, d->format.format);
if (sdl_format == SDL_PIXELFORMAT_UNKNOWN)
return SPA_RESULT_ERROR;
return -EINVAL;
d->texture = SDL_CreateTexture(d->renderer,
sdl_format,
@ -353,7 +353,7 @@ static int port_set_format(struct spa_node *node, enum spa_direction direction,
SDL_LockTexture(d->texture, NULL, &dest, &d->stride);
SDL_UnlockTexture(d->texture);
return SPA_RESULT_OK;
return 0;
}
static int impl_port_set_param(struct spa_node *node,
@ -368,7 +368,7 @@ static int impl_port_set_param(struct spa_node *node,
return port_set_format(node, direction, port_id, flags, param);
}
else
return SPA_RESULT_UNKNOWN_PARAM;
return -ENOENT;
}
static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -379,7 +379,7 @@ static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direc
for (i = 0; i < n_buffers; i++)
d->buffers[i] = buffers[i];
d->n_buffers = n_buffers;
return SPA_RESULT_OK;
return 0;
}
static int impl_node_process_input(struct spa_node *node)
@ -403,11 +403,11 @@ static int impl_node_process_input(struct spa_node *node)
map = NULL;
sdata = buf->datas[0].data;
} else
return SPA_RESULT_ERROR;
return -EINVAL;
if (SDL_LockTexture(d->texture, NULL, &ddata, &dstride) < 0) {
fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError());
return SPA_RESULT_ERROR;
return -EIO;
}
sstride = buf->datas[0].chunk->stride;
ostride = SPA_MIN(sstride, dstride);
@ -430,9 +430,9 @@ static int impl_node_process_input(struct spa_node *node)
handle_events(d);
d->io->status = SPA_RESULT_NEED_BUFFER;
d->io->status = SPA_STATUS_NEED_BUFFER;
return SPA_RESULT_NEED_BUFFER;
return SPA_STATUS_NEED_BUFFER;
}
static const struct spa_node impl_node = {

6
src/examples/video-play.c
View file

@ -246,7 +246,7 @@ on_stream_format_changed(void *_data, struct spa_pod_object *format)
void *d;
if (format == NULL) {
pw_stream_finish_format(stream, SPA_RESULT_OK, 0, NULL);
pw_stream_finish_format(stream, 0, 0, NULL);
return;
}
@ -254,7 +254,7 @@ on_stream_format_changed(void *_data, struct spa_pod_object *format)
sdl_format = id_to_sdl_format(data, data->format.format);
if (sdl_format == SDL_PIXELFORMAT_UNKNOWN) {
pw_stream_finish_format(stream, SPA_RESULT_ERROR, 0, NULL);
pw_stream_finish_format(stream, -EINVAL, 0, NULL);
return;
}
@ -279,7 +279,7 @@ on_stream_format_changed(void *_data, struct spa_pod_object *format)
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
pw_stream_finish_format(stream, SPA_RESULT_OK, 2, params);
pw_stream_finish_format(stream, 0, 2, params);
}
static const struct pw_stream_events stream_events = {

4
src/examples/video-src.c
View file

@ -176,7 +176,7 @@ on_stream_format_changed(void *_data, struct spa_pod_object *format)
struct spa_pod_object *params[2];
if (format == NULL) {
pw_stream_finish_format(stream, SPA_RESULT_OK, 0, NULL);
pw_stream_finish_format(stream, 0, 0, NULL);
return;
}
spa_format_video_raw_parse(format, &data->format, &data->type.format_video);
@ -196,7 +196,7 @@ on_stream_format_changed(void *_data, struct spa_pod_object *format)
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
pw_stream_finish_format(stream, SPA_RESULT_OK, 2, params);
pw_stream_finish_format(stream, 0, 2, params);
}
static const struct pw_stream_events stream_events = {

2
src/gst/gstpipewiredeviceprovider.c
View file

@ -525,7 +525,7 @@ gst_pipewire_device_provider_start (GstDeviceProvider * provider)
}
self->type = pw_core_get_type (self->core);
if (pw_thread_loop_start (self->main_loop) != SPA_RESULT_OK) {
if (pw_thread_loop_start (self->main_loop) < 0) {
GST_ERROR_OBJECT (self, "Could not start PipeWire mainloop");
goto failed_start;
}

4
src/gst/gstpipewiresink.c
View file

@ -265,7 +265,7 @@ pool_activated (GstPipeWirePool *pool, GstPipeWireSink *sink)
":", t->param_meta.ringbufferAlign, "i", 16);
pw_thread_loop_lock (sink->main_loop);
pw_stream_finish_format (sink->stream, SPA_RESULT_OK, 2, port_params);
pw_stream_finish_format (sink->stream, 0, 2, port_params);
pw_thread_loop_unlock (sink->main_loop);
}
@ -803,7 +803,7 @@ gst_pipewire_sink_open (GstPipeWireSink * pwsink)
{
const char *error = NULL;
if (pw_thread_loop_start (pwsink->main_loop) != SPA_RESULT_OK)
if (pw_thread_loop_start (pwsink->main_loop) < 0)
goto mainloop_error;
pw_thread_loop_lock (pwsink->main_loop);

8
src/gst/gstpipewiresrc.c
View file

@ -736,7 +736,7 @@ on_format_changed (void *data,
if (format == NULL) {
GST_DEBUG_OBJECT (pwsrc, "clear format");
pw_stream_finish_format (pwsrc->stream, SPA_RESULT_OK, 0, NULL);
pw_stream_finish_format (pwsrc->stream, 0, 0, NULL);
return;
}
@ -764,10 +764,10 @@ on_format_changed (void *data,
":", t->param_meta.size, "i", sizeof (struct spa_meta_header));
GST_DEBUG_OBJECT (pwsrc, "doing finish format");
pw_stream_finish_format (pwsrc->stream, SPA_RESULT_OK, 2, params);
pw_stream_finish_format (pwsrc->stream, 0, 2, params);
} else {
GST_WARNING_OBJECT (pwsrc, "finish format with error");
pw_stream_finish_format (pwsrc->stream, SPA_RESULT_INVALID_MEDIA_TYPE, 0, NULL);
pw_stream_finish_format (pwsrc->stream, -EINVAL, 0, NULL);
}
}
@ -1021,7 +1021,7 @@ gst_pipewire_src_open (GstPipeWireSrc * pwsrc)
struct pw_properties *props;
const char *error = NULL;
if (pw_thread_loop_start (pwsrc->main_loop) != SPA_RESULT_OK)
if (pw_thread_loop_start (pwsrc->main_loop) < 0)
goto mainloop_failed;
pw_thread_loop_lock (pwsrc->main_loop);

4
src/modules/module-autolink.c
View file

@ -124,7 +124,7 @@ link_state_changed(void *data, enum pw_link_state old, enum pw_link_state state,
pw_log_debug("module %p: link %p: state error: %s", impl, link, error);
if (owner)
pw_resource_error(pw_client_get_core_resource(owner), SPA_RESULT_ERROR, error);
pw_resource_error(pw_client_get_core_resource(owner), -ENODEV, error);
break;
}
@ -218,7 +218,7 @@ static void try_link_port(struct pw_node *node, struct pw_port *port, struct nod
struct pw_global *global = pw_node_get_global(info->node);
struct pw_client *owner = pw_global_get_owner(global);
if (owner)
pw_resource_error(pw_client_get_core_resource(owner), SPA_RESULT_ERROR, error);
pw_resource_error(pw_client_get_core_resource(owner), -EINVAL, error);
}
free(error);
return;

4
src/modules/module-client-node.c
View file

@ -67,11 +67,11 @@ static void *create_object(void *_data,
no_resource:
pw_log_error("client-node needs a resource");
pw_resource_error(resource, SPA_RESULT_INVALID_ARGUMENTS, "no resource");
pw_resource_error(resource, -EINVAL, "no resource");
goto done;
no_mem:
pw_log_error("can't create node");
pw_resource_error(resource, SPA_RESULT_NO_MEMORY, "no memory");
pw_resource_error(resource, -ENOMEM, "no memory");
goto done;
done:
if (properties)

124
src/modules/module-client-node/client-node.c
View file

@ -147,7 +147,7 @@ static int clear_buffers(struct proxy *this, struct proxy_port *port)
spa_log_info(this->log, "proxy %p: clear buffers", this);
port->n_buffers = 0;
}
return SPA_RESULT_OK;
return 0;
}
static int spa_proxy_node_enum_params(struct spa_node *node,
@ -158,9 +158,9 @@ static int spa_proxy_node_enum_params(struct spa_node *node,
struct proxy *this;
uint32_t offset;
spa_return_val_if_fail(node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail(index != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail(builder != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
spa_return_val_if_fail(builder != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct proxy, node);
@ -170,19 +170,19 @@ static int spa_proxy_node_enum_params(struct spa_node *node,
struct spa_pod_object *param;
if (*index >= this->n_params)
return SPA_RESULT_ENUM_END;
return 0;
param = this->params[(*index)++];
if (param->body.id != id)
continue;
if (spa_pod_filter(builder, &param->pod, &filter->pod) == SPA_RESULT_OK)
if (spa_pod_filter(builder, &param->pod, &filter->pod) == 0)
break;
spa_pod_builder_reset(builder, offset);
}
return SPA_RESULT_OK;
return 1;
}
static int spa_proxy_node_set_param(struct spa_node *node, uint32_t id, uint32_t flags,
@ -191,12 +191,12 @@ static int spa_proxy_node_set_param(struct spa_node *node, uint32_t id, uint32_t
struct proxy *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
if (this->resource == NULL)
return SPA_RESULT_OK;
return 0;
pw_client_node_resource_set_param(this->resource, this->seq, id, flags, param);
@ -214,16 +214,16 @@ static inline void do_flush(struct proxy *this)
static int spa_proxy_node_send_command(struct spa_node *node, const struct spa_command *command)
{
struct proxy *this;
int res = SPA_RESULT_OK;
int res = 0;
struct pw_type *t;
if (node == NULL || command == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
if (this->resource == NULL)
return SPA_RESULT_OK;
return 0;
t = this->impl->t;
@ -245,13 +245,13 @@ spa_proxy_node_set_callbacks(struct spa_node *node,
struct proxy *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
this->callbacks = callbacks;
this->callbacks_data = data;
return SPA_RESULT_OK;
return 0;
}
static int
@ -264,7 +264,7 @@ spa_proxy_node_get_n_ports(struct spa_node *node,
struct proxy *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
@ -277,7 +277,7 @@ spa_proxy_node_get_n_ports(struct spa_node *node,
if (max_output_ports)
*max_output_ports = this->max_outputs == 0 ? this->n_outputs : this->max_outputs;
return SPA_RESULT_OK;
return 0;
}
static int
@ -291,7 +291,7 @@ spa_proxy_node_get_port_ids(struct spa_node *node,
int c, i;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
@ -307,7 +307,7 @@ spa_proxy_node_get_port_ids(struct spa_node *node,
output_ids[c++] = i;
}
}
return SPA_RESULT_OK;
return 0;
}
static void
@ -394,17 +394,17 @@ spa_proxy_node_add_port(struct spa_node *node, enum spa_direction direction, uin
struct proxy_port *port;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
if (!CHECK_FREE_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
return -EINVAL;
port = GET_PORT(this, direction, port_id);
clear_port(this, port, direction, port_id);
return SPA_RESULT_OK;
return 0;
}
static int
@ -413,16 +413,16 @@ spa_proxy_node_remove_port(struct spa_node *node, enum spa_direction direction,
struct proxy *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
if (!CHECK_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
return -EINVAL;
do_uninit_port(this, direction, port_id);
return SPA_RESULT_OK;
return 0;
}
static int
@ -434,17 +434,17 @@ spa_proxy_node_port_get_info(struct spa_node *node,
struct proxy_port *port;
if (node == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
if (!CHECK_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
return -EINVAL;
port = GET_PORT(this, direction, port_id);
*info = &port->info;
return SPA_RESULT_OK;
return 0;
}
static int
@ -458,13 +458,13 @@ spa_proxy_node_port_enum_params(struct spa_node *node,
struct proxy_port *port;
uint32_t offset;
spa_return_val_if_fail(node != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail(index != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail(builder != NULL, SPA_RESULT_INVALID_ARGUMENTS);
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
spa_return_val_if_fail(builder != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct proxy, node);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), SPA_RESULT_INVALID_PORT);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
@ -473,19 +473,19 @@ spa_proxy_node_port_enum_params(struct spa_node *node,
struct spa_pod_object *param;
if (*index >= port->n_params)
return SPA_RESULT_ENUM_END;
return 0;
param = port->params[(*index)++];
if (param->body.id != id)
continue;
if (spa_pod_filter(builder, &param->pod, &filter->pod) == SPA_RESULT_OK)
if (spa_pod_filter(builder, &param->pod, &filter->pod) == 0)
break;
spa_pod_builder_reset(builder, offset);
}
return SPA_RESULT_OK;
return 1;
}
static int
@ -497,15 +497,15 @@ spa_proxy_node_port_set_param(struct spa_node *node,
struct proxy *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
if (!CHECK_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
return -EINVAL;
if (this->resource == NULL)
return SPA_RESULT_OK;
return 0;
pw_client_node_resource_port_set_param(this->resource,
this->seq,
@ -524,17 +524,17 @@ spa_proxy_node_port_set_io(struct spa_node *node,
struct proxy_port *port;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
if (!CHECK_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
return -EINVAL;
port = GET_PORT(this, direction, port_id);
port->io = io;
return SPA_RESULT_OK;
return 0;
}
static int
@ -560,12 +560,12 @@ spa_proxy_node_port_use_buffers(struct spa_node *node,
t = impl->t;
if (!CHECK_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
return -EINVAL;
port = GET_PORT(this, direction, port_id);
if (!port->have_format)
return SPA_RESULT_NO_FORMAT;
return -EIO;
clear_buffers(this, port);
@ -578,7 +578,7 @@ spa_proxy_node_port_use_buffers(struct spa_node *node,
port->n_buffers = n_buffers;
if (this->resource == NULL)
return SPA_RESULT_OK;
return 0;
n_mem = 0;
for (i = 0; i < n_buffers; i++) {
@ -587,7 +587,7 @@ spa_proxy_node_port_use_buffers(struct spa_node *node,
msh = spa_buffer_find_meta(buffers[i], t->meta.Shared);
if (msh == NULL) {
spa_log_error(this->log, "missing shared metadata on buffer %d", i);
return SPA_RESULT_ERROR;
return -EINVAL;
}
b->outbuf = buffers[i];
@ -660,19 +660,19 @@ spa_proxy_node_port_alloc_buffers(struct spa_node *node,
struct proxy_port *port;
if (node == NULL || buffers == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
if (!CHECK_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
return -EINVAL;
port = GET_PORT(this, direction, port_id);
if (!port->have_format)
return SPA_RESULT_NO_FORMAT;
return -EIO;
return SPA_RESULT_NOT_IMPLEMENTED;
return -ENOTSUP;
}
static int
@ -685,14 +685,14 @@ spa_proxy_node_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32
impl = this->impl;
if (!CHECK_OUT_PORT(this, SPA_DIRECTION_OUTPUT, port_id))
return SPA_RESULT_INVALID_PORT;
return -EINVAL;
spa_log_trace(this->log, "reuse buffer %d", buffer_id);
pw_client_node_transport_add_message(impl->transport, (struct pw_client_node_message *)
&PW_CLIENT_NODE_MESSAGE_REUSE_BUFFER_INIT(port_id, buffer_id));
return SPA_RESULT_OK;
return 0;
}
static int
@ -703,12 +703,12 @@ spa_proxy_node_port_send_command(struct spa_node *node,
struct proxy *this;
if (node == NULL || command == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
this = SPA_CONTAINER_OF(node, struct proxy, node);
spa_log_warn(this->log, "unhandled command %d", SPA_COMMAND_TYPE(command));
return SPA_RESULT_NOT_IMPLEMENTED;
return -ENOTSUP;
}
static int spa_proxy_node_process_input(struct spa_node *node)
@ -724,8 +724,8 @@ static int spa_proxy_node_process_input(struct spa_node *node)
/* the client is not ready to receive our buffers, recycle them */
pw_log_trace("node not ready, recycle buffers");
spa_list_for_each(p, &n->ports[SPA_DIRECTION_INPUT], link)
p->io->status = SPA_RESULT_NEED_BUFFER;
res = SPA_RESULT_NEED_BUFFER;
p->io->status = SPA_STATUS_NEED_BUFFER;
res = SPA_STATUS_NEED_BUFFER;
}
else {
spa_list_for_each(p, &n->ports[SPA_DIRECTION_INPUT], link) {
@ -743,7 +743,7 @@ static int spa_proxy_node_process_input(struct spa_node *node)
do_flush(this);
impl->input_ready--;
res = SPA_RESULT_OK;
res = SPA_STATUS_OK;
}
return res;
}
@ -779,7 +779,7 @@ static int spa_proxy_node_process_output(struct spa_node *node)
&PW_CLIENT_NODE_MESSAGE_INIT(PW_CLIENT_NODE_MESSAGE_PROCESS_OUTPUT));
do_flush(this);
return SPA_RESULT_OK;
return SPA_STATUS_OK;
}
static int handle_node_message(struct proxy *this, struct pw_client_node_message *message)
@ -812,7 +812,7 @@ static int handle_node_message(struct proxy *this, struct pw_client_node_message
p->body.buffer_id.value);
}
}
return SPA_RESULT_OK;
return 0;
}
static void setup_transport(struct impl *impl)
@ -832,7 +832,7 @@ client_node_done(void *data, int seq, int res)
struct impl *impl = data;
struct proxy *this = &impl->proxy;
if (seq == 0 && res == SPA_RESULT_OK)
if (seq == 0 && res == 0)
setup_transport(impl);
this->callbacks->done(this->callbacks_data, seq, res);
@ -946,7 +946,7 @@ static void proxy_on_data_fd_events(struct spa_source *source)
spa_log_warn(this->log, "proxy %p: error reading message: %s",
this, strerror(errno));
while (pw_client_node_transport_next_message(impl->transport, &message) == SPA_RESULT_OK) {
while (pw_client_node_transport_next_message(impl->transport, &message) == 1) {
struct pw_client_node_message *msg = alloca(SPA_POD_SIZE(&message));
pw_client_node_transport_parse_message(impl->transport, msg);
handle_node_message(this, msg);
@ -995,11 +995,11 @@ proxy_init(struct proxy *this,
}
if (this->data_loop == NULL) {
spa_log_error(this->log, "a data-loop is needed");
return SPA_RESULT_ERROR;
return -EINVAL;
}
if (this->map == NULL) {
spa_log_error(this->log, "a type map is needed");
return SPA_RESULT_ERROR;
return -EINVAL;
}
this->node = proxy_node;
@ -1026,7 +1026,7 @@ static int proxy_clear(struct proxy *this)
clear_port(this, &this->out_ports[i], SPA_DIRECTION_OUTPUT, i);
}
return SPA_RESULT_OK;
return 0;
}
static void client_node_resource_destroy(void *data)

24
src/modules/module-client-node/transport.c
View file

@ -87,11 +87,11 @@ static void transport_reset_area(struct pw_client_node_transport *trans)
struct pw_client_node_area *a = trans->area;
for (i = 0; i < a->max_input_ports; i++) {
trans->inputs[i].status = SPA_RESULT_OK;
trans->inputs[i].status = SPA_STATUS_OK;
trans->inputs[i].buffer_id = SPA_ID_INVALID;
}
for (i = 0; i < a->max_output_ports; i++) {
trans->outputs[i].status = SPA_RESULT_OK;
trans->outputs[i].status = SPA_STATUS_OK;
trans->outputs[i].buffer_id = SPA_ID_INVALID;
}
spa_ringbuffer_init(trans->input_buffer, INPUT_BUFFER_SIZE);
@ -115,20 +115,20 @@ static int add_message(struct pw_client_node_transport *trans, struct pw_client_
uint32_t size, index;
if (impl == NULL || message == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
filled = spa_ringbuffer_get_write_index(trans->output_buffer, &index);
avail = trans->output_buffer->size - filled;
size = SPA_POD_SIZE(message);
if (avail < size)
return SPA_RESULT_ERROR;
return -ENOSPC;
spa_ringbuffer_write_data(trans->output_buffer,
trans->output_data,
index & trans->output_buffer->mask, message, size);
spa_ringbuffer_write_update(trans->output_buffer, index + size);
return SPA_RESULT_OK;
return 0;
}
static int next_message(struct pw_client_node_transport *trans, struct pw_client_node_message *message)
@ -137,11 +137,11 @@ static int next_message(struct pw_client_node_transport *trans, struct pw_client
int32_t avail;
if (impl == NULL || message == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
avail = spa_ringbuffer_get_read_index(trans->input_buffer, &impl->current_index);
if (avail < sizeof(struct pw_client_node_message))
return SPA_RESULT_ENUM_END;
return 0;
spa_ringbuffer_read_data(trans->input_buffer,
trans->input_data,
@ -150,7 +150,7 @@ static int next_message(struct pw_client_node_transport *trans, struct pw_client
*message = impl->current;
return SPA_RESULT_OK;
return 1;
}
static int parse_message(struct pw_client_node_transport *trans, void *message)
@ -159,7 +159,7 @@ static int parse_message(struct pw_client_node_transport *trans, void *message)
uint32_t size;
if (impl == NULL || message == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
size = SPA_POD_SIZE(&impl->current);
@ -168,7 +168,7 @@ static int parse_message(struct pw_client_node_transport *trans, void *message)
impl->current_index & trans->input_buffer->mask, message, size);
spa_ringbuffer_read_update(trans->input_buffer, impl->current_index + size);
return SPA_RESULT_OK;
return 0;
}
/** Create a new transport
@ -229,7 +229,7 @@ pw_client_node_transport_new_from_info(struct pw_client_node_transport_info *inf
impl->mem.fd = info->memfd;
impl->mem.offset = info->offset;
impl->mem.size = info->size;
if (pw_memblock_map(&impl->mem) != SPA_RESULT_OK) {
if (pw_memblock_map(&impl->mem) < 0) {
pw_log_warn("transport %p: failed to map fd %d: %s", impl, info->memfd,
strerror(errno));
goto mmap_failed;
@ -278,5 +278,5 @@ int pw_client_node_transport_get_info(struct pw_client_node_transport *trans,
info->offset = impl->offset;
info->size = impl->mem.size;
return SPA_RESULT_OK;
return 0;
}

6
src/modules/module-flatpak.c
View file

@ -297,7 +297,7 @@ portal_response(DBusConnection *connection, DBusMessage *msg, void *user_data)
&p->properties->dict,
p->new_id);
} else {
pw_resource_error(p->resource->resource, SPA_RESULT_NO_PERMISSION, "not allowed");
pw_resource_error(p->resource->resource, -EPERM, "not allowed");
}
free_pending(p);
@ -424,7 +424,7 @@ static void do_create_object(void *data,
dbus_error_free(&error);
goto not_allowed;
not_allowed:
pw_resource_error(cinfo->core_resource->resource, SPA_RESULT_NO_PERMISSION, "not allowed");
pw_resource_error(cinfo->core_resource->resource, -EPERM, "not allowed");
return;
}
@ -442,7 +442,7 @@ do_create_link(void *data,
struct client_info *cinfo = resource->cinfo;
if (cinfo->is_sandboxed) {
pw_resource_error(resource->resource, SPA_RESULT_NO_PERMISSION, "not allowed");
pw_resource_error(resource->resource, -EPERM, "not allowed");
return;
}
pw_resource_do_parent(resource->resource,

8
src/modules/module-jack.c
View file

@ -330,7 +330,7 @@ static int do_add_node(struct spa_loop *loop, bool async, uint32_t seq, size_t s
struct jack_client *jc = user_data;
struct impl *impl = jc->data;
spa_list_append(&impl->rt.nodes, &jc->node->graph_link);
return SPA_RESULT_OK;
return 0;
}
static int do_remove_node(struct spa_loop *loop, bool async, uint32_t seq, size_t size, const void *data,
@ -338,7 +338,7 @@ static int do_remove_node(struct spa_loop *loop, bool async, uint32_t seq, size_
{
struct jack_client *jc = user_data;
spa_list_remove(&jc->node->graph_link);
return SPA_RESULT_OK;
return 0;
}
static int
@ -1102,7 +1102,7 @@ static int do_graph_order_changed(struct spa_loop *loop,
}
notify_clients(impl, jack_notify_GraphOrderCallback, false, "", 0, 0);
return SPA_RESULT_OK;
return 0;
}
static void jack_node_pull(void *data)
@ -1328,7 +1328,7 @@ static bool on_global(void *data, struct pw_global *global)
return true;
}
if (spa_node_enum_params(node->node, SPA_ID_INVALID, &index, NULL, &b) == SPA_RESULT_OK) {
if (spa_node_enum_params(node->node, SPA_ID_INVALID, &index, NULL, &b) == 1) {
int min_latency = -1;
struct spa_pod_object *props = spa_pod_builder_deref(&b, 0);

84
src/modules/module-jack/jack-node.c
View file

@ -128,26 +128,26 @@ static int node_enum_params(struct spa_node *node,
const struct spa_pod_object *filter,
struct spa_pod_builder *builder)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return -ENOTSUP;
}
static int node_set_param(struct spa_node *node,
uint32_t id, uint32_t flags,
const struct spa_pod_object *param)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return -ENOTSUP;
}
static int node_send_command(struct spa_node *node,
const struct spa_command *command)
{
return SPA_RESULT_OK;
return 0;
}
static int node_set_callbacks(struct spa_node *node,
const struct spa_node_callbacks *callbacks, void *data)
{
return SPA_RESULT_OK;
return 0;
}
static int node_get_n_ports(struct spa_node *node,
@ -167,7 +167,7 @@ static int node_get_n_ports(struct spa_node *node,
if (max_output_ports)
*max_output_ports = PORT_NUM_FOR_CLIENT / 2;
return SPA_RESULT_OK;
return 0;
}
static int node_get_port_ids(struct spa_node *node,
@ -187,17 +187,17 @@ static int node_get_port_ids(struct spa_node *node,
if (nd->port_data[SPA_DIRECTION_OUTPUT][i])
output_ids[c++] = nd->port_data[SPA_DIRECTION_OUTPUT][i]->port.port->port_id;
}
return SPA_RESULT_OK;
return 0;
}
static int node_add_port(struct spa_node *node, enum spa_direction direction, uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return -ENOTSUP;
}
static int node_remove_port(struct spa_node *node, enum spa_direction direction, uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return -ENOTSUP;
}
static struct buffer *buffer_dequeue(struct pw_jack_node *this, struct port_data *pd)
@ -222,7 +222,7 @@ static void recycle_buffer(struct pw_jack_node *this, struct port_data *pd, uint
static int driver_process_input(struct spa_node *node)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return -ENOTSUP;
}
static void conv_f32_s16(int16_t *out, float *in, int n_samples, int stride)
@ -267,8 +267,8 @@ static int driver_process_output(struct spa_node *node)
pw_log_trace(NAME "%p: process output", this);
if (out_io->status == SPA_RESULT_HAVE_BUFFER)
return SPA_RESULT_HAVE_BUFFER;
if (out_io->status == SPA_STATUS_HAVE_BUFFER)
return SPA_STATUS_HAVE_BUFFER;
if (out_io->buffer_id < opd->n_buffers) {
recycle_buffer(this, opd, out_io->buffer_id);
@ -277,10 +277,10 @@ static int driver_process_output(struct spa_node *node)
out = buffer_dequeue(this, opd);
if (out == NULL)
return SPA_RESULT_OUT_OF_BUFFERS;
return -EPIPE;
out_io->buffer_id = out->outbuf->id;
out_io->status = SPA_RESULT_HAVE_BUFFER;
out_io->status = SPA_STATUS_HAVE_BUFFER;
op = out->ptr;
@ -293,7 +293,7 @@ static int driver_process_output(struct spa_node *node)
struct buffer *in;
int stride = 2;
if (in_io->buffer_id < ipd->n_buffers && in_io->status == SPA_RESULT_HAVE_BUFFER) {
if (in_io->buffer_id < ipd->n_buffers && in_io->status == SPA_STATUS_HAVE_BUFFER) {
in = &ipd->buffers[in_io->buffer_id];
conv_f32_s16(op, in->ptr, ctrl->buffer_size, stride);
}
@ -301,14 +301,14 @@ static int driver_process_output(struct spa_node *node)
fill_s16(op, ctrl->buffer_size, stride);
}
op++;
in_io->status = SPA_RESULT_NEED_BUFFER;
in_io->status = SPA_STATUS_NEED_BUFFER;
}
out->outbuf->datas[0].chunk->size = ctrl->buffer_size * sizeof(int16_t) * 2;
spa_hook_list_call(&nd->listener_list, struct pw_jack_node_events, push);
gn->ready[SPA_DIRECTION_INPUT] = gn->required[SPA_DIRECTION_OUTPUT] = 0;
return SPA_RESULT_HAVE_BUFFER;
return SPA_STATUS_HAVE_BUFFER;
}
static int node_process_input(struct spa_node *node)
@ -324,8 +324,8 @@ static int node_process_input(struct spa_node *node)
int ref_num = this->control->ref_num;
pw_log_trace(NAME " %p: process input", nd);
if (nd->status == SPA_RESULT_HAVE_BUFFER)
return SPA_RESULT_HAVE_BUFFER;
if (nd->status == SPA_STATUS_HAVE_BUFFER)
return SPA_STATUS_HAVE_BUFFER;
mgr->client_timing[ref_num].status = Triggered;
mgr->client_timing[ref_num].signaled_at = current_date;
@ -340,10 +340,10 @@ static int node_process_input(struct spa_node *node)
struct port_data *opd = pw_port_get_user_data(port);
struct spa_port_io *out_io = opd->io;
out_io->buffer_id = 0;
out_io->status = SPA_RESULT_HAVE_BUFFER;
out_io->status = SPA_STATUS_HAVE_BUFFER;
pw_log_trace(NAME " %p: port %p: %d %d", nd, p, out_io->buffer_id, out_io->status);
}
return nd->status = SPA_RESULT_HAVE_BUFFER;
return nd->status = SPA_STATUS_HAVE_BUFFER;
}
static int node_process_output(struct spa_node *node)
@ -359,10 +359,10 @@ static int node_process_output(struct spa_node *node)
struct port_data *ipd = pw_port_get_user_data(port);
struct spa_port_io *in_io = ipd->io;
in_io->buffer_id = 0;
in_io->status = SPA_RESULT_NEED_BUFFER;
in_io->status = SPA_STATUS_NEED_BUFFER;
pw_log_trace(NAME " %p: port %p: %d %d", nd, p, in_io->buffer_id, in_io->status);
}
return nd->status = SPA_RESULT_NEED_BUFFER;
return nd->status = SPA_STATUS_NEED_BUFFER;
}
@ -372,7 +372,7 @@ static int port_set_io(struct spa_node *node, enum spa_direction direction, uint
struct node_data *nd = SPA_CONTAINER_OF(node, struct node_data, node_impl);
struct port_data *pd = nd->port_data[direction][port_id];
pd->io = io;
return SPA_RESULT_OK;
return 0;
}
static int port_get_info(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -389,7 +389,7 @@ static int port_get_info(struct spa_node *node, enum spa_direction direction, ui
pd->info.rate = pd->node->node.server->engine_control->sample_rate;
*info = &pd->info;
return SPA_RESULT_OK;
return 0;
}
static int port_enum_formats(struct spa_node *node,
@ -405,7 +405,7 @@ static int port_enum_formats(struct spa_node *node,
struct jack_engine_control *ctrl = pd->node->node.server->engine_control;
if (index > 0)
return SPA_RESULT_ENUM_END;
return 0;
if (pd->port.jack_port) {
if (pd->port.jack_port->type_id == 0) {
@ -424,7 +424,7 @@ static int port_enum_formats(struct spa_node *node,
"I", t->media_subtype_audio.midi);
}
else
return SPA_RESULT_ENUM_END;
return 0;
}
else {
*param = spa_pod_builder_object(builder,
@ -435,7 +435,7 @@ static int port_enum_formats(struct spa_node *node,
":", t->format_audio.rate, "i", ctrl->sample_rate,
":", t->format_audio.channels, "i", 2);
}
return SPA_RESULT_OK;
return 1;
}
static int port_enum_params(struct spa_node *node,
@ -454,15 +454,15 @@ static int port_enum_params(struct spa_node *node,
next:
if (id == t->param.idEnumFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, filter, builder, &param)) < 0)
if ((res = port_enum_formats(node, direction, port_id, index, filter, builder, &param)) <= 0)
return res;
}
else if (id == t->param.idFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, filter, builder, &param)) < 0)
if ((res = port_enum_formats(node, direction, port_id, index, filter, builder, &param)) <= 0)
return res;
}
else
return SPA_RESULT_UNKNOWN_PARAM;
return -ENOENT;
(*index)++;
@ -470,7 +470,7 @@ static int port_enum_params(struct spa_node *node,
if ((res = spa_pod_filter(builder, param, (struct spa_pod*)filter)) < 0)
goto next;
return SPA_RESULT_ENUM_END;
return 1;
}
static int port_set_param(struct spa_node *node,
@ -478,7 +478,7 @@ static int port_set_param(struct spa_node *node,
uint32_t id, uint32_t flags,
const struct spa_pod_object *param)
{
return SPA_RESULT_OK;
return 0;
}
static int port_use_buffers(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -490,7 +490,7 @@ static int port_use_buffers(struct spa_node *node, enum spa_direction direction,
int i;
if (pd->have_buffers)
return SPA_RESULT_OK;
return 0;
pw_log_debug("use_buffers %d", n_buffers);
for (i = 0; i < n_buffers; i++) {
@ -505,13 +505,13 @@ static int port_use_buffers(struct spa_node *node, enum spa_direction direction,
b->ptr = d[0].data;
} else {
pw_log_error(NAME " %p: invalid memory on buffer %p", pd, buffers[i]);
return SPA_RESULT_ERROR;
return -EINVAL;
}
spa_list_append(&pd->empty, &b->link);
}
pd->n_buffers = n_buffers;
return SPA_RESULT_OK;
return 0;
}
static int port_alloc_buffers(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
@ -537,12 +537,12 @@ static int port_alloc_buffers(struct spa_node *node, enum spa_direction directio
}
pd->n_buffers = *n_buffers;
return SPA_RESULT_OK;
return 0;
}
static int port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t buffer_id)
{
return SPA_RESULT_OK;
return 0;
}
static int driver_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t buffer_id)
@ -553,13 +553,13 @@ static int driver_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t
recycle_buffer(this, opd, buffer_id);
return SPA_RESULT_OK;
return 0;
}
static int port_send_command(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
const struct spa_command *command)
{
return SPA_RESULT_OK;
return 0;
}
static const struct spa_node driver_impl = {
@ -624,7 +624,7 @@ static int schedule_mix_input(struct spa_node *_node)
pw_log_trace("mix %p: input %d %d", node, p->io->buffer_id, link->output->n_buffers);
if (!(p->io->buffer_id < link->output->n_buffers && p->io->status == SPA_RESULT_HAVE_BUFFER))
if (!(p->io->buffer_id < link->output->n_buffers && p->io->status == SPA_STATUS_HAVE_BUFFER))
continue;
inbuf = link->output->buffers[p->io->buffer_id];
@ -638,10 +638,10 @@ static int schedule_mix_input(struct spa_node *_node)
p, p->io, io, p->io->status, p->io->buffer_id);
*io = *p->io;
io->buffer_id = 0;
p->io->status = SPA_RESULT_OK;
p->io->status = SPA_STATUS_OK;
p->io->buffer_id = SPA_ID_INVALID;
}
return SPA_RESULT_HAVE_BUFFER;
return SPA_STATUS_HAVE_BUFFER;
}
static int schedule_mix_output(struct spa_node *_node)

8
src/modules/module-mixer.c
View file

@ -74,10 +74,10 @@ static const struct spa_handle_factory *find_factory(struct impl *impl)
goto no_symbol;
}
for (index = 0;; index++) {
if ((res = enum_func(&factory, index)) < 0) {
if (res != SPA_RESULT_ENUM_END)
pw_log_error("can't enumerate factories: %d", res);
for (index = 0;;) {
if ((res = enum_func(&factory, &index)) <= 0) {
if (res != 0)
pw_log_error("can't enumerate factories: %s", spa_strerror(res));
goto enum_failed;
}
if (strcmp(factory->name, "audiomixer") == 0)

4
src/modules/spa/module-node-factory.c
View file

@ -83,7 +83,7 @@ static void *create_object(void *_data,
no_properties:
pw_log_error("needed properties: spa.library.name=<library-name> spa.factory.name=<factory-name>");
if (resource) {
pw_resource_error(resource, SPA_RESULT_INVALID_ARGUMENTS,
pw_resource_error(resource, -EINVAL,
"needed properties: "
"spa.library.name=<library-name> "
"spa.factory.name=<factory-name>");
@ -92,7 +92,7 @@ static void *create_object(void *_data,
no_mem:
pw_log_error("can't create node");
if (resource) {
pw_resource_error(resource, SPA_RESULT_NO_MEMORY, "no memory");
pw_resource_error(resource, -ENOMEM, "no memory");
}
return NULL;
}

16
src/modules/spa/spa-monitor.c
View file

@ -253,10 +253,10 @@ struct pw_spa_monitor *pw_spa_monitor_load(struct pw_core *core,
goto no_symbol;
}
for (index = 0;; index++) {
if ((res = enum_func(&factory, index)) < 0) {
if (res != SPA_RESULT_ENUM_END)
pw_log_error("can't enumerate factories: %d", res);
for (index = 0;;) {
if ((res = enum_func(&factory, &index)) <= 0) {
if (res != 0)
pw_log_error("can't enumerate factories: %s", spa_strerror(res));
goto enum_failed;
}
if (strcmp(factory->name, factory_name) == 0)
@ -294,13 +294,13 @@ struct pw_spa_monitor *pw_spa_monitor_load(struct pw_core *core,
spa_list_init(&impl->item_list);
for (index = 0;; index++) {
for (index = 0;;) {
struct spa_monitor_item *item;
int res;
if ((res = spa_monitor_enum_items(this->monitor, &item, index)) < 0) {
if (res != SPA_RESULT_ENUM_END)
pw_log_debug("spa_monitor_enum_items: got error %d\n", res);
if ((res = spa_monitor_enum_items(this->monitor, &item, &index)) <= 0) {
if (res != 0)
pw_log_debug("spa_monitor_enum_items: %s\n", spa_strerror(res));
break;
}
add_item(this, item);

20
src/modules/spa/spa-node.c
View file

@ -163,9 +163,9 @@ setup_props(struct pw_core *core, struct spa_node *spa_node, struct pw_propertie
uint8_t buf[2048];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf));
if ((res = spa_node_enum_params(spa_node, t->param.idProps, &index, NULL, &b)) != SPA_RESULT_OK) {
if ((res = spa_node_enum_params(spa_node, t->param.idProps, &index, NULL, &b)) <= 0) {
pw_log_debug("spa_node_get_props failed: %d", res);
return SPA_RESULT_ERROR;
return res;
}
props = spa_pod_builder_deref(&b, 0);
@ -218,11 +218,11 @@ setup_props(struct pw_core *core, struct spa_node *spa_node, struct pw_propertie
}
}
if ((res = spa_node_set_param(spa_node, t->param.idProps, 0, props)) != SPA_RESULT_OK) {
if ((res = spa_node_set_param(spa_node, t->param.idProps, 0, props)) < 0) {
pw_log_debug("spa_node_set_props failed: %d", res);
return SPA_RESULT_ERROR;
return res;
}
return SPA_RESULT_OK;
return 0;
}
@ -266,10 +266,10 @@ struct pw_node *pw_spa_node_load(struct pw_core *core,
goto no_symbol;
}
for (index = 0;; index++) {
if ((res = enum_func(&factory, index)) < 0) {
if (res != SPA_RESULT_ENUM_END)
pw_log_error("can't enumerate factories: %d", res);
for (index = 0;;) {
if ((res = enum_func(&factory, &index)) <= 0) {
if (res != 0)
pw_log_error("can't enumerate factories: %s", spa_strerror(res));
goto enum_failed;
}
if (strcmp(factory->name, factory_name) == 0)
@ -294,7 +294,7 @@ struct pw_node *pw_spa_node_load(struct pw_core *core,
spa_node = iface;
if (properties != NULL) {
if (setup_props(core, spa_node, properties) != SPA_RESULT_OK) {
if (setup_props(core, spa_node, properties) < 0) {
pw_log_debug("Unrecognized properties");
}
}

7
src/pipewire/client.c
View file

@ -17,6 +17,7 @@
* Boston, MA 02110-1301, USA.
*/
#include <errno.h>
#include <string.h>
#include "pipewire/pipewire.h"
@ -72,12 +73,12 @@ client_bind_func(struct pw_global *global,
pw_client_resource_info(resource, &this->info);
this->info.change_mask = 0;
return SPA_RESULT_OK;
return 0;
no_mem:
pw_log_error("can't create client resource");
pw_resource_error(client->core_resource, SPA_RESULT_NO_MEMORY, "no memory");
return SPA_RESULT_NO_MEMORY;
pw_resource_error(client->core_resource, -ENOMEM, "no memory");
return -ENOMEM;
}
/** Make a new client object

49
src/pipewire/core.c
View file

@ -16,6 +16,7 @@
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <errno.h>
#include <unistd.h>
#include <time.h>
#include <stdio.h>
@ -158,7 +159,7 @@ static void core_get_registry(void *object, uint32_t version, uint32_t new_id)
no_mem:
pw_log_error("can't create registry resource");
pw_core_resource_error(client->core_resource,
resource->id, SPA_RESULT_NO_MEMORY, "no memory");
resource->id, -ENOMEM, "no memory");
}
static void
@ -205,20 +206,20 @@ core_create_object(void *object,
no_factory:
pw_log_error("can't find node factory %s", factory_name);
pw_core_resource_error(client->core_resource,
resource->id, SPA_RESULT_INVALID_ARGUMENTS, "unknown factory name %s", factory_name);
resource->id, -EINVAL, "unknown factory name %s", factory_name);
goto done;
wrong_version:
wrong_type:
pw_log_error("invalid resource type/version");
pw_core_resource_error(client->core_resource,
resource->id, SPA_RESULT_INCOMPATIBLE_VERSION, "wrong resource type/version");
resource->id, -EINVAL, "wrong resource type/version");
goto done;
no_properties:
pw_log_error("can't create properties");
goto no_mem;
no_mem:
pw_core_resource_error(client->core_resource,
resource->id, SPA_RESULT_NO_MEMORY, "no memory");
resource->id, -ENOMEM, "no memory");
goto done;
}
@ -283,23 +284,23 @@ core_create_link(void *object,
no_output:
pw_core_resource_error(client->core_resource,
resource->id, SPA_RESULT_INVALID_ARGUMENTS, "unknown output node");
resource->id, -EINVAL, "unknown output node");
goto done;
no_input:
pw_core_resource_error(client->core_resource,
resource->id, SPA_RESULT_INVALID_ARGUMENTS, "unknown input node");
resource->id, -EINVAL, "unknown input node");
goto done;
no_output_port:
pw_core_resource_error(client->core_resource,
resource->id, SPA_RESULT_INVALID_ARGUMENTS, "unknown output port");
resource->id, -EINVAL, "unknown output port");
goto done;
no_input_port:
pw_core_resource_error(client->core_resource,
resource->id, SPA_RESULT_INVALID_ARGUMENTS, "unknown input port");
resource->id, -EINVAL, "unknown input port");
goto done;
no_link:
pw_core_resource_error(client->core_resource,
resource->id, SPA_RESULT_ERROR, "can't create link: %s, error");
resource->id, -ENOMEM, "can't create link: %s, error");
free(error);
goto done;
no_bind:
@ -375,11 +376,11 @@ core_bind_func(struct pw_global *global,
this->info.change_mask = PW_CORE_CHANGE_MASK_ALL;
pw_core_resource_info(resource, &this->info);
return SPA_RESULT_OK;
return 0;
no_mem:
pw_log_error("can't create core resource");
return SPA_RESULT_NO_MEMORY;
return -ENOMEM;
}
/** Create a new core object
@ -738,8 +739,10 @@ int pw_core_find_format(struct pw_core *core,
if ((res = spa_node_port_enum_params(output->node->node,
output->direction, output->port_id,
t->param.idFormat, &oidx,
NULL, builder)) < 0) {
asprintf(error, "error get output format: %d", res);
NULL, builder)) <= 0) {
if (res == 0)
res = -EBADF;
asprintf(error, "error get output format: %s", spa_strerror(res));
goto error;
}
} else if (out_state == PW_PORT_STATE_CONFIGURE && in_state > PW_PORT_STATE_CONFIGURE) {
@ -747,8 +750,10 @@ int pw_core_find_format(struct pw_core *core,
if ((res = spa_node_port_enum_params(input->node->node,
input->direction, input->port_id,
t->param.idFormat, &iidx,
NULL, builder)) < 0) {
asprintf(error, "error get input format: %d", res);
NULL, builder)) <= 0) {
if (res == 0)
res = -EBADF;
asprintf(error, "error get input format: %s", spa_strerror(res));
goto error;
}
} else if (in_state == PW_PORT_STATE_CONFIGURE && out_state == PW_PORT_STATE_CONFIGURE) {
@ -762,9 +767,9 @@ int pw_core_find_format(struct pw_core *core,
if ((res = spa_node_port_enum_params(input->node->node,
input->direction, input->port_id,
t->param.idEnumFormat, &iidx,
NULL, &fb)) < 0) {
if (res == SPA_RESULT_ENUM_END && iidx == 0) {
asprintf(error, "error input enum formats: %d", res);
NULL, &fb)) <= 0) {
if (res == 0 && iidx == 0) {
asprintf(error, "error input enum formats: %s", spa_strerror(res));
goto error;
}
asprintf(error, "no more input formats");
@ -778,8 +783,8 @@ int pw_core_find_format(struct pw_core *core,
if ((res = spa_node_port_enum_params(output->node->node,
output->direction, output->port_id,
t->param.idEnumFormat, &oidx,
format, builder)) < 0) {
if (res == SPA_RESULT_ENUM_END) {
format, builder)) <= 0) {
if (res == 0) {
oidx = 0;
goto again;
}
@ -792,13 +797,15 @@ int pw_core_find_format(struct pw_core *core,
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(&format->pod, SPA_DEBUG_FLAG_FORMAT);
} else {
res = SPA_RESULT_ERROR;
res = -EBADF;
asprintf(error, "error node state");
goto error;
}
return res;
error:
if (res == 0)
res = -EBADF;
return res;
}

8
src/pipewire/data-loop.c
View file

@ -174,15 +174,15 @@ int pw_data_loop_start(struct pw_data_loop *loop)
if ((err = pthread_create(&loop->thread, NULL, do_loop, loop)) != 0) {
pw_log_warn("data-loop %p: can't create thread: %s", loop, strerror(err));
loop->running = false;
return SPA_RESULT_ERROR;
return -err;
}
}
return SPA_RESULT_OK;
return 0;
}
/** Stop a data loop
* \param loop the data loop to Stop
* \return \ref SPA_RESULT_OK
* \return 0
*
* This will stop and join the realtime thread that manages the loop.
*
@ -195,7 +195,7 @@ int pw_data_loop_stop(struct pw_data_loop *loop)
pthread_join(loop->thread, NULL);
}
return SPA_RESULT_OK;
return 0;
}
/** Check if we are inside the data loop

8
src/pipewire/factory.c
View file

@ -17,6 +17,8 @@
* Boston, MA 02110-1301, USA.
*/
#include <errno.h>
#include "pipewire/pipewire.h"
#include "pipewire/factory.h"
#include "pipewire/private.h"
@ -103,13 +105,13 @@ factory_bind_func(struct pw_global *global,
pw_factory_resource_info(resource, &this->info);
this->info.change_mask = 0;
return SPA_RESULT_OK;
return 0;
no_mem:
pw_log_error("can't create factory resource");
pw_core_resource_error(client->core_resource,
client->core_resource->id, SPA_RESULT_NO_MEMORY, "no memory");
return SPA_RESULT_NO_MEMORY;
client->core_resource->id, -ENOMEM, "no memory");
return -ENOMEM;
}
void pw_factory_register(struct pw_factory *factory,

6
src/pipewire/global.c
View file

@ -16,6 +16,8 @@
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <errno.h>
#include <unistd.h>
#include <time.h>
#include <stdio.h>
@ -179,14 +181,14 @@ pw_global_bind(struct pw_global *global, struct pw_client *client, uint32_t perm
return res;
wrong_version:
res = SPA_RESULT_INCOMPATIBLE_VERSION;
res = -EINVAL;
pw_core_resource_error(client->core_resource,
client->core_resource->id,
res, "id %d: interface version %d < %d",
id, global->version, version);
return res;
no_bind:
res = SPA_RESULT_NOT_IMPLEMENTED;
res = -ENOTSUP;
pw_core_resource_error(client->core_resource,
client->core_resource->id,
res, "can't bind object id %d to interface", id);

71
src/pipewire/link.c
View file

@ -17,6 +17,7 @@
* Boston, MA 02110-1301, USA.
*/
#include <errno.h>
#include <string.h>
#include <stdio.h>
@ -113,7 +114,7 @@ static void complete_streaming(void *obj, void *data, int res, uint32_t id)
static int do_negotiate(struct pw_link *this, uint32_t in_state, uint32_t out_state)
{
struct impl *impl = SPA_CONTAINER_OF(this, struct impl, this);
int res = SPA_RESULT_ERROR, res2;
int res = -EIO, res2;
struct spa_pod_object *format = NULL, *current;
char *error = NULL;
struct pw_resource *resource;
@ -125,7 +126,7 @@ static int do_negotiate(struct pw_link *this, uint32_t in_state, uint32_t out_st
uint32_t index = 0;
if (in_state != PW_PORT_STATE_CONFIGURE && out_state != PW_PORT_STATE_CONFIGURE)
return SPA_RESULT_OK;
return 0;
pw_link_update_state(this, PW_LINK_STATE_NEGOTIATING, NULL);
@ -142,8 +143,10 @@ static int do_negotiate(struct pw_link *this, uint32_t in_state, uint32_t out_st
if ((res = spa_node_port_enum_params(output->node->node,
output->direction, output->port_id,
t->param.idFormat, &index,
NULL, &b)) < 0) {
asprintf(&error, "error get output format: %d", res);
NULL, &b)) <= 0) {
if (res == 0)
res = -EBADF;
asprintf(&error, "error get output format: %s", spa_strerror(res));
goto error;
}
current = spa_pod_builder_deref(&b, 0);
@ -161,8 +164,10 @@ static int do_negotiate(struct pw_link *this, uint32_t in_state, uint32_t out_st
if ((res = spa_node_port_enum_params(input->node->node,
input->direction, input->port_id,
t->param.idFormat, &index,
NULL, &b)) < 0) {
asprintf(&error, "error get input format: %d", res);
NULL, &b)) <= 0) {
if (res == 0)
res = -EBADF;
asprintf(&error, "error get input format: %s", spa_strerror(res));
goto error;
}
current = spa_pod_builder_deref(&b, 0);
@ -219,7 +224,7 @@ static int do_negotiate(struct pw_link *this, uint32_t in_state, uint32_t out_st
this->info.change_mask = 0;
}
return SPA_RESULT_OK;
return 0;
error:
pw_link_update_state(this, PW_LINK_STATE_ERROR, error);
@ -407,7 +412,7 @@ param_filter(struct pw_link *this,
spa_pod_builder_init(&ib, ibuf, sizeof(ibuf));
pw_log_debug("iparam %d", iidx);
if (spa_node_port_enum_params(in_port->node->node, in_port->direction, in_port->port_id,
id, &iidx, NULL, &ib) < 0)
id, &iidx, NULL, &ib) <= 0)
break;
iparam = spa_pod_builder_deref(&ib, 0);
@ -422,7 +427,7 @@ param_filter(struct pw_link *this,
pw_log_debug("oparam %d %d", oidx, offset);
if (spa_node_port_enum_params(out_port->node->node, out_port->direction,
out_port->port_id, id, &oidx,
iparam, result) < 0) {
iparam, result) <= 0) {
break;
}
oparam = spa_pod_builder_deref(result, offset);
@ -447,7 +452,7 @@ static int do_allocation(struct pw_link *this, uint32_t in_state, uint32_t out_s
struct pw_type *t = &this->core->type;
if (in_state != PW_PORT_STATE_READY && out_state != PW_PORT_STATE_READY)
return SPA_RESULT_OK;
return 0;
pw_link_update_state(this, PW_LINK_STATE_ALLOCATING, NULL);
@ -495,7 +500,7 @@ static int do_allocation(struct pw_link *this, uint32_t in_state, uint32_t out_s
in_flags = SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
} else {
asprintf(&error, "no common buffer alloc found");
res = SPA_RESULT_ERROR;
res = -EIO;
goto error;
}
} else if (in_state == PW_PORT_STATE_READY && out_state > PW_PORT_STATE_READY) {
@ -506,7 +511,7 @@ static int do_allocation(struct pw_link *this, uint32_t in_state, uint32_t out_s
out_flags &= ~SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
} else {
pw_log_debug("link %p: delay allocation, state %d %d", this, in_state, out_state);
return SPA_RESULT_OK;
return 0;
}
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG)) {
@ -667,7 +672,7 @@ static int do_allocation(struct pw_link *this, uint32_t in_state, uint32_t out_s
goto error;
}
return SPA_RESULT_OK;
return 0;
error:
output->buffers = NULL;
@ -686,7 +691,7 @@ do_activate_link(struct spa_loop *loop,
{
struct pw_link *this = user_data;
spa_graph_port_link(&this->rt.out_port, &this->rt.in_port);
return SPA_RESULT_OK;
return 0;
}
static int do_start(struct pw_link *this, uint32_t in_state, uint32_t out_state)
@ -697,7 +702,7 @@ static int do_start(struct pw_link *this, uint32_t in_state, uint32_t out_state)
struct pw_port *input, *output;
if (in_state < PW_PORT_STATE_PAUSED || out_state < PW_PORT_STATE_PAUSED)
return SPA_RESULT_OK;
return 0;
pw_link_update_state(this, PW_LINK_STATE_PAUSED, NULL);
@ -729,7 +734,7 @@ static int do_start(struct pw_link *this, uint32_t in_state, uint32_t out_state)
else
complete_streaming(output->node, output, res, 0);
}
return SPA_RESULT_OK;
return 0;
error:
pw_link_update_state(this, PW_LINK_STATE_ERROR, error);
@ -743,17 +748,17 @@ static int check_states(struct pw_link *this, void *user_data, int res)
struct pw_port *input, *output;
if (this->state == PW_LINK_STATE_ERROR)
return SPA_RESULT_ERROR;
return -EIO;
input = this->input;
output = this->output;
if (input == NULL || output == NULL)
return SPA_RESULT_OK;
return 0;
if (input->node->info.state == PW_NODE_STATE_ERROR ||
output->node->info.state == PW_NODE_STATE_ERROR)
return SPA_RESULT_ERROR;
return -EIO;
in_state = input->state;
out_state = output->state;
@ -762,21 +767,21 @@ static int check_states(struct pw_link *this, void *user_data, int res)
if (in_state == PW_PORT_STATE_ERROR || out_state == PW_PORT_STATE_ERROR) {
pw_link_update_state(this, PW_LINK_STATE_ERROR, NULL);
return SPA_RESULT_ERROR;
return -EIO;
}
if (in_state == PW_PORT_STATE_STREAMING && out_state == PW_PORT_STATE_STREAMING) {
pw_link_update_state(this, PW_LINK_STATE_RUNNING, NULL);
return SPA_RESULT_OK;
return 0;
}
if ((res = do_negotiate(this, in_state, out_state)) != SPA_RESULT_OK)
if ((res = do_negotiate(this, in_state, out_state)) != 0)
goto exit;
if ((res = do_allocation(this, in_state, out_state)) != SPA_RESULT_OK)
if ((res = do_allocation(this, in_state, out_state)) != 0)
goto exit;
if ((res = do_start(this, in_state, out_state)) != SPA_RESULT_OK)
if ((res = do_start(this, in_state, out_state)) != 0)
goto exit;
exit:
@ -786,7 +791,7 @@ static int check_states(struct pw_link *this, void *user_data, int res)
}
pw_work_queue_add(impl->work,
this, SPA_RESULT_WAIT_SYNC, (pw_work_func_t) check_states, this);
this, -EBUSY, (pw_work_func_t) check_states, this);
return res;
}
@ -822,7 +827,7 @@ do_remove_input(struct spa_loop *loop,
{
struct pw_link *this = user_data;
spa_graph_port_remove(&this->rt.in_port);
return SPA_RESULT_OK;
return 0;
}
static void input_remove(struct pw_link *this, struct pw_port *port)
@ -845,7 +850,7 @@ do_remove_output(struct spa_loop *loop,
{
struct pw_link *this = user_data;
spa_graph_port_remove(&this->rt.out_port);
return SPA_RESULT_OK;
return 0;
}
static void output_remove(struct pw_link *this, struct pw_port *port)
@ -916,7 +921,7 @@ bool pw_link_activate(struct pw_link *this)
this->input->node->n_used_input_links++;
pw_work_queue_add(impl->work,
this, SPA_RESULT_WAIT_SYNC, (pw_work_func_t) check_states, this);
this, -EBUSY, (pw_work_func_t) check_states, this);
return true;
}
@ -927,7 +932,7 @@ do_deactivate_link(struct spa_loop *loop,
{
struct pw_link *this = user_data;
spa_graph_port_unlink(&this->rt.out_port);
return SPA_RESULT_OK;
return 0;
}
bool pw_link_deactivate(struct pw_link *this)
@ -1011,13 +1016,13 @@ link_bind_func(struct pw_global *global,
pw_link_resource_info(resource, &this->info);
this->info.change_mask = 0;
return SPA_RESULT_OK;
return 0;
no_mem:
pw_log_error("can't create link resource");
pw_core_resource_error(client->core_resource,
client->core_resource->id, SPA_RESULT_NO_MEMORY, "no memory");
return SPA_RESULT_NO_MEMORY;
client->core_resource->id, -ENOMEM, "no memory");
return -ENOMEM;
}
static int
@ -1033,7 +1038,7 @@ do_add_link(struct spa_loop *loop,
spa_graph_port_add(&port->rt.mix_node, &this->rt.in_port);
}
return SPA_RESULT_OK;
return 0;
}
static const struct pw_port_events input_port_events = {

28
src/pipewire/mem.c
View file

@ -84,7 +84,7 @@ static inline int memfd_create(const char *name, unsigned int flags)
int pw_memblock_map(struct pw_memblock *mem)
{
if (mem->ptr != NULL)
return SPA_RESULT_OK;
return 0;
if (mem->flags & PW_MEMBLOCK_FLAG_MAP_READWRITE) {
int prot = 0;
@ -101,14 +101,14 @@ int pw_memblock_map(struct pw_memblock *mem)
mmap(NULL, mem->size << 1, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1,
0);
if (mem->ptr == MAP_FAILED)
return SPA_RESULT_NO_MEMORY;
return -errno;
ptr =
mmap(mem->ptr, mem->size, prot, MAP_FIXED | MAP_SHARED, mem->fd,
mem->offset);
if (ptr != mem->ptr) {
munmap(mem->ptr, mem->size << 1);
return SPA_RESULT_NO_MEMORY;
return -ENOMEM;
}
ptr =
@ -116,17 +116,17 @@ int pw_memblock_map(struct pw_memblock *mem)
mem->fd, mem->offset);
if (ptr != mem->ptr + mem->size) {
munmap(mem->ptr, mem->size << 1);
return SPA_RESULT_NO_MEMORY;
return -ENOMEM;
}
} else {
mem->ptr = mmap(NULL, mem->size, prot, MAP_SHARED, mem->fd, 0);
if (mem->ptr == MAP_FAILED)
return SPA_RESULT_NO_MEMORY;
return -ENOMEM;
}
} else {
mem->ptr = NULL;
}
return SPA_RESULT_OK;
return 0;
}
/** Create a new memblock
@ -141,7 +141,7 @@ int pw_memblock_alloc(enum pw_memblock_flags flags, size_t size, struct pw_membl
bool use_fd;
if (mem == NULL || size == 0)
return SPA_RESULT_INVALID_ARGUMENTS;
return -EINVAL;
mem->offset = 0;
mem->flags = flags;
@ -155,14 +155,14 @@ int pw_memblock_alloc(enum pw_memblock_flags flags, size_t size, struct pw_membl
mem->fd = memfd_create("pipewire-memfd", MFD_CLOEXEC | MFD_ALLOW_SEALING);
if (mem->fd == -1) {
pw_log_error("Failed to create memfd: %s\n", strerror(errno));
return SPA_RESULT_ERRNO;
return -errno;
}
#else
char filename[] = "/dev/shm/pipewire-tmpfile.XXXXXX";
mem->fd = mkostemp(filename, O_CLOEXEC);
if (mem->fd == -1) {
pw_log_error("Failed to create temporary file: %s\n", strerror(errno));
return SPA_RESULT_ERRNO;
return -errno;
}
unlink(filename);
#endif
@ -170,7 +170,7 @@ int pw_memblock_alloc(enum pw_memblock_flags flags, size_t size, struct pw_membl
if (ftruncate(mem->fd, size) < 0) {
pw_log_warn("Failed to truncate temporary file: %s", strerror(errno));
close(mem->fd);
return SPA_RESULT_ERRNO;
return -errno;
}
#ifdef USE_MEMFD
if (flags & PW_MEMBLOCK_FLAG_SEAL) {
@ -180,23 +180,23 @@ int pw_memblock_alloc(enum pw_memblock_flags flags, size_t size, struct pw_membl
}
}
#endif
if (pw_memblock_map(mem) != SPA_RESULT_OK)
if (pw_memblock_map(mem) != 0)
goto mmap_failed;
} else {
mem->ptr = malloc(size);
if (mem->ptr == NULL)
return SPA_RESULT_NO_MEMORY;
return -ENOMEM;
mem->fd = -1;
}
if (!(flags & PW_MEMBLOCK_FLAG_WITH_FD) && mem->fd != -1) {
close(mem->fd);
mem->fd = -1;
}
return SPA_RESULT_OK;
return 0;
mmap_failed:
close(mem->fd);
return SPA_RESULT_NO_MEMORY;
return -ENOMEM;
}
/** Free a memblock

6
src/pipewire/module.c
View file

@ -129,13 +129,13 @@ module_bind_func(struct pw_global *global,
pw_module_resource_info(resource, &this->info);
this->info.change_mask = 0;
return SPA_RESULT_OK;
return 0;
no_mem:
pw_log_error("can't create module resource");
pw_core_resource_error(client->core_resource,
client->core_resource->id, SPA_RESULT_NO_MEMORY, "no memory");
return SPA_RESULT_NO_MEMORY;
client->core_resource->id, -ENOMEM, "no memory");
return -ENOMEM;
}
struct pw_module * pw_core_find_module(struct pw_core *core, const char *filename)

28
src/pipewire/node.c
View file

@ -48,10 +48,10 @@ struct resource_data {
static int pause_node(struct pw_node *this)
{
int res = SPA_RESULT_OK;
int res = 0;
if (this->info.state <= PW_NODE_STATE_IDLE)
return SPA_RESULT_OK;
return 0;
pw_log_debug("node %p: pause node", this);
res = spa_node_send_command(this->node,
@ -64,7 +64,7 @@ static int pause_node(struct pw_node *this)
static int start_node(struct pw_node *this)
{
int res = SPA_RESULT_OK;
int res = 0;
pw_log_debug("node %p: start node", this);
res = spa_node_send_command(this->node,
@ -77,7 +77,7 @@ static int start_node(struct pw_node *this)
static int suspend_node(struct pw_node *this)
{
int res = SPA_RESULT_OK;
int res = 0;
struct pw_port *p;
pw_log_debug("node %p: suspend node", this);
@ -216,7 +216,7 @@ static int update_port_ids(struct pw_node *node)
update_port_map(node, PW_DIRECTION_INPUT, &node->input_port_map, input_port_ids, n_input_ports);
update_port_map(node, PW_DIRECTION_OUTPUT, &node->output_port_map, output_port_ids, n_output_ports);
return SPA_RESULT_OK;
return 0;
}
static void
@ -237,7 +237,7 @@ update_info(struct pw_node *this)
if (spa_node_port_enum_params(port->node->node,
port->direction, port->port_id,
this->core->type.param.idEnumFormat, &state,
NULL, &b) < 0)
NULL, &b) <= 0)
break;
fmt = spa_pod_builder_deref(&b, 0);
@ -260,7 +260,7 @@ update_info(struct pw_node *this)
if (spa_node_port_enum_params(port->node->node,
port->direction, port->port_id,
this->core->type.param.idEnumFormat, &state,
NULL, &b) < 0)
NULL, &b) <= 0)
break;
fmt = spa_pod_builder_deref(&b, 0);
@ -322,13 +322,13 @@ node_bind_func(struct pw_global *global,
pw_node_resource_info(resource, &this->info);
this->info.change_mask = 0;
return SPA_RESULT_OK;
return 0;
no_mem:
pw_log_error("can't create node resource");
pw_core_resource_error(client->core_resource,
client->core_resource->id, SPA_RESULT_NO_MEMORY, "no memory");
return SPA_RESULT_NO_MEMORY;
client->core_resource->id, -ENOMEM, "no memory");
return -ENOMEM;
}
static int
@ -339,7 +339,7 @@ do_node_add(struct spa_loop *loop,
spa_graph_node_add(this->rt.graph, &this->rt.node);
return SPA_RESULT_OK;
return 0;
}
@ -562,7 +562,7 @@ do_node_remove(struct spa_loop *loop,
spa_graph_node_remove(&this->rt.node);
return SPA_RESULT_OK;
return 0;
}
/** Destroy a node
@ -784,7 +784,7 @@ static void node_activate(struct pw_node *this)
*/
int pw_node_set_state(struct pw_node *node, enum pw_node_state state)
{
int res = SPA_RESULT_OK;
int res = 0;
struct impl *impl = SPA_CONTAINER_OF(node, struct impl, this);
spa_hook_list_call(&node->listener_list, struct pw_node_events, state_request, state);
@ -793,7 +793,7 @@ int pw_node_set_state(struct pw_node *node, enum pw_node_state state)
switch (state) {
case PW_NODE_STATE_CREATING:
return SPA_RESULT_ERROR;
return -EIO;
case PW_NODE_STATE_SUSPENDED:
res = suspend_node(node);

8
src/pipewire/pipewire.c
View file

@ -161,10 +161,10 @@ const struct spa_handle_factory *pw_get_support_factory(const char *factory_name
uint32_t index;
const struct spa_handle_factory *factory;
for (index = 0;; index++) {
if ((res = support_info.enum_func(&factory, index)) < 0) {
if (res != SPA_RESULT_ENUM_END)
fprintf(stderr, "can't enumerate factories: %d\n", res);
for (index = 0;;) {
if ((res = support_info.enum_func(&factory, &index)) <= 0) {
if (res != 0)
fprintf(stderr, "can't enumerate factories: %s\n", spa_strerror(res));
break;
}
if (strcmp(factory->name, factory_name) == 0)

16
src/pipewire/port.c
View file

@ -58,7 +58,7 @@ static int schedule_tee_input(struct spa_node *data)
io->buffer_id = SPA_ID_INVALID;
}
else
io->status = SPA_RESULT_NEED_BUFFER;
io->status = SPA_STATUS_NEED_BUFFER;
return io->status;
}
@ -86,7 +86,7 @@ static int schedule_tee_reuse_buffer(struct spa_node *data, uint32_t port_id, ui
pw_log_trace("tee reuse buffer %d %d", port_id, buffer_id);
spa_node_port_reuse_buffer(pp->node->implementation, port_id, buffer_id);
}
return SPA_RESULT_OK;
return 0;
}
static const struct spa_node schedule_tee_node = {
@ -142,7 +142,7 @@ static int schedule_mix_reuse_buffer(struct spa_node *data, uint32_t port_id, ui
spa_node_port_reuse_buffer(pp->node->implementation, port_id, buffer_id);
}
}
return SPA_RESULT_OK;
return 0;
}
static const struct spa_node schedule_mix_node = {
@ -264,7 +264,7 @@ static int do_add_port(struct spa_loop *loop,
spa_graph_port_add(&this->rt.mix_node, &this->rt.mix_port);
spa_graph_port_link(&this->rt.port, &this->rt.mix_port);
return SPA_RESULT_OK;
return 0;
}
bool pw_port_add(struct pw_port *port, struct pw_node *node)
@ -314,7 +314,7 @@ static int do_remove_port(struct spa_loop *loop,
spa_graph_port_remove(&this->rt.mix_port);
spa_graph_node_remove(&this->rt.mix_node);
return SPA_RESULT_OK;
return 0;
}
void pw_port_destroy(struct pw_port *port)
@ -395,10 +395,10 @@ int pw_port_use_buffers(struct pw_port *port, struct spa_buffer **buffers, uint3
int res;
if (n_buffers == 0 && port->state <= PW_PORT_STATE_READY)
return SPA_RESULT_OK;
return 0;
if (n_buffers > 0 && port->state < PW_PORT_STATE_READY)
return SPA_RESULT_NO_FORMAT;
return -EIO;
if (port->state > PW_PORT_STATE_PAUSED) {
pw_loop_invoke(port->node->data_loop,
@ -432,7 +432,7 @@ int pw_port_alloc_buffers(struct pw_port *port,
int res;
if (port->state < PW_PORT_STATE_READY)
return SPA_RESULT_NO_FORMAT;
return -EIO;
if (port->state > PW_PORT_STATE_PAUSED) {
pw_loop_invoke(port->node->data_loop,

28
src/pipewire/remote.c
View file

@ -436,7 +436,7 @@ do_remove_source(struct spa_loop *loop,
pw_loop_destroy_source(d->core->data_loop, d->rtsocket_source);
d->rtsocket_source = NULL;
}
return SPA_RESULT_OK;
return 0;
}
@ -504,7 +504,7 @@ on_rtsocket_condition(void *user_data, int fd, enum spa_io mask)
pw_log_warn("proxy %p: %ld messages", proxy, cmd);
while (pw_client_node_transport_next_message(data->trans, &message) == SPA_RESULT_OK) {
while (pw_client_node_transport_next_message(data->trans, &message) == 1) {
struct pw_client_node_message *msg = alloca(SPA_POD_SIZE(&message));
pw_client_node_transport_parse_message(data->trans, msg);
handle_rtnode_message(proxy, msg);
@ -657,7 +657,7 @@ static void add_port_update(struct pw_proxy *proxy, struct pw_port *port, uint32
if (spa_node_port_enum_params(port->node->node,
port->direction, port->port_id,
data->t->param.idList, &idx1,
NULL, &b) < 0)
NULL, &b) <= 0)
break;
param = spa_pod_builder_deref(&b, 0);
@ -669,7 +669,7 @@ static void add_port_update(struct pw_proxy *proxy, struct pw_port *port, uint32
if (spa_node_port_enum_params(port->node->node,
port->direction, port->port_id,
id, &idx2,
NULL, &b) < 0)
NULL, &b) <= 0)
break;
param = spa_pod_builder_deref(&b, 0);
@ -763,7 +763,7 @@ static void client_node_command(void *object, uint32_t seq, const struct spa_com
/* FIXME we should call process_output on the node and see what its
* status is */
for (i = 0; i < data->trans->area->max_input_ports; i++)
data->trans->inputs[i].status = SPA_RESULT_NEED_BUFFER;
data->trans->inputs[i].status = SPA_STATUS_NEED_BUFFER;
node_need_input(data);
pw_client_node_proxy_done(data->node_proxy, seq, res);
@ -785,7 +785,7 @@ static void client_node_command(void *object, uint32_t seq, const struct spa_com
}
else {
pw_log_warn("unhandled node command %d", SPA_COMMAND_TYPE(command));
pw_client_node_proxy_done(data->node_proxy, seq, SPA_RESULT_NOT_IMPLEMENTED);
pw_client_node_proxy_done(data->node_proxy, seq, -ENOTSUP);
}
}
@ -815,12 +815,12 @@ client_node_port_set_param(void *object,
port = find_port(data, direction, port_id);
if (port == NULL || port->port == NULL) {
res = SPA_RESULT_INVALID_PORT;
res = -EINVAL;
goto done;
}
res = pw_port_set_param(port->port, id, flags, param);
if (res != SPA_RESULT_OK)
if (res < 0)
goto done;
add_port_update(proxy, port->port,
@ -925,7 +925,7 @@ client_node_port_use_buffers(void *object,
port = find_port(data, direction, port_id);
if (port == NULL) {
res = SPA_RESULT_INVALID_PORT;
res = -EINVAL;
goto done;
}
@ -1011,7 +1011,7 @@ client_node_port_use_buffers(void *object,
map = mmap(NULL, d->maxsize + d->mapoffset, prot, MAP_SHARED, d->fd, 0);
if (map == MAP_FAILED) {
pw_log_error("data %d failed to mmap memory %m", j);
res = SPA_RESULT_ERROR;
res = errno;
goto done;
}
d->data = SPA_MEMBER(map, d->mapoffset, uint8_t);
@ -1083,7 +1083,7 @@ static void do_node_init(struct pw_proxy *proxy)
PW_CLIENT_NODE_PORT_UPDATE_PARAMS |
PW_CLIENT_NODE_PORT_UPDATE_INFO);
}
pw_client_node_proxy_done(data->node_proxy, 0, SPA_RESULT_OK);
pw_client_node_proxy_done(data->node_proxy, 0, 0);
}
static void node_destroy(void *data)
@ -1135,7 +1135,7 @@ static const struct pw_proxy_events proxy_events = {
static int impl_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t buffer_id)
{
pw_log_trace("node %p: reuse buffer %d %d", node, port_id, buffer_id);
return SPA_RESULT_OK;
return 0;
}
static int impl_process_input(struct spa_node *node)
@ -1143,7 +1143,7 @@ static int impl_process_input(struct spa_node *node)
struct node_data *data = SPA_CONTAINER_OF(node, struct node_data, out_node_impl);
pw_log_trace("node %p: process input", node);
node_have_output(data);
return SPA_RESULT_OK;
return 0;
}
static int impl_process_output(struct spa_node *node)
@ -1151,7 +1151,7 @@ static int impl_process_output(struct spa_node *node)
struct node_data *data = SPA_CONTAINER_OF(node, struct node_data, in_node_impl);
pw_log_trace("node %p: process output", node);
node_need_input(data);
return SPA_RESULT_OK;
return 0;
}
static const struct spa_node node_impl = {

22
src/pipewire/stream.c
View file

@ -295,7 +295,7 @@ do_remove_sources(struct spa_loop *loop,
close(impl->rtwritefd);
impl->rtwritefd = -1;
}
return SPA_RESULT_OK;
return 0;
}
static void unhandle_socket(struct pw_stream *stream)
@ -492,7 +492,7 @@ static void do_node_init(struct pw_stream *stream)
add_port_update(stream, PW_CLIENT_NODE_PORT_UPDATE_PARAMS |
PW_CLIENT_NODE_PORT_UPDATE_INFO);
add_async_complete(stream, 0, SPA_RESULT_OK);
add_async_complete(stream, 0, 0);
if (!(impl->flags & PW_STREAM_FLAG_INACTIVE))
pw_client_node_proxy_set_active(impl->node_proxy, true);
}
@ -570,7 +570,7 @@ static void handle_rtnode_message(struct pw_stream *stream, struct pw_client_nod
if (impl->client_reuse)
input->buffer_id = SPA_ID_INVALID;
if (input->status == SPA_RESULT_HAVE_BUFFER) {
if (input->status == SPA_STATUS_HAVE_BUFFER) {
bid->used = true;
impl->in_new_buffer = true;
spa_hook_list_call(&stream->listener_list, struct pw_stream_events,
@ -578,7 +578,7 @@ static void handle_rtnode_message(struct pw_stream *stream, struct pw_client_nod
impl->in_new_buffer = false;
}
input->status = SPA_RESULT_NEED_BUFFER;
input->status = SPA_STATUS_NEED_BUFFER;
}
send_need_input(stream);
} else if (PW_CLIENT_NODE_MESSAGE_TYPE(message) == PW_CLIENT_NODE_MESSAGE_PROCESS_OUTPUT) {
@ -631,7 +631,7 @@ on_rtsocket_condition(void *data, int fd, enum spa_io mask)
if (read(fd, &cmd, sizeof(uint64_t)) != sizeof(uint64_t))
pw_log_warn("stream %p: read failed %m", impl);
while (pw_client_node_transport_next_message(impl->trans, &message) == SPA_RESULT_OK) {
while (pw_client_node_transport_next_message(impl->trans, &message) == 1) {
struct pw_client_node_message *msg = alloca(SPA_POD_SIZE(&message));
pw_client_node_transport_parse_message(impl->trans, msg);
handle_rtnode_message(stream, msg);
@ -676,7 +676,7 @@ static void client_node_command(void *data, uint32_t seq, const struct spa_comma
struct pw_remote *remote = stream->remote;
if (SPA_COMMAND_TYPE(command) == remote->core->type.command_node.Pause) {
add_async_complete(stream, seq, SPA_RESULT_OK);
add_async_complete(stream, seq, 0);
if (stream->state == PW_STREAM_STATE_STREAMING) {
pw_log_debug("stream %p: pause %d", stream, seq);
@ -687,7 +687,7 @@ static void client_node_command(void *data, uint32_t seq, const struct spa_comma
stream_set_state(stream, PW_STREAM_STATE_PAUSED, NULL);
}
} else if (SPA_COMMAND_TYPE(command) == remote->core->type.command_node.Start) {
add_async_complete(stream, seq, SPA_RESULT_OK);
add_async_complete(stream, seq, 0);
if (stream->state == PW_STREAM_STATE_PAUSED) {
int i;
@ -700,7 +700,7 @@ static void client_node_command(void *data, uint32_t seq, const struct spa_comma
if (impl->direction == SPA_DIRECTION_INPUT) {
for (i = 0; i < impl->trans->area->max_input_ports; i++)
impl->trans->inputs[i].status = SPA_RESULT_NEED_BUFFER;
impl->trans->inputs[i].status = SPA_STATUS_NEED_BUFFER;
send_need_input(stream);
}
else {
@ -725,7 +725,7 @@ static void client_node_command(void *data, uint32_t seq, const struct spa_comma
impl->last_monotonic = cu->body.monotonic_time.value;
} else {
pw_log_warn("unhandled node command %d", SPA_COMMAND_TYPE(command));
add_async_complete(stream, seq, SPA_RESULT_NOT_IMPLEMENTED);
add_async_complete(stream, seq, -ENOTSUP);
}
}
@ -912,7 +912,7 @@ client_node_port_use_buffers(void *data,
spa_hook_list_call(&stream->listener_list, struct pw_stream_events, add_buffer, bid->id);
}
add_async_complete(stream, seq, SPA_RESULT_OK);
add_async_complete(stream, seq, 0);
if (n_buffers)
stream_set_state(stream, PW_STREAM_STATE_PAUSED, NULL);
@ -1158,7 +1158,7 @@ bool pw_stream_send_buffer(struct pw_stream *stream, uint32_t id)
bid->used = true;
spa_list_remove(&bid->link);
impl->trans->outputs[0].buffer_id = id;
impl->trans->outputs[0].status = SPA_RESULT_HAVE_BUFFER;
impl->trans->outputs[0].status = SPA_STATUS_HAVE_BUFFER;
pw_log_trace("stream %p: send buffer %d", stream, id);
if (!impl->in_need_buffer)
send_have_output(stream);

6
src/pipewire/thread-loop.c
View file

@ -168,7 +168,7 @@ static void *do_loop(void *user_data)
/** Start the thread to handle \a loop
*
* \param loop a \ref pw_thread_loop
* \return \ref SPA_RESULT_OK on success
* \return 0 on success
*
* \memberof pw_thread_loop
*/
@ -182,10 +182,10 @@ int pw_thread_loop_start(struct pw_thread_loop *loop)
pw_log_warn("thread-loop %p: can't create thread: %s", loop,
strerror(err));
loop->running = false;
return SPA_RESULT_ERROR;
return -err;
}
}
return SPA_RESULT_OK;
return 0;
}
/** Quit the loop and stop its thread

5
src/pipewire/work-queue.c
View file

@ -17,6 +17,7 @@
* Boston, MA 02110-1301, USA.
*/
#include <errno.h>
#include <stdio.h>
#include <string.h>
@ -58,7 +59,7 @@ static void process_work_queue(void *data, uint64_t count)
continue;
}
if (item->res == SPA_RESULT_WAIT_SYNC &&
if (item->res == -EBUSY &&
item != spa_list_first(&this->work_list, struct work_item, link)) {
pw_log_debug("work-queue %p: %d sync item %p not head", this,
this->n_queued, item->obj);
@ -158,7 +159,7 @@ pw_work_queue_add(struct pw_work_queue *queue, void *obj, int res, pw_work_func_
item->seq = SPA_RESULT_ASYNC_SEQ(res);
item->res = res;
pw_log_debug("work-queue %p: defer async %d for object %p", queue, item->seq, obj);
} else if (res == SPA_RESULT_WAIT_SYNC) {
} else if (res == -EBUSY) {
pw_log_debug("work-queue %p: wait sync object %p", queue, obj);
item->seq = SPA_ID_INVALID;
item->res = res;