murphy/utils.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <sys/stat.h>
   4 #include <stdio.h>
   5 #include <errno.h>
   6 #include <string.h>
   7 #include <fcntl.h>
   8 #include <unistd.h>
   9 #include <limits.h>
  10
  11 #include <sys/types.h>
  12 #include <sys/socket.h>
  13
  14 #include <pulsecore/pulsecore-config.h>
  15
  16 #include <pulsecore/card.h>
  17 #include <pulsecore/sink.h>
  18 #include <pulsecore/source.h>
  19 #include <pulsecore/sink-input.h>
  20
  21 #include "userdata.h"
  22 #include "utils.h"
  23
  24 #ifndef DEFAULT_CONFIG_DIR
  25 #define DEFAULT_CONFIG_DIR "/etc/pulse"
  26 #endif
  27
  28 #define DEFAULT_NULL_SINK_NAME "null.mir"
  29
  30 struct pa_null_sink {
  31     char      *name;
  32     uint32_t   module_index;
  33     uint32_t   sink_index;
  34 };
  35
  36
  37 static uint32_t stamp;
  38
  39 static char *sink_input_name(pa_proplist *);
  40
  41
  42 pa_null_sink *pa_utils_create_null_sink(struct userdata *u, const char *name)
  43 {
  44     pa_core      *core;
  45     pa_module    *module;
  46     pa_null_sink *ns;
  47     pa_sink      *sink;
  48     pa_sink      *s;
  49     uint32_t      idx;
  50     char          args[256];
  51
  52     pa_assert(u);
  53     pa_assert_se((core = u->core));
  54
  55
  56     if (!name)
  57         name = DEFAULT_NULL_SINK_NAME;
  58
  59
  60     snprintf(args, sizeof(args), "sink_name=\"%s\" channels=2", name);
  61     module = pa_module_load(core, "module-null-sink", args);
  62     sink = NULL;
  63
  64     if (!module)
  65         pa_log("failed to load null sink '%s'", name);
  66     else {
  67         PA_IDXSET_FOREACH(s, core->sinks, idx) {
  68             if (s->module && s->module == module) {
  69                 sink = s;
  70                 pa_log_info("mir null sink is '%s'", name);
  71                 break;
  72             }
  73         }
  74     }
  75
  76     ns = pa_xnew0(pa_null_sink, 1);
  77     ns->name = pa_xstrdup(name);
  78     ns->module_index = module ? module->index : PA_IDXSET_INVALID;
  79     ns->sink_index = sink ? sink->index : PA_IDXSET_INVALID;
  80
  81     return ns;
  82 }
  83
  84 void pa_utils_destroy_null_sink(struct userdata *u)
  85 {
  86     pa_core      *core;
  87     pa_module    *module;
  88     pa_null_sink *ns;
  89
  90     if (u && (ns = u->nullsink) && (core = u->core)) {
  91         if ((module = pa_idxset_get_by_index(core->modules,ns->module_index))){
  92             pa_log_info("unloading null sink '%s'", ns->name);
  93             pa_module_unload(core, module, FALSE);
  94         }
  95
  96         pa_xfree(ns->name);
  97         pa_xfree(ns);
  98     }
  99 }
 100
 101 pa_sink *pa_utils_get_null_sink(struct userdata *u)
 102 {
 103     pa_core *core;
 104     pa_null_sink *ns;
 105
 106     pa_assert(u);
 107     pa_assert_se((core = u->core));
 108     pa_assert_se((ns = u->nullsink));
 109
 110     return pa_idxset_get_by_index(core->sinks, ns->sink_index);
 111 }
 112
 113
 114
 115 char *pa_utils_get_card_name(pa_card *card)
 116 {
 117     return (card && card->name) ? card->name : "<unknown>";
 118 }
 119
 120 char *pa_utils_get_sink_name(pa_sink *sink)
 121 {
 122     return (sink && sink->name) ? sink->name : "<unknown>";
 123 }
 124
 125 char *pa_utils_get_source_name(pa_source *source)
 126 {
 127     return (source && source->name) ? source->name : "<unknown>";
 128 }
 129
 130 char *pa_utils_get_sink_input_name(pa_sink_input *sinp)
 131 {
 132     char *name;
 133
 134     if (sinp && (name = sink_input_name(sinp->proplist)))
 135         return name;
 136
 137     return "<unknown>";
 138 }
 139
 140 char *pa_utils_get_sink_input_name_from_data(pa_sink_input_new_data *data)
 141 {
 142     char *name;
 143
 144     if (data && (name = sink_input_name(data->proplist)))
 145         return name;
 146
 147     return "<unknown>";
 148 }
 149
 150 static char *sink_input_name(pa_proplist *pl)
 151 {
 152     const char  *appnam;
 153     const char  *binnam;
 154
 155     if ((appnam = pa_proplist_gets(pl, PA_PROP_APPLICATION_NAME)))
 156         return (char *)appnam;
 157
 158     if ((binnam = pa_proplist_gets(pl, PA_PROP_APPLICATION_PROCESS_BINARY)))
 159         return (char *)binnam;
 160
 161     return NULL;
 162 }
 163
 164
 165 const char *pa_utils_file_path(const char *file, char *buf, size_t len)
 166 {
 167     /*
 168     pa_assert(file);
 169     pa_assert(buf);
 170     pa_assert(len > 0);
 171     */
 172
 173     snprintf(buf, len, "%s/%s", DEFAULT_CONFIG_DIR, file);
 174
 175     return buf;
 176 }
 177
 178
 179 const uint32_t pa_utils_new_stamp(void)
 180 {
 181     return ++stamp;
 182 }
 183
 184 const uint32_t pa_utils_get_stamp(void)
 185 {
 186     return stamp;
 187 }
 188
 189
 190
 191
 192 /*
 193  * Local Variables:
 194  * c-basic-offset: 4
 195  * indent-tabs-mode: nil
 196  * End:
 197  *
 198  */
 199
 200