2 This file is part of PulseAudio.
4 Copyright 2009 Tanu Kaskinen
5 Copyright 2009 Vincent Filali-Ansary <filali.v@azurdigitalnetworks.net>
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
27 #include <pulsecore/core-util.h>
28 #include <pulsecore/dbus-util.h>
29 #include <pulsecore/protocol-dbus.h>
31 #include "iface-stream.h"
33 #define PLAYBACK_OBJECT_NAME "playback_stream"
34 #define RECORD_OBJECT_NAME "record_stream"
41 struct pa_dbusiface_stream
{
42 pa_dbusiface_core
*core
;
45 pa_sink_input
*sink_input
;
46 pa_source_output
*source_output
;
48 enum stream_type type
;
57 pa_proplist
*proplist
;
59 pa_dbus_protocol
*dbus_protocol
;
60 pa_subscription
*subscription
;
61 pa_hook_slot
*send_event_slot
;
64 static void handle_get_index(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
65 static void handle_get_driver(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
66 static void handle_get_owner_module(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
67 static void handle_get_client(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
68 static void handle_get_device(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
69 static void handle_get_sample_format(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
70 static void handle_get_sample_rate(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
71 static void handle_get_channels(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
72 static void handle_get_volume(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
73 static void handle_set_volume(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
74 static void handle_get_is_muted(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
75 static void handle_set_is_muted(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
76 static void handle_get_buffer_latency(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
77 static void handle_get_device_latency(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
78 static void handle_get_resample_method(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
79 static void handle_get_property_list(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
81 static void handle_get_all(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
83 static void handle_move(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
84 static void handle_kill(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
);
86 enum property_handler_index
{
87 PROPERTY_HANDLER_INDEX
,
88 PROPERTY_HANDLER_DRIVER
,
89 PROPERTY_HANDLER_OWNER_MODULE
,
90 PROPERTY_HANDLER_CLIENT
,
91 PROPERTY_HANDLER_DEVICE
,
92 PROPERTY_HANDLER_SAMPLE_FORMAT
,
93 PROPERTY_HANDLER_SAMPLE_RATE
,
94 PROPERTY_HANDLER_CHANNELS
,
95 PROPERTY_HANDLER_VOLUME
,
96 PROPERTY_HANDLER_IS_MUTED
,
97 PROPERTY_HANDLER_BUFFER_LATENCY
,
98 PROPERTY_HANDLER_DEVICE_LATENCY
,
99 PROPERTY_HANDLER_RESAMPLE_METHOD
,
100 PROPERTY_HANDLER_PROPERTY_LIST
,
104 static pa_dbus_property_handler property_handlers
[PROPERTY_HANDLER_MAX
] = {
105 [PROPERTY_HANDLER_INDEX
] = { .property_name
= "Index", .type
= "u", .get_cb
= handle_get_index
, .set_cb
= NULL
},
106 [PROPERTY_HANDLER_DRIVER
] = { .property_name
= "Driver", .type
= "s", .get_cb
= handle_get_driver
, .set_cb
= NULL
},
107 [PROPERTY_HANDLER_OWNER_MODULE
] = { .property_name
= "OwnerModule", .type
= "o", .get_cb
= handle_get_owner_module
, .set_cb
= NULL
},
108 [PROPERTY_HANDLER_CLIENT
] = { .property_name
= "Client", .type
= "o", .get_cb
= handle_get_client
, .set_cb
= NULL
},
109 [PROPERTY_HANDLER_DEVICE
] = { .property_name
= "Device", .type
= "o", .get_cb
= handle_get_device
, .set_cb
= NULL
},
110 [PROPERTY_HANDLER_SAMPLE_FORMAT
] = { .property_name
= "SampleFormat", .type
= "u", .get_cb
= handle_get_sample_format
, .set_cb
= NULL
},
111 [PROPERTY_HANDLER_SAMPLE_RATE
] = { .property_name
= "SampleRate", .type
= "u", .get_cb
= handle_get_sample_rate
, .set_cb
= NULL
},
112 [PROPERTY_HANDLER_CHANNELS
] = { .property_name
= "Channels", .type
= "au", .get_cb
= handle_get_channels
, .set_cb
= NULL
},
113 [PROPERTY_HANDLER_VOLUME
] = { .property_name
= "Volume", .type
= "au", .get_cb
= handle_get_volume
, .set_cb
= handle_set_volume
},
114 [PROPERTY_HANDLER_IS_MUTED
] = { .property_name
= "IsMuted", .type
= "b", .get_cb
= handle_get_is_muted
, .set_cb
= handle_set_is_muted
},
115 [PROPERTY_HANDLER_BUFFER_LATENCY
] = { .property_name
= "BufferLatency", .type
= "t", .get_cb
= handle_get_buffer_latency
, .set_cb
= NULL
},
116 [PROPERTY_HANDLER_DEVICE_LATENCY
] = { .property_name
= "DeviceLatency", .type
= "t", .get_cb
= handle_get_device_latency
, .set_cb
= NULL
},
117 [PROPERTY_HANDLER_RESAMPLE_METHOD
] = { .property_name
= "ResampleMethod", .type
= "s", .get_cb
= handle_get_resample_method
, .set_cb
= NULL
},
118 [PROPERTY_HANDLER_PROPERTY_LIST
] = { .property_name
= "PropertyList", .type
= "a{say}", .get_cb
= handle_get_property_list
, .set_cb
= NULL
}
121 enum method_handler_index
{
127 static pa_dbus_arg_info move_args
[] = { { "device", "o", "in" } };
129 static pa_dbus_method_handler method_handlers
[METHOD_HANDLER_MAX
] = {
130 [METHOD_HANDLER_MOVE
] = {
131 .method_name
= "Move",
132 .arguments
= move_args
,
133 .n_arguments
= sizeof(move_args
) / sizeof(pa_dbus_arg_info
),
134 .receive_cb
= handle_move
},
135 [METHOD_HANDLER_KILL
] = {
136 .method_name
= "Kill",
139 .receive_cb
= handle_kill
}
143 SIGNAL_DEVICE_UPDATED
,
144 SIGNAL_SAMPLE_RATE_UPDATED
,
145 SIGNAL_VOLUME_UPDATED
,
147 SIGNAL_PROPERTY_LIST_UPDATED
,
152 static pa_dbus_arg_info device_updated_args
[] = { { "device", "o", NULL
} };
153 static pa_dbus_arg_info sample_rate_updated_args
[] = { { "sample_rate", "u", NULL
} };
154 static pa_dbus_arg_info volume_updated_args
[] = { { "volume", "au", NULL
} };
155 static pa_dbus_arg_info mute_updated_args
[] = { { "muted", "b", NULL
} };
156 static pa_dbus_arg_info property_list_updated_args
[] = { { "property_list", "a{say}", NULL
} };
157 static pa_dbus_arg_info stream_event_args
[] = { { "name", "s", NULL
}, { "property_list", "a{say}", NULL
} };
159 static pa_dbus_signal_info signals
[SIGNAL_MAX
] = {
160 [SIGNAL_DEVICE_UPDATED
] = { .name
= "DeviceUpdated", .arguments
= device_updated_args
, .n_arguments
= 1 },
161 [SIGNAL_SAMPLE_RATE_UPDATED
] = { .name
= "SampleRateUpdated", .arguments
= sample_rate_updated_args
, .n_arguments
= 1 },
162 [SIGNAL_VOLUME_UPDATED
] = { .name
= "VolumeUpdated", .arguments
= volume_updated_args
, .n_arguments
= 1 },
163 [SIGNAL_MUTE_UPDATED
] = { .name
= "MuteUpdated", .arguments
= mute_updated_args
, .n_arguments
= 1 },
164 [SIGNAL_PROPERTY_LIST_UPDATED
] = { .name
= "PropertyListUpdated", .arguments
= property_list_updated_args
, .n_arguments
= 1 },
165 [SIGNAL_STREAM_EVENT
] = { .name
= "StreamEvent", .arguments
= stream_event_args
, .n_arguments
= sizeof(stream_event_args
) / sizeof(pa_dbus_arg_info
) }
168 static pa_dbus_interface_info stream_interface_info
= {
169 .name
= PA_DBUSIFACE_STREAM_INTERFACE
,
170 .method_handlers
= method_handlers
,
171 .n_method_handlers
= METHOD_HANDLER_MAX
,
172 .property_handlers
= property_handlers
,
173 .n_property_handlers
= PROPERTY_HANDLER_MAX
,
174 .get_all_properties_cb
= handle_get_all
,
176 .n_signals
= SIGNAL_MAX
179 static void handle_get_index(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
180 pa_dbusiface_stream
*s
= userdata
;
187 idx
= (s
->type
== STREAM_TYPE_PLAYBACK
) ? s
->sink_input
->index
: s
->source_output
->index
;
189 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_UINT32
, &idx
);
192 static void handle_get_driver(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
193 pa_dbusiface_stream
*s
= userdata
;
194 const char *driver
= NULL
;
200 driver
= (s
->type
== STREAM_TYPE_PLAYBACK
) ? s
->sink_input
->driver
: s
->source_output
->driver
;
203 if (s
->type
== STREAM_TYPE_PLAYBACK
)
204 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NO_SUCH_PROPERTY
,
205 "Playback stream %u doesn't have a driver.", s
->sink_input
->index
);
207 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NO_SUCH_PROPERTY
,
208 "Record stream %u doesn't have a driver.", s
->source_output
->index
);
212 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_STRING
, &driver
);
215 static void handle_get_owner_module(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
216 pa_dbusiface_stream
*s
= userdata
;
217 pa_module
*owner_module
= NULL
;
218 const char *object_path
= NULL
;
224 owner_module
= (s
->type
== STREAM_TYPE_PLAYBACK
) ? s
->sink_input
->module
: s
->source_output
->module
;
227 if (s
->type
== STREAM_TYPE_PLAYBACK
)
228 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NO_SUCH_PROPERTY
,
229 "Playback stream %u doesn't have an owner module.", s
->sink_input
->index
);
231 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NO_SUCH_PROPERTY
,
232 "Record stream %u doesn't have an owner module.", s
->source_output
->index
);
236 object_path
= pa_dbusiface_core_get_module_path(s
->core
, owner_module
);
238 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_OBJECT_PATH
, &object_path
);
241 static void handle_get_client(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
242 pa_dbusiface_stream
*s
= userdata
;
243 pa_client
*client
= NULL
;
244 const char *object_path
= NULL
;
250 client
= (s
->type
== STREAM_TYPE_PLAYBACK
) ? s
->sink_input
->client
: s
->source_output
->client
;
253 if (s
->type
== STREAM_TYPE_PLAYBACK
)
254 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NO_SUCH_PROPERTY
,
255 "Playback stream %u isn't associated to any client.", s
->sink_input
->index
);
257 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NO_SUCH_PROPERTY
,
258 "Record stream %u isn't associated to any client.", s
->source_output
->index
);
262 object_path
= pa_dbusiface_core_get_client_path(s
->core
, client
);
264 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_OBJECT_PATH
, &object_path
);
267 static void handle_get_device(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
268 pa_dbusiface_stream
*s
= userdata
;
269 const char *device
= NULL
;
275 if (s
->type
== STREAM_TYPE_PLAYBACK
)
276 device
= pa_dbusiface_core_get_sink_path(s
->core
, s
->sink
);
278 device
= pa_dbusiface_core_get_source_path(s
->core
, s
->source
);
280 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_OBJECT_PATH
, &device
);
283 static void handle_get_sample_format(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
284 pa_dbusiface_stream
*s
= userdata
;
285 dbus_uint32_t sample_format
= 0;
291 sample_format
= (s
->type
== STREAM_TYPE_PLAYBACK
)
292 ? s
->sink_input
->sample_spec
.format
293 : s
->source_output
->sample_spec
.format
;
295 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_UINT32
, &sample_format
);
298 static void handle_get_sample_rate(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
299 pa_dbusiface_stream
*s
= userdata
;
305 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_UINT32
, &s
->sample_rate
);
308 static void handle_get_channels(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
309 pa_dbusiface_stream
*s
= userdata
;
310 pa_channel_map
*channel_map
= NULL
;
311 dbus_uint32_t channels
[PA_CHANNELS_MAX
];
318 channel_map
= (s
->type
== STREAM_TYPE_PLAYBACK
) ? &s
->sink_input
->channel_map
: &s
->source_output
->channel_map
;
320 for (i
= 0; i
< channel_map
->channels
; ++i
)
321 channels
[i
] = channel_map
->map
[i
];
323 pa_dbus_send_basic_array_variant_reply(conn
, msg
, DBUS_TYPE_UINT32
, channels
, channel_map
->channels
);
326 static void handle_get_volume(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
327 pa_dbusiface_stream
*s
= userdata
;
328 dbus_uint32_t volume
[PA_CHANNELS_MAX
];
335 if (s
->type
== STREAM_TYPE_RECORD
) {
336 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NO_SUCH_PROPERTY
, "Record streams don't have volume.");
340 for (i
= 0; i
< s
->volume
.channels
; ++i
)
341 volume
[i
] = s
->volume
.values
[i
];
343 pa_dbus_send_basic_array_variant_reply(conn
, msg
, DBUS_TYPE_UINT32
, volume
, s
->volume
.channels
);
346 static void handle_set_volume(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
347 pa_dbusiface_stream
*s
= userdata
;
348 unsigned stream_channels
= 0;
349 dbus_uint32_t
*volume
= NULL
;
350 unsigned n_volume_entries
= 0;
358 if (s
->type
== STREAM_TYPE_RECORD
) {
359 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NO_SUCH_PROPERTY
, "Record streams don't have volume.");
363 pa_cvolume_init(&new_vol
);
365 stream_channels
= s
->sink_input
->channel_map
.channels
;
367 new_vol
.channels
= stream_channels
;
369 if (pa_dbus_get_fixed_array_set_property_arg(conn
, msg
, DBUS_TYPE_UINT32
, &volume
, &n_volume_entries
) < 0)
372 if (n_volume_entries
!= stream_channels
) {
373 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
,
374 "Expected %u volume entries, got %u.", stream_channels
, n_volume_entries
);
378 for (i
= 0; i
< n_volume_entries
; ++i
) {
379 if (volume
[i
] > PA_VOLUME_MAX
) {
380 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "Too large volume value: %u", volume
[i
]);
383 new_vol
.values
[i
] = volume
[i
];
386 pa_sink_input_set_volume(s
->sink_input
, &new_vol
, TRUE
, TRUE
);
388 pa_dbus_send_empty_reply(conn
, msg
);
391 static void handle_get_is_muted(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
392 pa_dbusiface_stream
*s
= userdata
;
398 if (s
->type
== STREAM_TYPE_RECORD
) {
399 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NO_SUCH_PROPERTY
, "Record streams don't have mute.");
403 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_BOOLEAN
, &s
->is_muted
);
406 static void handle_set_is_muted(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
407 pa_dbusiface_stream
*s
= userdata
;
408 dbus_bool_t is_muted
= FALSE
;
414 if (pa_dbus_get_basic_set_property_arg(conn
, msg
, DBUS_TYPE_BOOLEAN
, &is_muted
) < 0)
417 if (s
->type
== STREAM_TYPE_RECORD
) {
418 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NO_SUCH_PROPERTY
, "Record streams don't have mute.");
422 pa_sink_input_set_mute(s
->sink_input
, is_muted
, TRUE
);
424 pa_dbus_send_empty_reply(conn
, msg
);
427 static void handle_get_buffer_latency(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
428 pa_dbusiface_stream
*s
= userdata
;
429 dbus_uint64_t buffer_latency
= 0;
435 if (s
->type
== STREAM_TYPE_PLAYBACK
)
436 buffer_latency
= pa_sink_input_get_latency(s
->sink_input
, NULL
);
438 buffer_latency
= pa_source_output_get_latency(s
->source_output
, NULL
);
440 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_UINT64
, &buffer_latency
);
443 static void handle_get_device_latency(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
444 pa_dbusiface_stream
*s
= userdata
;
445 dbus_uint64_t device_latency
= 0;
451 if (s
->type
== STREAM_TYPE_PLAYBACK
)
452 pa_sink_input_get_latency(s
->sink_input
, &device_latency
);
454 pa_source_output_get_latency(s
->source_output
, &device_latency
);
456 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_UINT64
, &device_latency
);
459 static void handle_get_resample_method(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
460 pa_dbusiface_stream
*s
= userdata
;
461 const char *resample_method
= NULL
;
467 if (s
->type
== STREAM_TYPE_PLAYBACK
)
468 resample_method
= pa_resample_method_to_string(s
->sink_input
->actual_resample_method
);
470 resample_method
= pa_resample_method_to_string(s
->source_output
->actual_resample_method
);
472 pa_dbus_send_basic_variant_reply(conn
, msg
, DBUS_TYPE_STRING
, &resample_method
);
475 static void handle_get_property_list(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
476 pa_dbusiface_stream
*s
= userdata
;
482 pa_dbus_send_proplist_variant_reply(conn
, msg
, s
->proplist
);
485 static void handle_get_all(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
486 pa_dbusiface_stream
*s
= userdata
;
487 DBusMessage
*reply
= NULL
;
488 DBusMessageIter msg_iter
;
489 DBusMessageIter dict_iter
;
490 dbus_uint32_t idx
= 0;
491 const char *driver
= NULL
;
492 pa_module
*owner_module
= NULL
;
493 const char *owner_module_path
= NULL
;
494 pa_client
*client
= NULL
;
495 const char *client_path
= NULL
;
496 const char *device
= NULL
;
497 dbus_uint32_t sample_format
= 0;
498 pa_channel_map
*channel_map
= NULL
;
499 dbus_uint32_t channels
[PA_CHANNELS_MAX
];
500 dbus_uint32_t volume
[PA_CHANNELS_MAX
];
501 dbus_uint64_t buffer_latency
= 0;
502 dbus_uint64_t device_latency
= 0;
503 const char *resample_method
= NULL
;
510 if (s
->type
== STREAM_TYPE_PLAYBACK
) {
511 idx
= s
->sink_input
->index
;
512 driver
= s
->sink_input
->driver
;
513 owner_module
= s
->sink_input
->module
;
514 client
= s
->sink_input
->client
;
515 device
= pa_dbusiface_core_get_sink_path(s
->core
, s
->sink
);
516 sample_format
= s
->sink_input
->sample_spec
.format
;
517 channel_map
= &s
->sink_input
->channel_map
;
518 for (i
= 0; i
< s
->volume
.channels
; ++i
)
519 volume
[i
] = s
->volume
.values
[i
];
520 buffer_latency
= pa_sink_input_get_latency(s
->sink_input
, &device_latency
);
521 resample_method
= pa_resample_method_to_string(s
->sink_input
->actual_resample_method
);
523 idx
= s
->source_output
->index
;
524 driver
= s
->source_output
->driver
;
525 owner_module
= s
->source_output
->module
;
526 client
= s
->source_output
->client
;
527 device
= pa_dbusiface_core_get_source_path(s
->core
, s
->source
);
528 sample_format
= s
->source_output
->sample_spec
.format
;
529 channel_map
= &s
->source_output
->channel_map
;
530 buffer_latency
= pa_source_output_get_latency(s
->source_output
, &device_latency
);
531 resample_method
= pa_resample_method_to_string(s
->source_output
->actual_resample_method
);
534 owner_module_path
= pa_dbusiface_core_get_module_path(s
->core
, owner_module
);
536 client_path
= pa_dbusiface_core_get_client_path(s
->core
, client
);
537 for (i
= 0; i
< channel_map
->channels
; ++i
)
538 channels
[i
] = channel_map
->map
[i
];
540 pa_assert_se((reply
= dbus_message_new_method_return(msg
)));
542 dbus_message_iter_init_append(reply
, &msg_iter
);
543 pa_assert_se(dbus_message_iter_open_container(&msg_iter
, DBUS_TYPE_ARRAY
, "{sv}", &dict_iter
));
545 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_INDEX
].property_name
, DBUS_TYPE_UINT32
, &idx
);
548 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_DRIVER
].property_name
, DBUS_TYPE_STRING
, &driver
);
551 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_OWNER_MODULE
].property_name
, DBUS_TYPE_OBJECT_PATH
, &owner_module_path
);
554 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_CLIENT
].property_name
, DBUS_TYPE_OBJECT_PATH
, &client_path
);
556 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_SAMPLE_FORMAT
].property_name
, DBUS_TYPE_UINT32
, &sample_format
);
557 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_SAMPLE_RATE
].property_name
, DBUS_TYPE_UINT32
, &s
->sample_rate
);
558 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_CHANNELS
].property_name
, DBUS_TYPE_UINT32
, channels
, channel_map
->channels
);
560 if (s
->type
== STREAM_TYPE_PLAYBACK
) {
561 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_VOLUME
].property_name
, DBUS_TYPE_UINT32
, volume
, s
->volume
.channels
);
562 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_IS_MUTED
].property_name
, DBUS_TYPE_BOOLEAN
, &s
->is_muted
);
565 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_BUFFER_LATENCY
].property_name
, DBUS_TYPE_UINT64
, &buffer_latency
);
566 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_DEVICE_LATENCY
].property_name
, DBUS_TYPE_UINT64
, &device_latency
);
567 pa_dbus_append_basic_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_RESAMPLE_METHOD
].property_name
, DBUS_TYPE_STRING
, &resample_method
);
568 pa_dbus_append_proplist_variant_dict_entry(&dict_iter
, property_handlers
[PROPERTY_HANDLER_PROPERTY_LIST
].property_name
, s
->proplist
);
570 pa_assert_se(dbus_message_iter_close_container(&msg_iter
, &dict_iter
));
571 pa_assert_se(dbus_connection_send(conn
, reply
, NULL
));
572 dbus_message_unref(reply
);
575 static void handle_move(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
576 pa_dbusiface_stream
*s
= userdata
;
577 const char *device
= NULL
;
584 dbus_error_init(&error
);
586 if (!dbus_message_get_args(msg
, &error
, DBUS_TYPE_STRING
, &device
, DBUS_TYPE_INVALID
)) {
587 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "%s", error
.message
);
588 dbus_error_free(&error
);
592 if (s
->type
== STREAM_TYPE_PLAYBACK
) {
593 pa_sink
*sink
= pa_dbusiface_core_get_sink(s
->core
, device
);
596 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NOT_FOUND
, "%s: No such sink.", device
);
600 if (pa_sink_input_move_to(s
->sink_input
, sink
, TRUE
) < 0) {
601 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_FAILED
,
602 "Moving playback stream %u to sink %s failed.", s
->sink_input
->index
, sink
->name
);
606 pa_source
*source
= pa_dbusiface_core_get_source(s
->core
, device
);
609 pa_dbus_send_error(conn
, msg
, PA_DBUS_ERROR_NOT_FOUND
, "%s: No such source.", device
);
613 if (pa_source_output_move_to(s
->source_output
, source
, TRUE
) < 0) {
614 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_FAILED
,
615 "Moving record stream %u to source %s failed.", s
->source_output
->index
, source
->name
);
620 pa_dbus_send_empty_reply(conn
, msg
);
623 static void handle_kill(DBusConnection
*conn
, DBusMessage
*msg
, void *userdata
) {
624 pa_dbusiface_stream
*s
= userdata
;
630 if (s
->type
== STREAM_TYPE_PLAYBACK
)
631 pa_sink_input_kill(s
->sink_input
);
633 pa_source_output_kill(s
->source_output
);
635 pa_dbus_send_empty_reply(conn
, msg
);
638 static void subscription_cb(pa_core
*c
, pa_subscription_event_type_t t
, uint32_t idx
, void *userdata
) {
639 pa_dbusiface_stream
*s
= userdata
;
640 DBusMessage
*signal
= NULL
;
641 const char *new_device_path
= NULL
;
642 uint32_t new_sample_rate
= 0;
643 pa_proplist
*new_proplist
= NULL
;
649 if ((s
->type
== STREAM_TYPE_PLAYBACK
&& idx
!= s
->sink_input
->index
)
650 || (s
->type
== STREAM_TYPE_RECORD
&& idx
!= s
->source_output
->index
))
653 if ((t
& PA_SUBSCRIPTION_EVENT_TYPE_MASK
) != PA_SUBSCRIPTION_EVENT_CHANGE
)
656 pa_assert(((s
->type
== STREAM_TYPE_PLAYBACK
)
657 && ((t
& PA_SUBSCRIPTION_EVENT_FACILITY_MASK
) == PA_SUBSCRIPTION_EVENT_SINK_INPUT
))
658 || ((s
->type
== STREAM_TYPE_RECORD
)
659 && ((t
& PA_SUBSCRIPTION_EVENT_FACILITY_MASK
) == PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT
)));
661 if (s
->type
== STREAM_TYPE_PLAYBACK
) {
662 pa_sink
*new_sink
= s
->sink_input
->sink
;
664 if (s
->sink
!= new_sink
) {
665 pa_sink_unref(s
->sink
);
666 s
->sink
= pa_sink_ref(new_sink
);
668 new_device_path
= pa_dbusiface_core_get_sink_path(s
->core
, new_sink
);
670 pa_assert_se(signal
= dbus_message_new_signal(s
->path
,
671 PA_DBUSIFACE_STREAM_INTERFACE
,
672 signals
[SIGNAL_DEVICE_UPDATED
].name
));
673 pa_assert_se(dbus_message_append_args(signal
, DBUS_TYPE_OBJECT_PATH
, &new_device_path
, DBUS_TYPE_INVALID
));
675 pa_dbus_protocol_send_signal(s
->dbus_protocol
, signal
);
676 dbus_message_unref(signal
);
680 pa_source
*new_source
= s
->source_output
->source
;
682 if (s
->source
!= new_source
) {
683 pa_source_unref(s
->source
);
684 s
->source
= pa_source_ref(new_source
);
686 new_device_path
= pa_dbusiface_core_get_source_path(s
->core
, new_source
);
688 pa_assert_se(signal
= dbus_message_new_signal(s
->path
,
689 PA_DBUSIFACE_STREAM_INTERFACE
,
690 signals
[SIGNAL_DEVICE_UPDATED
].name
));
691 pa_assert_se(dbus_message_append_args(signal
, DBUS_TYPE_OBJECT_PATH
, &new_device_path
, DBUS_TYPE_INVALID
));
693 pa_dbus_protocol_send_signal(s
->dbus_protocol
, signal
);
694 dbus_message_unref(signal
);
699 new_sample_rate
= (s
->type
== STREAM_TYPE_PLAYBACK
) ? s
->sink_input
->sample_spec
.rate
: s
->source_output
->sample_spec
.rate
;
701 if (s
->sample_rate
!= new_sample_rate
) {
702 s
->sample_rate
= new_sample_rate
;
704 pa_assert_se(signal
= dbus_message_new_signal(s
->path
,
705 PA_DBUSIFACE_STREAM_INTERFACE
,
706 signals
[SIGNAL_SAMPLE_RATE_UPDATED
].name
));
707 pa_assert_se(dbus_message_append_args(signal
, DBUS_TYPE_UINT32
, &s
->sample_rate
, DBUS_TYPE_INVALID
));
709 pa_dbus_protocol_send_signal(s
->dbus_protocol
, signal
);
710 dbus_message_unref(signal
);
714 if (s
->type
== STREAM_TYPE_PLAYBACK
) {
715 pa_cvolume new_volume
;
716 pa_bool_t new_muted
= FALSE
;
718 pa_sink_input_get_volume(s
->sink_input
, &new_volume
, TRUE
);
720 if (!pa_cvolume_equal(&s
->volume
, &new_volume
)) {
721 dbus_uint32_t volume
[PA_CHANNELS_MAX
];
722 dbus_uint32_t
*volume_ptr
= volume
;
724 s
->volume
= new_volume
;
726 for (i
= 0; i
< s
->volume
.channels
; ++i
)
727 volume
[i
] = s
->volume
.values
[i
];
729 pa_assert_se(signal
= dbus_message_new_signal(s
->path
,
730 PA_DBUSIFACE_STREAM_INTERFACE
,
731 signals
[SIGNAL_VOLUME_UPDATED
].name
));
732 pa_assert_se(dbus_message_append_args(signal
,
733 DBUS_TYPE_ARRAY
, DBUS_TYPE_UINT32
, &volume_ptr
, s
->volume
.channels
,
736 pa_dbus_protocol_send_signal(s
->dbus_protocol
, signal
);
737 dbus_message_unref(signal
);
741 new_muted
= pa_sink_input_get_mute(s
->sink_input
);
743 if (s
->is_muted
!= new_muted
) {
744 s
->is_muted
= new_muted
;
746 pa_assert_se(signal
= dbus_message_new_signal(s
->path
,
747 PA_DBUSIFACE_STREAM_INTERFACE
,
748 signals
[SIGNAL_MUTE_UPDATED
].name
));
749 pa_assert_se(dbus_message_append_args(signal
, DBUS_TYPE_BOOLEAN
, &s
->is_muted
, DBUS_TYPE_INVALID
));
751 pa_dbus_protocol_send_signal(s
->dbus_protocol
, signal
);
752 dbus_message_unref(signal
);
757 new_proplist
= (s
->type
== STREAM_TYPE_PLAYBACK
) ? s
->sink_input
->proplist
: s
->source_output
->proplist
;
759 if (!pa_proplist_equal(s
->proplist
, new_proplist
)) {
760 DBusMessageIter msg_iter
;
762 pa_proplist_update(s
->proplist
, PA_UPDATE_SET
, new_proplist
);
764 pa_assert_se(signal
= dbus_message_new_signal(s
->path
,
765 PA_DBUSIFACE_STREAM_INTERFACE
,
766 signals
[SIGNAL_PROPERTY_LIST_UPDATED
].name
));
767 dbus_message_iter_init_append(signal
, &msg_iter
);
768 pa_dbus_append_proplist(&msg_iter
, s
->proplist
);
770 pa_dbus_protocol_send_signal(s
->dbus_protocol
, signal
);
771 dbus_message_unref(signal
);
776 static pa_hook_result_t
send_event_cb(void *hook_data
, void *call_data
, void *slot_data
) {
777 pa_dbusiface_stream
*s
= slot_data
;
778 DBusMessage
*signal
= NULL
;
779 DBusMessageIter msg_iter
;
780 const char *name
= NULL
;
781 pa_proplist
*property_list
= NULL
;
783 pa_assert(call_data
);
786 if (s
->type
== STREAM_TYPE_PLAYBACK
) {
787 pa_sink_input_send_event_hook_data
*data
= call_data
;
789 if (data
->sink_input
!= s
->sink_input
)
793 property_list
= data
->data
;
795 pa_source_output_send_event_hook_data
*data
= call_data
;
797 if (data
->source_output
!= s
->source_output
)
801 property_list
= data
->data
;
804 pa_assert_se(signal
= dbus_message_new_signal(s
->path
,
805 PA_DBUSIFACE_STREAM_INTERFACE
,
806 signals
[SIGNAL_STREAM_EVENT
].name
));
807 dbus_message_iter_init_append(signal
, &msg_iter
);
808 pa_assert_se(dbus_message_iter_append_basic(&msg_iter
, DBUS_TYPE_STRING
, &name
));
809 pa_dbus_append_proplist(&msg_iter
, property_list
);
811 pa_dbus_protocol_send_signal(s
->dbus_protocol
, signal
);
812 dbus_message_unref(signal
);
817 pa_dbusiface_stream
*pa_dbusiface_stream_new_playback(pa_dbusiface_core
*core
, pa_sink_input
*sink_input
) {
818 pa_dbusiface_stream
*s
;
821 pa_assert(sink_input
);
823 s
= pa_xnew(pa_dbusiface_stream
, 1);
825 s
->sink_input
= pa_sink_input_ref(sink_input
);
826 s
->type
= STREAM_TYPE_PLAYBACK
;
827 s
->path
= pa_sprintf_malloc("%s/%s%u", PA_DBUS_CORE_OBJECT_PATH
, PLAYBACK_OBJECT_NAME
, sink_input
->index
);
828 s
->sink
= pa_sink_ref(sink_input
->sink
);
829 s
->sample_rate
= sink_input
->sample_spec
.rate
;
830 pa_sink_input_get_volume(sink_input
, &s
->volume
, TRUE
);
831 s
->is_muted
= pa_sink_input_get_mute(sink_input
);
832 s
->proplist
= pa_proplist_copy(sink_input
->proplist
);
833 s
->dbus_protocol
= pa_dbus_protocol_get(sink_input
->core
);
834 s
->subscription
= pa_subscription_new(sink_input
->core
, PA_SUBSCRIPTION_MASK_SINK_INPUT
, subscription_cb
, s
);
835 s
->send_event_slot
= pa_hook_connect(&sink_input
->core
->hooks
[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT
],
840 pa_assert_se(pa_dbus_protocol_add_interface(s
->dbus_protocol
, s
->path
, &stream_interface_info
, s
) >= 0);
845 pa_dbusiface_stream
*pa_dbusiface_stream_new_record(pa_dbusiface_core
*core
, pa_source_output
*source_output
) {
846 pa_dbusiface_stream
*s
;
849 pa_assert(source_output
);
851 s
= pa_xnew(pa_dbusiface_stream
, 1);
853 s
->source_output
= pa_source_output_ref(source_output
);
854 s
->type
= STREAM_TYPE_RECORD
;
855 s
->path
= pa_sprintf_malloc("%s/%s%u", PA_DBUS_CORE_OBJECT_PATH
, RECORD_OBJECT_NAME
, source_output
->index
);
856 s
->source
= pa_source_ref(source_output
->source
);
857 s
->sample_rate
= source_output
->sample_spec
.rate
;
858 pa_cvolume_init(&s
->volume
);
860 s
->proplist
= pa_proplist_copy(source_output
->proplist
);
861 s
->dbus_protocol
= pa_dbus_protocol_get(source_output
->core
);
862 s
->subscription
= pa_subscription_new(source_output
->core
, PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT
, subscription_cb
, s
);
863 s
->send_event_slot
= pa_hook_connect(&source_output
->core
->hooks
[PA_CORE_HOOK_SOURCE_OUTPUT_SEND_EVENT
],
868 pa_assert_se(pa_dbus_protocol_add_interface(s
->dbus_protocol
, s
->path
, &stream_interface_info
, s
) >= 0);
873 void pa_dbusiface_stream_free(pa_dbusiface_stream
*s
) {
876 pa_assert_se(pa_dbus_protocol_remove_interface(s
->dbus_protocol
, s
->path
, stream_interface_info
.name
) >= 0);
878 if (s
->type
== STREAM_TYPE_PLAYBACK
) {
879 pa_sink_input_unref(s
->sink_input
);
880 pa_sink_unref(s
->sink
);
882 pa_source_output_unref(s
->source_output
);
883 pa_source_unref(s
->source
);
886 pa_proplist_free(s
->proplist
);
887 pa_dbus_protocol_unref(s
->dbus_protocol
);
888 pa_subscription_free(s
->subscription
);
889 pa_hook_slot_free(s
->send_event_slot
);
895 const char *pa_dbusiface_stream_get_path(pa_dbusiface_stream
*s
) {