};
+/*
static bool find_default_route(struct userdata *, mir_node *,
am_connect_data *);
+*/
static void *node_hash(mir_direction, uint16_t);
static void *conn_hash(uint16_t);
-
+static void fill_am_data_and_register(struct userdata *, mir_node *, pa_audiomgr *);
struct pa_audiomgr *pa_audiomgr_init(struct userdata *u)
{
pa_log_debug("unregistering domain '%s'", am->domain.name);
while ((node = pa_hashmap_iterate(am->nodes, &state, &key))) {
- pa_log_debug(" unregistering '%s' (%p/%p)", node->amname, key,node);
+ pa_log_debug(" unregistering '%s' (%p/%p)", node->amname, (void *)key, (void *)node);
node->amid = AM_ID_INVALID;
pa_hashmap_remove(am->nodes, key);
}
if (success) {
pa_log_debug("initiate registration node '%s' (%p)"
- "to audio manager", rd->name, node);
+ "to audio manager", rd->name, (void *)node);
}
else {
pa_log("%s: failed to register node '%s' (%p)"
- "to audio manager", __FILE__, rd->name, node);
+ "to audio manager", __FILE__, rd->name, (void *)node);
}
return;
};
pa_audiomgr *am;
- bool success;
const char *class_to_register;
int i;
}
pa_log_debug("skip registration of node '%s' (%p): "
- "not known by audio manager", node->amname, node);
+ "not known by audio manager", node->amname, (void *)node);
}
void pa_audiomgr_node_registered(struct userdata *u,
pa_audiomgr *am;
mir_node *node;
void *key;
- am_connect_data cd;
pa_assert(u);
pa_assert(rd);
key = node_hash(node->direction, id);
pa_log_debug("registering node '%s' (%p/%p)",
- node->amname, key, node);
+ node->amname, (void *)key, (void *)node);
pa_hashmap_put(am->nodes, key, node);
pa_log("%s: confused with data structures: key mismatch. "
"attempted to remove '%s' (%p/%p); "
"actually removed '%s' (%p/%p)", __FILE__,
- node->amname, key, node, removed->amname,
- node_hash(removed->direction, removed->amid), removed);
+ node->amname, (void *)key, (void *)node, removed->amname,
+ (void *)node_hash(removed->direction, removed->amid),
+ (void *)removed);
else
pa_log("%s: confused with data structures: node %u (%p)"
- "is not in the hash table", __FILE__, node->amid, node);
+ "is not in the hash table", __FILE__, node->amid, (void *)node);
}
if (success) {
pa_log_debug("sucessfully unregistered node '%s' (%p/%p)"
- "from audio manager", node->amname, key, node);
+ "from audio manager", node->amname,
+ (void *)key, (void *)node);
}
else {
pa_log("%s: failed to unregister node '%s' (%p)"
- "from audio manager", __FILE__, node->amname, node);
+ "from audio manager", __FILE__, node->amname, (void *)node);
}
}
}
if (defrts->nlink >= defrts->maxlink) {
defrts->maxlink += 16;
- size = sizeof(link_t) * defrts->maxlink;
+ size = sizeof(link_t) * (size_t)defrts->maxlink;
defrts->links = realloc(defrts->links, size);
pa_assert(defrts->links);
}
link = defrts->links + defrts->nlink++;
- link->fromidx = from->index;
- link->toidx = to->index;
+ link->fromidx = (uint16_t)from->index;
+ link->toidx = (uint16_t)to->index;
link->channels = from->channels < to->channels ?
from->channels : to->channels;
}
err = E_NOT_POSSIBLE;
else {
pa_log_debug("registering connection (%u/%p)",
- cd->connection, conn);
+ cd->connection, (void *)conn);
pa_hashmap_put(am->conns, conn_hash(cid), conn);
}
}
memset(&ad, 0, sizeof(ad));
ad.handle = cd->handle;
ad.param1 = cd->connection;
- ad.error = err;
+ ad.error = (am_uint16_t)err;
pa_routerif_acknowledge(u, audiomgr_connect_ack, &ad);
}
memset(&ad, 0, sizeof(ad));
ad.handle = cd->handle;
ad.param1 = cd->connection;
- ad.error = err;
+ ad.error = (am_uint16_t)err;
pa_routerif_acknowledge(u, audiomgr_disconnect_ack, &ad);
}
+#if 0
static bool find_default_route(struct userdata *u,
mir_node *node,
am_connect_data *cd)
return false;
}
+#endif
static void *node_hash(mir_direction direction, uint16_t amid)
{
- return NULL + ((uint32_t)direction << 16 | (uint32_t)amid);
+ return (char *)NULL + ((uint32_t)direction << 16 | (uint32_t)amid);
}
static void *conn_hash(uint16_t connid)
{
- return NULL + (uint32_t)connid;
+ return (char *)NULL + (uint32_t)connid;
}
pa_assert(node);
pa_assert(card);
- bus = pa_utils_get_card_bus(card);
+ bus = pa_utils_get_card_bus(card);
+
+ /* bus might be null */
+ if (!bus)
+ bus = " ";
+
form = pa_proplist_gets(card->proplist, PA_PROP_DEVICE_FORM_FACTOR);
/*
desc = pa_proplist_gets(card->proplist, PA_PROP_DEVICE_DESCRIPTION);
return map ? map->type : mir_player;
}
-static char *get_tag(pid_t pid, char *tag, char *buf, size_t size)
+static char *get_tag(pid_t pid, const char *tag, char *buf, size_t size)
{
char path[PATH_MAX];
char data[8192], *p, *q;
- int fd, n, tlen;
+ int fd, n;
+ size_t tlen;
fd = -1;
snprintf(path, sizeof(path), "/proc/%u/status", pid);
pid_t ppid;
if (get_tag(pid, "PPid", buf, sizeof(buf)) != NULL) {
- ppid = strtoul(buf, &end, 10);
+ ppid = strtol(buf, &end, 10);
if (end && !*end)
return ppid;
snprintf(path, sizeof(path), "/proc/%u/cmdline", ppid);
if ((f = fopen(path, "r"))) {
- if (fgets(buf, len-1, f)) {
+ if (fgets(buf, (int)len-1, f)) {
if ((p = strchr(buf, ' ')))
*p = '\0';
else if ((p = strchr(buf, '\n')))
p = buf + strlen(buf);
if ((q = strrchr(buf, '/')))
- memmove(buf, q+1, p-q);
+ memmove(buf, q+1, (size_t)(p-q));
st = 0;
}
{
char binary[PATH_MAX];
char path[PATH_MAX], *dir, *p, *base;
- int len;
+ unsigned int len;
if (!pid || !get_binary(pid, binary, sizeof(binary)))
return NULL;
if ((dir = strprev(p, '/', path)) == NULL || dir == path)
goto return_base;
- len = p - dir;
+ len = (size_t)(p - dir);
/* fetch 'apps' dir */
p = dir - 1;
mir_node *);
static void cstrlink_destroy(struct userdata *, mir_constr_link *);
-
-static void pa_hashmap_constrdef_free(void *cd, void *u)
-{
- cstrdef_destroy(u, cd);
-}
-
-
pa_constrain *pa_constrain_init(struct userdata *u)
{
pa_constrain *constrain = pa_xnew0(pa_constrain, 1);
{
mir_constr_def *cd;
mir_constr_link *cl;
- char *p, *e, *s;
+ char *p, *e;
+ const char *s;
pa_assert(node);
pa_assert(buf);
cd = cl->def;
- p += snprintf(p, e-p, "%s'%s'", s, cd->name);
+ p += snprintf(p, (size_t)(e-p), "%s'%s'", s, cd->name);
s = " ";
}
mir_node *active,
mir_node *node)
{
- char *active_port;
- char *node_port;
+ const char *active_port;
+ const char *node_port;
bool block;
pa_assert(u);
char pathbuf[128];
char ctlnambuf[128];
char ctlpathbuf[128];
- char *amrnam;
- char *amrpath;
- char *amcnam;
- char *amcpath;
+ const char *amrnam;
+ const char *amrpath;
+ const char *amcnam;
+ const char *amcpath;
char admarule[512];
int result;
}
if (ampath && *ampath) {
- char *slash = ampath[strlen(ampath)-1] == '/' ? "" : "/";
+ const char *slash = ampath[strlen(ampath)-1] == '/' ? "" : "/";
snprintf(pathbuf, sizeof(pathbuf), "%s%s" AUDIOMGR_DBUS_ROUTE_PATH,
ampath, slash);
amrpath = pathbuf;
}
if (amnam && *amnam){
- char *dot = amnam[strlen(amnam)-1] == '.' ? "" : ".";
+ const char *dot = amnam[strlen(amnam)-1] == '.' ? "" : ".";
snprintf(nambuf, sizeof(nambuf), "%s%s" AUDIOMGR_DBUS_ROUTE_NAME,
amnam, dot);
amrnam = nambuf;
char *name;
char *before;
char *after;
- int success;
+ bool success;
pa_assert(u);
pa_assert_se((routerif = u->routerif));
const char *error_descr;
dbus_uint16_t domain_id;
dbus_uint16_t status;
- int success;
+ bool success;
if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
success = dbus_message_get_args(reply, NULL,
const char *dbus_name;
const char *dbus_path;
const char *dbus_if;
- int success;
+ bool success;
uint16_t error = 0;
pa_assert(u);
pa_routerif *routerif;
DBusConnection *conn;
DBusMessage *msg;
- bool success;
+ bool success;
pa_assert(u);
pa_assert_se((routerif = u->routerif));
pa_routerif *routerif;
DBusConnection *conn;
DBusMessage *msg;
- bool success;
+ bool success;
pa_assert(u);
pa_assert_se((routerif = u->routerif));
const char *error_descr;
dbus_uint16_t object_id;
dbus_uint16_t status;
- int success;
+ bool success;
const char *objtype;
pa_assert(u);
DBusMessageIter mit;
DBusMessageIter cit;
DBusMessageIter dit;
- bool success = false;
+ bool success = false;
pa_assert(u);
pa_assert(rd);
{
const char *error_descr;
dbus_uint16_t status;
- int success;
+ bool success;
const char *objtype;
pa_assert(u);
pa_routerif *routerif;
DBusConnection *conn;
DBusMessage *msg;
- bool success = false;
+ bool success = false;
pa_assert(u);
pa_assert(ud);
static bool routerif_connect(struct userdata *u, DBusMessage *msg)
{
struct am_connect_data ac;
- int success;
+ bool success;
pa_assert(u);
pa_assert(msg);
static bool routerif_disconnect(struct userdata *u, DBusMessage *msg)
{
struct am_connect_data ac;
- int success;
+ bool success;
pa_assert(u);
pa_assert(msg);
pa_routerif *routerif;
DBusConnection *conn;
DBusMessage *msg;
- bool success;
+ bool success;
pa_assert(u);
pa_assert(method);
static bool get_bluetooth_port_availability(mir_node *, pa_device_port *);
static void handle_udev_loaded_card(struct userdata *, pa_card *,
- mir_node *, char *);
+ mir_node *, const char *);
static void handle_card_ports(struct userdata *, mir_node *,
pa_card *, pa_card_profile *);
static void parse_profile_name(pa_card_profile *,
char **, char **, char *, int);
-static char *node_key(struct userdata *, mir_direction,
+static const char *node_key(struct userdata *, mir_direction,
void *, pa_device_port *, char *, size_t);
static pa_sink *make_output_prerouting(struct userdata *, mir_node *,
const char *, mir_node **);
static mir_node_type get_stream_routing_class(pa_proplist *);
-static char *get_stream_amname(mir_node_type, char *, pa_proplist *);
+static const char *get_stream_amname(mir_node_type, const char *, pa_proplist *);
static void set_bluetooth_profile(struct userdata *, pa_card *, pa_direction_t);
static void schedule_stream_uncorking(struct userdata *, pa_sink *);
#endif
-static void pa_hashmap_node_free(void *node, void *u)
-{
- mir_node_destroy(u, node);
-}
-
-
struct pa_discover *pa_discover_init(struct userdata *u)
{
pa_discover *discover = pa_xnew0(pa_discover, 1);
if (!(bus = pa_utils_get_card_bus(card)))
bus = "<unknown>";
-
PA_HASHMAP_FOREACH(node, discover->nodes.byname, state) {
if (node->implement == mir_device &&
node->pacard.index == card->index)
pa_assert_se((core = u->core));
pa_assert_se((discover = u->discover));
-
if ((bus = pa_utils_get_card_bus(card)) == NULL) {
pa_log_debug("ignoring profile change on card '%s' due to lack of '%s'"
"property", pa_utils_get_card_name(card),
pa_module *module;
mir_node *node;
pa_card *card;
- char *key;
+ const char *key;
char kbf[256];
char nbf[2048];
const char *loopback_role;
pa_nodeset_map *map;
pa_nodeset_resdef *resdef;
- bool make_rset;
- pa_nodeset_resdef rdbuf;
+ bool make_rset;
pa_source *ns;
mir_node data;
mir_node_type type;
if (sink == pa_utils_get_null_sink(u)) {
data.visible = false;
data.type = mir_null;
- data.amname = pa_xstrdup("Silent");
+ data.amname = "Silent";
data.amid = AM_ID_INVALID;
data.paname = pa_xstrdup(sink->name);
}
if (data.type == mir_gateway_sink) {
data.privacy = mir_private;
data.visible = false;
- data.amname = pa_xstrdup(sink->name);
+ data.amname = sink->name;
data.amid = AM_ID_INVALID;
data.paname = pa_xstrdup(sink->name);
}
else {
data.privacy = mir_public;
data.visible = true;
- data.amname = pa_xstrdup(mir_node_type_str(data.type));
+ data.amname = mir_node_type_str(data.type);
data.amid = AM_ID_INVALID;
data.paname = pa_xstrdup(sink->name);
}
{
pa_discover *discover;
mir_node *node;
- char *name;
+ const char *name;
mir_node_type type;
pa_assert(u);
pa_discover *discover;
mir_node *node;
pa_card *card;
- char *key;
+ const char *key;
char kbf[256];
char nbf[2048];
const char *loopback_role;
if (source == pa_utils_get_null_source(u)) {
data.visible = false;
data.type = mir_null;
- data.amname = pa_xstrdup("Silent");
+ data.amname = "Silent";
data.amid = AM_ID_INVALID;
data.paname = pa_xstrdup(source->name);
data.paidx = source->index;
if (data.type == mir_gateway_source) {
data.privacy = mir_private;
data.visible = false;
- data.amname = pa_xstrdup(source->name);
+ data.amname = source->name;
data.amid = AM_ID_INVALID;
- data.paname = pa_xstrdup(source->name);
+ data.paname = source->name;
}
else {
data.privacy = mir_public;
data.visible = true;
- data.amname = pa_xstrdup(mir_node_type_str(data.type));
+ data.amname = mir_node_type_str(data.type);
data.amid = AM_ID_INVALID;
- data.paname = pa_xstrdup(source->name);
+ data.paname = source->name;
}
}
else {
{
pa_discover *discover;
mir_node *node;
- char *name;
+ const char *name;
mir_node_type type;
pa_assert(u);
pa_core *core;
pa_discover *discover;
pa_proplist *pl;
- char *name;
+ const char *name;
const char *media;
mir_node_type type;
mir_node data;
data.visible = true;
data.available = true;
data.amname = get_stream_amname(type, name, pl);
- data.amdescr = (char *)pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
+ data.amdescr = pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
data.amid = AM_ID_INVALID;
- data.paname = name;
+ data.paname = (char *)name;
data.paidx = sinp->index;
data.rsetid = pa_utils_get_rsetid(pl, idbuf, sizeof(idbuf));
if (node->direction == mir_output) {
pa_log_debug("refuse to preroute loopback sink-input "
"(current route: sink %u @ %p)", data->sink ?
- data->sink->index : PA_IDXSET_INVALID,data->sink);
+ data->sink->index : PA_IDXSET_INVALID,(void *)data->sink);
return true;
}
mir_node data;
mir_node *node;
mir_node *snod;
- char *name;
+ const char *name;
const char *media;
mir_node_type type;
char key[256];
data.visible = true;
data.available = true;
data.amname = get_stream_amname(type, name, pl);
- data.amdescr = (char *)pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
+ data.amdescr = pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
data.amid = AM_ID_INVALID;
- data.paname = name;
+ data.paname = (char *)name;
data.paidx = sinp->index;
data.mux = pa_multiplex_find_by_sink(u->multiplex,
sinp->sink->index);
s = csinp ? csinp->sink : NULL;
if ((sinp->flags & PA_SINK_INPUT_START_RAMP_MUTED)) {
- pa_log_debug("ramp '%s' to 100%", media);
+ pa_log_debug("ramp '%s' to 100%%", media);
pa_fader_ramp_volume(u, sinp, PA_VOLUME_NORM);
}
}
pa_discover *discover;
mir_node *node;
mir_node *sinknod;
- char *name;
+ const char *name;
bool had_properties = false;
pa_assert(u);
pa_core *core;
pa_discover *discover;
pa_proplist *pl;
- char *name;
+ const char *name;
const char *media;
mir_node_type type;
mir_node data;
data.visible = true;
data.available = true;
data.amname = name;
- data.amdescr = (char *)pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
+ data.amdescr = pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
data.amid = AM_ID_INVALID;
data.paname = name;
data.paidx = sout->index;
if (node->direction == mir_input) {
pa_log_debug("refuse to preroute loopback source-output "
"(current route: source %u @ %p)", data->source ?
- data->source->index : PA_IDXSET_INVALID,data->source);
+ data->source->index : PA_IDXSET_INVALID,(void *)data->source);
return true;
}
mir_node data;
mir_node *node;
mir_node *snod;
- char *name;
+ const char *name;
const char *media;
mir_node_type type;
char key[256];
data.visible = true;
data.available = true;
data.amname = name;
- data.amdescr = (char *)pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
+ data.amdescr = pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
data.amid = AM_ID_INVALID;
data.paname = name;
data.paidx = sout->index;
pa_discover *discover;
mir_node *node;
mir_node *srcnod;
- char *name;
+ const char *name;
pa_assert(u);
pa_assert(sout);
{
mir_node data;
const char *udd;
- char *cnam;
- char *cid;
+ const char *cnam;
+ const char *cid;
memset(&data, 0, sizeof(data));
data.zone = pa_utils_get_zone(card->proplist);
mir_node data;
mir_node *node;
mir_constr_def *cd;
- char *cnam;
- char *cid;
+ const char *cnam;
+ const char *cid;
const char *cdescr;
void *state0, *state1;
char paname[MAX_NAME_LENGTH+1];
char amname[MAX_NAME_LENGTH+1];
char key[MAX_NAME_LENGTH+1];
- int len;
- bool input;
- bool output;
+ unsigned int len;
+ bool input;
+ bool output;
pa_assert_se((discover = u->discover));
}
static void handle_udev_loaded_card(struct userdata *u, pa_card *card,
- mir_node *data, char *cardid)
+ mir_node *data, const char *cardid)
{
pa_discover *discover;
pa_card_profile *prof;
pa_card *card, pa_card_profile *prof)
{
mir_node *node = NULL;
- bool have_ports = false;
+ bool have_ports = false;
mir_constr_def *cd = NULL;
- char *amname = data->amname;
+ const char *amname = data->amname;
pa_device_port *port;
void *state;
- bool created;
+ bool created;
char key[MAX_NAME_LENGTH+1];
pa_assert(u);
{
have_ports = true;
- amname[0] = '\0';
+ amname = "";
snprintf(key, sizeof(key), "%s@%s", data->paname, port->name);
data->key = key;
}
if (!have_ports) {
- data->key = data->paname;
+ data->key = pa_xstrdup(data->paname);
data->available = true;
pa_classify_node_by_card(data, card, prof, NULL);
node->stamp = data->stamp;
}
+ amname = "";
data->amname = amname;
- *amname = '\0';
}
pa_device_port *port,
bool available)
{
- mir_node *node;
- char *key;
- char buf[256];
+ mir_node *node;
+ const char *key;
+ char buf[256];
pa_assert(u);
pa_assert(data);
pa_assert(prof->name);
- strncpy(buf, prof->name, buflen);
+ strncpy(buf, prof->name, (size_t)buflen);
buf[buflen-1] = '\0';
memset(sinks, 0, sizeof(char *) * (MAX_CARD_TARGET+1));
}
-static char *node_key(struct userdata *u, mir_direction direction,
+static const char *node_key(struct userdata *u, mir_direction direction,
void *data, pa_device_port *port, char *buf, size_t len)
{
pa_card *card;
pa_card_profile *profile;
const char *bus;
- bool pci;
- bool usb;
- bool bluetooth;
- bool platform;
+ bool pci;
+ bool usb;
+ bool bluetooth;
+ bool platform;
char *type;
- char *name;
+ const char *name;
const char *profile_name;
- char *key;
+ const char *key;
pa_assert(u);
pa_assert(data);
if (direction == mir_output) {
pa_sink *sink = data;
- type = "sink";
+ type = pa_xstrdup("sink");
name = pa_utils_get_sink_name(sink);
card = sink->card;
if (!port)
}
else {
pa_source *source = data;
- type = "source";
+ type = pa_xstrdup("source");
name = pa_utils_get_source_name(source);
card = source->card;
if (!port)
return mir_node_type_unknown;
}
-static char *get_stream_amname(mir_node_type type, char *name, pa_proplist *pl)
+static const char *get_stream_amname(mir_node_type type, const char *name, pa_proplist *pl)
{
const char *appid;
switch (type) {
case mir_radio:
- return "radio";
+ return pa_xstrdup("radio");
case mir_player:
case mir_game:
#include <pulsecore/tagstruct.h>
#include <pulsecore/pstream-util.h>
-#include "userdata.h"
+#include "extapi.h"
#include "node.h"
#include "router.h"
[mir_rear_speakers] = "rear_speakers",
[mir_microphone] = "microphone",
[mir_jack] = "jack",
- [mir_spdif] "spdif",
+ [mir_spdif] = "spdif",
[mir_hdmi] = "hdmi",
[mir_wired_headset] = "wired_headset",
[mir_wired_headphone] = "wired_headphone",
goto fail;
}
- if(!(conn = mir_router_add_explicit_route(u, id, from, to))) {
+ if(!(conn = mir_router_add_explicit_route(u, (uint16_t)id, from, to))) {
pa_log_debug("explicit connection failed in module-murphy-ivi");
goto fail;
}
static void *conn_hash(uint32_t connid)
{
- return NULL + connid;
+ return (char *)NULL + connid;
}
/*
#include "utils.h"
typedef struct {
- uint32_t fade_out;
- uint32_t fade_in;
+ long fade_out;
+ long fade_in;
} transition_time;
};
static void set_stream_volume_limit(struct userdata *, pa_sink_input *,
- pa_volume_t, uint32_t);
+ pa_volume_t, long);
pa_fader *pa_fader_init(const char *fade_out_str, const char *fade_in_str)
{
pa_fader *fader = pa_xnew0(pa_fader, 1);
- if (!fade_out_str || pa_atou(fade_out_str, &fader->transit.fade_out) < 0)
+ if (!fade_out_str || pa_atol(fade_out_str, &fader->transit.fade_out) < 0)
fader->transit.fade_out = 100;
- if (!fade_in_str || pa_atou(fade_in_str, &fader->transit.fade_in) < 0)
+ if (!fade_in_str || pa_atol(fade_in_str, &fader->transit.fade_in) < 0)
fader->transit.fade_in = 1000;
if (fader->transit.fade_out > 10000)
if (fader->transit.fade_in > 10000)
fader->transit.fade_in = 10000;
- pa_log_info("fader transition times: out %u ms, in %u ms",
+ pa_log_info("fader transition times: out %ld ms, in %ld ms",
fader->transit.fade_out, fader->transit.fade_in);
return fader;
double dB;
pa_volume_t newvol;
pa_volume_t oldvol;
- uint32_t time;
+ long time;
uint32_t i,j;
int class;
bool rampit;
if (!(sinp->flags & PA_SINK_INPUT_START_RAMP_MUTED))
pa_log_debug(" skipping");
else {
- sinp->flags &= ~PA_SINK_INPUT_START_RAMP_MUTED;
+ sinp->flags &= ~((unsigned int)PA_SINK_INPUT_START_RAMP_MUTED);
time = transit->fade_in;
pa_log_debug(" attenuation 0 dB "
- "transition time %u ms", time);
+ "transition time %ld ms", time);
set_stream_volume_limit(u, sinp, PA_VOLUME_NORM, time);
}
}
pa_log_debug(" attenuation %.2lf dB",dB);
else {
pa_log_debug(" attenuation %.2lf dB "
- "transition time %u ms", dB, time);
+ "transition time %ld ms", dB, time);
set_stream_volume_limit(u, sinp, newvol, time);
}
}
pa_sink_input *sinp,
pa_volume_t newvol)
{
- transition_time *transit;
- bool rampit;
- pa_volume_t oldvol;
+ transition_time *transit;
+ bool rampit;
+ pa_volume_t oldvol;
pa_cvolume_ramp_int *ramp;
- uint32_t time;
- pa_cvolume_ramp rampvol;
+ long time;
+ pa_cvolume_ramp rampvol;
pa_assert(u);
pa_assert(u->fader);
static void set_stream_volume_limit(struct userdata *u,
pa_sink_input *sinp,
pa_volume_t vol,
- uint32_t ramp_time)
+ long ramp_time)
{
pa_sink *sink;
pa_cvolume_ramp rampvol;
#define MIR_DIM(a) (sizeof(a)/sizeof((a)[0]))
#define MIR_OFFSET(structure, member) \
- ((int)((void *)((&((structure *)0)->member)) - (void *)0))
+ ((int)((char *)((&((structure *)0)->member)) - (char *)0))
#define MIR_LIST_RELOCATE(structure, member, ptr) \
- ((structure *)((void *)ptr - MIR_OFFSET(structure, member)))
+ ((structure *)(void *)((char *)ptr - MIR_OFFSET(structure, member)))
#define MIR_DLIST_HEAD(name) mir_dlist name = { &(name), &(name) }
uint32_t resource_set_flags,
uint32_t resource_audio_flags)
{
- static char *modnam = "module-loopback";
+ static const char *modnam = "module-loopback";
pa_loopnode *loop;
pa_source *source;
e = (p = buf) + len;
if (!loop)
- p += snprintf(p, e-p, "<not set>");
+ p += snprintf(p, (size_t)(e-p), "<not set>");
else {
- p += snprintf(p, e-p, "module %u, sink_input %u",
+ p += snprintf(p, (size_t)(e-p), "module %u, sink_input %u",
loop->module_index, loop->sink_input_index);
}
#endif
#ifdef WITH_DBUS
const char *dbustype;
- const char *ifnam;
- const char *mrppath;
- const char *mrpnam;
const char *ampath;
const char *amnam;
#else
#endif
#ifdef WITH_DBUS
dbustype = pa_modargs_get_value(ma, "dbus_bus_type", NULL);
- ifnam = pa_modargs_get_value(ma, "dbus_if_name", NULL);
- mrppath = pa_modargs_get_value(ma, "dbus_murphy_path", NULL);
- mrpnam = pa_modargs_get_value(ma, "dbus_murphy_name", NULL);
ampath = pa_modargs_get_value(ma, "dbus_audiomgr_path", NULL);
amnam = pa_modargs_get_value(ma, "dbus_audiomgr_name", NULL);
#else
const char *media_role,
int type)
{
- static char *modnam = "module-combine-sink";
+ static const char *modnam = "module-combine-sink";
struct userdata *u; /* combine's userdata! */
struct output *o;
pa_sink_input *sinp)
{
pa_muxnode *mux;
- char *name;
+ const char *name;
pa_assert(multiplex);
pa_assert(sinp);
e = (p = buf) + len;
if (!mux)
- p += snprintf(p, e-p, "<not set>");
+ p += snprintf(p, (size_t)(e-p), "<not set>");
else {
- p += snprintf(p, e-p, "module %u, sink %u, default stream %u",
+ p += snprintf(p, (size_t)(e-p), "module %u, sink %u, default stream %u",
mux->module_index, mux->sink_index,mux->defstream_index);
}
} classmap_def;
typedef struct {
- char *id;
+ const char *id;
mir_node_type type;
} typemap_def;
static zone_def zones[] = {
- "driver",
- "passanger1",
- "passanger2",
- "passanger3",
- "passanger4",
- NULL
+ {"driver"},
+ {"passanger1"},
+ {"passanger2"},
+ {"passanger3"},
+ {"passanger4"},
+ {NULL}
};
static rtgroup_def rtgroups[] = {
static double supprvol = -20.0;
static int exception_classes[] = {mir_phone, mir_navigator};
static mir_volume_suppress_arg suppress = {
- &supprvol, {DIM(exception_classes), exception_classes}
+ &supprvol, {DIM(exception_classes), exception_classes, 0}
};
}
pa_nodeset_print_maps(u, buf, sizeof(buf));
- pa_log_debug(buf);
+ pa_log_debug("maps %s", buf);
return success;
}
pa_assert(u);
for (z = zones; z->name; z++)
- pa_zoneset_add_zone(u, z->name, z - zones);
+ pa_zoneset_add_zone(u, z->name, (uint32_t)(z - zones));
for (r = rtgroups; r->name; r++)
mir_router_create_rtgroup(u, r->type, r->name, r->accept, r->compare);
static bool resource_fetch_request(mrp_msg_t *, void **, uint16_t *);
static bool resource_fetch_status(mrp_msg_t *, void **, int *);
static bool resource_fetch_rset_id(mrp_msg_t *, void **, uint32_t*);
+
+/*
static bool resource_fetch_rset_state(mrp_msg_t *, void **,
mrp_resproto_state_t *);
+
static bool resource_fetch_rset_mask(mrp_msg_t *, void **,
mrp_resproto_state_t *);
+*/
static bool resource_transport_create(struct userdata *, pa_murphyif *);
static void resource_transport_destroy(pa_murphyif *);
domctl_interface *dif;
mrp_domctl_table_t *t;
size_t size;
- size_t idx;
+ int idx;
pa_assert(u);
pa_assert(table);
dif = &murphyif->domctl;
idx = dif->ntable++;
- size = sizeof(mrp_domctl_table_t) * dif->ntable;
+ size = sizeof(mrp_domctl_table_t) * (size_t)(dif->ntable);
t = (dif->tables = pa_xrealloc(dif->tables, size)) + idx;
t->table = pa_xstrdup(table);
domctl_interface *dif;
mrp_domctl_watch_t *w;
size_t size;
- size_t idx;
+ int idx;
pa_assert(u);
pa_assert(table);
dif = &murphyif->domctl;
idx = dif->nwatch++;
- size = sizeof(mrp_domctl_watch_t) * dif->nwatch;
+ size = sizeof(mrp_domctl_watch_t) * (size_t)(dif->nwatch);
w = (dif->watches = pa_xrealloc(dif->watches, size)) + idx;
w->table = pa_xstrdup(table);
{
#ifdef WITH_RESOURCES
pa_murphyif *murphyif;
- resource_interface *rif;
const char *pid;
rset_data *rset;
rset_hash *rh;
pa_assert_se((murphyif = u->murphyif));
- rif = &murphyif->resource;
-
if (!node->rsetid) {
pa_log("can't register resource set for node %u '%s'.: missing rsetid",
node->paidx, node->amname);
{
#ifdef WITH_RESOURCES
pa_murphyif *murphyif;
- resource_interface *rif;
const char *pid;
- mir_node *deleted;
pa_assert(u);
pa_assert(node);
pa_assert_se((murphyif = u->murphyif));
- rif = &murphyif->resource;
-
if (node->rsetid) {
if (pa_streq(node->rsetid, PA_RESOURCE_SET_ID_PID)) {
if ((pid = get_node_pid(u, node))) {
int i, j;
char buf[1024], *p;
const char *t;
- int n, l;
+ int n;
+ int l;
pa_log_debug("Table #%d: %d rows x %d columns", table->id,
table->nrow, table->ncolumn);
for (j = 0, t = ""; j < table->ncolumn; j++, t = ", ") {
switch (row[j].type) {
case MRP_DOMCTL_STRING:
- l = snprintf(p, n, "%s'%s'", t, row[j].str);
+ l = snprintf(p, (size_t)n, "%s'%s'", t, row[j].str);
p += l;
n -= l;
break;
case MRP_DOMCTL_INTEGER:
- l = snprintf(p, n, "%s%d", t, row[j].s32);
+ l = snprintf(p, (size_t)n, "%s%d", t, row[j].s32);
p += l;
n -= l;
break;
case MRP_DOMCTL_UNSIGNED:
- l = snprintf(p, n, "%s%u", t, row[j].u32);
+ l = snprintf(p, (size_t)n, "%s%u", t, row[j].u32);
p += l;
n -= l;
break;
case MRP_DOMCTL_DOUBLE:
- l = snprintf(p, n, "%s%f", t, row[j].dbl);
+ l = snprintf(p, (size_t)n, "%s%f", t, row[j].dbl);
p += l;
n -= l;
break;
default:
- l = snprintf(p, n, "%s<invalid column 0x%x>",
+ l = snprintf(p, (size_t)n, "%s<invalid column 0x%x>",
t, row[j].type);
p += l;
n -= l;
pa_core *core;
pa_murphyif *murphyif;
resource_interface *rif;
- resource_request *req;
mrp_msg_t *msg;
uint16_t reqid;
uint32_t seqno;
rset.name = name;
rset.pid = pid;
- if (rset.autorel != 0 && rset.autorel != 1) {
+ if (cautorel->s32 < 0 || cautorel->s32 > 1) {
pa_log_debug("invalid autorel %d in table '%s'",
- rset.autorel, table);
+ cautorel->s32, table);
continue;
}
if (rset.state != RSET_RELEASE && rset.state != RSET_ACQUIRE) {
pa_log_debug("invalid state %d in table '%s'", rset.state, table);
continue;
}
- if (rset.grant != 0 && rset.grant != 1) {
- pa_log_debug("invalid grant %d in table '%s'", rset.grant, table);
+ if (cgrant->s32 < 0 || cgrant->s32 > 1) {
+ pa_log_debug("invalid grant %d in table '%s'", cgrant->s32, table);
continue;
}
if (!rset.policy) {
if (!mrp_msg_iterate(msg, pcursor, &tag, &type, &value, &size) ||
tag != RESPROTO_REQUEST_TYPE || type != MRP_MSG_FIELD_UINT16)
{
- *preqtype = INVALID_REQUEST;
+ *preqtype = (uint16_t)INVALID_REQUEST;
return false;
}
return true;
}
+#if 0
static bool resource_fetch_rset_state(mrp_msg_t *msg,
void **pcursor,
mrp_resproto_state_t *pstate)
return true;
}
-
static bool resource_fetch_rset_mask(mrp_msg_t *msg,
void **pcursor,
mrp_resproto_state_t *pmask)
*pmask = value.u32;
return true;
}
+#endif
static bool resource_transport_create(struct userdata *u,
pa_murphyif *murphyif)
static rset_hash *node_put_rset(struct userdata *u, mir_node *node, rset_data *rset)
{
pa_murphyif *murphyif;
- resource_interface *rif;
pa_proplist *pl;
rset_hash *rh;
+ resource_interface *rif;
int type;
pa_assert(u);
pa_assert(node->direction == mir_input || node->direction == mir_output);
pa_assert_se((murphyif = u->murphyif));
+
rif = &murphyif->resource;
type = (node->direction == mir_input) ? RSET_INPUT : RSET_OUTPUT;
static void rset_data_copy(rset_data *dst, rset_data *src)
{
- rset_data *dup;
-
pa_assert(dst);
pa_assert(src);
pa_assert(src->id);
static void rset_data_update(rset_data *dst, rset_data *src)
{
- rset_data *dup;
-
pa_assert(dst);
pa_assert(dst->id);
pa_assert(src);
#include "scripting.h"
#include "murphyif.h"
-#define APCLASS_DIM (mir_application_class_end - mir_application_class_begin)
+#define APCLASS_DIM (mir_application_class_end - mir_application_class_begin + 1)
struct pa_nodeset {
pa_idxset *nodes;
const char *class_name[APCLASS_DIM];
};
-
-static void free_map_cb(void *);
static int print_map(pa_hashmap *, const char *, char *, int);
pa_nodeset *pa_nodeset_init(struct userdata *u)
node->zone = pa_xstrdup(data->zone);
node->visible = data->visible;
node->available = data->available;
- node->amname = pa_xstrdup(data->amname ? data->amname : data->paname);
- node->amdescr = pa_xstrdup(data->amdescr ? data->amdescr : "");
+ node->amname = data->amname ? data->amname : data->paname;
+ node->amdescr = data->amdescr ? data->amdescr : "";
node->amid = data->amid;
- node->paname = pa_xstrdup(data->paname);
+ node->paname = data->paname;
node->paidx = data->paidx;
node->mux = data->mux;
node->loop = data->loop;
if (data->pacard.profile)
node->pacard.profile = pa_xstrdup(data->pacard.profile);
if (data->paport)
- node->paport = pa_xstrdup(data->paport);
+ node->paport = data->paport;
}
mir_router_register_node(u, node);
pa_xfree(node->key);
pa_xfree(node->zone);
- pa_xfree(node->amname);
- pa_xfree(node->amdescr);
- pa_xfree(node->paname);
pa_xfree(node->pacard.profile);
- pa_xfree(node->paport);
- pa_xfree(node->rsetid);
+ pa_xfree(node->rset.id);
pa_xfree(node);
}
e = (p = buf) + len;
-#define PRINT(f,v) if (p < e) p += snprintf(p, e-p, f "\n", v)
+#define PRINT(f,v) if (p < e) p += snprintf(p, (size_t)(e-p), f "\n", v)
PRINT(" index : %u" , node->index);
PRINT(" key : '%s'", node->key ? node->key : "");
}
}
-
-static void free_map_cb(void *void_map)
-{
- pa_nodeset_map *map = (pa_nodeset_map *)void_map;
-
- pa_xfree((void *)map->name);
- pa_xfree((void *)map->resdef);
-
- pa_xfree(map);
-}
-
static int print_map(pa_hashmap *map, const char *name, char *buf, int len)
{
#define PRINT(fmt,args...) \
- do { if (p < e) p += snprintf(p, e-p, fmt "\n", args); } while (0)
+ do { if (p < e) p += snprintf(p, (size_t)(e-p), fmt "\n", args); } while (0)
pa_nodeset_map *m;
pa_nodeset_resdef *r;
#define AM_ID_INVALID 65535
-enum mir_direction {
- mir_direction_unknown,
- mir_input,
- mir_output
-};
-
-enum mir_implement {
- mir_implementation_unknown = 0,
- mir_device,
- mir_stream
-};
-
-enum mir_location {
- mir_location_unknown = 0,
- mir_internal,
- mir_external
-};
-
-enum mir_node_type {
- mir_node_type_unknown = 0,
-
- /* application classes */
- mir_application_class_begin,
- mir_radio = mir_application_class_begin,
- mir_player,
- mir_navigator,
- mir_game,
- mir_browser,
- mir_camera,
- mir_phone, /**< telephony voice */
- mir_alert, /**< ringtone, alarm */
- mir_event, /**< notifications */
- mir_system, /**< always audible system notifications, events */
- mir_application_class_end,
-
- /* device types */
- mir_device_class_begin = 128,
- mir_null = mir_device_class_begin,
- mir_speakers,
- mir_front_speakers,
- mir_rear_speakers,
- mir_microphone,
- mir_jack,
- mir_hdmi,
- mir_spdif,
- mir_wired_headset,
- mir_wired_headphone,
- mir_usb_headset,
- mir_usb_headphone,
- mir_bluetooth_sco,
- mir_bluetooth_a2dp,
- mir_bluetooth_carkit,
- mir_bluetooth_source,
- mir_bluetooth_sink,
- mir_gateway_sink,
- mir_gateway_source,
- mir_device_class_end,
-
- /* extensions */
- mir_user_defined_start = 256
-};
-
-enum mir_privacy {
- mir_privacy_unknown = 0,
- mir_public,
- mir_private
-};
-
struct pa_nodeset_resdef {
uint32_t priority;
struct {
bool available; /**< eg. is the headset connected? */
bool ignore; /**< do not consider it while routing */
bool localrset; /**< locally generated resource set */
- char *amname; /**< audiomanager name */
- char *amdescr; /**< UI description */
+ const char *amname; /**< audiomanager name */
+ const char *amdescr; /**< UI description */
uint16_t amid; /**< handle to audiomanager, if any */
- char *paname; /**< sink|source|sink_input|source_output name */
+ const char *paname; /**< sink|source|sink_input|source_output name */
uint32_t paidx; /**< sink|source|sink_input|source_output index*/
pa_node_card pacard; /**< pulse card related data, if any */
- char *paport; /**< sink or source port if applies */
+ const char *paport; /**< sink or source port if applies */
pa_muxnode *mux; /**< for multiplexable input streams only */
pa_loopnode *loop; /**< for looped back sources only */
mir_dlist rtentries; /**< in device nodes: listhead of nodchain */
static int print_routing_table(pa_hashmap *, const char *, char *, int);
-
-static void pa_hashmap_rtgroup_free(void *rtg, void *u)
-{
- rtgroup_destroy(u, rtg);
-}
-
-
pa_router *pa_router_init(struct userdata *u)
{
size_t num_classes = mir_application_class_end;
bool mir_router_phone_accept(struct userdata *u, mir_rtgroup *rtg,
mir_node *node)
{
- pa_core *core;
- pa_sink *sink;
- pa_source *source;
- pa_proplist *pl;
mir_node_type class;
- const char *role, *expected_role;
pa_assert(u);
pa_assert(rtg);
node = rte->node;
if (p >= e)
break;
- p += snprintf(p, e-p, " '%s'", node->amname);
+ p += snprintf(p, (size_t)(e-p), " '%s'", node->amname);
}
return p - buf;
class = pa_classify_guess_application_class(node);
- if (class < 0 || class >= router->maplen)
+ if (class < 0 || class >= (int)router->maplen)
return 0;
return router->priormap[class];
n = 0;
if (len > 0) {
- p += snprintf(p, e-p, "%s routing table:\n", type);
+ p += snprintf(p, (size_t)(e-p), "%s routing table:\n", type);
state = NULL;
n++;
if (p >= e) break;
- p += snprintf(p, e-p, " %s:", rtg->name);
+ p += snprintf(p, (size_t)(e-p), " %s:", rtg->name);
if (p >= e) break;
p += rtgroup_print(rtg, p, e-p);
if (p >= e) break;
- p += snprintf(p, e-p, "\n");
+ p += snprintf(p, (size_t)(e-p), "\n");
}
if (!n && p < e)
- p += snprintf(p, e-p, " <empty>\n");
+ p += snprintf(p, (size_t)(e-p), " <empty>\n");
}
}
#include "userdata.h"
#include "list.h"
+#include "node.h"
typedef bool (*mir_rtgroup_accept_t)(struct userdata *, mir_rtgroup *,
mir_node *);
struct pa_router {
pa_rtgroup_hash rtgroups;
- int maplen; /**< length of the class- and priormap */
+ size_t maplen; /**< length of the class- and priormap */
pa_rtgroup_classmap classmap; /**< to map device node types to rtgroups */
int *priormap; /**< stream node priorities */
mir_dlist nodlist; /**< priorized list of the stream nodes
#include "userdata.h"
-enum am_method {
+typedef enum am_method {
audiomgr_unknown_method = 0,
audiomgr_register_domain,
audiomgr_setsinkprop_ack,
audiomgr_method_dim
-};
+} am_method;
#ifdef WITH_DBUS
char args[0];
};
-
typedef struct {
const char *name;
int value;
static int import_create(lua_State *L)
{
- struct userdata *u;
+ struct userdata *u = NULL;
pa_scripting *scripting;
size_t fldnamlen;
const char *fldnam;
const char *condition = NULL;
int maxrow = 0;
mrp_funcbridge_t *update = NULL;
- size_t maxcol;
+ int maxcol;
pa_value **rows;
pa_value **cols;
int i,j;
if (!update)
luaL_error(L, "missing update function");
- maxcol = columns->nstring;
+ maxcol = (int)columns->nstring;
if (maxcol >= MQI_COLUMN_MAX)
luaL_error(L, "too many columns (max %d allowed)", MQI_COLUMN_MAX);
imp->values = array_create(L, maxrow, NULL);
imp->update = update;
- for (i = 0, rows = imp->values->array; i < maxrow; i++) {
- cols = (rows[i] = array_create(L, maxcol, columns))->array;
+ for (i = 0, rows = imp->values->value.array; i < maxrow; i++) {
+ cols = (rows[i] = array_create(L, (int)maxcol, columns))->value.array;
lua_rawseti(L, -3, i+1); /* we add this to the import */
for (j = 0; j < maxcol; j++)
cols[j] = pa_xnew0(pa_value, 1);
for (colidx = 0; colidx < columns->nstring; colidx++) {
if (!strcmp(colnam, columns->strings[colidx])) {
pa_assert_se((values = imp->values));
- pa_assert_se((row = values->array[rowidx]));
+ pa_assert_se((row = values->value.array[rowidx]));
pa_assert(colidx < (size_t)-row->type);
- pa_assert_se((col = row->array[colidx]));
+ pa_assert_se((col = row->value.array[colidx]));
break;
}
}
}
- pa_log_debug("userdata: type:%d", col->type);
+ if(col)
+ pa_log_debug("userdata: type:%d", col->type);
lua_pushlightuserdata(L, col);
pa_assert(imp->columns);
pa_assert(imp->update);
pa_assert_se((ptval = imp->values));
- pa_assert_se((prow = ptval->array));
+ pa_assert_se((prow = ptval->value.array));
maxrow = -ptval->type;
- maxcol = imp->columns->nstring;
+ maxcol = (int)imp->columns->nstring;
pa_assert(maxrow >= 0);
pa_assert(nrow <= maxrow);
for (i = 0; i < maxrow; i++) {
pa_assert_se((prval = prow[i]));
- pa_assert_se((pcol = prval->array));
+ pa_assert_se((pcol = prval->value.array));
pa_assert(prval->type < 0);
pa_assert(maxcol == -prval->type);
switch (mcol->type) {
case MRP_DOMCTL_STRING:
pa_assert(!pcval->type || pcval->type == pa_value_string);
- pa_xfree((void *)pcval->string);
+ pa_xfree((void *)pcval->value.string);
pcval->type = pa_value_string;
- pcval->string = pa_xstrdup(mcol->str);
+ pcval->value.string = pa_xstrdup(mcol->str);
break;
case MRP_DOMCTL_INTEGER:
pa_assert(!pcval->type || pcval->type == pa_value_integer);
pcval->type = pa_value_integer;
- pcval->integer = mcol->s32;
+ pcval->value.integer = mcol->s32;
break;
case MRP_DOMCTL_UNSIGNED:
pa_assert(!pcval->type || pcval->type == pa_value_unsignd);
pcval->type = pa_value_unsignd;
- pcval->unsignd = mcol->u32;
+ pcval->value.unsignd = mcol->u32;
break;
case MRP_DOMCTL_DOUBLE:
pa_assert(!pcval->type || pcval->type ==pa_value_floating);
pcval->type = pa_value_floating;
- pcval->floating = mcol->dbl;
+ pcval->value.floating = mcol->dbl;
break;
default:
if (pcval->type == pa_value_string)
- pa_xfree((void *)pcval->string);
+ pa_xfree((void *)pcval->value.string);
memset(pcval, 0, sizeof(pa_value));
break;
}
pa_assert(dimension >= 0);
pa_assert(dimension < MQI_QUERY_RESULT_MAX);
- array = pa_xnew0(pa_value *, dimension + 1);
+ array = pa_xnew0(pa_value *, (size_t)(dimension + 1));
value = lua_newuserdata(L, sizeof(pa_value));
value->type = -dimension;
- value->array = array;
+ value->value.array = array;
array[dimension] = (pa_value *)names;
const char *key;
mrp_lua_strarray_t *names;
int idx;
- size_t i;
+ int i;
MRP_LUA_ENTER;
break;
case LUA_TSTRING:
idx = -1;
- if ((names = (mrp_lua_strarray_t *)arr->array[dimension])) {
- pa_assert(dimension == names->nstring);
+ if ((names = (mrp_lua_strarray_t *)arr->value.array[dimension])) {
+ pa_assert(dimension == (int)names->nstring);
key = lua_tostring(L, 2);
pa_assert(key);
for (i = 0; i < dimension; i++) {
}
- if (idx < 0 || idx >= dimension || !(value = arr->array[idx]))
+ if (idx < 0 || idx >= dimension || !(value = arr->value.array[idx]))
lua_pushnil(L);
else if (value->type < 0)
lua_rawgeti(L, 1, 1 - value->type);
else {
switch (value->type) {
- case pa_value_string: lua_pushstring(L, value->string); break;
- case pa_value_integer: lua_pushinteger(L, value->integer); break;
- case pa_value_unsignd: lua_pushinteger(L, value->unsignd); break;
- case pa_value_floating: lua_pushnumber(L, value->floating); break;
+ case pa_value_string: lua_pushstring(L, value->value.string); break;
+ case pa_value_integer: lua_pushinteger(L, value->value.integer); break;
+ case pa_value_unsignd: lua_pushinteger(L, (int)(value->value.unsignd)); break;
+ case pa_value_floating: lua_pushnumber(L, value->value.floating); break;
default: lua_pushnil(L); break;
}
}
if (value) {
pa_assert(value->type < 0);
- pa_xfree(value->array);
+ pa_xfree(value->value.array);
}
MRP_LUA_LEAVE_NOARG;
pa_assert_se((node = sn->node));
switch (fld) {
- case NAME: lua_pushstring(L, node->amname); break;
- case DESCRIPTION: lua_pushstring(L, node->amdescr); break;
- case DIRECTION: lua_pushinteger(L, node->direction); break;
- case IMPLEMENT: lua_pushinteger(L, node->implement); break;
- case CHANNELS: lua_pushinteger(L, node->channels); break;
- case LOCATION: lua_pushinteger(L, node->location); break;
- case PRIVACY: lua_pushinteger(L, node->privacy); break;
- case ZONE: lua_pushstring(L, node->zone); break;
- case TYPE: lua_pushinteger(L, node->type); break;
- case AVAILABLE: lua_pushboolean(L, node->available); break;
- default: lua_pushnil(L); break;
+ case NAME: lua_pushstring(L, node->amname); break;
+ case DESCRIPTION: lua_pushstring(L, node->amdescr); break;
+ case DIRECTION: lua_pushinteger(L, node->direction); break;
+ case IMPLEMENT: lua_pushinteger(L, node->implement); break;
+ case CHANNELS: lua_pushinteger(L, (int)(node->channels)); break;
+ case LOCATION: lua_pushinteger(L, node->location); break;
+ case PRIVACY: lua_pushinteger(L, node->privacy); break;
+ case ZONE: lua_pushstring(L, node->zone); break;
+ case TYPE: lua_pushinteger(L, node->type); break;
+ case AVAILABLE: lua_pushboolean(L, node->available); break;
+ default: lua_pushnil(L); break;
}
}
const char *fldnam;
scripting_zone *zone;
const char *name = NULL;
- attribute_t *attributes = NULL;
+ /* attribute_t *attributes = NULL; */
MRP_LUA_ENTER;
switch (field_name_to_type(fldnam, fldnamlen)) {
case NAME: name = luaL_checkstring(L, -1); break;
- case ATTRIBUTES: attributes = attributes_check(L, -1); break;
+ /* case ATTRIBUTES: attributes = attributes_check(L, -1); break; */
default: luaL_error(L, "bad field '%s'", fldnam); break;
}
struct userdata *u;
size_t fldnamlen;
const char *fldnam;
- mir_rtgroup *rtg;
scripting_resource *res;
resource_name_t *name = NULL;
attribute_t *attributes = NULL;
static int resource_getfield(lua_State *L)
{
- scripting_resource *res;
- field_t fld;
+ /* field_t fld; */
MRP_LUA_ENTER;
- fld = field_check(L, 2, NULL);
+ /* fld = field_check(L, 2, NULL);*/
lua_pop(L, 1);
- if (!(res = (scripting_resource*)mrp_lua_check_object(L,RESOURCE_CLASS,1)))
+ if (!mrp_lua_check_object(L,RESOURCE_CLASS,1))
lua_pushnil(L);
else {
#if 0
if (rt != MRP_FUNCBRIDGE_FLOATING)
pa_log("compare function returned invalid type");
else
- result = rv.floating;
+ result = (int)(rv.floating);
}
}
pa_assert(ret_type);
pa_assert(ret_val);
- pa_assert_se((accept = (mir_rtgroup_accept_t)data));
+ pa_assert((accept = (mir_rtgroup_accept_t)data));
if (strcmp(signature, "oo"))
success = false;
/* FIXME: is this how it is supposed to be done?! */
- if (imp->values && imp->values->array && imp->values->array[0] &&
- imp->values->array[0]->array &&
- imp->values->array[0]->array[0] &&
- imp->values->array[0]->array[0]->type == pa_value_string)
- pa_assert_se((s = imp->values->array[0]->array[0]->string));
+ if (imp->values && imp->values->value.array && imp->values->value.array[0] &&
+ imp->values->value.array[0]->value.array &&
+ imp->values->value.array[0]->value.array[0] &&
+ imp->values->value.array[0]->value.array[0]->type == pa_value_string)
+ pa_assert_se((s = imp->values->value.array[0]->value.array[0]->value.string));
success = true;
*ret_type = MRP_FUNCBRIDGE_NO_DATA;
route_t *route = NULL;
map_t *roles = NULL;
map_t *binaries = NULL;
- bool needs_resource = false;
pa_nodeset_resdef *resdef;
map_t *r, *b;
size_t i;
scripting_apclass *ac = (scripting_apclass *)data;
struct userdata *u;
map_t *r, *b;
- size_t i;
MRP_LUA_ENTER;
}
+#if 0
static void route_definition_free(const char **defs)
{
int i;
pa_xfree((void *)defs);
}
}
-
+#endif
static route_t *route_check(lua_State *L, int idx)
{
bool suppress = false;
bool correct = false;
size_t arglgh = 0;
- size_t i;
+ int i;
int class;
uint32_t mask, clmask;
char id[256];
vlim->calculate = calculate;
if (suppress) {
- mir_volume_suppress_arg *args = (mir_volume_suppress_arg *)vlim->args;
+ mir_volume_suppress_arg *args = (mir_volume_suppress_arg *)(void *)vlim->args;
size_t size = sizeof(int) * classes->nint;
size_t n = mir_application_class_end - mir_application_class_begin;
- for (i = 0, clmask = 0; i < classes->nint; i++) {
+ for (i = 0, clmask = 0; i < (int)(classes->nint); i++) {
class = classes->ints[i];
if (class <= mir_application_class_begin ||
mir_volume_add_generic_limit(u, vollim_calculate, vlim->args);
break;
case vollim_class:
- for (i = 0; i < classes->nint; i++) {
+ for (i = 0; i < (int)(classes->nint); i++) {
mir_volume_add_class_limit(u, classes->ints[i], vollim_calculate,
vlim->args);
}
class < mir_application_class_end) );
pa_assert(node);
- vlim = (scripting_vollim *)(data - offset);
+ vlim = (scripting_vollim *)(void*)((char *)data - offset);
pa_assert(u == vlim->userdata);
{
static double nolimit = 0.0;
- limit_data_t *ld;
+ limit_data_t *ld = NULL;
double value;
pa_value *v;
else {
ld = pa_xnew0(limit_data_t, 1);
ld->mallocd = false;
- ld->value = &v->floating;
+ ld->value = &v->value.floating;
}
break;
default:
+ ld = pa_xnew0(limit_data_t, 1);
ld->mallocd = false;
ld->value = &nolimit;
break;
static intarray_t *intarray_check(lua_State *L, int idx, int min, int max)
{
- size_t len;
+ int len;
size_t size;
intarray_t *arr;
int val;
- size_t i;
+ int i;
idx = (idx < 0) ? lua_gettop(L) + idx + 1 : idx;
if ((len = luaL_getn(L, idx)) < 1)
arr = NULL;
else {
- size = sizeof(intarray_t) + sizeof(int) * len;
+ size = sizeof(intarray_t) + sizeof(int) * (size_t)len;
arr = pa_xmalloc0(sizeof(intarray_t));
- arr->nint = len;
+ arr->nint = (size_t)len;
arr->ints = pa_xmalloc0(size);
for (i = 0; i < len; i++) {
if (!arr)
lua_pushnil(L);
else {
- lua_createtable(L, arr->nint, 0);
+ lua_createtable(L, (int)(arr->nint), 0);
for (i = 0; i < arr->nint; i++) {
lua_pushinteger(L, (int)(i+1));
attribute_t *attr, *attrs = NULL;
size_t nattr = 0;
mrp_attr_value_t *v;
- size_t i, len;
+ int i, len;
tbl = (tbl < 0) ? lua_gettop(L) + tbl + 1 : tbl;
size_t namlen;
const char *name;
const char *option;
- const char *role;
map_t *m, *map = NULL;
size_t n = 0;
- size_t i, len;
+ int i, len;
int priority;
pa_nodeset_resdef *rd;
if ((len = luaL_getn(L, def)) < 1)
luaL_error(L, "invalid resource definition '%s'", name);
- for (i = 1; i <= len; i++) {
+ for (i = 1; i < len+1; i++) {
lua_pushnumber(L, (int)i);
lua_gettable(L, def);
priority, name);
}
- m->resource.priority = priority;
+ m->resource.priority = (uint32_t)priority;
}
else {
option = luaL_checkstring(L, -1);
}
else {
lua_newtable(L);
- lua_pushinteger(L, m->resource.priority);
+ lua_pushinteger(L, (int)(m->resource.priority));
if (m->role)
lua_pushstring(L, m->role);
if (m->resource.flags.rset & RESPROTO_RSETFLAG_AUTORELEASE)
for (p = buf; (c = *p); p++) {
if (isalpha(c))
- c = tolower(c);
+ c = (char)tolower(c);
else if (!isdigit(c))
c = '_';
*p = c;
pa_assert(len > 0);
for (i = 0, e = (p = buf) + len; i < arr->nstring && p < e; i++)
- p += snprintf(p, e-p, "%s%s", (p == buf ? "" : ","), arr->strings[i]);
+ p += snprintf(p, (size_t)(e-p), "%s%s", (p == buf ? "" : ","), arr->strings[i]);
return (p < e) ? buf : NULL;
}
void pa_stream_state_change(struct userdata *u, mir_node *node, int req)
{
pa_loopnode *loop;
- uint32_t idx;
pa_sink_input *sinp;
pa_source_output *sout;
pa_core *core;
corked = (sinp->flags & PA_SINK_INPUT_START_CORKED);
if (corked && !block)
- sinp->flags &= ~PA_SINK_INPUT_START_CORKED;
+ sinp->flags &= ~((unsigned int)PA_SINK_INPUT_START_CORKED);
block_by_mute = !corked;
}
}
else {
+#if 0
+ /* this should be taken back if the block by mute goes away */
if ((corked && !block) || (!corked && block)) {
+#else
+ if (corked && !block) {
+#endif
pa_sink_input_cork_internal(sinp, block);
if (sinp->send_event) {
#define MIR_VOLUME_MAX_ATTENUATION -120 /* dB */
-typedef enum pa_value_type pa_value_type;
+//typedef enum pa_value_type pa_value_type;
typedef struct pa_value pa_value;
typedef struct pa_null_sink pa_null_sink;
typedef struct pa_tracker pa_tracker;
typedef struct pa_extapi pa_extapi;
typedef struct pa_murphyif pa_murphyif;
-typedef enum mir_direction mir_direction;
-typedef enum mir_implement mir_implement;
-typedef enum mir_location mir_location;
-typedef enum mir_node_type mir_node_type;
-typedef enum mir_privacy mir_privacy;
+//typedef enum mir_direction mir_direction;
+//typedef enum mir_implement mir_implement;
+//typedef enum mir_location mir_location;
+//typedef enum mir_node_type mir_node_type;
+//typedef enum mir_privacy mir_privacy;
typedef struct mir_node mir_node;
typedef struct mir_zone mir_zone;
typedef struct mir_rtgroup mir_rtgroup;
typedef struct scripting_apclass scripting_apclass;
typedef struct scripting_vollim scripting_vollim;
-typedef enum am_method am_method;
+//typedef enum am_method am_method;
typedef struct am_domainreg_data am_domainreg_data;
typedef struct am_nodereg_data am_nodereg_data;
typedef struct am_nodeunreg_data am_nodeunreg_data;
pa_value_floating,
};
+typedef union val_t {
+ const char *string;
+ int32_t integer;
+ uint32_t unsignd;
+ double floating;
+ pa_value **array;
+} val_t;
+
struct pa_value {
/* positive values are enumerations of pa_value_type
* negative values represent array dimensions,
* eg. -2 menas an array with two element
*/
- int type;
- union {
- const char *string;
- int32_t integer;
- uint32_t unsignd;
- double floating;
- pa_value **array;
- };
+ int type;
+ val_t value;
};
+typedef enum mir_direction {
+ mir_direction_unknown,
+ mir_input,
+ mir_output
+} mir_direction;
+
+typedef enum mir_implement {
+ mir_implementation_unknown = 0,
+ mir_device,
+ mir_stream
+} mir_implement;
+
+typedef enum mir_location {
+ mir_location_unknown = 0,
+ mir_internal,
+ mir_external
+} mir_location;
+
+typedef enum mir_node_type {
+ mir_node_type_unknown = 0,
+
+ /* application classes */
+ mir_application_class_begin,
+ mir_radio = mir_application_class_begin,
+ mir_player,
+ mir_navigator,
+ mir_game,
+ mir_browser,
+ mir_camera,
+ mir_phone, /**< telephony voice */
+ mir_alert, /**< ringtone, alarm */
+ mir_event, /**< notifications */
+ mir_system, /**< always audible system notifications, events */
+ mir_application_class_end,
+
+ /* device types */
+ mir_device_class_begin = 128,
+ mir_null = mir_device_class_begin,
+ mir_speakers,
+ mir_front_speakers,
+ mir_rear_speakers,
+ mir_microphone,
+ mir_jack,
+ mir_hdmi,
+ mir_spdif,
+ mir_wired_headset,
+ mir_wired_headphone,
+ mir_usb_headset,
+ mir_usb_headphone,
+ mir_bluetooth_sco,
+ mir_bluetooth_a2dp,
+ mir_bluetooth_carkit,
+ mir_bluetooth_source,
+ mir_bluetooth_sink,
+ mir_gateway_sink,
+ mir_gateway_source,
+ mir_device_class_end,
+
+ /* extensions */
+ mir_user_defined_start = 256
+} mir_node_type;
+
+typedef enum mir_privacy {
+ mir_privacy_unknown = 0,
+ mir_public,
+ mir_private
+} mir_privacy;
struct userdata {
pa_core *core;
-char *pa_utils_get_card_name(pa_card *card)
+const char *pa_utils_get_card_name(pa_card *card)
{
return (card && card->name) ? card->name : "<unknown>";
}
-char *pa_utils_get_card_bus(pa_card *card)
+const char *pa_utils_get_card_bus(pa_card *card)
{
const char *bus = NULL;
- char *name;
+ const char *name;
if (card && !(bus = pa_proplist_gets(card->proplist,PA_PROP_DEVICE_BUS))) {
name = pa_utils_get_card_name(card);
return (char *)bus;
}
-char *pa_utils_get_sink_name(pa_sink *sink)
+const char *pa_utils_get_sink_name(pa_sink *sink)
{
return (sink && sink->name) ? sink->name : "<unknown>";
}
-char *pa_utils_get_source_name(pa_source *source)
+const char *pa_utils_get_source_name(pa_source *source)
{
return (source && source->name) ? source->name : "<unknown>";
}
-char *pa_utils_get_sink_input_name(pa_sink_input *sinp)
+const char *pa_utils_get_sink_input_name(pa_sink_input *sinp)
{
char *name;
return "<unknown>";
}
-char *pa_utils_get_sink_input_name_from_data(pa_sink_input_new_data *data)
+const char *pa_utils_get_sink_input_name_from_data(pa_sink_input_new_data *data)
{
char *name;
}
-char *pa_utils_get_source_output_name(pa_source_output *sout)
+const char *pa_utils_get_source_output_name(pa_source_output *sout)
{
char *name;
return "<unknown>";
}
-char *pa_utils_get_source_output_name_from_data(pa_source_output_new_data*data)
+const char *pa_utils_get_source_output_name_from_data(pa_source_output_new_data*data)
{
char *name;
if (buf && length >= 2) {
if ((prop = pa_proplist_gets(pl, PA_PROP_RESOURCE_SET_NAME))) {
- snprintf(buf, length, "#%s", prop);
+ snprintf(buf, (size_t)length, "#%s", prop);
return buf;
}
if ((prop = pa_proplist_gets(pl, PA_PROP_RESOURCE_SET_ID))) {
- strncpy(buf, prop, length);
+ strncpy(buf, prop, (size_t)length);
buf[length-1] = '\0';
return buf;
}
pa_nodeset_resdef *pa_utils_get_resource_properties(pa_proplist *pl,
pa_nodeset_resdef *rd)
{
+ int success;
+
pa_assert(pl);
pa_assert(rd);
- int success;
-
memset(rd, 0, sizeof(pa_nodeset_resdef));
success = get_unsigned_property(pl, PA_PROP_RESOURCE_PRIORITY,
pa_sink *pa_utils_get_null_sink(struct userdata *);
pa_source *pa_utils_get_null_source(struct userdata *);
-char *pa_utils_get_card_name(pa_card *);
-char *pa_utils_get_card_bus(pa_card *);
-char *pa_utils_get_sink_name(pa_sink *);
-char *pa_utils_get_source_name(pa_source *);
-char *pa_utils_get_sink_input_name(pa_sink_input *);
-char *pa_utils_get_sink_input_name_from_data(pa_sink_input_new_data *);
-char *pa_utils_get_source_output_name(pa_source_output *);
-char *pa_utils_get_source_output_name_from_data(pa_source_output_new_data *);
+const char *pa_utils_get_card_name(pa_card *);
+const char *pa_utils_get_card_bus(pa_card *);
+const char *pa_utils_get_sink_name(pa_sink *);
+const char *pa_utils_get_source_name(pa_source *);
+const char *pa_utils_get_sink_input_name(pa_sink_input *);
+const char *pa_utils_get_sink_input_name_from_data(pa_sink_input_new_data *);
+const char *pa_utils_get_source_output_name(pa_source_output *);
+const char *pa_utils_get_source_output_name_from_data(pa_source_output_new_data *);
char *pa_utils_get_zone(pa_proplist *);
const char *pa_utils_get_appid(pa_proplist *);
if (class < volume->classlen)
table = volume->classlim + class;
else {
- newlen = class + 1;
+ newlen = (size_t)(class + 1);
size = sizeof(vlim_table) * newlen;
- diff = sizeof(vlim_table) * (newlen - volume->classlen);
+ diff = sizeof(vlim_table) * (newlen - (size_t)volume->classlen);
pa_assert_se((classlim = realloc(volume->classlim, size)));
memset(classlim + volume->classlen, 0, diff);
- volume->classlen = newlen;
+ volume->classlen = (int)newlen;
volume->classlim = classlim;
table = classlim + class;
double attenuation = 0.0;
double devlim, classlim;
vlim_table *tbl;
- uint32_t clmask;
double maxlim;
pa_assert(u);
pa_assert(class < mir_application_class_end);
maxlim = volume->maxlim[class];
- clmask = (uint32_t)1 << (class - mir_application_class_begin);
if (class < volume->classlen && (tbl = volume->classlim + class))
classlim = apply_table(classlim, tbl, u, class, node, "class");
#include "zone.h"
-
struct pa_zoneset {
struct {
pa_hashmap *hash;
} zones;
};
-
-static void free_zone_cb(void *);
-
-
pa_zoneset *pa_zoneset_init(struct userdata *u)
{
pa_zoneset *zs;
PA_HASHMAP_FOREACH(zone, zs->zones.hash, state) {
if (p >= e) break;
- p += snprintf(p, e-p, " '%s'", zone->name);
+ p += snprintf(p, (size_t)(e-p), " '%s'", zone->name);
}
pa_proplist_sets(module->proplist, PA_PROP_ZONES, buf+1);
}
-static void free_zone_cb(void *void_zone)
-{
- mir_zone *zone = (mir_zone *)void_zone;
-
- pa_xfree((void *)zone->name);
-
- pa_xfree(zone);
-}
-
-
-
-
-
/*
* Local Variables:
projects / profile / ivi / pulseaudio-module-murphy-ivi.git / commitdiff