2 This file is part of PulseAudio.
4 Copyright 2004-2008 Lennart Poettering
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2 of the License,
9 or (at your option) any later version.
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with PulseAudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
26 #include <pulse/xmalloc.h>
28 #include <pulsecore/core-error.h>
29 #include <pulsecore/namereg.h>
30 #include <pulsecore/sink.h>
31 #include <pulsecore/module.h>
32 #include <pulsecore/core-util.h>
33 #include <pulsecore/modargs.h>
34 #include <pulsecore/log.h>
35 #include <pulsecore/thread.h>
36 #include <pulsecore/thread-mq.h>
37 #include <pulsecore/rtpoll.h>
39 #include "module-remap-sink-symdef.h"
41 PA_MODULE_AUTHOR("Lennart Poettering");
42 PA_MODULE_DESCRIPTION("Virtual channel remapping sink");
43 PA_MODULE_VERSION(PACKAGE_VERSION
);
44 PA_MODULE_LOAD_ONCE(FALSE
);
46 "sink_name=<name for the sink> "
47 "master=<name of sink to remap> "
48 "master_channel_map=<channel map> "
49 "format=<sample format> "
50 "channels=<number of channels> "
52 "channel_map=<channel map> "
53 "remix=<remix channels?>");
59 pa_sink
*sink
, *master
;
60 pa_sink_input
*sink_input
;
63 static const char* const valid_modargs
[] = {
75 /* Called from I/O thread context */
76 static int sink_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
77 struct userdata
*u
= PA_SINK(o
)->userdata
;
81 case PA_SINK_MESSAGE_GET_LATENCY
: {
84 /* Get the latency of the master sink */
85 if (PA_MSGOBJECT(u
->master
)->process_msg(PA_MSGOBJECT(u
->master
), PA_SINK_MESSAGE_GET_LATENCY
, &usec
, 0, NULL
) < 0)
88 /* Add the latency internal to our sink input on top */
89 usec
+= pa_bytes_to_usec(pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
), &u
->master
->sample_spec
);
91 *((pa_usec_t
*) data
) = usec
;
96 return pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
99 /* Called from main context */
100 static int sink_set_state(pa_sink
*s
, pa_sink_state_t state
) {
103 pa_sink_assert_ref(s
);
104 pa_assert_se(u
= s
->userdata
);
106 if (PA_SINK_IS_LINKED(state
) &&
108 PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
110 pa_sink_input_cork(u
->sink_input
, state
== PA_SINK_SUSPENDED
);
115 /* Called from I/O thread context */
116 static void sink_request_rewind(pa_sink
*s
) {
119 pa_sink_assert_ref(s
);
120 pa_assert_se(u
= s
->userdata
);
122 pa_sink_input_request_rewind(u
->sink_input
, s
->thread_info
.rewind_nbytes
, TRUE
, FALSE
);
125 /* Called from I/O thread context */
126 static void sink_update_requested_latency(pa_sink
*s
) {
129 pa_sink_assert_ref(s
);
130 pa_assert_se(u
= s
->userdata
);
132 /* Just hand this one over to the master sink */
133 pa_sink_input_set_requested_latency_within_thread(
135 pa_sink_get_requested_latency_within_thread(s
));
138 /* Called from I/O thread context */
139 static int sink_input_pop_cb(pa_sink_input
*i
, size_t nbytes
, pa_memchunk
*chunk
) {
142 pa_sink_input_assert_ref(i
);
144 pa_assert_se(u
= i
->userdata
);
146 if (!u
->sink
|| !PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
))
149 pa_sink_render(u
->sink
, nbytes
, chunk
);
153 /* Called from I/O thread context */
154 static void sink_input_process_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
157 pa_sink_input_assert_ref(i
);
158 pa_assert_se(u
= i
->userdata
);
159 pa_assert(nbytes
> 0);
161 if (!u
->sink
|| !PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
))
164 if (u
->sink
->thread_info
.rewind_nbytes
> 0) {
167 amount
= PA_MIN(u
->sink
->thread_info
.rewind_nbytes
, nbytes
);
168 u
->sink
->thread_info
.rewind_nbytes
= 0;
171 pa_sink_process_rewind(u
->sink
, amount
);
175 /* Called from I/O thread context */
176 static void sink_input_update_max_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
179 pa_sink_input_assert_ref(i
);
180 pa_assert_se(u
= i
->userdata
);
182 if (!u
->sink
|| !PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
))
185 pa_sink_set_max_rewind(u
->sink
, nbytes
);
188 /* Called from I/O thread context */
189 static void sink_input_update_max_request_cb(pa_sink_input
*i
, size_t nbytes
) {
192 pa_sink_input_assert_ref(i
);
193 pa_assert_se(u
= i
->userdata
);
195 if (!u
->sink
|| !PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
))
198 pa_sink_set_max_request(u
->sink
, nbytes
);
201 /* Called from I/O thread context */
202 static void sink_input_update_sink_latency_range_cb(pa_sink_input
*i
) {
205 pa_sink_input_assert_ref(i
);
206 pa_assert_se(u
= i
->userdata
);
208 if (!u
->sink
|| !PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
))
211 pa_sink_update_latency_range(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
214 /* Called from I/O thread context */
215 static void sink_input_detach_cb(pa_sink_input
*i
) {
218 pa_sink_input_assert_ref(i
);
219 pa_assert_se(u
= i
->userdata
);
221 if (!u
->sink
|| !PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
))
224 pa_sink_detach_within_thread(u
->sink
);
225 pa_sink_set_asyncmsgq(u
->sink
, NULL
);
226 pa_sink_set_rtpoll(u
->sink
, NULL
);
229 /* Called from I/O thread context */
230 static void sink_input_attach_cb(pa_sink_input
*i
) {
233 pa_sink_input_assert_ref(i
);
234 pa_assert_se(u
= i
->userdata
);
236 if (!u
->sink
|| !PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
))
239 pa_sink_set_asyncmsgq(u
->sink
, i
->sink
->asyncmsgq
);
240 pa_sink_set_rtpoll(u
->sink
, i
->sink
->rtpoll
);
241 pa_sink_attach_within_thread(u
->sink
);
243 pa_sink_update_latency_range(u
->sink
, u
->master
->thread_info
.min_latency
, u
->master
->thread_info
.max_latency
);
246 /* Called from main context */
247 static void sink_input_kill_cb(pa_sink_input
*i
) {
250 pa_sink_input_assert_ref(i
);
251 pa_assert_se(u
= i
->userdata
);
253 pa_sink_unlink(u
->sink
);
254 pa_sink_input_unlink(u
->sink_input
);
256 pa_sink_unref(u
->sink
);
258 pa_sink_input_unref(u
->sink_input
);
259 u
->sink_input
= NULL
;
261 pa_module_unload_request(u
->module
);
264 /* Called from IO thread context */
265 static void sink_input_state_change_cb(pa_sink_input
*i
, pa_sink_input_state_t state
) {
268 pa_sink_input_assert_ref(i
);
269 pa_assert_se(u
= i
->userdata
);
271 /* If we are added for the first time, ask for a rewinding so that
272 * we are heard right-away. */
273 if (PA_SINK_INPUT_IS_LINKED(state
) &&
274 i
->thread_info
.state
== PA_SINK_INPUT_INIT
) {
275 pa_log_debug("Requesting rewind due to state change.");
276 pa_sink_input_request_rewind(i
, 0, FALSE
, TRUE
);
280 int pa__init(pa_module
*m
) {
283 pa_channel_map sink_map
, stream_map
;
287 pa_sink_input_new_data sink_input_data
;
288 pa_sink_new_data sink_data
;
289 pa_bool_t remix
= TRUE
;
293 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
294 pa_log("Failed to parse module arguments.");
298 if (!(master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "master", NULL
), PA_NAMEREG_SINK
, 1))) {
299 pa_log("Master sink not found");
303 ss
= master
->sample_spec
;
304 sink_map
= master
->channel_map
;
305 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &ss
, &sink_map
, PA_CHANNEL_MAP_DEFAULT
) < 0) {
306 pa_log("Invalid sample format specification or channel map");
310 stream_map
= sink_map
;
311 if (pa_modargs_get_channel_map(ma
, "master_channel_map", &stream_map
) < 0) {
312 pa_log("Invalid master channel map");
316 if (stream_map
.channels
!= ss
.channels
) {
317 pa_log("Number of channels doesn't match");
321 if (pa_channel_map_equal(&stream_map
, &master
->channel_map
))
322 pa_log_warn("No remapping configured, proceeding nonetheless!");
324 if (pa_modargs_get_value_boolean(ma
, "remix", &remix
) < 0) {
325 pa_log("Invalid boolean remix parameter");
329 u
= pa_xnew0(struct userdata
, 1);
335 u
->sink_input
= NULL
;
338 pa_sink_new_data_init(&sink_data
);
339 sink_data
.driver
= __FILE__
;
340 sink_data
.module
= m
;
341 if (!(sink_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "sink_name", NULL
))))
342 sink_data
.name
= pa_sprintf_malloc("%s.remapped", master
->name
);
343 pa_sink_new_data_set_sample_spec(&sink_data
, &ss
);
344 pa_sink_new_data_set_channel_map(&sink_data
, &sink_map
);
345 k
= pa_proplist_gets(master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
346 pa_proplist_setf(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "Remapped %s", k
? k
: master
->name
);
347 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, master
->name
);
348 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
350 u
->sink
= pa_sink_new(m
->core
, &sink_data
, PA_SINK_LATENCY
);
351 pa_sink_new_data_done(&sink_data
);
354 pa_log("Failed to create sink.");
358 u
->sink
->parent
.process_msg
= sink_process_msg
;
359 u
->sink
->set_state
= sink_set_state
;
360 u
->sink
->update_requested_latency
= sink_update_requested_latency
;
361 u
->sink
->request_rewind
= sink_request_rewind
;
362 u
->sink
->userdata
= u
;
364 pa_sink_set_asyncmsgq(u
->sink
, master
->asyncmsgq
);
365 pa_sink_set_rtpoll(u
->sink
, master
->rtpoll
);
367 /* Create sink input */
368 pa_sink_input_new_data_init(&sink_input_data
);
369 sink_input_data
.driver
= __FILE__
;
370 sink_input_data
.module
= m
;
371 sink_input_data
.sink
= u
->master
;
372 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_NAME
, "Remapped Stream");
373 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
374 pa_sink_input_new_data_set_sample_spec(&sink_input_data
, &ss
);
375 pa_sink_input_new_data_set_channel_map(&sink_input_data
, &stream_map
);
377 u
->sink_input
= pa_sink_input_new(m
->core
, &sink_input_data
, PA_SINK_INPUT_DONT_MOVE
| (remix
? 0 : PA_SINK_INPUT_NO_REMIX
));
378 pa_sink_input_new_data_done(&sink_input_data
);
383 u
->sink_input
->pop
= sink_input_pop_cb
;
384 u
->sink_input
->process_rewind
= sink_input_process_rewind_cb
;
385 u
->sink_input
->update_max_rewind
= sink_input_update_max_rewind_cb
;
386 u
->sink_input
->update_max_request
= sink_input_update_max_request_cb
;
387 u
->sink_input
->update_sink_latency_range
= sink_input_update_sink_latency_range_cb
;
388 u
->sink_input
->attach
= sink_input_attach_cb
;
389 u
->sink_input
->detach
= sink_input_detach_cb
;
390 u
->sink_input
->kill
= sink_input_kill_cb
;
391 u
->sink_input
->state_change
= sink_input_state_change_cb
;
392 u
->sink_input
->userdata
= u
;
394 pa_sink_put(u
->sink
);
395 pa_sink_input_put(u
->sink_input
);
410 void pa__done(pa_module
*m
) {
415 if (!(u
= m
->userdata
))
419 pa_sink_unlink(u
->sink
);
420 pa_sink_unref(u
->sink
);
424 pa_sink_input_unlink(u
->sink_input
);
425 pa_sink_input_unref(u
->sink_input
);