1 files changed, 168 insertions, 36 deletions

diff --git a/src/pulsecore/sink.c b/src/pulsecore/sink.c
index 30fa5579..13f0e11e 100644
--- a/src/pulsecore/sink.c
+++ b/src/pulsecore/sink.c
@@ -190,6 +190,7 @@ pa_sink* pa_sink_new(
     s->core = core;
     s->state = PA_SINK_INIT;
     s->flags = flags;
+    s->suspend_cause = 0;
     s->name = pa_xstrdup(name);
     s->proplist = pa_proplist_copy(data->proplist);
     s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
@@ -263,7 +264,9 @@ pa_sink* pa_sink_new(
     pa_proplist_setf(source_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Monitor of %s", dn ? dn : s->name);
     pa_proplist_sets(source_data.proplist, PA_PROP_DEVICE_CLASS, "monitor");
 
-    s->monitor_source = pa_source_new(core, &source_data, 0);
+    s->monitor_source = pa_source_new(core, &source_data,
+                                      ((flags & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
+                                      ((flags & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0));
 
     pa_source_new_data_done(&source_data);
 
@@ -349,31 +352,28 @@ void pa_sink_put(pa_sink* s) {
     pa_assert(s->rtpoll);
     pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
 
-    if (!(s->flags & PA_SINK_HW_VOLUME_CTRL)) {
+    /* Generally, flags should be initialized via pa_sink_new(). As a
+     * special exception we allow volume related flags to be set
+     * between _new() and _put(). */
+
+    if (!(s->flags & PA_SINK_HW_VOLUME_CTRL))
         s->flags |= PA_SINK_DECIBEL_VOLUME;
-        s->base_volume = PA_VOLUME_NORM;
-    }
+
+    if ((s->flags & PA_SINK_DECIBEL_VOLUME) && s->core->flat_volumes)
+        s->flags |= PA_SINK_FLAT_VOLUME;
 
     s->thread_info.soft_volume = s->soft_volume;
     s->thread_info.soft_muted = s->muted;
 
-    if (s->flags & PA_SINK_DECIBEL_VOLUME)
-        s->n_volume_steps = PA_VOLUME_NORM+1;
-
-    if (s->core->flat_volumes)
-        if (s->flags & PA_SINK_DECIBEL_VOLUME)
-            s->flags |= PA_SINK_FLAT_VOLUME;
-
-    if (s->flags & PA_SINK_LATENCY)
-        s->monitor_source->flags |= PA_SOURCE_LATENCY;
+    pa_assert((s->flags & PA_SINK_HW_VOLUME_CTRL) || (s->base_volume == PA_VOLUME_NORM && s->flags & PA_SINK_DECIBEL_VOLUME));
+    pa_assert(!(s->flags & PA_SINK_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
+    pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == (s->fixed_latency != 0));
+    pa_assert(!(s->flags & PA_SINK_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_LATENCY));
+    pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_DYNAMIC_LATENCY));
 
-    if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
-        s->monitor_source->flags |= PA_SOURCE_DYNAMIC_LATENCY;
-        s->fixed_latency = 0;
-    } else if (s->fixed_latency <= 0)
-        s->fixed_latency = DEFAULT_FIXED_LATENCY;
-
-    s->monitor_source->fixed_latency = s->fixed_latency;
+    pa_assert(s->monitor_source->fixed_latency == s->fixed_latency);
+    pa_assert(s->monitor_source->thread_info.min_latency == s->thread_info.min_latency);
+    pa_assert(s->monitor_source->thread_info.max_latency == s->thread_info.max_latency);
 
     pa_assert_se(sink_set_state(s, PA_SINK_IDLE) == 0);
 
@@ -500,11 +500,25 @@ int pa_sink_update_status(pa_sink*s) {
 }
 
 /* Called from main context */
-int pa_sink_suspend(pa_sink *s, pa_bool_t suspend) {
+int pa_sink_suspend(pa_sink *s, pa_bool_t suspend, pa_suspend_cause_t cause) {
     pa_sink_assert_ref(s);
     pa_assert(PA_SINK_IS_LINKED(s->state));
+    pa_assert(cause != 0);
 
-    if (suspend)
+    if (suspend) {
+        s->suspend_cause |= cause;
+        s->monitor_source->suspend_cause |= cause;
+    } else {
+        s->suspend_cause &= ~cause;
+        s->monitor_source->suspend_cause &= ~cause;
+    }
+
+    if ((pa_sink_get_state(s) == PA_SINK_SUSPENDED) == !!s->suspend_cause)
+        return 0;
+
+    pa_log_debug("Suspend cause of sink %s is 0x%04x, %s", s->name, s->suspend_cause, s->suspend_cause ? "suspending" : "resuming");
+
+    if (s->suspend_cause)
         return sink_set_state(s, PA_SINK_SUSPENDED);
     else
         return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
@@ -788,11 +802,17 @@ void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) {
         pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
 
         if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&volume)) {
-            pa_memchunk_make_writable(result, 0);
-            if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume))
-                pa_silence_memchunk(result, &s->sample_spec);
-            else
+            if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume)) {
+                pa_memblock_unref(result->memblock);
+                pa_silence_memchunk_get(&s->core->silence_cache,
+                                        s->core->mempool,
+                                        result,
+                                        &s->sample_spec,
+                                        result->length);
+            } else {
+                pa_memchunk_make_writable(result, 0);
                 pa_volume_memchunk(result, &s->sample_spec, &volume);
+            }
         }
     } else {
         void *ptr;
@@ -933,22 +953,95 @@ void pa_sink_render_into_full(pa_sink *s, pa_memchunk *target) {
 
 /* Called from IO thread context */
 void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result) {
+    pa_mix_info info[MAX_MIX_CHANNELS];
+    size_t length1st = length;
+    unsigned n;
+
     pa_sink_assert_ref(s);
     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
     pa_assert(length > 0);
     pa_assert(pa_frame_aligned(length, &s->sample_spec));
     pa_assert(result);
 
+    pa_sink_ref(s);
+
     pa_assert(!s->thread_info.rewind_requested);
     pa_assert(s->thread_info.rewind_nbytes == 0);
 
-    /*** This needs optimization ***/
+    pa_assert(length > 0);
 
-    result->index = 0;
-    result->length = length;
-    result->memblock = pa_memblock_new(s->core->mempool, length);
+    n = fill_mix_info(s, &length1st, info, MAX_MIX_CHANNELS);
 
-    pa_sink_render_into_full(s, result);
+    if (n == 0) {
+        pa_silence_memchunk_get(&s->core->silence_cache,
+                                s->core->mempool,
+                                result,
+                                &s->sample_spec,
+                                length1st);
+    } else if (n == 1) {
+        pa_cvolume volume;
+
+        *result = info[0].chunk;
+        pa_memblock_ref(result->memblock);
+
+        if (result->length > length)
+            result->length = length;
+
+        pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
+
+        if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&volume)) {
+            if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume)) {
+                pa_memblock_unref(result->memblock);
+                pa_silence_memchunk_get(&s->core->silence_cache,
+                                        s->core->mempool,
+                                        result,
+                                        &s->sample_spec,
+                                        result->length);
+            } else {
+                pa_memchunk_make_writable(result, length);
+                pa_volume_memchunk(result, &s->sample_spec, &volume);
+            }
+        }
+    } else {
+        void *ptr;
+
+        result->index = 0;
+        result->memblock = pa_memblock_new(s->core->mempool, length);
+
+        ptr = pa_memblock_acquire(result->memblock);
+
+        result->length = pa_mix(info, n,
+                                (uint8_t*) ptr + result->index, length1st,
+                                &s->sample_spec,
+                                &s->thread_info.soft_volume,
+                                s->thread_info.soft_muted);
+
+        pa_memblock_release(result->memblock);
+    }
+
+    inputs_drop(s, info, n, result);
+
+    if (result->length < length) {
+        pa_memchunk chunk;
+        size_t l, d;
+        pa_memchunk_make_writable(result, length);
+
+        l = length - result->length;
+        d = result->index + result->length;
+        while (l > 0) {
+            chunk = *result;
+            chunk.index = d;
+            chunk.length = l;
+
+            pa_sink_render_into(s, &chunk);
+
+            d += chunk.length;
+            l -= chunk.length;
+        }
+        result->length = length;
+    }
+
+    pa_sink_unref(s);
 }
 
 /* Called from main thread */
