2 * module-murphy-ivi -- PulseAudio module for providing audio routing support
3 * Copyright (c) 2012, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU Lesser General Public License,
7 * version 2.1, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.
12 * See the GNU Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this program; if not, write to the
16 * Free Software Foundation, Inc., 51 Franklin St - Fifth Floor, Boston,
20 #include <sys/types.h>
25 #include <pulse/utf8.h>
26 #include <pulse/timeval.h>
27 #include <pulsecore/pulsecore-config.h>
28 #include <pulsecore/module.h>
29 #include <pulsecore/llist.h>
30 #include <pulsecore/idxset.h>
31 #include <pulsecore/hashmap.h>
32 #include <pulsecore/core-util.h>
33 #include <pulsecore/sink-input.h>
34 #include <pulsecore/source-output.h>
38 #define WITH_RESOURCES
41 #if defined(WITH_DOMCTL) || defined(WITH_RESOURCES)
42 #include <murphy/common/macros.h>
43 #include <murphy/common/mainloop.h>
44 #include <murphy/pulse/pulse-glue.h>
48 #include <murphy/resource/protocol.h>
49 #include <murphy/common/transport.h>
50 #include <murphy/resource/protocol.h>
51 #include <murphy/resource/data-types.h>
56 #include "stream-state.h"
60 #define INVALID_ID (~(uint32_t)0)
61 #define INVALID_INDEX (~(uint32_t)0)
62 #define INVALID_SEQNO (~(uint32_t)0)
63 #define INVALID_REQUEST (~(uint16_t)0)
65 #define DISCONNECTED -1
69 #define RESCOL_NAMES "rsetid,autorel,state,grant,pid,policy"
70 #define RESCOL_RSETID 0
71 #define RESCOL_AUTOREL 1
72 #define RESCOL_STATE 2
73 #define RESCOL_GRANT 3
75 #define RESCOL_POLICY 5
77 #define RSET_RELEASE 1
78 #define RSET_ACQUIRE 2
80 #define PUSH_VALUE(msg, tag, typ, val) \
81 mrp_msg_append(msg, MRP_MSG_TAG_##typ(RESPROTO_##tag, val))
83 #define PUSH_ATTRS(msg, rif, proplist) \
84 resource_push_attributes(msg, rif, proplist)
86 typedef struct resource_attribute resource_attribute;
87 typedef struct resource_request resource_request;
89 struct resource_attribute {
90 PA_LLIST_FIELDS(resource_attribute);
95 struct resource_request {
96 PA_LLIST_FIELDS(resource_request);
109 mrp_domctl_table_t *tables;
111 mrp_domctl_watch_t *watches;
112 pa_murphyif_watch_cb watchcb;
123 audio_resource_t inpres;
124 audio_resource_t outres;
125 #ifdef WITH_RESOURCES
126 mrp_transport_t *transp;
127 mrp_sockaddr_t saddr;
143 PA_LLIST_HEAD(resource_attribute, attrs);
144 PA_LLIST_HEAD(resource_request, reqs);
146 } resource_interface;
150 #if defined(WITH_DOMCTL) || defined(WITH_RESOURCES)
153 domctl_interface domctl;
154 resource_interface resource;
157 #ifdef WITH_RESOURCES
174 #ifdef WITH_RESOURCES
175 static mir_node *find_node_by_rsetid(struct userdata *, const char *);
179 static void domctl_connect_notify(mrp_domctl_t *,int,int,const char *,void *);
180 static void domctl_watch_notify(mrp_domctl_t *,mrp_domctl_data_t *,int,void *);
181 static void domctl_dump_data(mrp_domctl_data_t *);
184 #ifdef WITH_RESOURCES
185 static void resource_attribute_destroy(resource_interface *,
186 resource_attribute *);
187 static int resource_transport_connect(resource_interface *);
188 static void resource_xport_closed_evt(mrp_transport_t *, int, void *);
190 static mrp_msg_t *resource_create_request(uint32_t, mrp_resproto_request_t);
191 static pa_bool_t resource_send_message(resource_interface *, mrp_msg_t *,
192 uint32_t, uint16_t, uint32_t);
193 static pa_bool_t resource_set_create_node(struct userdata *, mir_node *,
194 pa_nodeset_resdef *, pa_bool_t);
195 static pa_bool_t resource_set_create_all(struct userdata *);
196 static pa_bool_t resource_set_destroy_node(struct userdata *, uint32_t);
197 static pa_bool_t resource_set_destroy_all(struct userdata *);
198 static void resource_set_notification(struct userdata *, const char *,
199 int, mrp_domctl_value_t **);
201 static pa_bool_t resource_push_attributes(mrp_msg_t *, resource_interface *,
204 static void resource_recv_msg(mrp_transport_t *, mrp_msg_t *, void *);
205 static void resource_recvfrom_msg(mrp_transport_t *, mrp_msg_t *,
206 mrp_sockaddr_t *, socklen_t, void *);
207 static void resource_set_create_response(struct userdata *, mir_node *,
208 mrp_msg_t *, void **);
209 static void resource_set_create_response_abort(struct userdata *,
210 mrp_msg_t *, void **);
212 static pa_bool_t resource_fetch_seqno(mrp_msg_t *, void **, uint32_t *);
213 static pa_bool_t resource_fetch_request(mrp_msg_t *, void **, uint16_t *);
214 static pa_bool_t resource_fetch_status(mrp_msg_t *, void **, int *);
215 static pa_bool_t resource_fetch_rset_id(mrp_msg_t *, void **, uint32_t*);
216 static pa_bool_t resource_fetch_rset_state(mrp_msg_t *, void **,
217 mrp_resproto_state_t *);
218 static pa_bool_t resource_fetch_rset_mask(mrp_msg_t *, void **,
219 mrp_resproto_state_t *);
221 static pa_bool_t resource_transport_create(struct userdata *, pa_murphyif *);
222 static void resource_transport_destroy(pa_murphyif *);
224 static void connect_attempt(pa_mainloop_api *, pa_time_event *,
225 const struct timeval *, void *);
226 static void schedule_connect(struct userdata *, resource_interface *);
227 static void cancel_schedule(struct userdata *, resource_interface *);
229 static int node_put_rset(struct userdata *, mir_node *, rset_data *);
230 static void node_enforce_resource_policy(struct userdata *, mir_node *,
232 static rset_data *rset_data_dup(rset_data *);
233 static void rset_data_copy(rset_data *, rset_data *);
234 static void rset_data_free(rset_data *);
236 static void pid_hashmap_free(void *, void *);
237 static int pid_hashmap_put(struct userdata *, const char *,
238 mir_node *, rset_data *);
239 static mir_node *pid_hashmap_get_node(struct userdata *, const char *);
240 static rset_data *pid_hashmap_get_rset(struct userdata *, const char *);
241 static mir_node *pid_hashmap_remove_node(struct userdata *, const char *);
242 static rset_data *pid_hashmap_remove_rset(struct userdata *, const char *);
245 static pa_proplist *get_node_proplist(struct userdata *, mir_node *);
246 static const char *get_node_pid(struct userdata *, mir_node *);
249 pa_murphyif *pa_murphyif_init(struct userdata *u,
250 const char *ctl_addr,
251 const char *res_addr)
253 pa_murphyif *murphyif;
254 domctl_interface *dif;
255 resource_interface *rif;
256 #if defined(WITH_DOMCTL) || defined(WITH_RESOURCES)
259 if (!(ml = mrp_mainloop_pulse_get(u->core->mainloop))) {
260 pa_log_error("Failed to set up murphy mainloop.");
264 #ifdef WITH_RESOURCES
267 murphyif = pa_xnew0(pa_murphyif, 1);
268 dif = &murphyif->domctl;
269 rif = &murphyif->resource;
271 #if defined(WITH_DOMCTL) || defined(WITH_RESOURCES)
275 dif->addr = pa_xstrdup(ctl_addr ? ctl_addr:MRP_DEFAULT_DOMCTL_ADDRESS);
279 rif->addr = pa_xstrdup(res_addr ? res_addr:RESPROTO_DEFAULT_ADDRESS);
280 #ifdef WITH_RESOURCES
281 rif->alen = mrp_transport_resolve(NULL, rif->addr, &rif->saddr,
282 sizeof(rif->saddr), &rif->atype);
283 if (rif->alen <= 0) {
284 pa_log("can't resolve resource transport address '%s'", rif->addr);
287 rif->inpres.tblidx = -1;
288 rif->outres.tblidx = -1;
289 rif->connect.period = 1 * PA_USEC_PER_SEC;
291 if (!resource_transport_create(u, murphyif)) {
292 pa_log("failed to create resource transport");
293 schedule_connect(u, rif);
296 if (resource_transport_connect(rif) == DISCONNECTED)
297 schedule_connect(u, rif);
301 rif->seqno.request = 1;
302 rif->nodes.rsetid = pa_hashmap_new(pa_idxset_string_hash_func,
303 pa_idxset_string_compare_func);
304 rif->nodes.pid = pa_hashmap_new(pa_idxset_string_hash_func,
305 pa_idxset_string_compare_func);
306 PA_LLIST_HEAD_INIT(resource_attribute, rif->attrs);
307 PA_LLIST_HEAD_INIT(resource_request, rif->reqs);
314 void pa_murphyif_done(struct userdata *u)
316 pa_murphyif *murphyif;
317 domctl_interface *dif;
318 resource_interface *rif;
319 #ifdef WITH_RESOURCES
320 resource_attribute *attr, *a;
321 resource_request *req, *r;
324 if (u && (murphyif = u->murphyif)) {
326 mrp_domctl_table_t *t;
327 mrp_domctl_watch_t *w;
330 dif = &murphyif->domctl;
332 mrp_domctl_destroy(dif->ctl);
333 mrp_mainloop_destroy(murphyif->ml);
335 if (dif->ntable > 0 && dif->tables) {
336 for (i = 0; i < dif->ntable; i++) {
338 pa_xfree((void *)t->table);
339 pa_xfree((void *)t->mql_columns);
340 pa_xfree((void *)t->mql_index);
342 pa_xfree(dif->tables);
345 if (dif->nwatch > 0 && dif->watches) {
346 for (i = 0; i < dif->nwatch; i++) {
347 w = dif->watches + i;
348 pa_xfree((void *)w->table);
349 pa_xfree((void *)w->mql_columns);
350 pa_xfree((void *)w->mql_where);
352 pa_xfree(dif->watches);
355 pa_xfree((void *)dif->addr);
358 #ifdef WITH_RESOURCES
359 rif = &murphyif->resource;
361 resource_transport_destroy(murphyif);
363 pa_xfree((void *)rif->atype);
364 pa_hashmap_free(rif->nodes.rsetid, NULL, NULL);
365 pa_hashmap_free(rif->nodes.pid, pid_hashmap_free, NULL);
367 PA_LLIST_FOREACH_SAFE(attr, a, rif->attrs)
368 resource_attribute_destroy(rif, attr);
370 PA_LLIST_FOREACH_SAFE(req, r, rif->reqs)
373 pa_xfree((void *)rif->addr);
374 pa_xfree((void *)rif->inpres.name);
375 pa_xfree((void *)rif->outres.name);
383 void pa_murphyif_add_table(struct userdata *u,
388 pa_murphyif *murphyif;
389 domctl_interface *dif;
390 mrp_domctl_table_t *t;
397 pa_assert_se((murphyif = u->murphyif));
399 dif = &murphyif->domctl;
402 size = sizeof(mrp_domctl_table_t) * dif->ntable;
403 t = (dif->tables = pa_xrealloc(dif->tables, size)) + idx;
405 t->table = pa_xstrdup(table);
406 t->mql_columns = pa_xstrdup(columns);
407 t->mql_index = index ? pa_xstrdup(index) : NULL;
410 int pa_murphyif_add_watch(struct userdata *u,
416 pa_murphyif *murphyif;
417 domctl_interface *dif;
418 mrp_domctl_watch_t *w;
425 pa_assert(max_rows > 0 && max_rows < MQI_QUERY_RESULT_MAX);
426 pa_assert_se((murphyif = u->murphyif));
428 dif = &murphyif->domctl;
431 size = sizeof(mrp_domctl_watch_t) * dif->nwatch;
432 w = (dif->watches = pa_xrealloc(dif->watches, size)) + idx;
434 w->table = pa_xstrdup(table);
435 w->mql_columns = pa_xstrdup(columns);
436 w->mql_where = where ? pa_xstrdup(where) : NULL;
437 w->max_rows = max_rows;
442 void pa_murphyif_setup_domainctl(struct userdata *u, pa_murphyif_watch_cb wcb)
444 static const char *name = "pulse";
446 pa_murphyif *murphyif;
447 domctl_interface *dif;
451 pa_assert_se((murphyif = u->murphyif));
453 dif = &murphyif->domctl;
456 if (dif->ntable || dif->nwatch) {
457 dif->ctl = mrp_domctl_create(name, murphyif->ml,
458 dif->tables, dif->ntable,
459 dif->watches, dif->nwatch,
460 domctl_connect_notify,
461 domctl_watch_notify, u);
463 pa_log("failed to create '%s' domain controller", name);
467 if (!mrp_domctl_connect(dif->ctl, dif->addr, 0)) {
468 pa_log("failed to conect to murphyd");
473 pa_log_info("'%s' domain controller sucessfully created", name);
478 void pa_murphyif_add_audio_resource(struct userdata *u,
483 static const char *columns = RESCOL_NAMES;
484 static int maxrow = MQI_QUERY_RESULT_MAX - 1;
486 pa_murphyif *murphyif;
487 resource_interface *rif;
488 audio_resource_t *res;
492 pa_assert(dir == mir_input || dir == mir_output);
495 pa_assert_se((murphyif = u->murphyif));
496 rif = &murphyif->resource;
499 if (dir == mir_input) {
500 if (rif->inpres.name)
501 pa_log("attempt to register playback resource multiple time");
506 if (rif->outres.name)
507 pa_log("attempt to register recording resource multiple time");
513 res->name = pa_xstrdup(name);
515 snprintf(table, sizeof(table), "%s_users", name);
516 res->tblidx = pa_murphyif_add_watch(u, table, columns, NULL, maxrow);
521 void pa_murphyif_add_audio_attribute(struct userdata *u,
524 mqi_data_type_t type,
525 ... ) /* default value */
527 #ifdef WITH_RESOURCES
528 pa_murphyif *murphyif;
529 resource_interface *rif;
530 resource_attribute *attr;
531 mrp_attr_value_t *val;
537 pa_assert(type == mqi_string || type == mqi_integer ||
538 type == mqi_unsignd || type == mqi_floating);
540 pa_assert_se((murphyif = u->murphyif));
541 rif = &murphyif->resource;
543 attr = pa_xnew0(resource_attribute, 1);
544 val = &attr->def.value;
546 attr->prop = pa_xstrdup(propnam);
547 attr->def.name = pa_xstrdup(attrnam);
548 attr->def.type = type;
553 case mqi_string: val->string = pa_xstrdup(va_arg(ap, char *)); break;
554 case mqi_integer: val->integer = va_arg(ap, int32_t); break;
555 case mqi_unsignd: val->unsignd = va_arg(ap, uint32_t); break;
556 case mqi_floating: val->floating = va_arg(ap, double); break;
557 default: attr->def.type = mqi_error; break;
562 if (attr->def.type == mqi_error)
563 resource_attribute_destroy(rif, attr);
565 PA_LLIST_PREPEND(resource_attribute, rif->attrs, attr);
569 void pa_murphyif_create_resource_set(struct userdata *u,
571 pa_nodeset_resdef *resdef)
574 pa_murphyif *murphyif;
575 resource_interface *rif;
580 pa_assert((!node->loop && node->implement == mir_stream) ||
581 ( node->loop && node->implement == mir_device) );
582 pa_assert(node->direction == mir_input || node->direction == mir_output);
583 pa_assert(node->zone);
584 pa_assert(!node->rsetid);
586 pa_assert_se((core = u->core));
588 pa_assert_se((murphyif = u->murphyif));
589 rif = &murphyif->resource;
591 state = resource_transport_connect(rif);
596 resource_set_create_all(u);
600 node->localrset = resource_set_create_node(u, node, resdef, TRUE);
608 void pa_murphyif_destroy_resource_set(struct userdata *u, mir_node *node)
610 pa_murphyif *murphyif;
616 pa_assert_se((murphyif = u->murphyif));
618 if (node->localrset && node->rsetid) {
619 rsetid = strtoul(node->rsetid, &e, 10);
621 if (e == node->rsetid || *e) {
622 pa_log("can't destroy resource set: invalid rsetid '%s'",
626 if (resource_set_destroy_node(u, rsetid))
627 pa_log_debug("resource set %u destruction request", rsetid);
629 pa_log("falied to destroy resourse set %u for node '%s'",
630 rsetid, node->amname);
633 pa_xfree(node->rsetid);
635 node->localrset = FALSE;
639 pa_murphyif_delete_node(u, node);
643 int pa_murphyif_add_node(struct userdata *u, mir_node *node)
645 #ifdef WITH_RESOURCES
646 pa_murphyif *murphyif;
647 resource_interface *rif;
655 pa_assert_se((murphyif = u->murphyif));
657 rif = &murphyif->resource;
660 pa_log("can't register resource set for node '%s'.: missing rsetid",
663 else if (pa_streq(node->rsetid, PA_RESOURCE_SET_ID_PID)) {
664 if (!(pid = get_node_pid(u,node)))
665 pa_log("can't obtain PID for node '%s'", node->amname);
667 if (pid_hashmap_put(u, pid, node, NULL) == 0)
670 if ((rset = pid_hashmap_remove_rset(u, pid))) {
671 pa_log_debug("found resource-set %s for node '%s'",
672 rset->id, node->amname);
674 if (node_put_rset(u, node, rset) == 0) {
675 node_enforce_resource_policy(u, node, rset);
676 rset_data_free(rset);
680 pa_log("can't register resource set for node '%s': "
681 "failed to set rsetid", node->amname);
683 rset_data_free(rset);
686 pa_log("can't register resource set for node '%s': "
687 "conflicting pid", node->amname);
692 if (pa_hashmap_put(rif->nodes.rsetid, node->rsetid, node) == 0)
695 pa_log("can't register resource set for node '%s': conflicting "
696 "resource id '%s'", node->amname, node->rsetid);
706 void pa_murphyif_delete_node(struct userdata *u, mir_node *node)
708 #ifdef WITH_RESOURCES
709 pa_murphyif *murphyif;
710 resource_interface *rif;
717 pa_assert_se((murphyif = u->murphyif));
719 rif = &murphyif->resource;
722 if (pa_streq(node->rsetid, PA_RESOURCE_SET_ID_PID)) {
723 if ((pid = get_node_pid(u, node))) {
724 deleted = pid_hashmap_remove_node(u, pid);
725 pa_assert(!deleted || deleted == node);
729 deleted = pa_hashmap_remove(rif->nodes.rsetid, node->rsetid);
730 pa_assert(!deleted || deleted == node);
736 #ifdef WITH_RESOURCES
737 static mir_node *find_node_by_rsetid(struct userdata *u, const char *rsetid)
739 pa_murphyif *murphyif;
740 resource_interface *rif;
744 pa_assert_se((murphyif = u->murphyif));
746 rif = &murphyif->resource;
751 node = pa_hashmap_get(rif->nodes.rsetid, rsetid);
759 static void domctl_connect_notify(mrp_domctl_t *dc, int connected, int errcode,
760 const char *errmsg, void *user_data)
763 MRP_UNUSED(user_data);
766 pa_log_info("Successfully registered to Murphy.");
768 pa_log_error("Domain control Connection to Murphy failed (%d: %s).",
773 static void domctl_watch_notify(mrp_domctl_t *dc, mrp_domctl_data_t *tables,
774 int ntable, void *user_data)
776 struct userdata *u = (struct userdata *)user_data;
777 pa_murphyif *murphyif;
778 domctl_interface *dif;
779 resource_interface *rif;
780 mrp_domctl_data_t *t;
781 mrp_domctl_watch_t *w;
787 pa_assert(ntable > 0);
789 pa_assert_se((murphyif = u->murphyif));
791 dif = &murphyif->domctl;
792 rif = &murphyif->resource;
794 pa_log_info("Received change notification for %d tables.", ntable);
796 for (i = 0; i < ntable; i++) {
801 pa_assert(t->id >= 0);
802 pa_assert(t->id < dif->nwatch);
804 w = dif->watches + t->id;
806 #ifdef WITH_RESOURCES
807 if (t->id == rif->inpres.tblidx || t->id == rif->outres.tblidx) {
808 resource_set_notification(u, w->table, t->nrow, t->rows);
813 dif->watchcb(u, w->table, t->nrow, t->rows);
817 static void domctl_dump_data(mrp_domctl_data_t *table)
819 mrp_domctl_value_t *row;
825 pa_log_debug("Table #%d: %d rows x %d columns", table->id,
826 table->nrow, table->ncolumn);
828 for (i = 0; i < table->nrow; i++) {
829 row = table->rows[i];
833 for (j = 0, t = ""; j < table->ncolumn; j++, t = ", ") {
834 switch (row[j].type) {
835 case MRP_DOMCTL_STRING:
836 l = snprintf(p, n, "%s'%s'", t, row[j].str);
840 case MRP_DOMCTL_INTEGER:
841 l = snprintf(p, n, "%s%d", t, row[j].s32);
845 case MRP_DOMCTL_UNSIGNED:
846 l = snprintf(p, n, "%s%u", t, row[j].u32);
850 case MRP_DOMCTL_DOUBLE:
851 l = snprintf(p, n, "%s%f", t, row[j].dbl);
856 l = snprintf(p, n, "%s<invalid column 0x%x>",
863 pa_log_debug("row #%d: { %s }", i, buf);
868 #ifdef WITH_RESOURCES
869 static void resource_attribute_destroy(resource_interface *rif,
870 resource_attribute *attr)
874 PA_LLIST_REMOVE(resource_attribute, rif->attrs, attr);
876 pa_xfree((void *)attr->prop);
877 pa_xfree((void *)attr->def.name);
879 if (attr->def.type == mqi_string)
880 pa_xfree((void *)attr->def.value.string);
886 static int resource_transport_connect(resource_interface *rif)
895 if (!mrp_transport_connect(rif->transp, &rif->saddr, rif->alen))
896 status = DISCONNECTED;
898 pa_log_info("resource transport connected to '%s'", rif->addr);
899 rif->connected = TRUE;
907 static void resource_xport_closed_evt(mrp_transport_t *transp, int error,
910 struct userdata *u = (struct userdata *)void_u;
911 pa_murphyif *murphyif;
912 resource_interface *rif;
917 pa_assert_se((murphyif = u->murphyif));
919 rif = &murphyif->resource;
922 pa_log("Resource transport connection closed by peer");
924 pa_log("Resource transport connection closed with error %d (%s)",
925 error, strerror(error));
928 resource_transport_destroy(murphyif);
929 resource_set_destroy_all(u);
930 schedule_connect(u, rif);
933 static mrp_msg_t *resource_create_request(uint32_t seqno,
934 mrp_resproto_request_t req)
939 msg = mrp_msg_create(RESPROTO_SEQUENCE_NO , MRP_MSG_FIELD_UINT32, seqno,
940 RESPROTO_REQUEST_TYPE, MRP_MSG_FIELD_UINT16, type ,
941 RESPROTO_MESSAGE_END );
944 pa_log("can't to create new resource message");
949 static pa_bool_t resource_send_message(resource_interface *rif,
955 resource_request *req;
956 pa_bool_t success = TRUE;
958 if (!mrp_transport_send(rif->transp, msg)) {
959 pa_log("failed to send resource message");
963 req = pa_xnew0(resource_request, 1);
964 req->nodidx = nodidx;
968 PA_LLIST_PREPEND(resource_request, rif->reqs, req);
976 static pa_bool_t resource_set_create_node(struct userdata *u,
978 pa_nodeset_resdef *resdef,
982 pa_murphyif *murphyif;
983 resource_interface *rif;
984 resource_request *req;
994 pa_source_output *sout;
995 audio_resource_t *res;
997 mir_node_type type = 0;
998 uint32_t audio_flags = 0;
1000 pa_proplist *proplist = NULL;
1001 pa_bool_t success = TRUE;
1005 pa_assert(node->index != PA_IDXSET_INVALID);
1006 pa_assert((!node->loop && node->implement == mir_stream) ||
1007 ( node->loop && node->implement == mir_device) );
1008 pa_assert(node->direction == mir_input || node->direction == mir_output);
1009 pa_assert(node->zone);
1010 pa_assert(!node->rsetid);
1012 pa_assert_se((core = u->core));
1014 if ((loop = node->loop)) {
1015 if (node->direction == mir_input) {
1016 sout = pa_idxset_get_by_index(core->source_outputs,
1017 loop->source_output_index);
1019 proplist = sout->proplist;
1022 sinp = pa_idxset_get_by_index(core->sink_inputs,
1023 loop->sink_input_index);
1025 proplist = sinp->proplist;
1027 if (proplist && (role = pa_proplist_gets(proplist, PA_PROP_MEDIA_ROLE))) {
1028 if ((map = pa_nodeset_get_map_by_role(u, role)))
1033 if (node->direction == mir_output) {
1034 if ((sout = pa_idxset_get_by_index(core->source_outputs, node->paidx)))
1035 proplist = sout->proplist;
1038 if ((sinp = pa_idxset_get_by_index(core->sink_inputs, node->paidx)))
1039 proplist = sinp->proplist;
1044 pa_assert_se((class = pa_nodeset_get_class(u, type)));
1045 pa_assert_se((murphyif = u->murphyif));
1046 rif = &murphyif->resource;
1048 reqid = RESPROTO_CREATE_RESOURCE_SET;
1049 seqno = rif->seqno.request++;
1050 res = (node->direction == mir_input) ? &rif->inpres : &rif->outres;
1052 pa_assert_se((resnam = res->name));
1054 rset_flags = RESPROTO_RSETFLAG_NOEVENTS;
1055 rset_flags |= (acquire ? RESPROTO_RSETFLAG_AUTOACQUIRE : 0);
1056 rset_flags |= (resdef ? resdef->flags.rset : 0);
1058 audio_flags = (resdef ? resdef->flags.audio : 0);
1060 priority = (resdef ? resdef->priority : 0);
1062 msg = resource_create_request(seqno, reqid);
1064 if (PUSH_VALUE(msg, RESOURCE_FLAGS , UINT32, rset_flags) &&
1065 PUSH_VALUE(msg, RESOURCE_PRIORITY, UINT32, priority) &&
1066 PUSH_VALUE(msg, CLASS_NAME , STRING, class) &&
1067 PUSH_VALUE(msg, ZONE_NAME , STRING, node->zone) &&
1068 PUSH_VALUE(msg, RESOURCE_NAME , STRING, resnam) &&
1069 PUSH_VALUE(msg, RESOURCE_FLAGS , UINT32, audio_flags) &&
1070 PUSH_VALUE(msg, ATTRIBUTE_NAME , STRING, "policy") &&
1071 PUSH_VALUE(msg, ATTRIBUTE_VALUE , STRING, "strict") &&
1072 PUSH_ATTRS(msg, rif, proplist) &&
1073 PUSH_VALUE(msg, SECTION_END , UINT8 , 0) )
1075 success = resource_send_message(rif, msg, node->index, reqid, seqno);
1083 pa_log_debug("requested resource set for '%s'", node->amname);
1085 pa_log_debug("failed to create resource set for '%s'", node->amname);
1090 static pa_bool_t resource_set_create_all(struct userdata *u)
1100 idx = PA_IDXSET_INVALID;
1102 while ((node = pa_nodeset_iterate_nodes(u, &idx))) {
1103 if ((node->implement == mir_stream && !node->loop) ||
1104 (node->implement == mir_device && node->loop) )
1106 if (!node->rsetid) {
1107 node->localrset = resource_set_create_node(u, node, NULL, FALSE);
1108 success &= node->localrset;
1116 static pa_bool_t resource_set_destroy_node(struct userdata *u, uint32_t rsetid)
1118 pa_murphyif *murphyif;
1119 resource_interface *rif;
1128 pa_assert_se((murphyif = u->murphyif));
1129 rif = &murphyif->resource;
1131 reqid = RESPROTO_DESTROY_RESOURCE_SET;
1132 seqno = rif->seqno.request++;
1133 nodidx = PA_IDXSET_INVALID;
1134 msg = resource_create_request(seqno, reqid);
1136 if (PUSH_VALUE(msg, RESOURCE_SET_ID, UINT32, rsetid))
1137 success = resource_send_message(rif, msg, nodidx, reqid, seqno);
1146 static pa_bool_t resource_set_destroy_all(struct userdata *u)
1148 pa_murphyif *murphyif;
1149 resource_interface *rif;
1157 pa_assert_se((murphyif = u->murphyif));
1159 rif = &murphyif->resource;
1163 idx = PA_IDXSET_INVALID;
1165 while ((node = pa_nodeset_iterate_nodes(u, &idx))) {
1166 if (node->implement == mir_stream && node->localrset) {
1167 pa_log_debug("destroying resource set for '%s'", node->amname);
1169 if (rif->connected && node->rsetid) {
1170 rsetid = strtoul(node->rsetid, &e, 10);
1172 if (e == node->rsetid || *e)
1175 success &= resource_set_destroy_node(u, rsetid);
1178 pa_xfree(node->rsetid);
1180 node->localrset = FALSE;
1181 node->rsetid = NULL;
1188 static void resource_set_notification(struct userdata *u,
1191 mrp_domctl_value_t **values)
1193 pa_murphyif *murphyif;
1194 resource_interface *rif;
1196 mrp_domctl_value_t *row;
1197 mrp_domctl_value_t *crsetid;
1198 mrp_domctl_value_t *cautorel;
1199 mrp_domctl_value_t *cstate;
1200 mrp_domctl_value_t *cgrant;
1201 mrp_domctl_value_t *cpid;
1202 mrp_domctl_value_t *cpolicy;
1206 rset_data rset, *rs;
1211 pa_assert_se((murphyif = u->murphyif));
1212 rif = &murphyif->resource;
1214 for (r = 0; r < nrow; r++) {
1216 crsetid = row + RESCOL_RSETID;
1217 cautorel = row + RESCOL_AUTOREL;
1218 cstate = row + RESCOL_STATE;
1219 cgrant = row + RESCOL_GRANT;
1220 cpid = row + RESCOL_PID;
1221 cpolicy = row + RESCOL_POLICY;
1223 if (crsetid->type != MRP_DOMCTL_UNSIGNED ||
1224 cautorel->type != MRP_DOMCTL_INTEGER ||
1225 cstate->type != MRP_DOMCTL_INTEGER ||
1226 cgrant->type != MRP_DOMCTL_INTEGER ||
1227 cpid->type != MRP_DOMCTL_STRING ||
1228 cpolicy->type != MRP_DOMCTL_STRING )
1230 pa_log("invalid field type in '%s' (%d|%d|%d|%d|%d|%d)", table,
1231 crsetid->type, cautorel->type, cstate->type,
1232 cgrant->type, cpid->type, cpolicy->type);
1236 snprintf(rsetid, sizeof(rsetid), "%d", crsetid->s32);
1240 rset.autorel = cautorel->s32;
1241 rset.state = cstate->s32;
1242 rset.grant = cgrant->s32;
1243 rset.policy = cpolicy->str;
1246 if (rset.autorel != 0 && rset.autorel != 1) {
1247 pa_log_debug("invalid autorel %d in table '%s'",
1248 rset.autorel, table);
1251 if (rset.state != RSET_RELEASE && rset.state != RSET_ACQUIRE) {
1252 pa_log_debug("invalid state %d in table '%s'", rset.state, table);
1255 if (rset.grant != 0 && rset.grant != 1) {
1256 pa_log_debug("invalid grant %d in table '%s'", rset.grant, table);
1260 if (!(node = find_node_by_rsetid(u, rset.id))) {
1262 pa_log_debug("can't find node for resource set %s "
1263 "(pid in resource set unknown)", rset.id);
1267 if ((node = pid_hashmap_remove_node(u, pid))) {
1268 pa_log_debug("found node %s for resource-set '%s'",
1269 node->amname, rset.id);
1271 if (node_put_rset(u, node, &rset) < 0) {
1272 pa_log("can't register resource set for node '%s': "
1273 "failed to set rsetid", node->amname);
1278 if (pid_hashmap_put(u, pid, NULL, rset_data_dup(&rset)) < 0) {
1279 if (!(rs = pid_hashmap_get_rset(u, pid)))
1280 pa_log("failed to add resource set to pid hash");
1282 if (!pa_streq(rs->id, rset.id)) {
1283 pa_log("process %s appears to have multiple resour"
1284 "ce sets (%s and %s)", pid, rs->id,rset.id);
1286 pa_log_debug("update resource-set %s data in "
1287 "pid hash (pid %s)", rs->id, pid);
1288 rset_data_copy(rs, &rset);
1292 pa_log_debug("can't find node for resource set %s. "
1293 "Beleive the stream will appear later on",
1301 pa_log_debug("resource notification for node '%s' autorel:%s state:%s "
1302 "grant:%s pid:%s policy:%s", node->amname,
1303 rset.autorel ? "yes":"no",
1304 rset.state == RSET_ACQUIRE ? "acquire":"release",
1305 rset.grant ? "yes":"no", pid, rset.policy);
1307 node_enforce_resource_policy(u, node, &rset);
1312 static pa_bool_t resource_push_attributes(mrp_msg_t *msg,
1313 resource_interface *rif,
1314 pa_proplist *proplist)
1316 resource_attribute *attr;
1330 PA_LLIST_FOREACH(attr, rif->attrs) {
1331 if (!PUSH_VALUE(msg, ATTRIBUTE_NAME, STRING, attr->def.name))
1335 sts = pa_proplist_get(proplist, attr->prop, &v.ptr, &size);
1339 switch (attr->def.type) {
1342 v.str = attr->def.value.string;
1343 else if (v.str[size-1] != '\0' || strlen(v.str) != (size-1) ||
1344 !pa_utf8_valid(v.str))
1346 if (!PUSH_VALUE(msg, ATTRIBUTE_VALUE, STRING, v.str))
1352 v.i32 = &attr->def.value.integer;
1353 else if (size != sizeof(*v.i32))
1355 if (!PUSH_VALUE(msg, ATTRIBUTE_VALUE, SINT8, *v.i32))
1361 v.u32 = &attr->def.value.unsignd;
1362 else if (size != sizeof(*v.u32))
1364 if (!PUSH_VALUE(msg, ATTRIBUTE_VALUE, SINT8, *v.u32))
1370 v.dbl = &attr->def.value.floating;
1371 else if (size != sizeof(*v.dbl))
1373 if (!PUSH_VALUE(msg, ATTRIBUTE_VALUE, SINT8, *v.dbl))
1377 default: /* we should never get here */
1387 static void resource_recv_msg(mrp_transport_t *t, mrp_msg_t *msg, void *void_u)
1389 return resource_recvfrom_msg(t, msg, NULL, 0, void_u);
1392 static void resource_recvfrom_msg(mrp_transport_t *transp, mrp_msg_t *msg,
1393 mrp_sockaddr_t *addr, socklen_t addrlen,
1396 struct userdata *u = (struct userdata *)void_u;
1398 pa_murphyif *murphyif;
1399 resource_interface *rif;
1404 resource_request *req, *n;
1409 MRP_UNUSED(addrlen);
1412 pa_assert_se((core = u->core));
1413 pa_assert_se((murphyif = u->murphyif));
1415 rif = &murphyif->resource;
1417 if (!resource_fetch_seqno (msg, &curs, &seqno) ||
1418 !resource_fetch_request (msg, &curs, &reqid) )
1420 pa_log("ignoring malformed message");
1424 PA_LLIST_FOREACH_SAFE(req, n, rif->reqs) {
1425 if (req->seqno <= seqno) {
1426 nodidx = req->nodidx;
1428 if (req->reqid == reqid) {
1429 PA_LLIST_REMOVE(resource_request, rif->reqs, req);
1433 if (!(node = mir_node_find_by_index(u, nodidx))) {
1434 if (reqid != RESPROTO_DESTROY_RESOURCE_SET) {
1435 pa_log("got response (reqid:%u seqno:%u) but can't "
1436 "find the corresponding node", reqid, seqno);
1437 resource_set_create_response_abort(u, msg, &curs);
1441 if (req->seqno < seqno) {
1442 pa_log("unanswered request %d", req->seqno);
1445 pa_log_debug("got response (reqid:%u seqno:%u "
1446 "node:'%s')", reqid, seqno,
1447 node ? node->amname : "<unknown>");
1450 case RESPROTO_CREATE_RESOURCE_SET:
1451 resource_set_create_response(u, node, msg, &curs);
1453 case RESPROTO_DESTROY_RESOURCE_SET:
1456 pa_log("ignoring unsupported resource request "
1462 } /* PA_LLIST_FOREACH_SAFE */
1467 static void resource_set_create_response(struct userdata *u, mir_node *node,
1468 mrp_msg_t *msg, void **pcursor)
1479 if (!resource_fetch_status(msg, pcursor, &status) || (status == 0 &&
1480 !resource_fetch_rset_id(msg, pcursor, &rsetid)))
1482 pa_log("ignoring malformed response to resource set creation");
1487 pa_log("creation of resource set failed. error code %u", status);
1491 node->rsetid = pa_sprintf_malloc("%d", rsetid);
1493 if (pa_murphyif_add_node(u, node) == 0) {
1494 pa_log_debug("resource set was successfully created");
1495 mir_node_print(node, buf, sizeof(buf));
1496 pa_log_debug("modified node:\n%s", buf);
1499 pa_log("failed to create resource set: "
1500 "conflicting resource set id");
1504 static void resource_set_create_response_abort(struct userdata *u,
1505 mrp_msg_t *msg, void **pcursor)
1514 if (!resource_fetch_status(msg, pcursor, &status) || (status == 0 &&
1515 !resource_fetch_rset_id(msg, pcursor, &rsetid)))
1517 pa_log("ignoring malformed response to resource set creation");
1522 pa_log("creation of resource set failed. error code %u", status);
1526 if (resource_set_destroy_node(u, rsetid))
1527 pa_log_debug("destroying resource set %u", rsetid);
1529 pa_log("attempt to destroy resource set %u failed", rsetid);
1533 static pa_bool_t resource_fetch_seqno(mrp_msg_t *msg,
1539 mrp_msg_value_t value;
1542 if (!mrp_msg_iterate(msg, pcursor, &tag, &type, &value, &size) ||
1543 tag != RESPROTO_SEQUENCE_NO || type != MRP_MSG_FIELD_UINT32)
1545 *pseqno = INVALID_SEQNO;
1549 *pseqno = value.u32;
1554 static pa_bool_t resource_fetch_request(mrp_msg_t *msg,
1560 mrp_msg_value_t value;
1563 if (!mrp_msg_iterate(msg, pcursor, &tag, &type, &value, &size) ||
1564 tag != RESPROTO_REQUEST_TYPE || type != MRP_MSG_FIELD_UINT16)
1566 *preqtype = INVALID_REQUEST;
1570 *preqtype = value.u16;
1574 static pa_bool_t resource_fetch_status(mrp_msg_t *msg,
1580 mrp_msg_value_t value;
1583 if (!mrp_msg_iterate(msg, pcursor, &tag, &type, &value, &size) ||
1584 tag != RESPROTO_REQUEST_STATUS || type != MRP_MSG_FIELD_SINT16)
1590 *pstatus = value.s16;
1594 static pa_bool_t resource_fetch_rset_id(mrp_msg_t *msg,
1600 mrp_msg_value_t value;
1603 if (!mrp_msg_iterate(msg, pcursor, &tag, &type, &value, &size) ||
1604 tag != RESPROTO_RESOURCE_SET_ID || type != MRP_MSG_FIELD_UINT32)
1614 static pa_bool_t resource_fetch_rset_state(mrp_msg_t *msg,
1616 mrp_resproto_state_t *pstate)
1620 mrp_msg_value_t value;
1623 if (!mrp_msg_iterate(msg, pcursor, &tag, &type, &value, &size) ||
1624 tag != RESPROTO_RESOURCE_STATE || type != MRP_MSG_FIELD_UINT16)
1630 *pstate = value.u16;
1635 static pa_bool_t resource_fetch_rset_mask(mrp_msg_t *msg,
1637 mrp_resproto_state_t *pmask)
1641 mrp_msg_value_t value;
1644 if (!mrp_msg_iterate(msg, pcursor, &tag, &type, &value, &size) ||
1645 tag != RESPROTO_RESOURCE_GRANT || type != MRP_MSG_FIELD_UINT32)
1655 static pa_bool_t resource_transport_create(struct userdata *u,
1656 pa_murphyif *murphyif)
1658 static mrp_transport_evt_t ev = {
1659 { .recvmsg = resource_recv_msg },
1660 { .recvmsgfrom = resource_recvfrom_msg },
1661 .closed = resource_xport_closed_evt,
1665 resource_interface *rif;
1668 pa_assert(murphyif);
1670 rif = &murphyif->resource;
1673 rif->transp = mrp_transport_create(murphyif->ml, rif->atype, &ev, u,0);
1675 return rif->transp ? TRUE : FALSE;
1678 static void resource_transport_destroy(pa_murphyif *murphyif)
1680 resource_interface *rif;
1682 pa_assert(murphyif);
1683 rif = &murphyif->resource;
1686 mrp_transport_destroy(rif->transp);
1689 rif->connected = FALSE;
1692 static void connect_attempt(pa_mainloop_api *a,
1694 const struct timeval *t,
1697 struct userdata *u = (struct userdata *)data;
1698 pa_murphyif *murphyif;
1699 resource_interface *rif;
1704 pa_assert_se((murphyif = u->murphyif));
1706 rif = &murphyif->resource;
1708 if (!resource_transport_create(u, murphyif))
1709 schedule_connect(u, rif);
1711 state = resource_transport_connect(rif);
1716 resource_set_create_all(u);
1717 cancel_schedule(u, rif);
1721 cancel_schedule(u, rif);
1725 schedule_connect(u, rif);
1731 static void schedule_connect(struct userdata *u, resource_interface *rif)
1734 pa_mainloop_api *mainloop;
1735 struct timeval when;
1740 pa_assert_se((core = u->core));
1741 pa_assert_se((mainloop = core->mainloop));
1743 pa_gettimeofday(&when);
1744 pa_timeval_add(&when, rif->connect.period);
1746 if ((tev = rif->connect.evt))
1747 mainloop->time_restart(tev, &when);
1749 rif->connect.evt = mainloop->time_new(mainloop, &when,
1750 connect_attempt, u);
1754 static void cancel_schedule(struct userdata *u, resource_interface *rif)
1757 pa_mainloop_api *mainloop;
1762 pa_assert_se((core = u->core));
1763 pa_assert_se((mainloop = core->mainloop));
1765 if ((tev = rif->connect.evt)) {
1766 mainloop->time_free(tev);
1767 rif->connect.evt = NULL;
1771 static int node_put_rset(struct userdata *u, mir_node *node, rset_data *rset)
1773 pa_murphyif *murphyif;
1774 resource_interface *rif;
1780 pa_assert(rset->id);
1782 pa_assert(node->implement == mir_stream);
1783 pa_assert(node->direction == mir_input || node->direction == mir_output);
1785 pa_assert_se((murphyif = u->murphyif));
1786 rif = &murphyif->resource;
1788 pa_log_debug("setting rsetid %s for node %s", rset->id, node->amname);
1790 pa_xfree(node->rsetid);
1791 node->rsetid = pa_xstrdup(rset->id);
1793 if (!(pl = get_node_proplist(u, node))) {
1794 pa_log("can't obtain property list for node %s", node->amname);
1798 if ((pa_proplist_sets(pl, PA_PROP_RESOURCE_SET_ID, node->rsetid) < 0)) {
1799 pa_log("failed to set '" PA_PROP_RESOURCE_SET_ID "' property "
1800 "of '%s' node", node->amname);
1804 if (pa_hashmap_put(rif->nodes.rsetid, node->rsetid, node) < 0) {
1805 pa_log("conflicting rsetid %s for %s", node->rsetid, node->amname);
1812 static void node_enforce_resource_policy(struct userdata *u,
1820 pa_assert(rset->policy);
1823 if (pa_streq(rset->policy, "relaxed"))
1824 req = PA_STREAM_RUN;
1826 if (rset->state == RSET_RELEASE)
1827 req = PA_STREAM_KILL;
1830 req = PA_STREAM_RUN;
1832 req = PA_STREAM_BLOCK;
1836 pa_stream_state_change(u, node, req);
1839 static rset_data *rset_data_dup(rset_data *orig)
1844 pa_assert(orig->id);
1845 pa_assert(orig->policy);
1847 dup = pa_xnew0(rset_data, 1);
1849 dup->id = pa_xstrdup(orig->id);
1850 dup->autorel = orig->autorel;
1851 dup->state = orig->state;
1852 dup->grant = orig->grant;
1853 dup->policy = pa_xstrdup(orig->policy);
1858 static void rset_data_copy(rset_data *dst, rset_data *src)
1865 pa_assert(src->policy);
1867 pa_xfree((void *)dst->id);
1868 pa_xfree((void *)dst->policy);
1870 dst->id = pa_xstrdup(src->id);
1871 dst->autorel = src->autorel;
1872 dst->state = src->state;
1873 dst->grant = src->grant;
1874 dst->policy = pa_xstrdup(src->policy);
1878 static void rset_data_free(rset_data *rset)
1881 pa_xfree((void *)rset->id);
1882 pa_xfree((void *)rset->policy);
1887 static void pid_hashmap_free(void *p, void *userdata)
1889 pid_hash *ph = (pid_hash *)p;
1894 pa_xfree((void *)ph->pid);
1895 rset_data_free(ph->rset);
1900 static int pid_hashmap_put(struct userdata *u, const char *pid,
1901 mir_node *node, rset_data *rset)
1903 pa_murphyif *murphyif;
1904 resource_interface *rif;
1909 pa_assert(node || rset);
1910 pa_assert_se((murphyif = u->murphyif));
1912 rif = &murphyif->resource;
1914 ph = pa_xnew0(pid_hash, 1);
1915 ph->pid = pa_xstrdup(pid);
1919 if (pa_hashmap_put(rif->nodes.pid, ph->pid, ph) == 0)
1922 pid_hashmap_free(ph, NULL);
1927 static mir_node *pid_hashmap_get_node(struct userdata *u, const char *pid)
1929 pa_murphyif *murphyif;
1930 resource_interface *rif;
1935 pa_assert(murphyif = u->murphyif);
1937 rif = &murphyif->resource;
1939 if ((ph = pa_hashmap_get(rif->nodes.pid, pid)))
1945 static rset_data *pid_hashmap_get_rset(struct userdata *u, const char *pid)
1947 pa_murphyif *murphyif;
1948 resource_interface *rif;
1953 pa_assert(murphyif = u->murphyif);
1955 rif = &murphyif->resource;
1957 if ((ph = pa_hashmap_get(rif->nodes.pid, pid)))
1963 static mir_node *pid_hashmap_remove_node(struct userdata *u, const char *pid)
1965 pa_murphyif *murphyif;
1966 resource_interface *rif;
1971 pa_assert_se((murphyif = u->murphyif));
1973 rif = &murphyif->resource;
1975 if (!(ph = pa_hashmap_remove(rif->nodes.pid, pid)))
1977 else if (!(node = ph->node))
1978 pa_hashmap_put(rif->nodes.pid, ph->pid, ph);
1980 pid_hashmap_free(ph, NULL);
1985 static rset_data *pid_hashmap_remove_rset(struct userdata *u, const char *pid)
1987 pa_murphyif *murphyif;
1988 resource_interface *rif;
1995 pa_assert_se((murphyif = u->murphyif));
1997 rif = &murphyif->resource;
1999 if (!(ph = pa_hashmap_remove(rif->nodes.pid, pid)))
2001 else if (!(rset = ph->rset))
2002 pa_hashmap_put(rif->nodes.pid, ph->pid, ph);
2005 pid_hashmap_free(ph, NULL);
2015 static pa_proplist *get_node_proplist(struct userdata *u, mir_node *node)
2019 pa_source_output *o;
2023 pa_assert_se((core = u->core));
2025 if (node->implement == mir_stream && node->paidx != PA_IDXSET_INVALID) {
2026 if (node->direction == mir_input) {
2027 if ((i = pa_idxset_get_by_index(core->sink_inputs, node->paidx)))
2030 else if (node->direction == mir_output) {
2031 if ((o = pa_idxset_get_by_index(core->source_outputs,node->paidx)))
2039 static const char *get_node_pid(struct userdata *u, mir_node *node)
2045 if (node && (pl = get_node_proplist(u, node)))
2046 return pa_proplist_gets(pl, PA_PROP_APPLICATION_PROCESS_ID);
2054 * indent-tabs-mode: nil