{
srs_context_t *srs = plugin->srs;
context_t *ctx = NULL;
- int sts;
mrp_debug("creating bluetooth voice recognition client plugin");
static int config_bt_voicerec(srs_plugin_t *plugin, srs_cfg_t *settings)
{
- context_t *ctx = (context_t *)plugin->plugin_data;
- srs_cfg_t *cfgs, *c, *s;
+ srs_cfg_t *cfgs, *c;
const char *key;
int pfxlen;
int n, i;
int success;
+ MRP_UNUSED(plugin);
+
mrp_debug("configuring bluetooth voice recognition client plugin");
n = srs_collect_config(settings, BLUETOOTH_PREFIX, &cfgs);
static void destroy_bt_voicerec(srs_plugin_t *plugin)
{
- srs_context_t *srs = plugin->srs;
- context_t *ctx = (context_t *)plugin->plugin_data;
+ context_t *ctx = (context_t *)plugin->plugin_data;
mrp_debug("destroy bluetooth voice recognition client plugin");
int fd;
if (stat(file, &buf) < 0) {
- printf("*** could not stat sample file '%s'\n");
+ printf("*** could not stat sample file '%s'\n", file);
return;
}
if ((size = buf.st_size) > 500000) {
- printf("*** file too length %u exceeds the max 500000\n", size);
+ printf("*** file too length %zd exceeds the max 500000\n", size);
return;
}
nsample = len / sizeof(int16_t);
- printf("*** succesfully read %u samples\n", nsample);
+ printf("*** succesfully read %zd samples\n", nsample);
}
int clients_stop(context_t *ctx)
{
+ MRP_UNUSED(ctx);
+
return 0;
}
static int notify_focus(srs_client_t *srs_client, srs_voice_focus_t focus)
{
+ MRP_UNUSED(srs_client);
+ MRP_UNUSED(focus);
+
return TRUE;
}
reference_modem(modem);
mrp_list_prepend(&dbusif->modems, &modem->link);
+
+ return modem;
}
static void destroy_modem(modem_t *modem)
int type;
DBusBasicValue value;
+ MRP_UNUSED(dbus);
+
if (ctx && (dbusif = ctx->dbusif) && dbus_message_iter_init(msg, &mit)) {
path = dbus_message_get_path(msg);
DBusBasicValue value;
hfp_state_t state;
+ MRP_UNUSED(dbus);
+
if (ctx && (dbusif = ctx->dbusif) && dbus_message_iter_init(msg, &mit)) {
path = dbus_message_get_path(msg);
const char *addr;
const char *name;
dbus_bool_t online;
- hfp_state_t state;
modem_t *modem;
DBusMessageIter mit, ait, sit;
+ MRP_UNUSED(dbus);
+
if (ctx && (dbusif = ctx->dbusif) && dbus_message_iter_init(msg, &mit)) {
if (dbus_message_iter_get_arg_type(&mit) != DBUS_TYPE_ARRAY)
return;
const char *addr;
const char *name;
dbus_bool_t online;
- hfp_state_t state;
- DBusMessageIter mit, ait, sit;
+ DBusMessageIter mit;
+
+ MRP_UNUSED(dbus);
if (modem && (ctx = modem->ctx)) {
modem_t *modem = (modem_t *)user_data;
context_t *ctx;
hfp_state_t state;
- DBusMessageIter mit, ait, sit;
+ DBusMessageIter mit;
+
+ MRP_UNUSED(dbus);
if (modem && (ctx = modem->ctx)) {
const char **btname,
dbus_bool_t *online)
{
- modem_t *modem;
const char *prop;
int type;
DBusBasicValue value;
const char *prop;
int type;
DBusBasicValue value;
- DBusMessageIter ait, dit, vit, iit;
- dbus_bool_t has_handsfree_interface = FALSE;
+ DBusMessageIter ait, dit, vit;
if (!modem || !sit || !state)
return;
int pulseif_create(context_t *ctx, pa_mainloop *mloop)
{
pulseif_t *pulseif = NULL;
- pa_mainloop_api *api = NULL;
+#if 0
+ pa_mainloop_api *api;
+#endif
if (!(pulseif = mrp_allocz(sizeof(pulseif_t))))
goto failed;
+#if 0
api = pa_mainloop_get_api(mloop);
-#if 0
if (pa_signal_init(api) < 0)
goto failed;
#endif
double m;
int16_t *s;
+ MRP_UNUSED(bytes);
+
if (!card || !(device = card->device) || !(ctx = device->ctx) ||
!(pulseif = ctx->pulseif))
goto confused;
return;
could_not_write:
- mrp_log_error("bluetooth plugin: could not write %u bytes to stream %s",
+ mrp_log_error("bluetooth plugin: could not write %zd bytes to stream %s",
bytes, device->btaddr);
}
const char *btaddr;
uint32_t j;
+ MRP_UNUSED(c);
+
if (pend && (ctx = pend->ctx)) {
if (eol)
remove_pending_op(pend);
modem_t *modem;
const char *proto;
const char *btaddr;
- uint32_t j;
+
+ MRP_UNUSED(c);
if (pend && (ctx = pend->ctx)) {
if (eol)
modem_t *modem;
const char *proto;
const char *btaddr;
- uint32_t j;
+
+ MRP_UNUSED(c);
if (pend && (ctx = pend->ctx)) {
if (eol)
srs_plugin_t *pl;
srs_context_t *srs;
clients_t *clients;
- player_t *player;
srs_client_ops_t callbacks;
if (!ctx || !(pl = ctx->plugin) || !(srs = pl->srs) ||
int clients_stop(context_t *ctx)
{
+ MRP_UNUSED(ctx);
+
return 0;
}
static int notify_focus(srs_client_t *srs_client, srs_voice_focus_t focus)
{
+ MRP_UNUSED(srs_client);
+ MRP_UNUSED(focus);
+
return TRUE;
}
{
player_t *player = (player_t *)user_data;
+ MRP_UNUSED(api);
+ MRP_UNUSED(e);
+ MRP_UNUSED(tv);
+
dbusif_query_playlists(player);
dbusif_set_player_state(player, player->request.state);
memset(&player->request, 0, sizeof(player->request));
{
context_t *ctx = (context_t *)user_data;
player_t *player = (player_t *)object;
- int sts;
+
+ MRP_UNUSED(key);
dbusif_register_player(ctx, player->name);
if (strcmp(key, player->name))
- mrp_log_error("mpris2-client: corrupt hashtable (key '%s')", key);
+ mrp_log_error("mpris2-client: corrupt hashtable (key '%s')",
+ (char *)key);
else {
if (player->timer && (ctx = player->ctx) && (pl = ctx->plugin) &&
(srs = pl->srs) && (api = pa_mainloop_get_api(srs->pa)))
DBusMessage *msg;
DBusMessageIter mit;
DBusMessageIter vit;
- int success;
if (!player || !player->name || !player->address ||
!(ctx = player->ctx) || !(dbusif = ctx->dbusif))
context_t *ctx;
dbusif_t *dbusif;
DBusMessage *msg;
- const char *member;
if (!player || !player->address ||
!(ctx = player->ctx) || !(dbusif = ctx->dbusif))
context_t *ctx;
dbusif_t *dbusif;
DBusMessage *msg;
- const char *member;
if (!player || !player->address ||
!(ctx = player->ctx) || !(dbusif = ctx->dbusif))
const char *dot;
const char *name;
+ MRP_UNUSED(dbus);
+ MRP_UNUSED(error);
+
if (ctx && (dbusif = ctx->dbusif) && (dot = strrchr(dbus_name, '.'))) {
name = dot + 1;
context_t *ctx;
DBusMessageIter mit;
+ MRP_UNUSED(dbus);
+
if (player && (ctx = player->ctx) && dbus_message_iter_init(msg, &mit))
parse_properties(ctx, player, &mit);
}
{
player_t *player = (player_t *)user_data;
context_t *ctx;
- DBusMessageIter mit;
dbus_bool_t success;
const char *xml;
+ MRP_UNUSED(dbus);
+
if (player && (ctx = player->ctx)) {
success = dbus_message_get_args(msg, NULL,
DBUS_TYPE_STRING, &xml,
playlist_t *list;
size_t nlist;
+ MRP_UNUSED(dbus);
+
if (!player || !(ctx = player->ctx))
return;
const char *interface;
DBusMessageIter mit;
+ MRP_UNUSED(dbus);
+
if (!ctx || ! sender)
return FALSE;
{
srs_context_t *srs = plugin->srs;
context_t *ctx = NULL;
- int sts;
mrp_debug("creating Mpris2 client plugin");
static int start_mpris2(srs_plugin_t *plugin)
{
- srs_context_t *srs = plugin->srs;
context_t *ctx = (context_t *)plugin->plugin_data;
mrp_debug("start Mpris2 client plugin");
static void destroy_mpris2(srs_plugin_t *plugin)
{
- srs_context_t *srs = plugin->srs;
- context_t *ctx = (context_t *)plugin->plugin_data;
+ context_t *ctx = (context_t *)plugin->plugin_data;
mrp_debug("destroy Mpris2 client plugin");
input_buf_t *inpbuf;
filter_buf_t *filtbuf;
cont_ad_t *cont;
- int32_t l, max, len, rem;
+ int32_t l, max, len;
if (!ctx || !(decset = ctx->decset) || !(dec = decset->curdec) ||
!(inpbuf = ctx->inpbuf) || !(cont = inpbuf->cont) ||
input_buf_t *inpbuf;
filter_buf_t *filtbuf;
cont_ad_t *cont;
- int32 l, max, rem;
uint32_t minreq;
size_t maxlen;
size_t totlen;
size_t extra;
- size_t move;
if (!ctx || !(decset = ctx->decset) || !(dec = decset->curdec) ||
!(inpbuf = ctx->inpbuf) || !(cont = inpbuf->cont) ||
if ((totlen = len + inpbuf->len) > maxlen) {
extra = totlen - maxlen;
- mrp_log_error("input buffer overflow (%u bytes). "
+ mrp_log_error("input buffer overflow (%zd bytes). "
"throwing away extra bytes", extra);
if (extra > maxlen) {
buf += (len - (len % maxlen));
len = maxlen;
- }
+ }
else {
inpbuf->len -= extra;
memmove(inpbuf->buf, inpbuf->buf + extra, inpbuf->len);
static int32 ad_buffer_read(ad_rec_t *ud, int16 *buf, int32 reqlen)
{
input_buf_t *inpbuf = (input_buf_t *)ud;
- context_t *ctx = inpbuf->ctx;
size_t len = reqlen * sizeof(int16);
if (!inpbuf->max || !inpbuf->buf)
memmove(inpbuf->buf, inpbuf->buf + len, inpbuf->len);
}
}
-
+
if ((len % sizeof(int16)))
- mrp_log_error("%s(): odd buffer size %u", __FUNCTION__, len);
+ mrp_log_error("%s(): odd buffer size %zd", __FUNCTION__, len);
return (int32)(len / sizeof(int16));
}
const char *key;
const char *value;
char *e;
- int c;
bool verbose;
int i;
int sts;
options_t *opts = ctx->opts;
pulse_interface_t *pulseif = ctx->pulseif;
input_buf_t *inpbuf = ctx->inpbuf;
- decoder_set_t *decset = ctx->decset;
- decoder_t *dec = decset->decs;
- cmd_ln_t *cfg = dec->cfg;
double rate = opts->rate;
double dsilen = opts->silen;
const char *source = opts->srcnam;
const void *data;
size_t size;
+ MRP_UNUSED(bytes);
+
if (pulseif->stream != stream) {
mrp_log_error("sphinx plugin: %s() confused with internal "
"data structures", __FUNCTION__);
{
context_t *ctx = (context_t *)plugin->plugin_data;
srs_cfg_t *cfg;
- int n, i;
+ int n;
mrp_debug("configuring CMU Sphinx speech recognition backend plugin");
double prob;
ps_nbest_t *nb;
ps_seg_t *seg;
- ps_lattice_t *dag;
- ps_latnode_iter_t *it;
- ps_latlink_t *lnk;
- ps_latnode_t *nod;
int32 start, end;
- size_t ncand, nsort;
+ size_t ncand;
srs_srec_candidate_t *cand;
srs_srec_token_t *tkn;
- int32_t length, purgelen;
+ int32_t length;
if (!ctx || !(decset = ctx->decset) || !(dec = decset->curdec))
return;
decoder_set_t *decset;
decoder_t *dec;
logmath_t *lmath;
- const char *hyp;
const char *uttid;
int32_t score;
double prob;
const char *token;
int32_t start;
int16 fef, lef;
- int32_t purgelen;
if (!ctx || !(decset = ctx->decset) || !(dec = decset->curdec))
return;
lmath = ps_get_logmath(dec->ps);
- hyp = ps_get_hyp(dec->ps, &score, &uttid);
prob = logmath_exp(lmath, score);
cand = cands;
{
start = ps_latnode_times(nod, &fef, &lef);
- if (tkn && start < tkn->end)
+ if (tkn && start < (int32_t)tkn->end)
break; /* just take one candidate */
if (!tkn || !tkneq(token, tkn->token)) {
size_t i,j;
if (ctx && (decset = ctx->decset) && (dec = decset->curdec)) {
- mrp_log_info("*** %15s (%.4lf) %u candidates, length %u",
+ mrp_log_info("*** %15s (%.4lf) %zd candidates, length %u",
utt->id, utt->score, utt->ncand, utt->length);
- for (i = 0; cand = utt->cands[i]; i++) {
+ for (i = 0; (cand = utt->cands[i]) != NULL; i++) {
mrp_log_info(" (%.4lf) ----------------------", cand->score);
for (j = 0; j < cand->ntoken; j++) {
static bool tkneq(const char *tkn1, const char *tkn2)
{
const char *e1, *e2;
- int l1, l2, l;
+ int l1, l2;
if (!tkn1 || !tkn2)
return false;