X-Git-Url: https://code.delx.au/pulseaudio/blobdiff_plain/41f6aea8fdbc744c13bc461056a2d694a5c4d06f..fa499dad06ba6558111cdef64c18f2401e803cff:/polyp/sink.c

diff --git a/polyp/sink.c b/polyp/sink.c
index 20fa76a6..c17af4ae 100644
--- a/polyp/sink.c
+++ b/polyp/sink.c
@@ -4,7 +4,7 @@
   This file is part of polypaudio.
  
   polypaudio is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published
+  it under the terms of the GNU Lesser General Public License as published
   by the Free Software Foundation; either version 2 of the License,
   or (at your option) any later version.
  
@@ -13,7 +13,7 @@
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   General Public License for more details.
  
-  You should have received a copy of the GNU General Public License
+  You should have received a copy of the GNU Lesser General Public License
   along with polypaudio; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
   USA.
@@ -33,6 +33,9 @@
 #include "namereg.h"
 #include "util.h"
 #include "sample-util.h"
+#include "xmalloc.h"
+#include "subscribe.h"
+#include "log.h"
 
 #define MAX_MIX_CHANNELS 32
 
@@ -41,18 +44,20 @@ struct pa_sink* pa_sink_new(struct pa_core *core, const char *name, int fail, co
     char *n = NULL;
     char st[256];
     int r;
-    assert(core && name && spec);
+    assert(core && name && *name && spec);
 
-    s = malloc(sizeof(struct pa_sink));
-    assert(s);
+    s = pa_xmalloc(sizeof(struct pa_sink));
 
     if (!(name = pa_namereg_register(core, name, PA_NAMEREG_SINK, s, fail))) {
-        free(s);
+        pa_xfree(s);
         return NULL;
     }
-    
-    s->name = strdup(name);
+
+    s->name = pa_xstrdup(name);
     s->description = NULL;
+
+    s->ref = 1;
+    s->state = PA_SINK_RUNNING;
     
     s->owner = NULL;
     s->core = core;
@@ -62,8 +67,9 @@ struct pa_sink* pa_sink_new(struct pa_core *core, const char *name, int fail, co
     n = pa_sprintf_malloc("%s_monitor", name);
     s->monitor_source = pa_source_new(core, n, 0, spec);
     assert(s->monitor_source);
-    free(n);
+    pa_xfree(n);
     s->monitor_source->monitor_of = s;
+    s->monitor_source->description = pa_sprintf_malloc("Monitor source of sink '%s'", s->name);
     
     s->volume = PA_VOLUME_NORM;
 
@@ -74,15 +80,17 @@ struct pa_sink* pa_sink_new(struct pa_core *core, const char *name, int fail, co
     r = pa_idxset_put(core->sinks, s, &s->index);
     assert(s->index != PA_IDXSET_INVALID && r >= 0);
     
-    pa_sample_snprint(st, sizeof(st), spec);
-    fprintf(stderr, "sink: created %u \"%s\" with sample spec \"%s\"\n", s->index, s->name, st);
+    pa_sample_spec_snprint(st, sizeof(st), spec);
+    pa_log(__FILE__": created %u \"%s\" with sample spec \"%s\"\n", s->index, s->name, st);
+
+    pa_subscription_post(core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_NEW, s->index);
     
     return s;
 }
 
-void pa_sink_free(struct pa_sink *s) {
+void pa_sink_disconnect(struct pa_sink* s) {
     struct pa_sink_input *i, *j = NULL;
-    assert(s);
+    assert(s && s->state == PA_SINK_RUNNING);
 
     pa_namereg_unregister(s->core, s->name);
     
@@ -91,20 +99,51 @@ void pa_sink_free(struct pa_sink *s) {
         pa_sink_input_kill(i);
         j = i;
     }
-    pa_idxset_free(s->inputs, NULL, NULL);
 
-    pa_source_free(s->monitor_source);
+    pa_source_disconnect(s->monitor_source);
+
     pa_idxset_remove_by_data(s->core->sinks, s, NULL);
+    pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
 
-    fprintf(stderr, "sink: freed %u \"%s\"\n", s->index, s->name);
+    s->notify = NULL;
+    s->get_latency = NULL;
     
-    free(s->name);
-    free(s->description);
-    free(s);
+    s->state = PA_SINK_DISCONNECTED;
+}
+
+static void sink_free(struct pa_sink *s) {
+    assert(s && s->ref == 0);
+    
+    if (s->state != PA_SINK_DISCONNECTED)
+        pa_sink_disconnect(s);
+
+    pa_log(__FILE__": freed %u \"%s\"\n", s->index, s->name);
+
+    pa_source_unref(s->monitor_source);
+    s->monitor_source = NULL;
+    
+    pa_idxset_free(s->inputs, NULL, NULL);
+
+    pa_xfree(s->name);
+    pa_xfree(s->description);
+    pa_xfree(s);
+}
+
+void pa_sink_unref(struct pa_sink*s) {
+    assert(s && s->ref >= 1);
+
+    if (!(--s->ref))
+        sink_free(s);
+}
+
+struct pa_sink* pa_sink_ref(struct pa_sink *s) {
+    assert(s && s->ref >= 1);
+    s->ref++;
+    return s;
 }
 
 void pa_sink_notify(struct pa_sink*s) {
-    assert(s);
+    assert(s && s->ref >= 1);
 
     if (s->notify)
         s->notify(s);
@@ -115,16 +154,20 @@ static unsigned fill_mix_info(struct pa_sink *s, struct pa_mix_info *info, unsig
     struct pa_sink_input *i;
     unsigned n = 0;
     
-    assert(s && info);
+    assert(s && s->ref >= 1 && info);
 
     for (i = pa_idxset_first(s->inputs, &index); maxinfo > 0 && i; i = pa_idxset_next(s->inputs, &index)) {
-        if (pa_sink_input_peek(i, &info->chunk) < 0)
+        pa_sink_input_ref(i);
+
+        if (pa_sink_input_peek(i, &info->chunk) < 0) {
+            pa_sink_input_unref(i);
             continue;
+        }
 
         info->volume = i->volume;
+        info->userdata = i;
         
         assert(info->chunk.memblock && info->chunk.memblock->data && info->chunk.length);
-        info->userdata = i;
         
         info++;
         maxinfo--;
@@ -135,14 +178,17 @@ static unsigned fill_mix_info(struct pa_sink *s, struct pa_mix_info *info, unsig
 }
 
 static void inputs_drop(struct pa_sink *s, struct pa_mix_info *info, unsigned maxinfo, size_t length) {
-    assert(s && info);
-    
+    assert(s && s->ref >= 1 && info);
+
     for (; maxinfo > 0; maxinfo--, info++) {
         struct pa_sink_input *i = info->userdata;
         assert(i && info->chunk.memblock);
         
+        pa_sink_input_drop(i, &info->chunk, length);
         pa_memblock_unref(info->chunk.memblock);
-        pa_sink_input_drop(i, length);
+
+        pa_sink_input_unref(i);
+        info->userdata = NULL;
     }
 }
         
@@ -150,12 +196,18 @@ int pa_sink_render(struct pa_sink*s, size_t length, struct pa_memchunk *result)
     struct pa_mix_info info[MAX_MIX_CHANNELS];
     unsigned n;
     size_t l;
-    assert(s && length && result);
+    int r = -1;
+    assert(s);
+    assert(s->ref >= 1);
+    assert(length);
+    assert(result);
+
+    pa_sink_ref(s);
     
     n = fill_mix_info(s, info, MAX_MIX_CHANNELS);
 
     if (n <= 0)
-        return -1;
+        goto finish;
 
     if (n == 1) {
         uint32_t volume = PA_VOLUME_NORM;
@@ -173,11 +225,11 @@ int pa_sink_render(struct pa_sink*s, size_t length, struct pa_memchunk *result)
             volume = pa_volume_multiply(s->volume, info[0].volume);
         
         if (volume != PA_VOLUME_NORM) {
-            pa_memchunk_make_writable(result);
+            pa_memchunk_make_writable(result, s->core->memblock_stat);
             pa_volume_memchunk(result, &s->sample_spec, volume);
         }
     } else {
-        result->memblock = pa_memblock_new(length);
+        result->memblock = pa_memblock_new(length, s->core->memblock_stat);
         assert(result->memblock);
 
         result->length = l = pa_mix(info, n, result->memblock->data, length, &s->sample_spec, s->volume);
@@ -191,19 +243,27 @@ int pa_sink_render(struct pa_sink*s, size_t length, struct pa_memchunk *result)
     assert(s->monitor_source);
     pa_source_post(s->monitor_source, result);
 
-    return 0;
+    r = 0;
+
+finish:
+    pa_sink_unref(s);
+
+    return r;
 }
 
 int pa_sink_render_into(struct pa_sink*s, struct pa_memchunk *target) {
     struct pa_mix_info info[MAX_MIX_CHANNELS];
     unsigned n;
     size_t l;
-    assert(s && target && target->length && target->memblock && target->memblock->data);
+    int r = -1;
+    assert(s && s->ref >= 1 && target && target->length && target->memblock && target->memblock->data);
+
+    pa_sink_ref(s);
     
     n = fill_mix_info(s, info, MAX_MIX_CHANNELS);
 
     if (n <= 0)
-        return -1;
+        goto finish;
 
     if (n == 1) {
         uint32_t volume = PA_VOLUME_NORM;
@@ -214,7 +274,7 @@ int pa_sink_render_into(struct pa_sink*s, struct pa_memchunk *target) {
         if (l > info[0].chunk.length)
             l = info[0].chunk.length;
         
-        memcpy(target->memblock->data+target->index, info[0].chunk.memblock->data + info[0].chunk.index, l);
+        memcpy((uint8_t*) target->memblock->data+target->index, (uint8_t*) info[0].chunk.memblock->data + info[0].chunk.index, l);
         target->length = l;
 
         if (s->volume != PA_VOLUME_NORM || info[0].volume != PA_VOLUME_NORM)
@@ -223,7 +283,7 @@ int pa_sink_render_into(struct pa_sink*s, struct pa_memchunk *target) {
         if (volume != PA_VOLUME_NORM)
             pa_volume_memchunk(target, &s->sample_spec, volume);
     } else
-        target->length = l = pa_mix(info, n, target->memblock->data+target->index, target->length, &s->sample_spec, s->volume);
+        target->length = l = pa_mix(info, n, (uint8_t*) target->memblock->data+target->index, target->length, &s->sample_spec, s->volume);
     
     assert(l);
     inputs_drop(s, info, n, l);
@@ -231,14 +291,21 @@ int pa_sink_render_into(struct pa_sink*s, struct pa_memchunk *target) {
     assert(s->monitor_source);
     pa_source_post(s->monitor_source, target);
 
-    return 0;
+    r = 0;
+
+finish:
+    pa_sink_unref(s);
+    
+    return r;
 }
 
 void pa_sink_render_into_full(struct pa_sink *s, struct pa_memchunk *target) {
     struct pa_memchunk chunk;
     size_t l, d;
-    assert(s && target && target->memblock && target->length && target->memblock->data);
+    assert(s && s->ref >= 1 && target && target->memblock && target->length && target->memblock->data);
 
+    pa_sink_ref(s);
+    
     l = target->length;
     d = 0;
     while (l > 0) {
@@ -259,10 +326,23 @@ void pa_sink_render_into_full(struct pa_sink *s, struct pa_memchunk *target) {
         chunk.length -= d;
         pa_silence_memchunk(&chunk, &s->sample_spec);
     }
+
+    pa_sink_unref(s);
 }
 
-uint32_t pa_sink_get_latency(struct pa_sink *s) {
-    assert(s);
+void pa_sink_render_full(struct pa_sink *s, size_t length, struct pa_memchunk *result) {
+    assert(s && s->ref >= 1 && length && result);
+
+    /*** This needs optimization ***/
+    
+    result->memblock = pa_memblock_new(result->length = length, s->core->memblock_stat);
+    result->index = 0;
+
+    pa_sink_render_into_full(s, result);
+}
+
+pa_usec_t pa_sink_get_latency(struct pa_sink *s) {
+    assert(s && s->ref >= 1);
 
     if (!s->get_latency)
         return 0;
@@ -270,23 +350,20 @@ uint32_t pa_sink_get_latency(struct pa_sink *s) {
     return s->get_latency(s);
 }
 
-struct pa_sink* pa_sink_get_default(struct pa_core *c) {
-    struct pa_sink *sink;
-    assert(c);
+void pa_sink_set_owner(struct pa_sink *s, struct pa_module *m) {
+    assert(s && s->ref >= 1);
+           
+    s->owner = m;
 
-    if ((sink = pa_idxset_get_by_index(c->sinks, c->default_sink_index)))
-        return sink;
-
-    if (!(sink = pa_idxset_first(c->sinks, &c->default_sink_index)))
-        return NULL;
-
-    fprintf(stderr, "core: default sink vanished, setting to %u.\n", sink->index);
-    return sink;
+    if (s->monitor_source)
+        pa_source_set_owner(s->monitor_source, m);
 }
 
-void pa_sink_set_owner(struct pa_sink *sink, struct pa_module *m) {
-    sink->owner = m;
-
-    if (sink->monitor_source)
-        pa_source_set_owner(sink->monitor_source, m);
+void pa_sink_set_volume(struct pa_sink *s, pa_volume_t volume) {
+    assert(s && s->ref >= 1);
+    
+    if (s->volume != volume) {
+        s->volume = volume;
+        pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+    }
 }