introduce default channel map in addition to the default sample spec

[pulseaudio] / src / modules / module-null-sink.c

diff --git a/src/modules/module-null-sink.c b/src/modules/module-null-sink.c
index aff244fa17da31c0bdf439777f83df32f142f952..e18da5fd180022d3f9c34accf85395c0ee26bf46 100644 (file)
--- a/src/modules/module-null-sink.c
+++ b/src/modules/module-null-sink.c
@@ -1,5 +1,3 @@
-/* $Id$ */
-
 /***
   This file is part of PulseAudio.
 
@@ -59,8 +57,8 @@ PA_MODULE_USAGE(
         "format=<sample format> "
         "channels=<number of channels> "
         "rate=<sample rate> "
-        "sink_name=<name of sink>"
-        "channel_map=<channel map>"
+        "sink_name=<name of sink> "
+        "channel_map=<channel map> "
         "description=<description for the sink>");
 
 #define DEFAULT_SINK_NAME "null"
@@ -75,8 +73,6 @@ struct userdata {
     pa_thread_mq thread_mq;
     pa_rtpoll *rtpoll;
 
-    size_t block_size;
-
     pa_usec_t block_usec;
     pa_usec_t timestamp;
 };
@@ -91,7 +87,13 @@ static const char* const valid_modargs[] = {
     NULL
 };
 
-static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
+static int sink_process_msg(
+        pa_msgobject *o,
+        int code,
+        void *data,
+        int64_t offset,
+        pa_memchunk *chunk) {
+
     struct userdata *u = PA_SINK(o)->userdata;
 
     switch (code) {
@@ -106,7 +108,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
             pa_usec_t now;
 
             now = pa_rtclock_usec();
-            *((pa_usec_t*) data) = u->timestamp > now ? u->timestamp - now : 0;
+            *((pa_usec_t*) data) = u->timestamp > now ? u->timestamp - now : 0ULL;
 
             return 0;
         }
@@ -119,10 +121,12 @@ static void sink_update_requested_latency_cb(pa_sink *s) {
     struct userdata *u;
 
     pa_sink_assert_ref(s);
-    u = s->userdata;
-    pa_assert(u);
+    pa_assert_se(u = s->userdata);
 
     u->block_usec = pa_sink_get_requested_latency_within_thread(s);
+
+    if (u->block_usec == (pa_usec_t) -1)
+        u->block_usec = s->thread_info.max_latency;
 }
 
 static void process_rewind(struct userdata *u, pa_usec_t now) {
@@ -139,13 +143,13 @@ static void process_rewind(struct userdata *u, pa_usec_t now) {
     pa_log_debug("Requested to rewind %lu bytes.", (unsigned long) rewind_nbytes);
 
     if (u->timestamp <= now)
-        return;
+        goto do_nothing;
 
     delay = u->timestamp - now;
     in_buffer = pa_usec_to_bytes(delay, &u->sink->sample_spec);
 
     if (in_buffer <= 0)
-        return;
+        goto do_nothing;
 
     if (rewind_nbytes > in_buffer)
         rewind_nbytes = in_buffer;
@@ -154,37 +158,40 @@ static void process_rewind(struct userdata *u, pa_usec_t now) {
     u->timestamp -= pa_bytes_to_usec(rewind_nbytes, &u->sink->sample_spec);
 
     pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
+    return;
+
+do_nothing:
+
+    pa_sink_process_rewind(u->sink, 0);
 }
 
 static void process_render(struct userdata *u, pa_usec_t now) {
-    size_t nbytes;
     size_t ate = 0;
 
     pa_assert(u);
 
     /* This is the configured latency. Sink inputs connected to us
-    might not have a single frame more than this value queued. Hence:
-    at maximum read this many bytes from the sink inputs. */
-
-    nbytes = pa_usec_to_bytes(u->block_usec, &u->sink->sample_spec);
+    might not have a single frame more than the maxrequest value
+    queed. Hence: at maximum read this many bytes from the sink
+    inputs. */
 
     /* Fill the buffer up the the latency size */
     while (u->timestamp < now + u->block_usec) {
         pa_memchunk chunk;
 
-        pa_sink_render(u->sink, nbytes, &chunk);
+        pa_sink_render(u->sink, u->sink->thread_info.max_request, &chunk);
         pa_memblock_unref(chunk.memblock);
 
-        pa_log_debug("Ate %lu bytes.", (unsigned long) chunk.length);
+/*         pa_log_debug("Ate %lu bytes.", (unsigned long) chunk.length); */
         u->timestamp += pa_bytes_to_usec(chunk.length, &u->sink->sample_spec);
 
         ate += chunk.length;
 
-        if (ate >= nbytes)
+        if (ate >= u->sink->thread_info.max_request)
             break;
     }
 
