Changeset 5a6cc679 in mainline for uspace/srv/audio

Timestamp:

2018-01-31T02:21:24Z (8 years ago)

Author:

Jenda <jenda.jzqk73@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

a0a9cc2

Parents:

132ab5d1

Message:

Merge commit '50f19b7ee8e94570b5c63896736c4eb49cfa18db' into forwardport

Not all ints are converted to errno_t in xhci tree yet, however it compiles and works

Location:

uspace/srv/audio/hound

Files:

• audio_data.c (modified) (1 diff)
• audio_data.h (modified) (2 diffs)
• audio_device.c (modified) (16 diffs)
• audio_device.h (modified) (1 diff)
• audio_sink.c (modified) (4 diffs)
• audio_sink.h (modified) (2 diffs)
• audio_source.c (modified) (3 diffs)
• audio_source.h (modified) (2 diffs)
• connection.c (modified) (2 diffs)
• connection.h (modified) (1 diff)
• hound.c (modified) (21 diffs)
• hound.h (modified) (1 diff)
• hound_ctx.c (modified) (11 diffs)
• hound_ctx.h (modified) (1 diff)
• iface.c (modified) (11 diffs)
• main.c (modified) (2 diffs)

uspace/srv/audio/hound/audio_data.c

@@ -213 +213 @@
  * @return Error code.
  */
