utils: add directory support to pa_utils_file_path()
[profile/ivi/pulseaudio-module-murphy-ivi.git] / murphy / node.c
1 /*
2  * module-murphy-ivi -- PulseAudio module for providing audio routing support
3  * Copyright (c) 2012, Intel Corporation.
4  *
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.
8  *
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.
13  *
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,
17  * MA 02110-1301 USA.
18  *
19  */
20 #include <stdio.h>
21
22 #include <pulsecore/pulsecore-config.h>
23
24 #include <pulsecore/hashmap.h>
25 #include <pulsecore/idxset.h>
26 #include <pulsecore/strbuf.h>
27
28
29 #include "node.h"
30 #include "discover.h"
31 #include "router.h"
32 #include "constrain.h"
33
34 struct pa_nodeset {
35     pa_idxset *nodes;
36 };
37
38
39 pa_nodeset *pa_nodeset_init(struct userdata *u)
40 {
41     pa_nodeset *ns;
42
43     pa_assert(u);
44
45     ns = pa_xnew0(pa_nodeset, 1);
46     ns->nodes = pa_idxset_new(pa_idxset_trivial_hash_func,
47                               pa_idxset_trivial_compare_func);
48     return ns;
49 }
50
51 void pa_nodeset_done(struct userdata *u)
52 {
53     pa_nodeset *ns;
54
55     if (u && (ns = u->nodeset)) {
56         pa_idxset_free(ns->nodes, NULL, NULL);
57         free(ns);
58     }    
59 }
60
61
62 mir_node *mir_node_create(struct userdata *u, mir_node *data)
63 {
64     pa_nodeset *ns;
65     mir_node *node;
66
67     pa_assert(u);
68     pa_assert(data);
69     pa_assert_se((ns = u->nodeset));
70     pa_assert(data->key);
71     pa_assert(data->paname);
72     
73     node = pa_xnew0(mir_node, 1);
74
75     node->key       = pa_xstrdup(data->key);
76     node->direction = data->direction;
77     node->implement = data->implement;
78     node->channels  = data->channels;
79     node->location  = data->location;
80     node->privacy   = data->privacy;
81     node->type      = data->type;
82     node->visible   = data->visible;
83     node->available = data->available;
84     node->amname    = pa_xstrdup(data->amname ? data->amname : data->paname);
85     node->amdescr   = pa_xstrdup(data->amdescr ? data->amdescr : "");
86     node->amid      = data->amid;
87     node->paname    = pa_xstrdup(data->paname);
88     node->paidx     = data->paidx;
89     node->mux       = data->mux;
90     node->loop      = data->loop;
91     node->stamp     = data->stamp;
92     MIR_DLIST_INIT(node->rtentries);
93     MIR_DLIST_INIT(node->rtprilist);
94     MIR_DLIST_INIT(node->constrains);
95     
96     if (node->implement == mir_device) {
97         node->pacard.index   = data->pacard.index;
98         if (data->pacard.profile)
99             node->pacard.profile = pa_xstrdup(data->pacard.profile);
100         if (data->paport)
101             node->paport = pa_xstrdup(data->paport);
102     }
103
104     pa_idxset_put(ns->nodes, node, &node->index);
105
106     mir_router_register_node(u, node);
107     
108     return node;
109 }
110
111 void mir_node_destroy(struct userdata *u, mir_node *node)
112 {
113     pa_nodeset *ns;
114
115     pa_assert(u);
116     pa_assert_se((ns = u->nodeset));
117
118     if (node) {
119         mir_router_unregister_node(u, node);
120
121         pa_idxset_remove_by_index(ns->nodes, node->index);
122
123         pa_xfree(node->key);
124         pa_xfree(node->amname);
125         pa_xfree(node->amdescr);
126         pa_xfree(node->paname);
127         pa_xfree(node->pacard.profile);
128         pa_xfree(node->paport);
129
130         pa_xfree(node);
131     }
132 }
133
134 mir_node *mir_node_find_by_index(struct userdata *u, uint32_t nodidx)
135 {
136     pa_nodeset *ns;
137     mir_node *node;
138
139     pa_assert(u);
140     pa_assert_se((ns = u->nodeset));
141
142     node = pa_idxset_get_by_index(ns->nodes, nodidx);
143
144     return node;
145 }
146
147 int mir_node_print(mir_node *node, char *buf, int len)
148 {
149     char *p, *e;
150     char mux[256];
151     char loop[256];
152     char constr[512];
153
154     pa_assert(node);
155     pa_assert(buf);
156     pa_assert(len > 0);
157
158     pa_multiplex_print(node->mux, mux, sizeof(mux));
159     pa_loopback_print(node->loop, loop, sizeof(loop));
160     mir_constrain_print(node, constr, sizeof(constr));
161
162     e = (p = buf) + len;
163
164 #define PRINT(f,v) if (p < e) p += snprintf(p, e-p, f "\n", v)
165
166     PRINT("   index         : %u"  ,  node->index);
167     PRINT("   key           : '%s'",  node->key ? node->key : "");
168     PRINT("   direction     : %s"  ,  mir_direction_str(node->direction));
169     PRINT("   implement     : %s"  ,  mir_implement_str(node->implement));
170     PRINT("   channels      : %u"  ,  node->channels);
171     PRINT("   location      : %s"  ,  mir_location_str(node->location));
172     PRINT("   privacy       : %s"  ,  mir_privacy_str(node->privacy));
173     PRINT("   type          : %s"  ,  mir_node_type_str(node->type));
174     PRINT("   visible       : %s"  ,  node->visible ? "yes" : "no");
175     PRINT("   available     : %s"  ,  node->available ? "yes" : "no");
176     PRINT("   amname        : '%s'",  node->amname ? node->amname : "");
177     PRINT("   amdescr       : '%s'",  node->amdescr ? node->amdescr : "");
178     PRINT("   amid          : %u"  ,  node->amid);
179     PRINT("   paname        : '%s'",  node->paname ? node->paname : "");
180     PRINT("   paidx         : %u"  ,  node->paidx);
181     PRINT("   pacard.index  : %u"  ,  node->pacard.index);
182     PRINT("   pacard.profile: '%s'",  node->pacard.profile ?
183                                       node->pacard.profile : "");
184     PRINT("   paport        : '%s'",  node->paport ? node->paport : "");
185     PRINT("   mux           : %s"  ,  mux);
186     PRINT("   loop          : %s"  ,  loop);
187     PRINT("   constrain     : %s"  ,  constr);
188     PRINT("   stamp         : %u"  ,  node->stamp);
189
190 #undef PRINT
191
192     return p - buf;
193 }
194
195 const char *mir_direction_str(mir_direction direction)
196 {
197     switch (direction) {
198     case mir_direction_unknown:  return "unknown";
199     case mir_input:              return "input";
200     case mir_output:             return "output";
201     default:                     return "< ??? >";
202     }
203 }
204
205 const char *mir_implement_str(mir_implement implement)
206 {
207     switch (implement) {
208     case mir_implementation_unknown:  return "unknown";
209     case mir_device:                  return "device";
210     case mir_stream:                  return "stream";
211     default:                          return "< ??? >";
212     }
213 }
214
215 const char *mir_location_str(mir_location location)
216 {
217     switch (location) {
218     case mir_location_unknown:  return "unknown";
219     case mir_internal:          return "internal";
220     case mir_external:          return "external";
221     default:                    return "< ??? >";
222     }
223
224
225
226 const char *mir_node_type_str(mir_node_type type)
227 {
228     switch (type) {
229     case mir_node_type_unknown:   return "Unknown";
230     case mir_radio:               return "Radio";
231     case mir_player:              return "Player";
232     case mir_navigator:           return "Navigator";
233     case mir_game:                return "Game";
234     case mir_browser:             return "Browser";
235     case mir_camera:              return "Camera";
236     case mir_phone:               return "Phone";
237     case mir_alert:               return "Alert";
238     case mir_event:               return "Event";
239     case mir_system:              return "System";
240     case mir_speakers:            return "Speakers";
241     case mir_microphone:          return "Microphone";
242     case mir_jack:                return "Line";
243     case mir_spdif:               return "SPDIF";
244     case mir_hdmi:                return "HDMI";
245     case mir_wired_headset:       return "Wired Headset";
246     case mir_wired_headphone:     return "Wired Headphone";
247     case mir_usb_headset:         return "USB Headset";
248     case mir_bluetooth_sco:       return "Bluetooth Mono Handsfree";
249     case mir_bluetooth_carkit:    return "Car Kit";
250     case mir_bluetooth_a2dp:      return "Bluetooth Stereo Headphone";
251     case mir_bluetooth_source:    return "Bluetooth Source";
252     case mir_bluetooth_sink:      return "Bluetooth Sink";
253     default:                      return "<user defined>";
254     }
255 }
256
257
258 const char *mir_privacy_str(mir_privacy privacy)
259 {
260     switch (privacy) {
261     case mir_privacy_unknown:  return "<unknown>";
262     case mir_public:           return "public";
263     case mir_private:          return "private";
264     default:                   return "< ??? >";
265     }
266 }
267
268                                   
269 /*
270  * Local Variables:
271  * c-basic-offset: 4
272  * indent-tabs-mode: nil
273  * End:
274  *
275  */