-    pa_log_debug("Ate in sum %lu bytes (of %lu)", (unsigned long) ate, (unsigned long) nbytes);
+/*     pa_log_debug("Ate in sum %lu bytes (of %lu)", (unsigned long) ate, (unsigned long) nbytes); */
 }
 
 static void thread_func(void *userdata) {
@@ -203,13 +210,17 @@ static void thread_func(void *userdata) {
         int ret;
 
         /* Render some data and drop it immediately */
-        if (u->sink->thread_info.state == PA_SINK_RUNNING) {
+        if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
             pa_usec_t now;
 
             now = pa_rtclock_usec();
 
-            if (u->sink->thread_info.rewind_nbytes > 0)
-                process_rewind(u, now);
+            if (u->sink->thread_info.rewind_requested) {
+                if (u->sink->thread_info.rewind_nbytes > 0)
+                    process_rewind(u, now);
+                else
+                    pa_sink_process_rewind(u->sink, 0);
+            }
 
             if (u->timestamp <= now)
                 process_render(u, now);
@@ -251,15 +262,15 @@ int pa__init(pa_module*m) {
     }
 
     ss = m->core->default_sample_spec;
+    map = m->core->default_channel_map;
     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
         pa_log("Invalid sample format specification or channel map");
         goto fail;
     }
 
-    u = pa_xnew0(struct userdata, 1);
+    m->userdata = u = pa_xnew0(struct userdata, 1);
     u->core = m->core;
     u->module = m;
-    m->userdata = u;
     u->rtpoll = pa_rtpoll_new();
     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
 
@@ -270,6 +281,7 @@ int pa__init(pa_module*m) {
     pa_sink_new_data_set_sample_spec(&data, &ss);
     pa_sink_new_data_set_channel_map(&data, &map);
     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, pa_modargs_get_value(ma, "description", "Null Output"));
+    pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "abstract");
 
     u->sink = pa_sink_new(m->core, &data, PA_SINK_LATENCY);
     pa_sink_new_data_done(&data);
@@ -286,9 +298,12 @@ int pa__init(pa_module*m) {
     pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
     pa_sink_set_rtpoll(u->sink, u->rtpoll);
 
-    u->block_usec = u->sink->max_latency = MAX_LATENCY_USEC;
+    pa_sink_set_latency_range(u->sink, (pa_usec_t) -1, MAX_LATENCY_USEC);
+    u->block_usec = u->sink->thread_info.max_latency;
 
-    u->sink->thread_info.max_rewind = pa_usec_to_bytes(u->block_usec, &u->sink->sample_spec);
+    u->sink->thread_info.max_rewind =
+        u->sink->thread_info.max_request =
+        pa_usec_to_bytes(u->block_usec, &u->sink->sample_spec);
 
     if (!(u->thread = pa_thread_new(thread_func, u))) {
         pa_log("Failed to create thread.");
@@ -310,6 +325,15 @@ fail:
     return -1;
 }
 
+int pa__get_n_used(pa_module *m) {
+    struct userdata *u;
+
+    pa_assert(m);
+    pa_assert_se(u = m->userdata);
+
+    return pa_sink_linked_by(u->sink);
+}
+
 void pa__done(pa_module*m) {
     struct userdata *u;