@@ -1272,8 +1365,12 @@ pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) {
 
         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
 
-        if (old_muted != s->muted)
+        if (old_muted != s->muted) {
             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+
+            /* Make sure the soft mute status stays in sync */
+            pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
+        }
     }
 
     return s->muted;
@@ -1744,17 +1841,18 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse
 }
 
 /* Called from main thread */
-int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend) {
+int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause) {
     pa_sink *sink;
     uint32_t idx;
     int ret = 0;
 
     pa_core_assert_ref(c);
+    pa_assert(cause != 0);
 
     for (sink = PA_SINK(pa_idxset_first(c->sinks, &idx)); sink; sink = PA_SINK(pa_idxset_next(c->sinks, &idx))) {
         int r;
 
-        if ((r = pa_sink_suspend(sink, suspend)) < 0)
+        if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
             ret = r;
     }
 
@@ -1863,8 +1961,11 @@ pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
     if (result != (pa_usec_t) -1)
         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
 
-    s->thread_info.requested_latency = result;
-    s->thread_info.requested_latency_valid = TRUE;
+    if (PA_SINK_IS_LINKED(s->thread_info.state)) {
+        /* Only cache if properly initialized */
+        s->thread_info.requested_latency = result;
+        s->thread_info.requested_latency_valid = TRUE;
+    }
 
     return result;
 }
@@ -2050,6 +2151,22 @@ void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency,
     pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
 }
 
+/* Called from main thread, before the sink is put */
+void pa_sink_set_fixed_latency(pa_sink *s, pa_usec_t latency) {
+    pa_sink_assert_ref(s);
+
+    pa_assert(pa_sink_get_state(s) == PA_SINK_INIT);
+
+    if (latency < ABSOLUTE_MIN_LATENCY)
+        latency = ABSOLUTE_MIN_LATENCY;
+
+    if (latency > ABSOLUTE_MAX_LATENCY)
+        latency = ABSOLUTE_MAX_LATENCY;
+
+    s->fixed_latency = latency;
+    pa_source_set_fixed_latency(s->monitor_source, latency);
+}
+
 /* Called from main context */
 size_t pa_sink_get_max_rewind(pa_sink *s) {
     size_t r;
@@ -2099,6 +2216,21 @@ pa_bool_t pa_device_init_icon(pa_proplist *p, pa_bool_t is_sink) {
             t = "multimedia-player";
         else if (pa_streq(ff, "tv"))
             t = "video-display";
+
+        /*
+         * The following icons are not part of the icon naming spec,
+         * because Rodney Dawes sucks as the maintainer of that spec.
+         *
+         * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
+         */
+        else if (pa_streq(ff, "headset"))
+            t = "audio-headset";
+        else if (pa_streq(ff, "headphone"))
+            t = "audio-headphones";
+        else if (pa_streq(ff, "speaker"))
+            t = "audio-speakers";
+        else if (pa_streq(ff, "hands-free"))
+            t = "audio-handsfree";
     }
 
     if (!t)