Changeset d988ef2 in mainline

Timestamp:

2013-04-05T12:02:45Z (12 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

f1438e5

Parents:

4b33db8e

Message:

hound: audio pipe class

This will be used by both streams and connections

Location:

uspace/srv/audio/hound

Files:

• audio_data.c (modified) (6 diffs)
• audio_data.h (modified) (4 diffs)

uspace/srv/audio/hound/audio_data.c

@@ -34 +34 @@
  */
 
+#include <macros.h>
 #include <malloc.h>
 #include "audio_data.h"
 
-static void ref_inc(audio_data_t *adata)
+audio_data_t *audio_data_create(const void *data, size_t size,
+    pcm_format_t format)
+{
+        audio_data_t *adata = malloc(sizeof(audio_data_t));
+        if (adata) {
+                adata->data = data;
+                adata->size = size;
+                adata->format = format;
+                atomic_set(&adata->refcount, 1);
+        }
+        return adata;
+}
+
+void audio_data_addref(audio_data_t *adata)
 {
         assert(adata);
@@ -44 +58 @@
 }
 
-static void ref_dec(audio_data_t *adata)
+void audio_data_unref(audio_data_t *adata)
 {
         assert(adata);
@@ -55 +69 @@
 }
 
-audio_data_t *audio_data_create(const void *data, size_t size,
-    pcm_format_t format)
-{
-        audio_data_t *adata = malloc(sizeof(audio_data_t));
-        if (adata) {
-                adata->data = data;
-                adata->size = size;
-                adata->format = format;
-                atomic_set(&adata->refcount, 1);
-        }
-        return adata;
-}
-
-void audio_data_unref(audio_data_t *adata)
-{
-        ref_dec(adata);
-}
-
 audio_data_link_t *audio_data_link_create(audio_data_t *adata)
 {
@@ -78 +74 @@
         audio_data_link_t *link = malloc(sizeof(audio_data_link_t));
         if (link) {
-                ref_inc(adata);
+                audio_data_addref(adata);
                 link->adata = adata;
                 link->position = 0;
@@ -103 +99 @@
         assert(link);
         assert(!link_in_use(&link->link));
-        ref_dec(link->adata);
+        audio_data_unref(link->adata);
         free(link);
 }
@@ -111 +107 @@
         assert(alink);
         assert(alink->adata);
-        return pcm_format_size_to_frames(alink->adata->size - alink->position,
+        return pcm_format_size_to_frames(audio_data_link_remain_size(alink),
             &alink->adata->format);
+}
+
+/* Audio Pipe */
+
+
+void audio_pipe_init(audio_pipe_t *pipe)
+{
+        assert(pipe);
+        list_initialize(&pipe->list);
+        fibril_mutex_initialize(&pipe->guard);
+        pipe->frames = 0;
+        pipe->bytes = 0;
+}
+
+
+
+void audio_pipe_fini(audio_pipe_t *pipe)
+{
+        assert(pipe);
+        while (!list_empty(&pipe->list)) {
+                audio_data_t *adata = audio_pipe_pop(pipe);
+                audio_data_unref(adata);
+        }
+}
+
+int audio_pipe_push(audio_pipe_t *pipe, audio_data_t *data)
+{
+        assert(pipe);
+        assert(data);
+        audio_data_link_t *alink = audio_data_link_create(data);
+        if (!alink)
+                return ENOMEM;
+
+        fibril_mutex_lock(&pipe->guard);
+        list_append(&alink->link, &pipe->list);
+        pipe->bytes += audio_data_link_remain_size(alink);
+        pipe->frames += audio_data_link_available_frames(alink);
+        fibril_mutex_unlock(&pipe->guard);
+        return EOK;
+}
+
+audio_data_t *audio_pipe_pop(audio_pipe_t *pipe)
+{
+        assert(pipe);
+        fibril_mutex_lock(&pipe->guard);
+        audio_data_t *adata = NULL;
+        link_t *l = list_first(&pipe->list);
+        if (l) {
+                audio_data_link_t *alink = audio_data_link_list_instance(l);
+                list_remove(&alink->link);
+                adata = alink->adata;
+                audio_data_addref(adata);
+                audio_data_link_destroy(alink);
+        }
+        fibril_mutex_unlock(&pipe->guard);
+        return adata;
+}
+
+ssize_t audio_pipe_mix_data(audio_pipe_t *pipe, void *data,
+    size_t size, const pcm_format_t *f)
+{
+        assert(pipe);
+        const size_t dst_frame_size = pcm_format_frame_size(f);
+        size_t needed_frames = size / dst_frame_size;
+        size_t copied_size = 0;
+        fibril_mutex_lock(&pipe->guard);
+        while (needed_frames > 0 && !list_empty(&pipe->list)) {
+                /* Get first audio chunk */
+                link_t *l = list_first(&pipe->list);
+                audio_data_link_t *alink = audio_data_link_list_instance(l);
+
+                /* Get audio chunk metadata */
+                const size_t src_frame_size =
+                    pcm_format_frame_size(&alink->adata->format);
+                const size_t available_frames =
+                    audio_data_link_available_frames(alink);
+                const size_t copy_frames = min(available_frames, needed_frames);
+                const size_t copy_size = copy_frames * dst_frame_size;
+
+                /* Copy audio data */
+                pcm_format_convert_and_mix(data, copy_size,
+                    audio_data_link_start(alink),
+                    audio_data_link_remain_size(alink),
+                    &alink->adata->format, f);
+
+                /* Update values */
+                copied_size += copy_size;
+                needed_frames -= copy_frames;
+                data += copy_size;
+                alink->position += (copy_frames * src_frame_size);
+                if (audio_data_link_remain_size(alink) == 0) {
+                        list_remove(&alink->link);
+                        audio_data_link_destroy(alink);
+                } else {
+                        assert(needed_frames == 0);
+                }
+        }
+        fibril_mutex_unlock(&pipe->guard);
+        return copied_size;
 }
 

uspace/srv/audio/hound/audio_data.h

@@ -37 +37 @@
 #define AUDIO_DATA_H_
 
-#include <pcm/format.h>
 #include <adt/list.h>
 #include <atomic.h>
+#include <errno.h>
+#include <fibril_synch.h>
+#include <pcm/format.h>
 
 typedef struct {
@@ -54 +56 @@
 } audio_data_link_t;
 
+typedef struct {
+        list_t list;
+        size_t bytes;
+        size_t frames;
+        fibril_mutex_t guard;
+} audio_pipe_t;
+
 static inline audio_data_link_t * audio_data_link_list_instance(link_t *l)
 {
@@ -61 +70 @@
 audio_data_t * audio_data_create(const void *data, size_t size,
     pcm_format_t format);
+void audio_data_addref(audio_data_t *adata);
 void audio_data_unref(audio_data_t *adata);
 
@@ -83 +93 @@
         return alink->adata->size - alink->position;
 }
+
+void audio_pipe_init(audio_pipe_t *pipe);
+void audio_pipe_fini(audio_pipe_t *pipe);
+
+int audio_pipe_push(audio_pipe_t *pipe, audio_data_t *data);
+audio_data_t *audio_pipe_pop(audio_pipe_t *pipe);
+
+ssize_t audio_pipe_mix_data(audio_pipe_t *pipe, void *buffer, size_t size,
+    const pcm_format_t *f);
+
+static inline size_t audio_pipe_bytes(audio_pipe_t *pipe)
+{
+        assert(pipe);
+        return pipe->bytes;
+}
+
+static inline size_t audio_pipe_frames(audio_pipe_t *pipe)
+{
+        assert(pipe);
+        return pipe->frames;
+}
+
+static inline int 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);
+                audio_data_unref(adata);
+                return ret;
+        }
+        return ENOMEM;
+}
+
+
 #endif