-int audio_pipe_push(audio_pipe_t *pipe, audio_data_t *data)
+errno_t audio_pipe_push(audio_pipe_t *pipe, audio_data_t *data)
 {
         assert(pipe);

uspace/srv/audio/hound/audio_data.h

@@ -75 +75 @@
 void audio_pipe_fini(audio_pipe_t *pipe);
 
-int audio_pipe_push(audio_pipe_t *pipe, audio_data_t *data);
+errno_t audio_pipe_push(audio_pipe_t *pipe, audio_data_t *data);
 audio_data_t *audio_pipe_pop(audio_pipe_t *pipe);
 
@@ -113 +113 @@
  * Reference counted buffer is created automatically.
  */
-static inline int audio_pipe_push_data(audio_pipe_t *pipe,
+static inline errno_t audio_pipe_push_data(audio_pipe_t *pipe,
     const void *data, size_t size, pcm_format_t f)
 {
         audio_data_t *adata = audio_data_create(data, size, f);
         if (adata) {
-                const int ret = audio_pipe_push(pipe, adata);
+                const errno_t ret = audio_pipe_push(pipe, adata);
                 audio_data_unref(adata);
                 return ret;

uspace/srv/audio/hound/audio_device.c

@@ -51 +51 @@
 #define BUFFER_PARTS   16
 
-static int device_sink_connection_callback(audio_sink_t *sink, bool new);
-static int device_source_connection_callback(audio_source_t *source, bool new);
+static errno_t device_sink_connection_callback(audio_sink_t *sink, bool new);
+static errno_t device_source_connection_callback(audio_source_t *source, bool new);
 static void device_event_callback(ipc_callid_t iid, ipc_call_t *icall, void *arg);
-static int device_check_format(audio_sink_t* sink);
-static int get_buffer(audio_device_t *dev);
-static int release_buffer(audio_device_t *dev);
+static errno_t device_check_format(audio_sink_t* sink);
+static errno_t get_buffer(audio_device_t *dev);
+static errno_t release_buffer(audio_device_t *dev);
 static void advance_buffer(audio_device_t *dev, size_t size);
 static inline bool is_running(audio_device_t *dev)
@@ -72 +72 @@
  * @return Error code.
  */
-int audio_device_init(audio_device_t *dev, service_id_t id, const char *name)
+errno_t audio_device_init(audio_device_t *dev, service_id_t id, const char *name)
 {
         assert(dev);
@@ -122 +122 @@
         assert(dev);
         sysarg_t val;
-        int rc = audio_pcm_query_cap(dev->sess, AUDIO_CAP_CAPTURE, &val);
+        errno_t rc = audio_pcm_query_cap(dev->sess, AUDIO_CAP_CAPTURE, &val);
         if (rc == EOK && val)
                 return &dev->source;
@@ -138 +138 @@
         assert(dev);
         sysarg_t val;
-        int rc = audio_pcm_query_cap(dev->sess, AUDIO_CAP_PLAYBACK, &val);
+        errno_t rc = audio_pcm_query_cap(dev->sess, AUDIO_CAP_PLAYBACK, &val);
         if (rc == EOK && val)
                 return &dev->sink;
@@ -153 +153 @@
  * connections.
  */
-static int device_sink_connection_callback(audio_sink_t* sink, bool new)
+static errno_t device_sink_connection_callback(audio_sink_t* sink, bool new)
 {
         assert(sink);
@@ -160 +160 @@
                 log_verbose("First connection on device sink '%s'", sink->name);
 
-                int ret = get_buffer(dev);
+                errno_t ret = get_buffer(dev);
                 if (ret != EOK) {
                         log_error("Failed to get device buffer: %s",
@@ -196 +196 @@
                 log_verbose("Removed last connection on device sink '%s'",
                     sink->name);
-                int ret = audio_pcm_stop_playback(dev->sess);
+                errno_t ret = audio_pcm_stop_playback(dev->sess);
                 if (ret != EOK) {
                         log_error("Failed to stop playback: %s",
@@ -215 +215 @@
  * connections.
  */
-static int device_source_connection_callback(audio_source_t *source, bool new)
+static errno_t device_source_connection_callback(audio_source_t *source, bool new)
 {
         assert(source);
         audio_device_t *dev = source->private_data;
         if (new && list_count(&source->connections) == 1) {
-                int ret = get_buffer(dev);
+                errno_t ret = get_buffer(dev);
                 if (ret != EOK) {
                         log_error("Failed to get device buffer: %s",
@@ -244 +244 @@
         if (list_count(&source->connections) == 0) { /* Disconnected */
                 assert(!new);
-                int ret = audio_pcm_stop_capture_immediate(dev->sess);
+                errno_t ret = audio_pcm_stop_capture_immediate(dev->sess);
                 if (ret != EOK) {
                         log_error("Failed to start recording: %s",
@@ -289 +289 @@
                         log_verbose("Capture terminated");
                         dev->source.format = AUDIO_FORMAT_ANY;
-                        const int ret = release_buffer(dev);
+                        const errno_t ret = release_buffer(dev);
                         if (ret != EOK) {
                                 log_error("Failed to release buffer: %s",
@@ -300 +300 @@
                         log_verbose("Playback Terminated");
                         dev->sink.format = AUDIO_FORMAT_ANY;
-                        const int ret = release_buffer(dev);
+                        const errno_t ret = release_buffer(dev);
                         if (ret != EOK) {
                                 log_error("Failed to release buffer: %s",
@@ -309 +309 @@
                 }
                 case PCM_EVENT_FRAMES_CAPTURED: {
-                        const int ret = audio_source_push_data(&dev->source,
+                        const errno_t ret = audio_source_push_data(&dev->source,
                             dev->buffer.position, dev->buffer.fragment_size);
                         advance_buffer(dev, dev->buffer.fragment_size);
@@ -329 +329 @@
  * @return Error code.
  */
-static int device_check_format(audio_sink_t* sink)
+static errno_t device_check_format(audio_sink_t* sink)
 {
         assert(sink);
@@ -347 +347 @@
  * @return Error code.
  */
-static int get_buffer(audio_device_t *dev)
+static errno_t get_buffer(audio_device_t *dev)
 {
         assert(dev);
@@ -362 +362 @@
         size_t preferred_size = 0;
 
-        const int ret = audio_pcm_get_buffer(dev->sess, &dev->buffer.base,
+        const errno_t ret = audio_pcm_get_buffer(dev->sess, &dev->buffer.base,
             &preferred_size);
         if (ret == EOK) {
@@ -378 +378 @@
  * @return Error code.
  */
-static int release_buffer(audio_device_t *dev)
+static errno_t release_buffer(audio_device_t *dev)
 {
         assert(dev);
         assert(dev->buffer.base);
 
-        const int ret = audio_pcm_release_buffer(dev->sess);
+        const errno_t ret = audio_pcm_release_buffer(dev->sess);
         if (ret == EOK) {
                 as_area_destroy(dev->buffer.base);

uspace/srv/audio/hound/audio_device.h

@@ -76 +76 @@
 };
 
-int audio_device_init(audio_device_t *dev, service_id_t id, const char *name);
+errno_t audio_device_init(audio_device_t *dev, service_id_t id, const char *name);
 void audio_device_fini(audio_device_t *dev);
 audio_source_t * audio_device_get_source(audio_device_t *dev);
 audio_sink_t * audio_device_get_sink(audio_device_t *dev);
-int audio_device_recorded_data(audio_device_t *dev, void **base, size_t *size);
-int audio_device_available_buffer(audio_device_t *dev, void **base, size_t *size);
+errno_t audio_device_recorded_data(audio_device_t *dev, void **base, size_t *size);
+errno_t audio_device_available_buffer(audio_device_t *dev, void **base, size_t *size);
 
 #endif

uspace/srv/audio/hound/audio_sink.c

@@ -56 +56 @@
  * @return Error code.
  */
-int audio_sink_init(audio_sink_t *sink, const char *name, void *private_data,
-    int (*connection_change)(audio_sink_t *, bool),
-    int (*check_format)(audio_sink_t *), int (*data_available)(audio_sink_t *),
+errno_t audio_sink_init(audio_sink_t *sink, const char *name, void *private_data,
+    errno_t (*connection_change)(audio_sink_t *, bool),
+    errno_t (*check_format)(audio_sink_t *), errno_t (*data_available)(audio_sink_t *),
     const pcm_format_t *f)
 {
@@ -97 +97 @@
  * @return Error code.
  */
-int audio_sink_set_format(audio_sink_t *sink, const pcm_format_t *format)
+errno_t audio_sink_set_format(audio_sink_t *sink, const pcm_format_t *format)
 {
         assert(sink);
@@ -114 +114 @@
         }
         if (sink->check_format) {
-                const int ret = sink->check_format(sink);
+                const errno_t ret = sink->check_format(sink);
                 if (ret != EOK && ret != ELIMIT) {
                         log_debug("Format check failed on sink %s", sink->name);
@@ -141 +141 @@
         pcm_format_silence(dest, size, &sink->format);
         list_foreach(sink->connections, sink_link, connection_t, conn) {
-                const int ret = connection_add_source_data(
+                const errno_t ret = connection_add_source_data(
                     conn, dest, size, sink->format);
                 if (ret != EOK) {

uspace/srv/audio/hound/audio_sink.h

@@ -60 +60 @@
         void *private_data;
         /** Connect/disconnect callback */
-        int (*connection_change)(audio_sink_t *, bool);
+        errno_t (*connection_change)(audio_sink_t *, bool);
         /** Backend callback to check data */
-        int (*check_format)(audio_sink_t *);
+        errno_t (*check_format)(audio_sink_t *);
         /** new data notifier */
-        int (*data_available)(audio_sink_t *);
+        errno_t (*data_available)(audio_sink_t *);
 };
 
@@ -77 +77 @@
 }
 
-int audio_sink_init(audio_sink_t *sink, const char *name, void *private_data,
-    int (*connection_change)(audio_sink_t *, bool),
-    int (*check_format)(audio_sink_t *), int (*data_available)(audio_sink_t *),
+errno_t audio_sink_init(audio_sink_t *sink, const char *name, void *private_data,
+    errno_t (*connection_change)(audio_sink_t *, bool),
+    errno_t (*check_format)(audio_sink_t *), errno_t (*data_available)(audio_sink_t *),
     const pcm_format_t *f);
 
 void audio_sink_fini(audio_sink_t *sink);
-int audio_sink_set_format(audio_sink_t *sink, const pcm_format_t *format);
+errno_t audio_sink_set_format(audio_sink_t *sink, const pcm_format_t *format);
 void audio_sink_mix_inputs(audio_sink_t *sink, void* dest, size_t size);
 

uspace/srv/audio/hound/audio_source.c

@@ -56 +56 @@
  * @return Error code.
  */
-int audio_source_init(audio_source_t *source, const char *name, void *data,
-    int (*connection_change)(audio_source_t *, bool new),
-    int (*update_available_data)(audio_source_t *, size_t),
+errno_t audio_source_init(audio_source_t *source, const char *name, void *data,
+    errno_t (*connection_change)(audio_source_t *, bool new),
+    errno_t (*update_available_data)(audio_source_t *, size_t),
     const pcm_format_t *f)
 {
@@ -96 +96 @@
  * @return Error code.
  */
-int audio_source_push_data(audio_source_t *source, const void *data,
+errno_t audio_source_push_data(audio_source_t *source, const void *data,
     size_t size)
 {
@@ -107 +107 @@
 
         list_foreach(source->connections, source_link, connection_t, conn) {
-                const int ret = connection_push_data(conn, adata);
+                const errno_t ret = connection_push_data(conn, adata);
                 if (ret != EOK) {
                         log_warning("Failed push data to %s: %s",

uspace/srv/audio/hound/audio_source.h

@@ -55 +55 @@
         void *private_data;
         /** Callback for connection and disconnection */
-        int (*connection_change)(audio_source_t *source, bool added);
+        errno_t (*connection_change)(audio_source_t *source, bool added);
         /** Ask backend for more data */
-        int (*update_available_data)(audio_source_t *source, size_t size);
+        errno_t (*update_available_data)(audio_source_t *source, size_t size);
 };
 
@@ -70 +70 @@
 }
 
-int audio_source_init(audio_source_t *source, const char *name, void *data,
-    int (*connection_change)(audio_source_t *, bool),
-    int (*update_available_data)(audio_source_t *, size_t),
+errno_t audio_source_init(audio_source_t *source, const char *name, void *data,
+    errno_t (*connection_change)(audio_source_t *, bool),
+    errno_t (*update_available_data)(audio_source_t *, size_t),
     const pcm_format_t *f);
 void audio_source_fini(audio_source_t *source);
-int audio_source_push_data(audio_source_t *source, const void *data,
+errno_t audio_source_push_data(audio_source_t *source, const void *data,
     size_t size);
 static inline const pcm_format_t *audio_source_format(const audio_source_t *s)

uspace/srv/audio/hound/connection.c

@@ -101 +101 @@
  * @param format format of the destination audio buffer.
  */
-int connection_add_source_data(connection_t *connection, void *data,
+errno_t connection_add_source_data(connection_t *connection, void *data,
     size_t size, pcm_format_t format)
 {
@@ -129 +129 @@
  * @return Error code.
  */
-int connection_push_data(connection_t *connection,
+errno_t connection_push_data(connection_t *connection,
     audio_data_t *adata)
 {
         assert(connection);
         assert(adata);
-        const int ret = audio_pipe_push(&connection->fifo, adata);
+        const errno_t ret = audio_pipe_push(&connection->fifo, adata);
         if (ret == EOK && connection->sink->data_available)
                 connection->sink->data_available(connection->sink);

uspace/srv/audio/hound/connection.h

@@ -84 +84 @@
 void connection_destroy(connection_t *connection);
 
-int connection_add_source_data(connection_t *connection, void *data,
+errno_t connection_add_source_data(connection_t *connection, void *data,
     size_t size, pcm_format_t format);
 
-int connection_push_data(connection_t *connection, audio_data_t *adata);
+errno_t connection_push_data(connection_t *connection, audio_data_t *adata);
 
 /**

uspace/srv/audio/hound/hound.c

@@ -110 +110 @@
 }
 
-static int hound_disconnect_internal(hound_t *hound, const char* source_name, const char* sink_name);
+static errno_t hound_disconnect_internal(hound_t *hound, const char* source_name, const char* sink_name);
 
 /**
@@ -162 +162 @@
  * @return Error code.
  */
-int hound_init(hound_t *hound)
+errno_t hound_init(hound_t *hound)
 {
         assert(hound);
@@ -180 +180 @@
  * @return Error code.
  */
-int hound_add_ctx(hound_t *hound, hound_ctx_t *ctx)
+errno_t hound_add_ctx(hound_t *hound, hound_ctx_t *ctx)
 {
         log_info("Trying to add context %p", ctx);
@@ -189 +189 @@
         list_append(&ctx->link, &hound->contexts);
         fibril_mutex_unlock(&hound->list_guard);
-        int ret = EOK;
+        errno_t ret = EOK;
         if (ret == EOK && ctx->source)
                 ret = hound_add_source(hound, ctx->source);
@@ -208 +208 @@
  * @return Error code.
  */
-int hound_remove_ctx(hound_t *hound, hound_ctx_t *ctx)
+errno_t hound_remove_ctx(hound_t *hound, hound_ctx_t *ctx)
 {
         assert(hound);
@@ -254 +254 @@
  * @return Error code.
  */
-int hound_add_device(hound_t *hound, service_id_t id, const char *name)
+errno_t hound_add_device(hound_t *hound, service_id_t id, const char *name)
 {
         log_verbose("Adding device \"%s\", service: %zu", name, id);
@@ -283 +283 @@
         }
 
-        const int ret = audio_device_init(dev, id, name);
+        const errno_t ret = audio_device_init(dev, id, name);
         if (ret != EOK) {
                 log_debug("Failed to initialize new audio device: %s",
@@ -296 +296 @@
         audio_source_t *source = audio_device_get_source(dev);
         if (source) {
-                const int ret = hound_add_source(hound, source);
+                const errno_t ret = hound_add_source(hound, source);
                 if (ret != EOK) {
                         log_debug("Failed to add device source: %s",
@@ -308 +308 @@
         audio_sink_t *sink = audio_device_get_sink(dev);
         if (sink) {
-                const int ret = hound_add_sink(hound, sink);
+                const errno_t ret = hound_add_sink(hound, sink);
                 if (ret != EOK) {
                         log_debug("Failed to add device sink: %s",
@@ -330 +330 @@
  * @return Error code.
  */
-int hound_add_source(hound_t *hound, audio_source_t *source)
+errno_t hound_add_source(hound_t *hound, audio_source_t *source)
 {
         assert(hound);
@@ -354 +354 @@
  * @return Error code.
  */
-int hound_add_sink(hound_t *hound, audio_sink_t *sink)
+errno_t hound_add_sink(hound_t *hound, audio_sink_t *sink)
 {
         assert(hound);
@@ -378 +378 @@
  * @return Error code.
  */
-int hound_remove_source(hound_t *hound, audio_source_t *source)
+errno_t hound_remove_source(hound_t *hound, audio_source_t *source)
 {
         assert(hound);
@@ -395 +395 @@
  * @return Error code.
  */
-int hound_remove_sink(hound_t *hound, audio_sink_t *sink)
+errno_t hound_remove_sink(hound_t *hound, audio_sink_t *sink)
 {
         assert(hound);
@@ -413 +413 @@
  * @return Error code.
  */
-int hound_list_sources(hound_t *hound, const char ***list, size_t *size)
+errno_t hound_list_sources(hound_t *hound, const char ***list, size_t *size)
 {
         assert(hound);
@@ -428 +428 @@
         }
         const char **names = calloc(count, sizeof(char *));
-        int ret = names ? EOK : ENOMEM;
+        errno_t ret = names ? EOK : ENOMEM;
         for (unsigned long i = 0; i < count && ret == EOK; ++i) {
                 link_t *slink = list_nth(&hound->sources, i);
@@ -455 +455 @@
  * @return Error code.
  */
-int hound_list_sinks(hound_t *hound, const char ***list, size_t *size)
+errno_t hound_list_sinks(hound_t *hound, const char ***list, size_t *size)
 {
         assert(hound);
@@ -470 +470 @@
         }
         const char **names = calloc(count, sizeof(char *));
-        int ret = names ? EOK : ENOMEM;
+        errno_t ret = names ? EOK : ENOMEM;
         for (size_t i = 0; i < count && ret == EOK; ++i) {
                 link_t *slink = list_nth(&hound->sinks, i);
@@ -501 +501 @@
  * identifiers with the same index are connected.
  */
-int hound_list_connections(hound_t *hound, const char ***sources,
+errno_t hound_list_connections(hound_t *hound, const char ***sources,
     const char ***sinks, size_t *size)
 {
@@ -516 +516 @@
  * @return Error code.
  */
-int hound_connect(hound_t *hound, const char* source_name, const char* sink_name)
+errno_t hound_connect(hound_t *hound, const char* source_name, const char* sink_name)
 {
         assert(hound);
@@ -555 +555 @@
  * @return Error code.
  */
-int hound_disconnect(hound_t *hound, const char* source_name, const char* sink_name)
-{
-        assert(hound);
-        fibril_mutex_lock(&hound->list_guard);
-        const int ret = hound_disconnect_internal(hound, source_name, sink_name);
+errno_t hound_disconnect(hound_t *hound, const char* source_name, const char* sink_name)
+{
+        assert(hound);
+        fibril_mutex_lock(&hound->list_guard);
+        const errno_t ret = hound_disconnect_internal(hound, source_name, sink_name);
         fibril_mutex_unlock(&hound->list_guard);
         return ret;
@@ -573 +573 @@
  * This function has to be called with the list_guard lock held.
  */
-static int hound_disconnect_internal(hound_t *hound, const char* source_name,
+static errno_t hound_disconnect_internal(hound_t *hound, const char* source_name,
     const char* sink_name)
 {

uspace/srv/audio/hound/hound.h

@@ -65 +65 @@
 } hound_t;
 
-int hound_init(hound_t *hound);
-int hound_add_ctx(hound_t *hound, hound_ctx_t *ctx);
-int hound_remove_ctx(hound_t *hound, hound_ctx_t *ctx);
+errno_t hound_init(hound_t *hound);
+errno_t hound_add_ctx(hound_t *hound, hound_ctx_t *ctx);
+errno_t hound_remove_ctx(hound_t *hound, hound_ctx_t *ctx);
 hound_ctx_t *hound_get_ctx_by_id(hound_t *hound, hound_context_id_t id);
 
-int hound_add_device(hound_t *hound, service_id_t id, const char* name);
-int hound_add_source(hound_t *hound, audio_source_t *source);
-int hound_add_sink(hound_t *hound, audio_sink_t *sink);
-int hound_list_sources(hound_t *hound, const char ***list, size_t *size);
-int hound_list_sinks(hound_t *hound, const char ***list, size_t *size);
-int hound_list_connections(hound_t *hound, const char ***sources,
+errno_t hound_add_device(hound_t *hound, service_id_t id, const char* name);
+errno_t hound_add_source(hound_t *hound, audio_source_t *source);
+errno_t hound_add_sink(hound_t *hound, audio_sink_t *sink);
+errno_t hound_list_sources(hound_t *hound, const char ***list, size_t *size);
+errno_t hound_list_sinks(hound_t *hound, const char ***list, size_t *size);
+errno_t hound_list_connections(hound_t *hound, const char ***sources,
     const char ***sinks, size_t *size);
-int hound_remove_source(hound_t *hound, audio_source_t *source);
-int hound_remove_sink(hound_t *hound, audio_sink_t *sink);
-int hound_connect(hound_t *hound, const char* source_name, const char* sink_name);
-int hound_disconnect(hound_t *hound, const char* source_name, const char* sink_name);
+errno_t hound_remove_source(hound_t *hound, audio_source_t *source);
+errno_t hound_remove_sink(hound_t *hound, audio_sink_t *sink);
+errno_t hound_connect(hound_t *hound, const char* source_name, const char* sink_name);
+errno_t hound_disconnect(hound_t *hound, const char* source_name, const char* sink_name);
 
 #endif

uspace/srv/audio/hound/hound_ctx.c

@@ -45 +45 @@
 #include "log.h"
 
-static int update_data(audio_source_t *source, size_t size);
-static int new_data(audio_sink_t *sink);
+static errno_t update_data(audio_source_t *source, size_t size);
+static errno_t new_data(audio_sink_t *sink);
 
 /**
@@ -68 +68 @@
                         return NULL;
                 }
-                const int ret = audio_sink_init(ctx->sink, name, ctx, NULL,
+                const errno_t ret = audio_sink_init(ctx->sink, name, ctx, NULL,
                     NULL, new_data, &AUDIO_FORMAT_DEFAULT);
                 if (ret != EOK) {
@@ -99 +99 @@
                         return NULL;
                 }
-                const int ret = audio_source_init(ctx->source, name, ctx, NULL,
+                const errno_t ret = audio_source_init(ctx->source, name, ctx, NULL,
                     update_data, &AUDIO_FORMAT_DEFAULT);
                 if (ret != EOK) {
@@ -199 +199 @@
  * @return Error code.
  */
-static int stream_push_data(hound_ctx_stream_t *stream, audio_data_t *adata)
+static errno_t stream_push_data(hound_ctx_stream_t *stream, audio_data_t *adata)
 {
         assert(stream);
@@ -216 +216 @@
         }
 
-        const int ret = audio_pipe_push(&stream->fifo, adata);
+        const errno_t ret = audio_pipe_push(&stream->fifo, adata);
         fibril_mutex_unlock(&stream->guard);
         if (ret == EOK)
@@ -297 +297 @@
  * @return Error code.
  */
-int hound_ctx_stream_write(hound_ctx_stream_t *stream, const void *data,
+errno_t hound_ctx_stream_write(hound_ctx_stream_t *stream, const void *data,
     size_t size)
 {
@@ -312 +312 @@
         }
 
-        const int ret =
+        const errno_t ret =
             audio_pipe_push_data(&stream->fifo, data, size, stream->format);
         fibril_mutex_unlock(&stream->guard);
@@ -327 +327 @@
  * @return Error code.
  */
-int hound_ctx_stream_read(hound_ctx_stream_t *stream, void *data, size_t size)
+errno_t hound_ctx_stream_read(hound_ctx_stream_t *stream, void *data, size_t size)
 {
         assert(stream);
@@ -391 +391 @@
  * Mixes data from all streams and pushes it to all connections.
  */
-int update_data(audio_source_t *source, size_t size)
+errno_t update_data(audio_source_t *source, size_t size)
 {
         assert(source);
@@ -425 +425 @@
 }
 
-int new_data(audio_sink_t *sink)
+errno_t new_data(audio_sink_t *sink)
 {
         assert(sink);
@@ -463 +463 @@
         /* push to all streams */
         list_foreach(ctx->streams, link, hound_ctx_stream_t, stream) {
-                const int ret = stream_push_data(stream, adata);
+                const errno_t ret = stream_push_data(stream, adata);
                 if (ret != EOK)
                         log_error("Failed to push data to stream: %s",

uspace/srv/audio/hound/hound_ctx.h

@@ -72 +72 @@
 void hound_ctx_destroy_stream(hound_ctx_stream_t *stream);
 
-int hound_ctx_stream_write(hound_ctx_stream_t *stream, const void *buffer,
+errno_t hound_ctx_stream_write(hound_ctx_stream_t *stream, const void *buffer,
     size_t size);
-int hound_ctx_stream_read(hound_ctx_stream_t *stream, void *buffer, size_t size);
+errno_t hound_ctx_stream_read(hound_ctx_stream_t *stream, void *buffer, size_t size);
 size_t hound_ctx_stream_add_self(hound_ctx_stream_t *stream, void *data,
     size_t size, const pcm_format_t *f);

uspace/srv/audio/hound/iface.c

@@ -43 +43 @@
 #include "log.h"
 
-static int iface_add_context(void *server, hound_context_id_t *id,
+static errno_t iface_add_context(void *server, hound_context_id_t *id,
     const char *name, bool record)
 {
@@ -55 +55 @@
                 return ENOMEM;
 
-        const int ret = hound_add_ctx(server, ctx);
+        const errno_t ret = hound_add_ctx(server, ctx);
         if (ret != EOK)
                 hound_ctx_destroy(ctx);
@@ -63 +63 @@
 }
 
-static int iface_rem_context(void *server, hound_context_id_t id)
+static errno_t iface_rem_context(void *server, hound_context_id_t id)
 {
         assert(server);
@@ -69 +69 @@
         if (!ctx)
                 return EINVAL;
-        const int ret = hound_remove_ctx(server, ctx);
+        const errno_t ret = hound_remove_ctx(server, ctx);
         if (ret == EOK) {
                 hound_ctx_destroy(ctx);
@@ -86 +86 @@
 }
 
-static int iface_get_list(void *server, const char ***list, size_t *size,
+static errno_t iface_get_list(void *server, const char ***list, size_t *size,
     const char *connection, int flags)
 {
@@ -98 +98 @@
 }
 
-static int iface_connect(void *server, const char *source, const char *sink)
+static errno_t iface_connect(void *server, const char *source, const char *sink)
 {
         log_info("%s: %p, %s -> %s", __FUNCTION__, server, source, sink);
@@ -104 +104 @@
 }
 
-static int iface_disconnect(void *server, const char *source, const char *sink)
+static errno_t iface_disconnect(void *server, const char *source, const char *sink)
 {
         log_info("%s: %p, %s -> %s", __FUNCTION__, server, source, sink);
@@ -110 +110 @@
 }
 
-static int iface_add_stream(void *server, hound_context_id_t id, int flags,
+static errno_t iface_add_stream(void *server, hound_context_id_t id, int flags,
     pcm_format_t format, size_t size, void **data)
 {
@@ -130 +130 @@
 }
 
-static int iface_rem_stream(void *server, void *stream)
+static errno_t iface_rem_stream(void *server, void *stream)
 {
         hound_ctx_destroy_stream(stream);
@@ -136 +136 @@
 }
 
-static int iface_drain_stream(void *stream)
+static errno_t iface_drain_stream(void *stream)
 {
         hound_ctx_stream_drain(stream);
@@ -142 +142 @@
 }
 
-static int iface_stream_data_read(void *stream, void *buffer, size_t size)
+static errno_t iface_stream_data_read(void *stream, void *buffer, size_t size)
 {
         return hound_ctx_stream_read(stream, buffer, size);
 }
 
-static int iface_stream_data_write(void *stream, const void *buffer, size_t size)
+static errno_t iface_stream_data_write(void *stream, const void *buffer, size_t size)
 {
         return hound_ctx_stream_write(stream, buffer, size);

uspace/srv/audio/hound/main.c

@@ -57 +57 @@
 static hound_t hound;
 
-static int device_callback(service_id_t id, const char *name)
+static errno_t device_callback(service_id_t id, const char *name)
 {
         return hound_add_device(&hound, id, name);
@@ -76 +76 @@
         }
 
-        int ret = hound_init(&hound);
+        errno_t ret = hound_init(&hound);
         if (ret != EOK) {
                 log_fatal("Failed to initialize hound structure: %s",