forked from enlightenment/enlightenment
e mixer - replace with epulse/emixer
this is emixer (epulse) from http://git.enlightenment.org/devs/ceolin/epulse.git the emixer binar is rewritten though and the emix lib is compiled-in into the module and into the binary as oppopsed to a shared lib with loadable modules. this supports alsa and pulse. a much more solid mixer.
This commit is contained in:
parent
d17851f714
commit
4f6df6b7ca
25
configure.ac
25
configure.ac
|
@ -722,28 +722,13 @@ define([CHECK_MODULE_NOTIFICATION],
|
|||
|
||||
|
||||
AM_CONDITIONAL(HAVE_ALSA, false)
|
||||
AM_CONDITIONAL(HAVE_PULSE, false)
|
||||
define([CHECK_MODULE_MIXER],
|
||||
[
|
||||
if test "x$enable_alsa" = "x" || test "x$enable_alsa" = "xdefault" || test "x$enable_alsa" = "xyes"; then
|
||||
AC_E_CHECK_PKG(ALSA, [alsa >= 1.0.8],
|
||||
[ SOUND_CFLAGS="$ALSA_CFLAGS -DHAVE_ALSA $SOUND_CFLAGS"
|
||||
SOUND_LIBS="$ALSA_LIBS $SOUND_LDFLAGS"
|
||||
],
|
||||
[ if test "x$enable_alsa" = "xyes"; then
|
||||
AC_MSG_ERROR([alsa library >= 1.0.8 not found])
|
||||
else
|
||||
AC_MSG_WARN([alsa library development files not present. no alsa support.])
|
||||
fi
|
||||
])
|
||||
else
|
||||
have_alsa=no
|
||||
fi
|
||||
|
||||
if test "$have_alsa" = "yes"; then
|
||||
AC_DEFINE(HAVE_ALSA, 1, [Define if the ALSA output plugin should be built])
|
||||
else
|
||||
have_alsa=no
|
||||
fi
|
||||
AC_E_CHECK_PKG(ALSA, [alsa >= 1.0.8],
|
||||
[ ], [ ])
|
||||
AC_E_CHECK_PKG([PULSE], [libpulse-simple libpulse],
|
||||
[ ], [ ])
|
||||
])
|
||||
|
||||
SHM_OPEN_LIBS=""
|
||||
|
|
|
@ -238,10 +238,8 @@ src/modules/ibox/e_mod_config.c
|
|||
src/modules/ibox/e_mod_main.c
|
||||
src/modules/lokker/e_mod_main.c
|
||||
src/modules/lokker/lokker.c
|
||||
src/modules/mixer/app_mixer.c
|
||||
src/modules/mixer/conf_gadget.c
|
||||
src/modules/mixer/conf_module.c
|
||||
src/modules/mixer/e_mod_main.c
|
||||
src/modules/mixer/e_mod_config.c
|
||||
src/modules/music-control/e_mod_main.c
|
||||
src/modules/music-control/ui.c
|
||||
src/modules/notification/e_mod_config.c
|
||||
|
|
|
@ -5,41 +5,35 @@ mixerdir = $(MDIR)/mixer
|
|||
mixer_DATA = src/modules/mixer/e-module-mixer.edj \
|
||||
src/modules/mixer/module.desktop
|
||||
|
||||
|
||||
mixerpkgdir = $(MDIR)/mixer/$(MODULE_ARCH)
|
||||
mixerpkg_LTLIBRARIES = src/modules/mixer/module.la
|
||||
|
||||
src_modules_mixer_module_la_CPPFLAGS = $(MOD_CPPFLAGS) @SOUND_CFLAGS@
|
||||
emixerlib = src/modules/mixer/lib/emix.c src/modules/mixer/lib/emix.h
|
||||
|
||||
if HAVE_ALSA
|
||||
emixerlib += src/modules/mixer/lib/backends/alsa/alsa.c
|
||||
endif
|
||||
|
||||
if HAVE_PULSE
|
||||
emixerlib += src/modules/mixer/lib/backends/pulseaudio/pulse_ml.c
|
||||
emixerlib += src/modules/mixer/lib/backends/pulseaudio/pulse.c
|
||||
endif
|
||||
|
||||
src_modules_mixer_emixerdir = $(mixerpkgdir)
|
||||
src_modules_mixer_emixer_PROGRAMS = src/modules/mixer/emixer
|
||||
src_modules_mixer_emixer_SOURCES = src/modules/mixer/emixer.c \
|
||||
$(emixerlib)
|
||||
src_modules_mixer_emixer_CPPFLAGS = $(MOD_CPPFLAGS) @e_cflags@ -I$(top_srcdir)/src/modules/mixer/lib
|
||||
src_modules_mixer_emixer_LDADD = $(MOD_LIBS) @PULSE_LIBS@ @ALSA_LIBS@
|
||||
|
||||
src_modules_mixer_module_la_CPPFLAGS = $(MOD_CPPFLAGS) @e_cflags@ @ALSA_CFLAGS@ @PULSE_CFLAGS@ -I$(top_srcdir)/src/modules/mixer/lib
|
||||
src_modules_mixer_module_la_LDFLAGS = $(MOD_LDFLAGS)
|
||||
src_modules_mixer_module_la_SOURCES = src/modules/mixer/e_mod_main.c \
|
||||
src/modules/mixer/e_mod_main.h \
|
||||
src/modules/mixer/e_mod_mixer.h \
|
||||
src/modules/mixer/e_mod_mixer.c \
|
||||
src/modules/mixer/app_mixer.c \
|
||||
src/modules/mixer/conf_gadget.c \
|
||||
src/modules/mixer/conf_module.c \
|
||||
src/modules/mixer/msg.c \
|
||||
src/modules/mixer/Pulse.h \
|
||||
src/modules/mixer/pa.h \
|
||||
src/modules/mixer/pa.c \
|
||||
src/modules/mixer/serial.c \
|
||||
src/modules/mixer/sink.c \
|
||||
src/modules/mixer/sys_pulse.c \
|
||||
src/modules/mixer/tag.c
|
||||
|
||||
if HAVE_ALSA
|
||||
src_modules_mixer_module_la_SOURCES += src/modules/mixer/sys_alsa.c
|
||||
else
|
||||
src_modules_mixer_module_la_SOURCES += src/modules/mixer/sys_dummy.c
|
||||
endif
|
||||
|
||||
src_modules_mixer_module_la_LIBADD = $(MOD_LIBS) @SOUND_LIBS@
|
||||
|
||||
if HAVE_ENOTIFY
|
||||
src_modules_mixer_module_la_CPPFLAGS += @ENOTIFY_CFLAGS@
|
||||
src_modules_mixer_module_la_LIBADD += @ENOTIFY_LIBS@
|
||||
endif
|
||||
src/modules/mixer/e_mod_config.c \
|
||||
src/modules/mixer/e_mod_config.h \
|
||||
$(emixerlib)
|
||||
src_modules_mixer_module_la_LIBADD = $(MOD_LIBS) @PULSE_LIBS@ @ALSA_LIBS@
|
||||
|
||||
PHONIES += mixer install-mixer
|
||||
mixer: $(mixerpkg_LTLIBRARIES) $(mixer_DATA)
|
||||
|
|
|
@ -0,0 +1 @@
|
|||
emixer
|
|
@ -0,0 +1,201 @@
|
|||
#include "e.h"
|
||||
#include "e_mod_config.h"
|
||||
#include "e_mod_main.h"
|
||||
#include "emix.h"
|
||||
|
||||
typedef struct _Emix_Config
|
||||
{
|
||||
const char *backend;
|
||||
int notify;
|
||||
int mute;
|
||||
|
||||
emix_config_backend_changed cb;
|
||||
const void *userdata;
|
||||
} Emix_Config;
|
||||
|
||||
struct _E_Config_Dialog_Data
|
||||
{
|
||||
Emix_Config config;
|
||||
Evas_Object *list;
|
||||
};
|
||||
|
||||
static E_Config_DD *cd;
|
||||
static Emix_Config *_config;
|
||||
|
||||
static E_Config_DD*
|
||||
_emix_config_dd_new(void)
|
||||
{
|
||||
E_Config_DD *result = E_CONFIG_DD_NEW("Emix_Config", Emix_Config);
|
||||
|
||||
E_CONFIG_VAL(result, Emix_Config, backend, STR);
|
||||
E_CONFIG_VAL(result, Emix_Config, notify, INT);
|
||||
E_CONFIG_VAL(result, Emix_Config, mute, INT);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
const char *
|
||||
emix_config_backend_get(void)
|
||||
{
|
||||
return _config->backend;
|
||||
}
|
||||
|
||||
void
|
||||
emix_config_backend_set(const char *backend)
|
||||
{
|
||||
eina_stringshare_replace(&_config->backend, backend);
|
||||
e_config_domain_save("module.emix", cd, _config);
|
||||
}
|
||||
|
||||
Eina_Bool
|
||||
emix_config_notify_get(void)
|
||||
{
|
||||
return _config->notify;
|
||||
}
|
||||
|
||||
Eina_Bool
|
||||
emix_config_desklock_mute_get(void)
|
||||
{
|
||||
return _config->mute;
|
||||
}
|
||||
|
||||
static void
|
||||
_config_set(Emix_Config *config)
|
||||
{
|
||||
if ((config->backend) && (_config->backend != config->backend))
|
||||
eina_stringshare_replace(&_config->backend, config->backend);
|
||||
|
||||
_config->notify = config->notify;
|
||||
_config->mute = config->mute;
|
||||
|
||||
DBG("SAVING CONFIG %s %d %d", _config->backend, config->notify,
|
||||
config->mute);
|
||||
e_config_domain_save("module.emix", cd, config);
|
||||
}
|
||||
|
||||
void
|
||||
emix_config_init(emix_config_backend_changed cb, const void *userdata)
|
||||
{
|
||||
const Eina_List *l;
|
||||
|
||||
EINA_SAFETY_ON_FALSE_RETURN(emix_init());
|
||||
cd = _emix_config_dd_new();
|
||||
_config = e_config_domain_load("module.emix", cd);
|
||||
if (!_config)
|
||||
{
|
||||
_config = E_NEW(Emix_Config, 1);
|
||||
l = emix_backends_available();
|
||||
if (l)
|
||||
_config->backend = eina_stringshare_add(l->data);
|
||||
}
|
||||
|
||||
_config->cb = cb;
|
||||
_config->userdata = userdata;
|
||||
DBG("Config loaded, backend to use: %s", _config->backend);
|
||||
}
|
||||
|
||||
void
|
||||
emix_config_shutdown(void)
|
||||
{
|
||||
E_CONFIG_DD_FREE(cd);
|
||||
if (_config->backend)
|
||||
eina_stringshare_del(_config->backend);
|
||||
free(_config);
|
||||
emix_shutdown();
|
||||
}
|
||||
|
||||
static void*
|
||||
_create_data(E_Config_Dialog *cfg EINA_UNUSED)
|
||||
{
|
||||
E_Config_Dialog_Data *d;
|
||||
|
||||
d = E_NEW(E_Config_Dialog_Data, 1);
|
||||
d->config.backend = eina_stringshare_add(_config->backend);
|
||||
d->config.notify = _config->notify;
|
||||
d->config.mute = _config->mute;
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
static void
|
||||
_free_data(E_Config_Dialog *c EINA_UNUSED, E_Config_Dialog_Data *cf)
|
||||
{
|
||||
eina_stringshare_del(cf->config.backend);
|
||||
free(cf);
|
||||
}
|
||||
|
||||
static Evas_Object *
|
||||
_basic_create_widgets(E_Config_Dialog *cfd EINA_UNUSED, Evas *evas,
|
||||
E_Config_Dialog_Data *cfdata)
|
||||
{
|
||||
Evas_Object *o, *l;
|
||||
const Eina_List *node;
|
||||
char *name;
|
||||
int i = 0;
|
||||
|
||||
o = e_widget_list_add(evas, 0, 0);
|
||||
|
||||
l = e_widget_check_add(evas, "Notify on volume change", &cfdata->config.notify);
|
||||
e_widget_list_object_append(o, l, 0, 0, 0);
|
||||
|
||||
l = e_widget_check_add(evas, "Mute on lock", &cfdata->config.mute);
|
||||
e_widget_list_object_append(o, l, 0, 0, 0);
|
||||
|
||||
l = e_widget_label_add(evas, "Backend to use:");
|
||||
e_widget_list_object_append(o, l, 0, 0, 0);
|
||||
|
||||
cfdata->list = l = e_widget_ilist_add(evas, 0, 0, NULL);
|
||||
e_widget_ilist_multi_select_set(l, EINA_FALSE);
|
||||
e_widget_size_min_set(l, 100, 100);
|
||||
EINA_LIST_FOREACH(emix_backends_available(), node, name)
|
||||
{
|
||||
e_widget_ilist_append(l, NULL, name, NULL, NULL, NULL);
|
||||
i ++;
|
||||
if (_config->backend && !strcmp(_config->backend, name))
|
||||
e_widget_ilist_selected_set(l, i);
|
||||
}
|
||||
e_widget_ilist_go(l);
|
||||
e_widget_ilist_thaw(l);
|
||||
e_widget_list_object_append(o, l, 1, 1, 0);
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
static int
|
||||
_basic_apply_data(E_Config_Dialog *cfd EINA_UNUSED,
|
||||
E_Config_Dialog_Data *cfdata)
|
||||
{
|
||||
char *new_backend = eina_list_nth(
|
||||
emix_backends_available(),
|
||||
e_widget_ilist_selected_get(cfdata->list));
|
||||
|
||||
eina_stringshare_replace(&cfdata->config.backend, new_backend);
|
||||
|
||||
_config_set(&cfdata->config);
|
||||
if (_config->cb)
|
||||
_config->cb(new_backend, (void *)_config->userdata);
|
||||
return 1;
|
||||
}
|
||||
|
||||
E_Config_Dialog*
|
||||
emix_config_popup_new(Evas_Object *comp, const char *p EINA_UNUSED)
|
||||
{
|
||||
E_Config_Dialog *cfd;
|
||||
E_Config_Dialog_View *v;
|
||||
|
||||
if (e_config_dialog_find("E", "windows/emix"))
|
||||
return NULL;
|
||||
|
||||
v = E_NEW(E_Config_Dialog_View, 1);
|
||||
v->create_cfdata = _create_data;
|
||||
v->free_cfdata = _free_data;
|
||||
v->basic.apply_cfdata = _basic_apply_data;
|
||||
v->basic.create_widgets = _basic_create_widgets;
|
||||
|
||||
cfd = e_config_dialog_new(comp,
|
||||
"Emix Configuration",
|
||||
"E", "windows/emix",
|
||||
NULL,
|
||||
0, v, NULL);
|
||||
return cfd;
|
||||
}
|
|
@ -0,0 +1,18 @@
|
|||
#ifndef E_MOD_CONFIG_H
|
||||
#define E_MOD_CONFIG_H
|
||||
|
||||
#include <e.h>
|
||||
|
||||
typedef void (*emix_config_backend_changed)(const char *backend, void *data);
|
||||
typedef void (*emix_config_meter_changed)(Eina_Bool enable, void *data);
|
||||
|
||||
void emix_config_init(emix_config_backend_changed cb, const void *userdata);
|
||||
void emix_config_shutdown(void);
|
||||
const char *emix_config_backend_get(void);
|
||||
void emix_config_backend_set(const char *backend);
|
||||
Eina_Bool emix_config_desklock_mute_get(void);
|
||||
Eina_Bool emix_config_meter_get(void);
|
||||
Eina_Bool emix_config_notify_get(void);
|
||||
E_Config_Dialog* emix_config_popup_new(Evas_Object *comp, const char*p);
|
||||
|
||||
#endif
|
|
@ -0,0 +1,817 @@
|
|||
#include <e.h>
|
||||
#include <Eina.h>
|
||||
#include "emix.h"
|
||||
#include "e_mod_main.h"
|
||||
#include "e_mod_config.h"
|
||||
|
||||
#define VOLUME_STEP 5
|
||||
|
||||
int _e_emix_log_domain;
|
||||
|
||||
/* module requirements */
|
||||
E_API E_Module_Api e_modapi =
|
||||
{
|
||||
E_MODULE_API_VERSION,
|
||||
"Mixer"
|
||||
};
|
||||
|
||||
/* necessary forward delcaration */
|
||||
static E_Gadcon_Client *_gc_init(E_Gadcon *gc, const char *name,
|
||||
const char *id, const char *style);
|
||||
static void _gc_shutdown(E_Gadcon_Client *gcc);
|
||||
static void _gc_orient(E_Gadcon_Client *gcc,
|
||||
E_Gadcon_Orient orient);
|
||||
static const char *_gc_label(const E_Gadcon_Client_Class *client_class);
|
||||
static Evas_Object *_gc_icon(const E_Gadcon_Client_Class *client_class,
|
||||
Evas *evas);
|
||||
static const char *_gc_id_new(const E_Gadcon_Client_Class *client_class);
|
||||
|
||||
static const E_Gadcon_Client_Class _gadcon_class =
|
||||
{
|
||||
GADCON_CLIENT_CLASS_VERSION,
|
||||
"emix",
|
||||
{
|
||||
_gc_init, _gc_shutdown,
|
||||
_gc_orient, _gc_label, _gc_icon, _gc_id_new, NULL,
|
||||
e_gadcon_site_is_not_toolbar
|
||||
},
|
||||
E_GADCON_CLIENT_STYLE_PLAIN
|
||||
};
|
||||
|
||||
typedef struct _Context Context;
|
||||
struct _Context
|
||||
{
|
||||
char *theme;
|
||||
Ecore_Exe *emixer;
|
||||
Ecore_Event_Handler *desklock_handler;
|
||||
Ecore_Event_Handler *emix_event_handler;
|
||||
const Emix_Sink *sink_default;
|
||||
E_Module *module;
|
||||
Eina_List *instances;
|
||||
E_Menu *menu;
|
||||
unsigned int notification_id;
|
||||
|
||||
struct {
|
||||
E_Action *incr;
|
||||
E_Action *decr;
|
||||
E_Action *mute;
|
||||
} actions;
|
||||
};
|
||||
|
||||
typedef struct _Instance Instance;
|
||||
struct _Instance
|
||||
{
|
||||
E_Gadcon_Client *gcc;
|
||||
E_Gadcon_Orient orient;
|
||||
|
||||
E_Gadcon_Popup *popup;
|
||||
Evas *evas;
|
||||
Evas_Object *gadget;
|
||||
Evas_Object *list;
|
||||
Evas_Object *slider;
|
||||
Evas_Object *check;
|
||||
|
||||
Eina_Bool mute;
|
||||
};
|
||||
|
||||
static Context *mixer_context = NULL;
|
||||
|
||||
static void
|
||||
_notify_cb(void *data EINA_UNUSED, unsigned int id)
|
||||
{
|
||||
mixer_context->notification_id = id;
|
||||
}
|
||||
|
||||
static void
|
||||
_notify(const int val)
|
||||
{
|
||||
E_Notification_Notify n;
|
||||
char *icon, buf[56];
|
||||
int ret;
|
||||
|
||||
if (!emix_config_notify_get())
|
||||
return;
|
||||
|
||||
memset(&n, 0, sizeof(E_Notification_Notify));
|
||||
if (val > EMIX_VOLUME_MAX || val < 0)
|
||||
return;
|
||||
|
||||
ret = snprintf(buf, (sizeof(buf) - 1), "%s: %d%%", _("New volume"), val);
|
||||
if ((ret < 0) || ((unsigned int)ret > sizeof(buf)))
|
||||
return;
|
||||
//Names are taken from FDO icon naming scheme
|
||||
if (val == 0)
|
||||
icon = "audio-volume-muted";
|
||||
else if ((val > 33) && (val < 66))
|
||||
icon = "audio-volume-medium";
|
||||
else if (val < 33)
|
||||
icon = "audio-volume-low";
|
||||
else
|
||||
icon = "audio-volume-high";
|
||||
|
||||
n.app_name = _("Emix");
|
||||
n.replaces_id = mixer_context->notification_id;
|
||||
n.icon.icon = icon;
|
||||
n.summary = _("Volume changed");
|
||||
n.body = buf;
|
||||
n.timeout = 2000;
|
||||
e_notification_client_send(&n, _notify_cb, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
_mixer_popup_update(Instance *inst, int mute, int vol)
|
||||
{
|
||||
elm_check_state_set(inst->check, !!mute);
|
||||
elm_slider_value_set(inst->slider, vol);
|
||||
}
|
||||
|
||||
static void _popup_del(Instance *inst);
|
||||
|
||||
static void
|
||||
_mixer_gadget_update(void)
|
||||
{
|
||||
Edje_Message_Int_Set *msg;
|
||||
Instance *inst;
|
||||
Eina_List *l;
|
||||
|
||||
EINA_LIST_FOREACH(mixer_context->instances, l, inst)
|
||||
{
|
||||
msg = alloca(sizeof(Edje_Message_Int_Set) + (2 * sizeof(int)));
|
||||
msg->count = 3;
|
||||
|
||||
if (!mixer_context->sink_default)
|
||||
{
|
||||
msg->val[0] = EINA_FALSE;
|
||||
msg->val[1] = 0;
|
||||
msg->val[2] = 0;
|
||||
if (inst->popup)
|
||||
_popup_del(inst);
|
||||
}
|
||||
else
|
||||
{
|
||||
int vol = 0;
|
||||
unsigned int i = 0;
|
||||
for (i = 0; i <
|
||||
mixer_context->sink_default->volume.channel_count; i++)
|
||||
vol += mixer_context->sink_default->volume.volumes[i];
|
||||
if (mixer_context->sink_default->volume.channel_count)
|
||||
vol /= mixer_context->sink_default->volume.channel_count;
|
||||
msg->val[0] = mixer_context->sink_default->mute;
|
||||
msg->val[1] = vol;
|
||||
msg->val[2] = msg->val[1];
|
||||
if (inst->popup)
|
||||
_mixer_popup_update(inst, mixer_context->sink_default->mute,
|
||||
msg->val[1]);
|
||||
}
|
||||
edje_object_message_send(inst->gadget, EDJE_MESSAGE_INT_SET, 0, msg);
|
||||
edje_object_signal_emit(inst->gadget, "e,action,volume,change", "e");
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
_volume_increase_cb(E_Object *obj EINA_UNUSED, const char *params EINA_UNUSED)
|
||||
{
|
||||
unsigned int i;
|
||||
EINA_SAFETY_ON_NULL_RETURN(mixer_context->sink_default);
|
||||
Emix_Volume volume;
|
||||
|
||||
Emix_Sink *s = (Emix_Sink *)mixer_context->sink_default;
|
||||
volume.channel_count = s->volume.channel_count;
|
||||
volume.volumes = calloc(s->volume.channel_count, sizeof(int));
|
||||
for (i = 0; i < volume.channel_count; i++)
|
||||
{
|
||||
if (s->volume.volumes[i] < EMIX_VOLUME_MAX - VOLUME_STEP)
|
||||
volume.volumes[i] = s->volume.volumes[i] + VOLUME_STEP;
|
||||
else if (s->volume.volumes[i] < EMIX_VOLUME_MAX)
|
||||
volume.volumes[i] = EMIX_VOLUME_MAX;
|
||||
else
|
||||
volume.volumes[i] = s->volume.volumes[i];
|
||||
}
|
||||
|
||||
emix_sink_volume_set(s, volume);
|
||||
free(volume.volumes);
|
||||
}
|
||||
|
||||
static void
|
||||
_volume_decrease_cb(E_Object *obj EINA_UNUSED, const char *params EINA_UNUSED)
|
||||
{
|
||||
unsigned int i;
|
||||
EINA_SAFETY_ON_NULL_RETURN(mixer_context->sink_default);
|
||||
Emix_Volume volume;
|
||||
|
||||
Emix_Sink *s = (Emix_Sink *)mixer_context->sink_default;
|
||||
volume.channel_count = s->volume.channel_count;
|
||||
volume.volumes = calloc(s->volume.channel_count, sizeof(int));
|
||||
for (i = 0; i < volume.channel_count; i++)
|
||||
{
|
||||
if (s->volume.volumes[i] > VOLUME_STEP)
|
||||
volume.volumes[i] = s->volume.volumes[i] - VOLUME_STEP;
|
||||
else if (s->volume.volumes[i] < VOLUME_STEP)
|
||||
volume.volumes[i] = 0;
|
||||
else
|
||||
volume.volumes[i] = s->volume.volumes[i];
|
||||
}
|
||||
|
||||
emix_sink_volume_set(s, volume);
|
||||
free(volume.volumes);
|
||||
}
|
||||
|
||||
static void
|
||||
_volume_mute_cb(E_Object *obj EINA_UNUSED, const char *params EINA_UNUSED)
|
||||
{
|
||||
EINA_SAFETY_ON_NULL_RETURN(mixer_context->sink_default);
|
||||
|
||||
Emix_Sink *s = (Emix_Sink *)mixer_context->sink_default;
|
||||
Eina_Bool mute = !s->mute;
|
||||
emix_sink_mute_set(s, mute);
|
||||
}
|
||||
|
||||
static void
|
||||
_actions_register(void)
|
||||
{
|
||||
mixer_context->actions.incr = e_action_add("volume_increase");
|
||||
if (mixer_context->actions.incr)
|
||||
{
|
||||
mixer_context->actions.incr->func.go = _volume_increase_cb;
|
||||
e_action_predef_name_set("Mixer", _("Increase Volume"),
|
||||
"volume_increase", NULL, NULL, 0);
|
||||
}
|
||||
|
||||
mixer_context->actions.decr = e_action_add("volume_decrease");
|
||||
if (mixer_context->actions.decr)
|
||||
{
|
||||
mixer_context->actions.decr->func.go = _volume_decrease_cb;
|
||||
e_action_predef_name_set("Mixer", _("Decrease Volume"),
|
||||
"volume_decrease", NULL, NULL, 0);
|
||||
}
|
||||
|
||||
mixer_context->actions.mute = e_action_add("volume_mute");
|
||||
if (mixer_context->actions.mute)
|
||||
{
|
||||
mixer_context->actions.mute->func.go = _volume_mute_cb;
|
||||
e_action_predef_name_set("Mixer", _("Mute volume"), "volume_mute",
|
||||
NULL, NULL, 0);
|
||||
}
|
||||
|
||||
e_comp_canvas_keys_ungrab();
|
||||
e_comp_canvas_keys_grab();
|
||||
}
|
||||
|
||||
static void
|
||||
_actions_unregister(void)
|
||||
{
|
||||
if (mixer_context->actions.incr)
|
||||
{
|
||||
e_action_predef_name_del("Mixer", _("Increase Volume"));
|
||||
e_action_del("volume_increase");
|
||||
mixer_context->actions.incr = NULL;
|
||||
}
|
||||
|
||||
if (mixer_context->actions.decr)
|
||||
{
|
||||
e_action_predef_name_del("Mixer", _("Decrease Volume"));
|
||||
e_action_del("volume_decrease");
|
||||
mixer_context->actions.decr = NULL;
|
||||
}
|
||||
|
||||
if (mixer_context->actions.mute)
|
||||
{
|
||||
e_action_predef_name_del("Mixer", _("Mute Volume"));
|
||||
e_action_del("volume_mute");
|
||||
mixer_context->actions.mute = NULL;
|
||||
}
|
||||
|
||||
e_comp_canvas_keys_ungrab();
|
||||
e_comp_canvas_keys_grab();
|
||||
}
|
||||
|
||||
static void
|
||||
_popup_del(Instance *inst)
|
||||
{
|
||||
inst->slider = NULL;
|
||||
inst->check = NULL;
|
||||
E_FREE_FUNC(inst->popup, e_object_del);
|
||||
}
|
||||
|
||||
static void
|
||||
_popup_del_cb(void *obj)
|
||||
{
|
||||
_popup_del(e_object_data_get(obj));
|
||||
}
|
||||
|
||||
static void
|
||||
_popup_comp_del_cb(void *data, Evas_Object *obj EINA_UNUSED)
|
||||
{
|
||||
Instance *inst = data;
|
||||
|
||||
E_FREE_FUNC(inst->popup, e_object_del);
|
||||
}
|
||||
|
||||
static Eina_Bool
|
||||
_emixer_del_cb(void *data EINA_UNUSED, int type EINA_UNUSED,
|
||||
void *info EINA_UNUSED)
|
||||
{
|
||||
mixer_context->emixer = NULL;
|
||||
if (mixer_context->emix_event_handler)
|
||||
ecore_event_handler_del(mixer_context->emix_event_handler);
|
||||
|
||||
return EINA_TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
_emixer_exec_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
|
||||
{
|
||||
Instance *inst = data;
|
||||
char buf[PATH_MAX];
|
||||
|
||||
_popup_del(inst);
|
||||
if (mixer_context->emixer)
|
||||
return;
|
||||
|
||||
snprintf(buf, sizeof(buf), "%s/%s/emixer %s",
|
||||
e_module_dir_get(mixer_context->module),
|
||||
MODULE_ARCH, emix_config_backend_get());
|
||||
mixer_context->emixer = ecore_exe_run(buf, NULL);
|
||||
if (mixer_context->emix_event_handler)
|
||||
ecore_event_handler_del(mixer_context->emix_event_handler);
|
||||
mixer_context->emix_event_handler =
|
||||
ecore_event_handler_add(ECORE_EXE_EVENT_DEL, _emixer_del_cb, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
_check_changed_cb(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
|
||||
void *event EINA_UNUSED)
|
||||
{
|
||||
Emix_Sink *s = (Emix_Sink *)mixer_context->sink_default;
|
||||
emix_sink_mute_set(s, !s->mute);
|
||||
/*
|
||||
*TODO: is it really necessary ? or it will be update
|
||||
* with the sink changed hanlder
|
||||
*/
|
||||
_mixer_gadget_update();
|
||||
}
|
||||
|
||||
static void
|
||||
_slider_changed_cb(void *data EINA_UNUSED, Evas_Object *obj,
|
||||
void *event EINA_UNUSED)
|
||||
{
|
||||
int val;
|
||||
Emix_Volume v;
|
||||
unsigned int i;
|
||||
Emix_Sink *s = (Emix_Sink *)mixer_context->sink_default;
|
||||
|
||||
val = (int)elm_slider_value_get(obj);
|
||||
v.volumes = calloc(s->volume.channel_count, sizeof(int));
|
||||
v.channel_count = s->volume.channel_count;
|
||||
for (i = 0; i < s->volume.channel_count; i++)
|
||||
v.volumes[i] = val;
|
||||
|
||||
emix_sink_volume_set(s, v);
|
||||
}
|
||||
|
||||
static Evas_Object *
|
||||
_popup_add_slider(void)
|
||||
{
|
||||
unsigned int volume, i;
|
||||
unsigned int channels = mixer_context->sink_default->volume.channel_count;
|
||||
|
||||
Evas_Object *slider = elm_slider_add(e_comp->elm);
|
||||
evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
||||
evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, 0.0);
|
||||
|
||||
for (volume = 0, i = 0; i < channels; i++)
|
||||
volume += mixer_context->sink_default->volume.volumes[i];
|
||||
|
||||
if (channels)
|
||||
volume = volume / channels;
|
||||
|
||||
evas_object_show(slider);
|
||||
elm_slider_min_max_set(slider, 0.0, (double) EMIX_VOLUME_MAX);
|
||||
evas_object_smart_callback_add(slider, "changed", _slider_changed_cb,
|
||||
NULL);
|
||||
|
||||
elm_slider_value_set(slider, volume);
|
||||
return slider;
|
||||
}
|
||||
|
||||
static void
|
||||
_sink_selected_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
|
||||
{
|
||||
Emix_Sink *s = data;
|
||||
|
||||
mixer_context->sink_default = s;
|
||||
_mixer_gadget_update();
|
||||
}
|
||||
|
||||
static void
|
||||
_popup_new(Instance *inst)
|
||||
{
|
||||
Evas_Object *button, *list, *icon;
|
||||
Emix_Sink *s;
|
||||
Eina_List *l;
|
||||
|
||||
EINA_SAFETY_ON_NULL_RETURN(mixer_context->sink_default);
|
||||
|
||||
inst->popup = e_gadcon_popup_new(inst->gcc, 0);
|
||||
list = elm_box_add(e_comp->elm);
|
||||
|
||||
inst->list = elm_list_add(e_comp->elm);
|
||||
evas_object_size_hint_align_set(inst->list, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
||||
evas_object_size_hint_weight_set(inst->list, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
||||
evas_object_show(inst->list);
|
||||
|
||||
EINA_LIST_FOREACH((Eina_List *)emix_sinks_get(), l, s)
|
||||
{
|
||||
Elm_Object_Item *it;
|
||||
|
||||
it = elm_list_item_append(inst->list, s->name, NULL, NULL, _sink_selected_cb, s);
|
||||
if (mixer_context->sink_default == s)
|
||||
elm_list_item_selected_set(it, EINA_TRUE);
|
||||
}
|
||||
elm_box_pack_end(list, inst->list);
|
||||
|
||||
inst->slider = _popup_add_slider();
|
||||
elm_box_pack_end(list, inst->slider);
|
||||
evas_object_show(inst->slider);
|
||||
|
||||
inst->mute = (int) mixer_context->sink_default->mute;
|
||||
|
||||
inst->check = elm_check_add(e_comp->elm);
|
||||
elm_object_text_set(inst->check, _("Mute"));
|
||||
elm_check_state_pointer_set(inst->check, &(inst->mute));
|
||||
evas_object_smart_callback_add(inst->check, "changed", _check_changed_cb,
|
||||
NULL);
|
||||
elm_box_pack_end(list, inst->check);
|
||||
evas_object_show(inst->check);
|
||||
|
||||
icon = elm_icon_add(e_comp->elm);
|
||||
elm_icon_standard_set(icon, "preferences-system");
|
||||
|
||||
button = elm_button_add(e_comp->elm);
|
||||
evas_object_size_hint_align_set(button, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
||||
evas_object_size_hint_weight_set(button, EVAS_HINT_EXPAND, 0.0);
|
||||
elm_object_part_content_set(button, "icon", icon);
|
||||
evas_object_smart_callback_add(button, "clicked", _emixer_exec_cb, inst);
|
||||
elm_box_pack_end(list, button);
|
||||
evas_object_show(button);
|
||||
|
||||
evas_object_size_hint_min_set(list, 208, 208);
|
||||
|
||||
|
||||
e_gadcon_popup_content_set(inst->popup, list);
|
||||
e_comp_object_util_autoclose(inst->popup->comp_object,
|
||||
_popup_comp_del_cb, NULL, inst);
|
||||
e_gadcon_popup_show(inst->popup);
|
||||
e_object_data_set(E_OBJECT(inst->popup), inst);
|
||||
E_OBJECT_DEL_SET(inst->popup, _popup_del_cb);
|
||||
}
|
||||
|
||||
static void
|
||||
_menu_cb(void *data, E_Menu *menu EINA_UNUSED, E_Menu_Item *mi EINA_UNUSED)
|
||||
{
|
||||
_emixer_exec_cb(data, NULL, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
_settings_cb(void *data EINA_UNUSED, E_Menu *menu EINA_UNUSED,
|
||||
E_Menu_Item *mi EINA_UNUSED)
|
||||
{
|
||||
emix_config_popup_new(NULL, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
_menu_new(Instance *inst, Evas_Event_Mouse_Down *ev)
|
||||
{
|
||||
E_Zone *zone;
|
||||
E_Menu *m;
|
||||
E_Menu_Item *mi;
|
||||
int x, y;
|
||||
|
||||
zone = e_zone_current_get();
|
||||
|
||||
m = e_menu_new();
|
||||
|
||||
mi = e_menu_item_new(m);
|
||||
e_menu_item_label_set(mi, _("Advanced"));
|
||||
e_util_menu_item_theme_icon_set(mi, "configure");
|
||||
e_menu_item_callback_set(mi, _menu_cb, inst);
|
||||
|
||||
mi = e_menu_item_new(m);
|
||||
e_menu_item_label_set(mi, _("Settings"));
|
||||
e_util_menu_item_theme_icon_set(mi, "configure");
|
||||
e_menu_item_callback_set(mi, _settings_cb, inst);
|
||||
|
||||
m = e_gadcon_client_util_menu_items_append(inst->gcc, m, 0);
|
||||
|
||||
e_gadcon_canvas_zone_geometry_get(inst->gcc->gadcon, &x, &y, NULL, NULL);
|
||||
e_menu_activate_mouse(m, zone, x + ev->output.x, y + ev->output.y,
|
||||
1, 1, E_MENU_POP_DIRECTION_AUTO, ev->timestamp);
|
||||
evas_event_feed_mouse_up(inst->gcc->gadcon->evas, ev->button,
|
||||
EVAS_BUTTON_NONE, ev->timestamp, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
_mouse_down_cb(void *data, Evas *evas EINA_UNUSED,
|
||||
Evas_Object *obj EINA_UNUSED, void *event)
|
||||
{
|
||||
Instance *inst = data;
|
||||
Evas_Event_Mouse_Down *ev = event;
|
||||
|
||||
if (ev->button == 1)
|
||||
{
|
||||
if (!inst->popup)
|
||||
_popup_new(inst);
|
||||
}
|
||||
else if (ev->button == 2)
|
||||
{
|
||||
_volume_mute_cb(NULL, NULL);
|
||||
}
|
||||
else if (ev->button == 3)
|
||||
{
|
||||
_menu_new(inst, ev);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
_mouse_wheel_cb(void *data EINA_UNUSED, Evas *evas EINA_UNUSED,
|
||||
Evas_Object *obj EINA_UNUSED, void *event)
|
||||
{
|
||||
Evas_Event_Mouse_Wheel *ev = event;
|
||||
|
||||
if (ev->z > 0)
|
||||
_volume_decrease_cb(NULL, NULL);
|
||||
else if (ev->z < 0)
|
||||
_volume_increase_cb(NULL, NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Gadcon functions
|
||||
*/
|
||||
static E_Gadcon_Client *
|
||||
_gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style)
|
||||
{
|
||||
E_Gadcon_Client *gcc;
|
||||
Instance *inst;
|
||||
|
||||
inst = E_NEW(Instance, 1);
|
||||
|
||||
inst->gadget = edje_object_add(gc->evas);
|
||||
inst->evas = gc->evas;
|
||||
e_theme_edje_object_set(inst->gadget,
|
||||
"base/theme/modules/mixer",
|
||||
"e/modules/mixer/main");
|
||||
|
||||
gcc = e_gadcon_client_new(gc, name, id, style, inst->gadget);
|
||||
gcc->data = inst;
|
||||
inst->gcc = gcc;
|
||||
|
||||
evas_object_event_callback_add(inst->gadget, EVAS_CALLBACK_MOUSE_DOWN,
|
||||
_mouse_down_cb, inst);
|
||||
evas_object_event_callback_add(inst->gadget, EVAS_CALLBACK_MOUSE_WHEEL,
|
||||
_mouse_wheel_cb, inst);
|
||||
mixer_context->instances = eina_list_append(mixer_context->instances, inst);
|
||||
|
||||
if (mixer_context->sink_default)
|
||||
_mixer_gadget_update();
|
||||
|
||||
return gcc;
|
||||
}
|
||||
|
||||
static void
|
||||
_gc_shutdown(E_Gadcon_Client *gcc)
|
||||
{
|
||||
Instance *inst;
|
||||
|
||||
inst = gcc->data;
|
||||
evas_object_del(inst->gadget);
|
||||
mixer_context->instances = eina_list_remove(mixer_context->instances, inst);
|
||||
free(inst);
|
||||
}
|
||||
|
||||
static void
|
||||
_gc_orient(E_Gadcon_Client *gcc, E_Gadcon_Orient orient EINA_UNUSED)
|
||||
{
|
||||
e_gadcon_client_aspect_set(gcc, 16, 16);
|
||||
e_gadcon_client_min_size_set(gcc, 16, 16);
|
||||
}
|
||||
|
||||
static const char *
|
||||
_gc_label(const E_Gadcon_Client_Class *client_class EINA_UNUSED)
|
||||
{
|
||||
return "Mixer";
|
||||
}
|
||||
|
||||
static Evas_Object *
|
||||
_gc_icon(const E_Gadcon_Client_Class *client_class EINA_UNUSED, Evas *evas)
|
||||
{
|
||||
Evas_Object *o;
|
||||
char buf[4096] = { 0 };
|
||||
|
||||
o = edje_object_add(evas);
|
||||
snprintf(buf, sizeof(buf), "%s/e-module-mixer.edj",
|
||||
e_module_dir_get(mixer_context->module));
|
||||
edje_object_file_set(o, buf, "icon");
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
static const char *
|
||||
_gc_id_new(const E_Gadcon_Client_Class *client_class EINA_UNUSED)
|
||||
{
|
||||
return _gadcon_class.name;
|
||||
}
|
||||
|
||||
static void
|
||||
_sink_event(int type, void *info)
|
||||
{
|
||||
Emix_Sink *sink = info;
|
||||
const Eina_List *l;
|
||||
|
||||
if (type == EMIX_SINK_REMOVED_EVENT)
|
||||
{
|
||||
if (sink == mixer_context->sink_default)
|
||||
{
|
||||
l = emix_sinks_get();
|
||||
mixer_context->sink_default = l->data;
|
||||
_mixer_gadget_update();
|
||||
}
|
||||
}
|
||||
else if (type == EMIX_SINK_CHANGED_EVENT)
|
||||
{
|
||||
if (mixer_context->sink_default == sink)
|
||||
{
|
||||
_mixer_gadget_update();
|
||||
_notify(sink->mute ? 0 : sink->volume.volumes[0]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
DBG("Sink added");
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
_disconnected(void)
|
||||
{
|
||||
if (mixer_context) mixer_context->sink_default = NULL;
|
||||
_mixer_gadget_update();
|
||||
}
|
||||
|
||||
static void
|
||||
_ready(void)
|
||||
{
|
||||
if (emix_sink_default_support())
|
||||
mixer_context->sink_default = emix_sink_default_get();
|
||||
else
|
||||
mixer_context->sink_default = emix_sinks_get()->data;
|
||||
|
||||
_mixer_gadget_update();
|
||||
}
|
||||
|
||||
static void
|
||||
_events_cb(void *data EINA_UNUSED, enum Emix_Event type, void *event_info)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case EMIX_SINK_ADDED_EVENT:
|
||||
case EMIX_SINK_CHANGED_EVENT:
|
||||
case EMIX_SINK_REMOVED_EVENT:
|
||||
_sink_event(type, event_info);
|
||||
break;
|
||||
case EMIX_DISCONNECTED_EVENT:
|
||||
_disconnected();
|
||||
break;
|
||||
case EMIX_READY_EVENT:
|
||||
_ready();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static Eina_Bool
|
||||
_desklock_cb(void *data EINA_UNUSED, int type EINA_UNUSED, void *info)
|
||||
{
|
||||
E_Event_Desklock *ev = info;
|
||||
static Eina_Bool _was_mute = EINA_FALSE;
|
||||
|
||||
if (emix_config_desklock_mute_get() == EINA_FALSE)
|
||||
return ECORE_CALLBACK_PASS_ON;
|
||||
|
||||
if (ev->on)
|
||||
{
|
||||
_was_mute = mixer_context->sink_default->mute;
|
||||
if (!_was_mute)
|
||||
emix_sink_mute_set((Emix_Sink *)mixer_context->sink_default, EINA_TRUE);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!_was_mute)
|
||||
emix_sink_mute_set((Emix_Sink *)mixer_context->sink_default, EINA_FALSE);
|
||||
}
|
||||
|
||||
return ECORE_CALLBACK_PASS_ON;
|
||||
}
|
||||
|
||||
static void
|
||||
_backend_changed(const char *backend, void *data EINA_UNUSED)
|
||||
{
|
||||
_disconnected();
|
||||
|
||||
if (emix_backend_set(backend) == EINA_FALSE)
|
||||
ERR("Could not load backend: %s", backend);
|
||||
}
|
||||
|
||||
E_API void *
|
||||
e_modapi_init(E_Module *m)
|
||||
{
|
||||
Eina_List *l;
|
||||
char buf[4096];
|
||||
const char *backend;
|
||||
Eina_Bool backend_loaded = EINA_FALSE;
|
||||
|
||||
_e_emix_log_domain = eina_log_domain_register("mixer", EINA_COLOR_RED);
|
||||
|
||||
if (!mixer_context)
|
||||
{
|
||||
mixer_context = E_NEW(Context, 1);
|
||||
|
||||
mixer_context->desklock_handler =
|
||||
ecore_event_handler_add(E_EVENT_DESKLOCK, _desklock_cb, NULL);
|
||||
mixer_context->module = m;
|
||||
snprintf(buf, sizeof(buf), "%s/mixer.edj",
|
||||
e_module_dir_get(mixer_context->module));
|
||||
mixer_context->theme = strdup(buf);
|
||||
}
|
||||
|
||||
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL(emix_init(), NULL);
|
||||
emix_config_init(_backend_changed, NULL);
|
||||
emix_event_callback_add(_events_cb, NULL);
|
||||
|
||||
backend = emix_config_backend_get();
|
||||
if (backend && emix_backend_set(backend))
|
||||
backend_loaded = EINA_TRUE;
|
||||
else
|
||||
{
|
||||
if (backend)
|
||||
WRN("Could not load %s, trying another one ...", backend);
|
||||
EINA_LIST_FOREACH((Eina_List *)emix_backends_available(), l,
|
||||
backend)
|
||||
{
|
||||
if (emix_backend_set(backend) == EINA_TRUE)
|
||||
{
|
||||
DBG("Loaded backend: %s!", backend);
|
||||
backend_loaded = EINA_TRUE;
|
||||
emix_config_backend_set(backend);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!backend_loaded) goto err;
|
||||
|
||||
e_configure_registry_category_add("extensions", 90, _("Extensions"), NULL,
|
||||
"preferences-extensions");
|
||||
e_configure_registry_item_add("extensions/emix", 30, _("Mixer"), NULL,
|
||||
"preferences-desktop-mixer",
|
||||
emix_config_popup_new);
|
||||
|
||||
if (emix_sink_default_support())
|
||||
mixer_context->sink_default = emix_sink_default_get();
|
||||
|
||||
e_gadcon_provider_register(&_gadcon_class);
|
||||
_actions_register();
|
||||
|
||||
return m;
|
||||
|
||||
err:
|
||||
emix_config_shutdown();
|
||||
emix_shutdown();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
E_API int
|
||||
e_modapi_shutdown(E_Module *m EINA_UNUSED)
|
||||
{
|
||||
_actions_unregister();
|
||||
e_gadcon_provider_unregister((const E_Gadcon_Client_Class *)&_gadcon_class);
|
||||
|
||||
if (mixer_context)
|
||||
{
|
||||
free(mixer_context->theme);
|
||||
E_FREE(mixer_context);
|
||||
}
|
||||
|
||||
emix_event_callback_del(_events_cb);
|
||||
emix_shutdown();
|
||||
emix_config_shutdown();
|
||||
return 1;
|
||||
}
|
||||
|
||||
E_API int
|
||||
e_modapi_save(E_Module *m EINA_UNUSED)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#ifndef _E_MOD_MAIN_H_
|
||||
#define _E_MOD_MAIN_H_
|
||||
|
||||
#define CONFIG_VERSION 1
|
||||
|
||||
extern int _e_emix_log_domain;
|
||||
|
||||
#undef DBG
|
||||
#undef INF
|
||||
#undef WRN
|
||||
#undef ERR
|
||||
#undef CRIT
|
||||
#define DBG(...) EINA_LOG_DOM_DBG(_e_emix_log_domain, __VA_ARGS__)
|
||||
#define INF(...) EINA_LOG_DOM_INF(_e_emix_log_domain, __VA_ARGS__)
|
||||
#define WRN(...) EINA_LOG_DOM_WARN(_e_emix_log_domain, __VA_ARGS__)
|
||||
#define ERR(...) EINA_LOG_DOM_ERR(_e_emix_log_domain, __VA_ARGS__)
|
||||
#define CRIT(...) EINA_LOG_DOM_CRIT(_e_emix_log_domain, __VA_ARGS__)
|
||||
|
||||
E_API extern E_Module_Api e_modapi;
|
||||
|
||||
E_API void *e_modapi_init(E_Module *m);
|
||||
E_API int e_modapi_shutdown(E_Module *m);
|
||||
E_API int e_modapi_save(E_Module *m);
|
||||
|
||||
#endif /* _E_MOD_MAIN_H_ */
|
|
@ -0,0 +1,727 @@
|
|||
#include <Elementary.h>
|
||||
#include "emix.h"
|
||||
|
||||
Evas_Object *win;
|
||||
Evas_Object *source_scroller, *sink_input_scroller, *sink_scroller;
|
||||
Evas_Object *source_box, *sink_input_box, *sink_box;
|
||||
|
||||
Eina_List *source_list = NULL, *sink_input_list = NULL, *sink_list = NULL;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static Eina_Bool
|
||||
_backend_init(const char *back)
|
||||
{
|
||||
const Eina_List *l;
|
||||
const char *name;
|
||||
|
||||
if (!back) back = "PULSEAUDIO";
|
||||
if (emix_backend_set(back)) return EINA_TRUE;
|
||||
EINA_LIST_FOREACH(emix_backends_available(), l, name)
|
||||
{
|
||||
if (emix_backend_set(name)) return EINA_TRUE;
|
||||
}
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#define VOLSET(vol, srcvol, target, func) \
|
||||
do { \
|
||||
Emix_Volume _v; \
|
||||
_v.channel_count = srcvol.channel_count; \
|
||||
_v.volumes = calloc(srcvol.channel_count, sizeof(int)); \
|
||||
if (_v.volumes) { \
|
||||
unsigned int _i; \
|
||||
for (_i = 0; _i < _v.channel_count; _i++) _v.volumes[_i] = vol; \
|
||||
func(target, _v); \
|
||||
free(_v.volumes); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
static void
|
||||
_cb_sink_port_change(void *data,
|
||||
Evas_Object *obj,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
Emix_Port *port = data;
|
||||
Evas_Object *bxv = evas_object_data_get(obj, "parent");
|
||||
Emix_Sink *sink = evas_object_data_get(bxv, "sink");
|
||||
elm_object_text_set(obj, port->description);
|
||||
emix_sink_port_set(sink, port);
|
||||
}
|
||||
|
||||
static void
|
||||
_cb_sink_volume_change(void *data,
|
||||
Evas_Object *obj,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
Evas_Object *bxv = data;
|
||||
Emix_Sink *sink = evas_object_data_get(bxv, "sink");
|
||||
double vol = elm_slider_value_get(obj);
|
||||
VOLSET(vol, sink->volume, sink, emix_sink_volume_set);
|
||||
}
|
||||
|
||||
static void
|
||||
_cb_sink_mute_change(void *data,
|
||||
Evas_Object *obj,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
Evas_Object *bxv = data;
|
||||
Emix_Sink *sink = evas_object_data_get(bxv, "sink");
|
||||
Evas_Object *sl = evas_object_data_get(bxv, "volume");
|
||||
Eina_Bool mute = elm_check_state_get(obj);
|
||||
elm_object_disabled_set(sl, mute);
|
||||
emix_sink_mute_set(sink, mute);
|
||||
}
|
||||
|
||||
static void
|
||||
_emix_sink_add(Emix_Sink *sink)
|
||||
{
|
||||
Evas_Object *bxv, *bx, *lb, *ck, *sl, *hv, *sep;
|
||||
const Eina_List *l;
|
||||
Emix_Port *port;
|
||||
|
||||
bxv = elm_box_add(win);
|
||||
sink_list = eina_list_append(sink_list, bxv);
|
||||
evas_object_data_set(bxv, "sink", sink);
|
||||
evas_object_size_hint_weight_set(bxv, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bxv, EVAS_HINT_FILL, 0.0);
|
||||
|
||||
bx = elm_box_add(win);
|
||||
elm_box_horizontal_set(bx, EINA_TRUE);
|
||||
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.0);
|
||||
elm_box_pack_end(bxv, bx);
|
||||
evas_object_show(bx);
|
||||
|
||||
lb = elm_label_add(win);
|
||||
elm_object_text_set(lb, sink->name);
|
||||
evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, 0.5);
|
||||
evas_object_size_hint_align_set(lb, 0.0, 0.5);
|
||||
elm_box_pack_end(bx, lb);
|
||||
evas_object_show(lb);
|
||||
|
||||
hv = elm_hoversel_add(win);
|
||||
evas_object_data_set(hv, "parent", bxv);
|
||||
evas_object_data_set(bxv, "port", hv);
|
||||
elm_hoversel_hover_parent_set(hv, win);
|
||||
EINA_LIST_FOREACH(sink->ports, l, port)
|
||||
{
|
||||
elm_hoversel_item_add(hv, port->description,
|
||||
NULL, ELM_ICON_NONE,
|
||||
_cb_sink_port_change, port);
|
||||
if (port->active) elm_object_text_set(hv, port->description);
|
||||
}
|
||||
evas_object_size_hint_weight_set(hv, 0.0, 0.5);
|
||||
evas_object_size_hint_align_set(hv, EVAS_HINT_FILL, 0.5);
|
||||
elm_box_pack_end(bx, hv);
|
||||
evas_object_show(hv);
|
||||
|
||||
bx = elm_box_add(win);
|
||||
elm_box_horizontal_set(bx, EINA_TRUE);
|
||||
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.0);
|
||||
elm_box_pack_end(bxv, bx);
|
||||
evas_object_show(bx);
|
||||
|
||||
sl = elm_slider_add(win);
|
||||
evas_object_data_set(bxv, "volume", sl);
|
||||
elm_slider_min_max_set(sl, 0.0, 100.0);
|
||||
elm_slider_span_size_set(sl, 100 * elm_config_scale_get());
|
||||
elm_slider_unit_format_set(sl, "%1.0f");
|
||||
elm_slider_indicator_format_set(sl, "%1.0f");
|
||||
evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.5);
|
||||
evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
|
||||
elm_slider_value_set(sl, sink->volume.volumes[0]);
|
||||
elm_box_pack_end(bx, sl);
|
||||
evas_object_show(sl);
|
||||
evas_object_smart_callback_add(sl, "changed", _cb_sink_volume_change, bxv);
|
||||
|
||||
ck = elm_check_add(win);
|
||||
evas_object_data_set(bxv, "mute", ck);
|
||||
elm_object_text_set(ck, "Mute");
|
||||
elm_check_state_set(ck, sink->mute);
|
||||
elm_object_disabled_set(sl, sink->mute);
|
||||
elm_box_pack_end(bx, ck);
|
||||
evas_object_show(ck);
|
||||
evas_object_smart_callback_add(ck, "changed", _cb_sink_mute_change, bxv);
|
||||
|
||||
sep = elm_separator_add(win);
|
||||
elm_separator_horizontal_set(sep, EINA_TRUE);
|
||||
evas_object_size_hint_weight_set(sep, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(sep, EVAS_HINT_FILL, 0.0);
|
||||
elm_box_pack_end(bxv, sep);
|
||||
evas_object_show(sep);
|
||||
|
||||
elm_box_pack_end(sink_box, bxv);
|
||||
evas_object_show(bxv);
|
||||
}
|
||||
|
||||
static void
|
||||
_emix_sink_del(Emix_Sink *sink)
|
||||
{
|
||||
Eina_List *l;
|
||||
Evas_Object *bxv;
|
||||
EINA_LIST_FOREACH(sink_list, l, bxv)
|
||||
{
|
||||
if (evas_object_data_get(bxv, "sink") == sink)
|
||||
{
|
||||
sink_list = eina_list_remove_list(sink_list, l);
|
||||
evas_object_del(bxv);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
_emix_sink_change(Emix_Sink *sink)
|
||||
{
|
||||
const Eina_List *l;
|
||||
Evas_Object *bxv, *hv, *ck, *sl;
|
||||
Emix_Port *port;
|
||||
|
||||
EINA_LIST_FOREACH(sink_list, l, bxv)
|
||||
{
|
||||
if (evas_object_data_get(bxv, "sink") == sink) break;
|
||||
}
|
||||
if (!l) return;
|
||||
hv = evas_object_data_get(bxv, "port");
|
||||
elm_hoversel_clear(hv);
|
||||
EINA_LIST_FOREACH(sink->ports, l, port)
|
||||
{
|
||||
elm_hoversel_item_add(hv, port->description,
|
||||
NULL, ELM_ICON_NONE,
|
||||
_cb_sink_port_change, port);
|
||||
if (port->active) elm_object_text_set(hv, port->description);
|
||||
}
|
||||
sl = evas_object_data_get(bxv, "volume");
|
||||
elm_slider_value_set(sl, sink->volume.volumes[0]);
|
||||
|
||||
ck = evas_object_data_get(bxv, "mute");
|
||||
elm_check_state_set(ck, sink->mute);
|
||||
elm_object_disabled_set(sl, sink->mute);
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static void
|
||||
_cb_sink_input_port_change(void *data,
|
||||
Evas_Object *obj,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
Emix_Sink *sink = data;
|
||||
Evas_Object *bxv = evas_object_data_get(obj, "parent");
|
||||
Emix_Sink_Input *input = evas_object_data_get(bxv, "input");
|
||||
elm_object_text_set(obj, sink->name);
|
||||
emix_sink_input_sink_change(input, sink);
|
||||
}
|
||||
|
||||
static void
|
||||
_cb_sink_input_volume_change(void *data,
|
||||
Evas_Object *obj,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
Evas_Object *bxv = data;
|
||||
Emix_Sink_Input *input = evas_object_data_get(bxv, "input");
|
||||
double vol = elm_slider_value_get(obj);
|
||||
VOLSET(vol, input->volume, input, emix_sink_input_volume_set);
|
||||
}
|
||||
|
||||
static void
|
||||
_cb_sink_input_mute_change(void *data,
|
||||
Evas_Object *obj,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
Evas_Object *bxv = data;
|
||||
Emix_Sink_Input *input = evas_object_data_get(bxv, "input");
|
||||
Evas_Object *sl = evas_object_data_get(bxv, "volume");
|
||||
Eina_Bool mute = elm_check_state_get(obj);
|
||||
elm_object_disabled_set(sl, mute);
|
||||
emix_sink_input_mute_set(input, mute);
|
||||
}
|
||||
|
||||
static void
|
||||
_emix_sink_input_add(Emix_Sink_Input *input)
|
||||
{
|
||||
Evas_Object *bxv, *bx, *lb, *ck, *sl, *hv, *sep;
|
||||
const Eina_List *l;
|
||||
Emix_Sink *sink;
|
||||
|
||||
bxv = elm_box_add(win);
|
||||
sink_input_list = eina_list_append(sink_input_list, bxv);
|
||||
evas_object_data_set(bxv, "input", input);
|
||||
evas_object_size_hint_weight_set(bxv, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bxv, EVAS_HINT_FILL, 0.0);
|
||||
|
||||
bx = elm_box_add(win);
|
||||
elm_box_horizontal_set(bx, EINA_TRUE);
|
||||
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.0);
|
||||
elm_box_pack_end(bxv, bx);
|
||||
evas_object_show(bx);
|
||||
|
||||
lb = elm_label_add(win);
|
||||
elm_object_text_set(lb, input->name);
|
||||
evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, 0.5);
|
||||
evas_object_size_hint_align_set(lb, 0.0, 0.5);
|
||||
elm_box_pack_end(bx, lb);
|
||||
evas_object_show(lb);
|
||||
|
||||
hv = elm_hoversel_add(win);
|
||||
evas_object_data_set(hv, "parent", bxv);
|
||||
evas_object_data_set(bxv, "port", hv);
|
||||
elm_hoversel_hover_parent_set(hv, win);
|
||||
EINA_LIST_FOREACH(emix_sinks_get(), l, sink)
|
||||
{
|
||||
elm_hoversel_item_add(hv, sink->name,
|
||||
NULL, ELM_ICON_NONE,
|
||||
_cb_sink_input_port_change, sink);
|
||||
if (input->sink == sink) elm_object_text_set(hv, sink->name);
|
||||
}
|
||||
evas_object_size_hint_weight_set(hv, 0.0, 0.5);
|
||||
evas_object_size_hint_align_set(hv, EVAS_HINT_FILL, 0.5);
|
||||
elm_box_pack_end(bx, hv);
|
||||
evas_object_show(hv);
|
||||
|
||||
bx = elm_box_add(win);
|
||||
elm_box_horizontal_set(bx, EINA_TRUE);
|
||||
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.0);
|
||||
elm_box_pack_end(bxv, bx);
|
||||
evas_object_show(bx);
|
||||
|
||||
sl = elm_slider_add(win);
|
||||
evas_object_data_set(bxv, "volume", sl);
|
||||
elm_slider_min_max_set(sl, 0.0, 100.0);
|
||||
elm_slider_span_size_set(sl, 100 * elm_config_scale_get());
|
||||
elm_slider_unit_format_set(sl, "%1.0f");
|
||||
elm_slider_indicator_format_set(sl, "%1.0f");
|
||||
evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.5);
|
||||
evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
|
||||
elm_slider_value_set(sl, input->volume.volumes[0]);
|
||||
elm_box_pack_end(bx, sl);
|
||||
evas_object_show(sl);
|
||||
evas_object_smart_callback_add(sl, "changed",
|
||||
_cb_sink_input_volume_change, bxv);
|
||||
|
||||
ck = elm_check_add(win);
|
||||
evas_object_data_set(bxv, "mute", ck);
|
||||
elm_object_text_set(ck, "Mute");
|
||||
elm_check_state_set(ck, input->mute);
|
||||
elm_object_disabled_set(sl, input->mute);
|
||||
elm_box_pack_end(bx, ck);
|
||||
evas_object_show(ck);
|
||||
evas_object_smart_callback_add(ck, "changed",
|
||||
_cb_sink_input_mute_change, bxv);
|
||||
|
||||
sep = elm_separator_add(win);
|
||||
elm_separator_horizontal_set(sep, EINA_TRUE);
|
||||
evas_object_size_hint_weight_set(sep, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(sep, EVAS_HINT_FILL, 0.0);
|
||||
elm_box_pack_end(bxv, sep);
|
||||
evas_object_show(sep);
|
||||
|
||||
elm_box_pack_end(sink_input_box, bxv);
|
||||
evas_object_show(bxv);
|
||||
}
|
||||
|
||||
static void
|
||||
_emix_sink_input_del(Emix_Sink_Input *input)
|
||||
{
|
||||
Eina_List *l;
|
||||
Evas_Object *bxv;
|
||||
EINA_LIST_FOREACH(sink_input_list, l, bxv)
|
||||
{
|
||||
if (evas_object_data_get(bxv, "input") == input)
|
||||
{
|
||||
sink_input_list = eina_list_remove_list(sink_input_list, l);
|
||||
evas_object_del(bxv);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
_emix_sink_input_change(Emix_Sink_Input *input)
|
||||
{
|
||||
const Eina_List *l;
|
||||
Evas_Object *bxv, *hv, *ck, *sl;
|
||||
Emix_Sink *sink;
|
||||
|
||||
EINA_LIST_FOREACH(sink_input_list, l, bxv)
|
||||
{
|
||||
if (evas_object_data_get(bxv, "input") == input) break;
|
||||
}
|
||||
if (!l) return;
|
||||
hv = evas_object_data_get(bxv, "port");
|
||||
elm_hoversel_clear(hv);
|
||||
EINA_LIST_FOREACH(emix_sinks_get(), l, sink)
|
||||
{
|
||||
elm_hoversel_item_add(hv, sink->name,
|
||||
NULL, ELM_ICON_NONE,
|
||||
_cb_sink_input_port_change, sink);
|
||||
if (input->sink == sink) elm_object_text_set(hv, sink->name);
|
||||
}
|
||||
sl = evas_object_data_get(bxv, "volume");
|
||||
elm_slider_value_set(sl, input->volume.volumes[0]);
|
||||
|
||||
ck = evas_object_data_get(bxv, "mute");
|
||||
elm_check_state_set(ck, input->mute);
|
||||
elm_object_disabled_set(sl, input->mute);
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static void
|
||||
_cb_source_volume_change(void *data,
|
||||
Evas_Object *obj,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
Evas_Object *bxv = data;
|
||||
Emix_Source *source = evas_object_data_get(bxv, "source");
|
||||
double vol = elm_slider_value_get(obj);
|
||||
VOLSET(vol, source->volume, source, emix_source_volume_set);
|
||||
}
|
||||
|
||||
static void
|
||||
_cb_source_mute_change(void *data,
|
||||
Evas_Object *obj,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
Evas_Object *bxv = data;
|
||||
Emix_Source *source = evas_object_data_get(bxv, "source");
|
||||
Evas_Object *sl = evas_object_data_get(bxv, "volume");
|
||||
Eina_Bool mute = elm_check_state_get(obj);
|
||||
elm_object_disabled_set(sl, mute);
|
||||
emix_source_mute_set(source, mute);
|
||||
}
|
||||
|
||||
static void
|
||||
_emix_source_add(Emix_Source *source)
|
||||
{
|
||||
Evas_Object *bxv, *bx, *lb, *ck, *sl, *sep;
|
||||
|
||||
bxv = elm_box_add(win);
|
||||
source_list = eina_list_append(source_list, bxv);
|
||||
evas_object_data_set(bxv, "source", source);
|
||||
evas_object_size_hint_weight_set(bxv, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bxv, EVAS_HINT_FILL, 0.0);
|
||||
|
||||
bx = elm_box_add(win);
|
||||
elm_box_horizontal_set(bx, EINA_TRUE);
|
||||
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.0);
|
||||
elm_box_pack_end(bxv, bx);
|
||||
evas_object_show(bx);
|
||||
|
||||
lb = elm_label_add(win);
|
||||
elm_object_text_set(lb, source->name);
|
||||
evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, 0.5);
|
||||
evas_object_size_hint_align_set(lb, 0.0, 0.5);
|
||||
elm_box_pack_end(bx, lb);
|
||||
evas_object_show(lb);
|
||||
|
||||
bx = elm_box_add(win);
|
||||
elm_box_horizontal_set(bx, EINA_TRUE);
|
||||
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.0);
|
||||
elm_box_pack_end(bxv, bx);
|
||||
evas_object_show(bx);
|
||||
|
||||
sl = elm_slider_add(win);
|
||||
evas_object_data_set(bxv, "volume", sl);
|
||||
elm_slider_min_max_set(sl, 0.0, 100.0);
|
||||
elm_slider_span_size_set(sl, 100 * elm_config_scale_get());
|
||||
elm_slider_unit_format_set(sl, "%1.0f");
|
||||
elm_slider_indicator_format_set(sl, "%1.0f");
|
||||
evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.5);
|
||||
evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
|
||||
elm_slider_value_set(sl, source->volume.volumes[0]);
|
||||
elm_box_pack_end(bx, sl);
|
||||
evas_object_show(sl);
|
||||
evas_object_smart_callback_add(sl, "changed",
|
||||
_cb_source_volume_change, bxv);
|
||||
|
||||
ck = elm_check_add(win);
|
||||
evas_object_data_set(bxv, "mute", ck);
|
||||
elm_object_text_set(ck, "Mute");
|
||||
elm_check_state_set(ck, source->mute);
|
||||
elm_object_disabled_set(sl, source->mute);
|
||||
elm_box_pack_end(bx, ck);
|
||||
evas_object_show(ck);
|
||||
evas_object_smart_callback_add(ck, "changed",
|
||||
_cb_source_mute_change, bxv);
|
||||
|
||||
sep = elm_separator_add(win);
|
||||
elm_separator_horizontal_set(sep, EINA_TRUE);
|
||||
evas_object_size_hint_weight_set(sep, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(sep, EVAS_HINT_FILL, 0.0);
|
||||
elm_box_pack_end(bxv, sep);
|
||||
evas_object_show(sep);
|
||||
|
||||
elm_box_pack_end(source_box, bxv);
|
||||
evas_object_show(bxv);
|
||||
}
|
||||
|
||||
static void
|
||||
_emix_source_del(Emix_Source *source)
|
||||
{
|
||||
Eina_List *l;
|
||||
Evas_Object *bxv;
|
||||
EINA_LIST_FOREACH(source_list, l, bxv)
|
||||
{
|
||||
if (evas_object_data_get(bxv, "source") == source)
|
||||
{
|
||||
source_list = eina_list_remove_list(source_list, l);
|
||||
evas_object_del(bxv);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
_emix_source_change(Emix_Source *source)
|
||||
{
|
||||
const Eina_List *l;
|
||||
Evas_Object *bxv, *ck, *sl;
|
||||
|
||||
EINA_LIST_FOREACH(source_list, l, bxv)
|
||||
{
|
||||
if (evas_object_data_get(bxv, "source") == source) break;
|
||||
}
|
||||
if (!l) return;
|
||||
sl = evas_object_data_get(bxv, "volume");
|
||||
elm_slider_value_set(sl, source->volume.volumes[0]);
|
||||
|
||||
ck = evas_object_data_get(bxv, "mute");
|
||||
elm_check_state_set(ck, source->mute);
|
||||
elm_object_disabled_set(sl, source->mute);
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static void
|
||||
_cb_emix_event(void *data EINA_UNUSED, enum Emix_Event event, void *event_info)
|
||||
{
|
||||
switch (event)
|
||||
{
|
||||
case EMIX_READY_EVENT:
|
||||
break;
|
||||
case EMIX_DISCONNECTED_EVENT:
|
||||
elm_exit();
|
||||
break;
|
||||
case EMIX_SINK_ADDED_EVENT:
|
||||
_emix_sink_add(event_info);
|
||||
break;
|
||||
case EMIX_SINK_REMOVED_EVENT:
|
||||
_emix_sink_del(event_info);
|
||||
break;
|
||||
case EMIX_SINK_CHANGED_EVENT:
|
||||
_emix_sink_change(event_info);
|
||||
break;
|
||||
case EMIX_SINK_INPUT_ADDED_EVENT:
|
||||
_emix_sink_input_add(event_info);
|
||||
break;
|
||||
case EMIX_SINK_INPUT_REMOVED_EVENT:
|
||||
_emix_sink_input_del(event_info);
|
||||
break;
|
||||
case EMIX_SINK_INPUT_CHANGED_EVENT:
|
||||
_emix_sink_input_change(event_info);
|
||||
break;
|
||||
case EMIX_SOURCE_ADDED_EVENT:
|
||||
_emix_source_add(event_info);
|
||||
break;
|
||||
case EMIX_SOURCE_REMOVED_EVENT:
|
||||
_emix_source_del(event_info);
|
||||
break;
|
||||
case EMIX_SOURCE_CHANGED_EVENT:
|
||||
_emix_source_change(event_info);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static void
|
||||
_cb_playback(void *data EINA_UNUSED,
|
||||
Evas_Object *obj EINA_UNUSED,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
evas_object_hide(source_scroller);
|
||||
evas_object_show(sink_input_scroller);
|
||||
evas_object_hide(sink_scroller);
|
||||
}
|
||||
|
||||
static void
|
||||
_cb_outputs(void *data EINA_UNUSED,
|
||||
Evas_Object *obj EINA_UNUSED,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
evas_object_hide(source_scroller);
|
||||
evas_object_hide(sink_input_scroller);
|
||||
evas_object_show(sink_scroller);
|
||||
}
|
||||
|
||||
static void
|
||||
_cb_inputs(void *data EINA_UNUSED,
|
||||
Evas_Object *obj EINA_UNUSED,
|
||||
void *event_info EINA_UNUSED)
|
||||
{
|
||||
evas_object_show(source_scroller);
|
||||
evas_object_hide(sink_input_scroller);
|
||||
evas_object_hide(sink_scroller);
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static void
|
||||
_event_init(void)
|
||||
{
|
||||
emix_event_callback_add(_cb_emix_event, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
_fill_source(void)
|
||||
{
|
||||
const Eina_List *l;
|
||||
Emix_Source *source;
|
||||
|
||||
EINA_LIST_FOREACH(emix_sources_get(), l, source)
|
||||
{
|
||||
_emix_source_add(source);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
_fill_sink_input(void)
|
||||
{
|
||||
const Eina_List *l;
|
||||
Emix_Sink_Input *input;
|
||||
|
||||
EINA_LIST_FOREACH(emix_sink_inputs_get(), l, input)
|
||||
{
|
||||
_emix_sink_input_add(input);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
_fill_sink(void)
|
||||
{
|
||||
const Eina_List *l;
|
||||
Emix_Sink *sink;
|
||||
|
||||
EINA_LIST_FOREACH(emix_sinks_get(), l, sink)
|
||||
{
|
||||
_emix_sink_add(sink);
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
EAPI_MAIN int
|
||||
elm_main(int argc, char **argv)
|
||||
{
|
||||
Evas_Object *tb, *tbar, *sc, *rect, *bx;
|
||||
const char *back = NULL;
|
||||
|
||||
emix_init();
|
||||
if (argc > 1) back = argv[1];
|
||||
if (!_backend_init(back)) goto done;
|
||||
_event_init();
|
||||
|
||||
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
|
||||
|
||||
win = elm_win_util_standard_add("emix", "Mixer");
|
||||
elm_win_autodel_set(win, EINA_TRUE);
|
||||
|
||||
/*
|
||||
icon = evas_object_image_add(evas_object_evas_get(mw->win));
|
||||
snprintf(buf, sizeof(buf), "%s/icons/emixer.png",
|
||||
elm_app_data_dir_get());
|
||||
evas_object_image_file_set(icon, buf, NULL);
|
||||
elm_win_icon_object_set(mw->win, icon);
|
||||
elm_win_icon_name_set(mw->win, "emixer");
|
||||
*/
|
||||
|
||||
tb = elm_table_add(win);
|
||||
evas_object_size_hint_weight_set(tb, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
||||
elm_win_resize_object_add(win, tb);
|
||||
evas_object_show(tb);
|
||||
|
||||
tbar = elm_toolbar_add(win);
|
||||
elm_toolbar_select_mode_set(tbar, ELM_OBJECT_SELECT_MODE_ALWAYS);
|
||||
elm_toolbar_homogeneous_set(tbar, EINA_TRUE);
|
||||
evas_object_size_hint_weight_set(tbar, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(tbar, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
||||
|
||||
elm_toolbar_item_append(tbar, NULL, "Playback", _cb_playback, NULL);
|
||||
elm_toolbar_item_append(tbar, NULL, "Outputs", _cb_outputs, NULL);
|
||||
elm_toolbar_item_append(tbar, NULL, "Inputs", _cb_inputs, NULL);
|
||||
|
||||
elm_table_pack(tb, tbar, 0, 0, 1, 1);
|
||||
evas_object_show(tbar);
|
||||
|
||||
sc = elm_scroller_add(win);
|
||||
source_scroller = sc;
|
||||
evas_object_size_hint_weight_set(sc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
||||
evas_object_size_hint_align_set(sc, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
||||
elm_table_pack(tb, sc, 0, 1, 1, 1);
|
||||
|
||||
sc = elm_scroller_add(win);
|
||||
sink_input_scroller = sc;
|
||||
evas_object_size_hint_weight_set(sc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
||||
evas_object_size_hint_align_set(sc, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
||||
elm_table_pack(tb, sc, 0, 1, 1, 1);
|
||||
evas_object_show(sc);
|
||||
|
||||
sc = elm_scroller_add(win);
|
||||
sink_scroller = sc;
|
||||
evas_object_size_hint_weight_set(sc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
||||
evas_object_size_hint_align_set(sc, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
||||
elm_table_pack(tb, sc, 0, 1, 1, 1);
|
||||
|
||||
bx = elm_box_add(win);
|
||||
source_box = bx;
|
||||
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.0);
|
||||
elm_object_content_set(source_scroller, bx);
|
||||
evas_object_show(bx);
|
||||
|
||||
bx = elm_box_add(win);
|
||||
sink_input_box = bx;
|
||||
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.0);
|
||||
elm_object_content_set(sink_input_scroller, bx);
|
||||
evas_object_show(bx);
|
||||
|
||||
bx = elm_box_add(win);
|
||||
sink_box = bx;
|
||||
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
|
||||
evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.0);
|
||||
elm_object_content_set(sink_scroller, bx);
|
||||
evas_object_show(bx);
|
||||
|
||||
rect = evas_object_rectangle_add(evas_object_evas_get(win));
|
||||
evas_object_size_hint_weight_set(rect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
||||
evas_object_size_hint_align_set(rect, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
||||
evas_object_size_hint_min_set(rect,
|
||||
440 * elm_config_scale_get(),
|
||||
220 * elm_config_scale_get());
|
||||
elm_table_pack(tb, rect, 0, 1, 1, 1);
|
||||
|
||||
_fill_source();
|
||||
_fill_sink_input();
|
||||
_fill_sink();
|
||||
evas_object_show(win);
|
||||
|
||||
elm_run();
|
||||
done:
|
||||
emix_shutdown();
|
||||
return 0;
|
||||
}
|
||||
ELM_MAIN()
|
|
@ -0,0 +1,523 @@
|
|||
#include "emix.h"
|
||||
#include <alsa/asoundlib.h>
|
||||
|
||||
#define ERR(...) EINA_LOG_ERR(__VA_ARGS__)
|
||||
#define DBG(...) EINA_LOG_DBG(__VA_ARGS__)
|
||||
#define WRN(...) EINA_LOG_WARN(__VA_ARGS__)
|
||||
|
||||
typedef struct _Context
|
||||
{
|
||||
Emix_Event_Cb cb;
|
||||
const void *userdata;
|
||||
Eina_List *sinks;
|
||||
Eina_List *sources;
|
||||
Eina_List *cards;
|
||||
} Context;
|
||||
|
||||
static Context *ctx = NULL;
|
||||
|
||||
typedef struct _Alsa_Emix_Sink
|
||||
{
|
||||
Emix_Sink sink;
|
||||
const char *hw_name;
|
||||
Eina_List *channels;
|
||||
} Alsa_Emix_Sink;
|
||||
|
||||
typedef struct _Alsa_Emix_Source
|
||||
{
|
||||
Emix_Source source;
|
||||
const char *hw_name;
|
||||
Eina_List *channels;
|
||||
} Alsa_Emix_Source;
|
||||
/*
|
||||
* TODO problems:
|
||||
*
|
||||
* - mono stereo problem...
|
||||
*/
|
||||
|
||||
/*
|
||||
* util functions
|
||||
*/
|
||||
|
||||
static int
|
||||
_alsa_mixer_sink_changed_cb(snd_mixer_t *ctl, unsigned int mask EINA_UNUSED,
|
||||
snd_mixer_elem_t *elem EINA_UNUSED)
|
||||
{
|
||||
Alsa_Emix_Sink *sink = snd_mixer_get_callback_private(ctl);
|
||||
|
||||
if (ctx->cb)
|
||||
ctx->cb((void *)ctx->userdata, EMIX_SINK_CHANGED_EVENT,
|
||||
(Emix_Sink *)sink);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
_alsa_mixer_source_changed_cb(snd_mixer_t *ctl, unsigned int mask EINA_UNUSED,
|
||||
snd_mixer_elem_t *elem EINA_UNUSED)
|
||||
{
|
||||
Alsa_Emix_Source *source = snd_mixer_get_callback_private(ctl);
|
||||
|
||||
if (ctx->cb)
|
||||
ctx->cb((void *)ctx->userdata, EMIX_SOURCE_CHANGED_EVENT,
|
||||
(Emix_Source *)source);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_channel_volume_get(snd_mixer_elem_t *channel, int *v, Eina_Bool capture)
|
||||
{
|
||||
long int min, max, vol;
|
||||
int range, divide;
|
||||
|
||||
if (capture)
|
||||
snd_mixer_selem_get_capture_volume_range(channel, &min, &max);
|
||||
else
|
||||
snd_mixer_selem_get_playback_volume_range(channel, &min, &max);
|
||||
|
||||
divide = 100 + min;
|
||||
if (divide == 0)
|
||||
{
|
||||
divide = 1;
|
||||
min++;
|
||||
}
|
||||
|
||||
range = max - min;
|
||||
if (range < 1)
|
||||
return;
|
||||
|
||||
if (capture)
|
||||
snd_mixer_selem_get_capture_volume(channel, 0, &vol);
|
||||
else
|
||||
snd_mixer_selem_get_playback_volume(channel, 0, &vol);
|
||||
|
||||
*v = (((vol + min) * divide) - ((double) range / 2)) / range + 0.5;
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_channel_volume_set(snd_mixer_elem_t *channel, int v, Eina_Bool capture)
|
||||
{
|
||||
long int vol, min, max, divide, range;
|
||||
snd_mixer_selem_get_playback_volume_range(channel, &min, &max);
|
||||
|
||||
divide = 100 + min;
|
||||
range = max - min;
|
||||
if (range < 1)
|
||||
return;
|
||||
|
||||
vol = (((v * range) + (range / 2)) / divide) - min;
|
||||
if (!capture)
|
||||
snd_mixer_selem_set_playback_volume_all(channel, vol);
|
||||
else
|
||||
snd_mixer_selem_set_capture_volume_all(channel, vol);
|
||||
}
|
||||
|
||||
/*
|
||||
* This will append a new device to the cards and call the ecore event for
|
||||
* a new device!
|
||||
*/
|
||||
static snd_mixer_t *
|
||||
_alsa_card_create(char *addr)
|
||||
{
|
||||
snd_mixer_t *control;
|
||||
|
||||
if (snd_mixer_open(&control, 0) < 0)
|
||||
goto error_open;
|
||||
if (snd_mixer_attach(control, addr) < 0)
|
||||
goto error_load;
|
||||
if (snd_mixer_selem_register(control, NULL, NULL) < 0)
|
||||
goto error_load;
|
||||
if (snd_mixer_load(control))
|
||||
goto error_load;
|
||||
|
||||
return control;
|
||||
|
||||
error_load:
|
||||
snd_mixer_close(control);
|
||||
error_open:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_volume_create(Emix_Volume *volume, Eina_List *channels)
|
||||
{
|
||||
unsigned int i = 0, count = eina_list_count(channels);
|
||||
Eina_List *l;
|
||||
snd_mixer_elem_t *elem;
|
||||
|
||||
volume->channel_count = count;
|
||||
volume->volumes = calloc(count, sizeof(int));
|
||||
|
||||
EINA_LIST_FOREACH(channels, l, elem)
|
||||
{
|
||||
_alsa_channel_volume_get(elem, &(volume->volumes[i]), EINA_FALSE);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_sink_mute_get(Alsa_Emix_Sink *as)
|
||||
{
|
||||
int i = 0;
|
||||
snd_mixer_elem_t *elem;
|
||||
|
||||
elem = eina_list_data_get(as->channels);
|
||||
snd_mixer_selem_get_playback_switch(elem, 0, &i);
|
||||
as->sink.mute = !i;
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_sources_mute_get(Alsa_Emix_Source *as)
|
||||
{
|
||||
int i = 0;
|
||||
snd_mixer_elem_t *elem;
|
||||
|
||||
elem = eina_list_data_get(as->channels);
|
||||
snd_mixer_selem_get_capture_switch(elem, 0, &i);
|
||||
as->source.mute = !i;
|
||||
}
|
||||
|
||||
static Alsa_Emix_Sink*
|
||||
_alsa_device_sink_create(const char *name, const char* hw_name,
|
||||
Eina_List *channels)
|
||||
{
|
||||
Alsa_Emix_Sink *sink;
|
||||
|
||||
if (!(sink = calloc(1, sizeof(Alsa_Emix_Sink))))
|
||||
{
|
||||
ERR("Allocation Failed");
|
||||
return NULL;
|
||||
}
|
||||
sink->sink.name = eina_stringshare_add(name);
|
||||
_alsa_volume_create(&sink->sink.volume, channels);
|
||||
sink->hw_name = eina_stringshare_add(hw_name);
|
||||
sink->channels = channels;
|
||||
_alsa_sink_mute_get(sink);
|
||||
if (ctx->cb)
|
||||
{
|
||||
ctx->cb((void *)ctx->userdata, EMIX_SINK_ADDED_EVENT,
|
||||
(Emix_Sink *)sink);
|
||||
|
||||
}
|
||||
ctx->sinks = eina_list_append(ctx->sinks, sink);
|
||||
return sink;
|
||||
}
|
||||
|
||||
static Alsa_Emix_Source*
|
||||
_alsa_device_source_create(const char *name, const char* hw_name,
|
||||
Eina_List *channels)
|
||||
{
|
||||
Alsa_Emix_Source *source;
|
||||
|
||||
if (!(source = calloc(1, sizeof(Alsa_Emix_Source))))
|
||||
{
|
||||
ERR("Allocation Failed");
|
||||
return NULL;
|
||||
}
|
||||
source->source.name = eina_stringshare_add(name);
|
||||
_alsa_volume_create(&source->source.volume, channels);
|
||||
source->hw_name = eina_stringshare_add(hw_name);
|
||||
source->channels = channels;
|
||||
_alsa_sources_mute_get(source);
|
||||
if (ctx->cb)
|
||||
ctx->cb((void *)ctx->userdata, EMIX_SOURCE_ADDED_EVENT,
|
||||
(Emix_Sink *)source);
|
||||
ctx->sources = eina_list_append(ctx->sources, source);
|
||||
return source;
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_device_sink_free(Alsa_Emix_Sink *sink)
|
||||
{
|
||||
eina_stringshare_del(sink->hw_name);
|
||||
eina_stringshare_del(sink->sink.name);
|
||||
free(sink->sink.volume.volumes);
|
||||
free(sink);
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_device_source_free(Alsa_Emix_Source *source)
|
||||
{
|
||||
eina_stringshare_del(source->hw_name);
|
||||
eina_stringshare_del(source->source.name);
|
||||
free(source->source.volume.volumes);
|
||||
free(source);
|
||||
}
|
||||
|
||||
static char*
|
||||
_alsa_cards_name_get(char *name)
|
||||
{
|
||||
snd_ctl_t *control;
|
||||
snd_ctl_card_info_t *hw_info;
|
||||
char *result = NULL;
|
||||
|
||||
snd_ctl_card_info_alloca(&hw_info);
|
||||
|
||||
if (snd_ctl_open(&control, name, 0) < 0)
|
||||
{
|
||||
ERR("Failed to open device");
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (snd_ctl_card_info(control, hw_info) < 0)
|
||||
{
|
||||
ERR("Failed to get card information");
|
||||
goto err_open;
|
||||
}
|
||||
|
||||
result = strdup(snd_ctl_card_info_get_name(hw_info));
|
||||
|
||||
err_open:
|
||||
snd_ctl_close(control);
|
||||
err:
|
||||
return result;
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_cards_refresh(void)
|
||||
{
|
||||
int err, card_num = -1;
|
||||
Eina_List *tmp_source = NULL, *tmp_sink = NULL;
|
||||
|
||||
while (((err = snd_card_next(&card_num)) == 0) && (card_num >= 0))
|
||||
{
|
||||
char buf[PATH_MAX];
|
||||
char *device_name;
|
||||
snd_mixer_t *mixer;
|
||||
snd_mixer_elem_t *elem;
|
||||
Alsa_Emix_Source *source;
|
||||
Alsa_Emix_Sink *sink;
|
||||
|
||||
source = NULL;
|
||||
sink = NULL;
|
||||
tmp_source = NULL;
|
||||
tmp_sink = NULL;
|
||||
|
||||
//generate card addr
|
||||
snprintf(buf, sizeof(buf), "hw:%d", card_num);
|
||||
//save the addr to see if there are missing devices in the cache list
|
||||
|
||||
mixer = _alsa_card_create(buf);
|
||||
ctx->cards = eina_list_append(ctx->cards, mixer);
|
||||
//get elements of the device
|
||||
elem = snd_mixer_first_elem(mixer);
|
||||
for (; elem; elem = snd_mixer_elem_next(elem))
|
||||
{
|
||||
//check if its a source or a sink
|
||||
if (snd_mixer_selem_has_capture_volume(elem))
|
||||
tmp_source = eina_list_append(tmp_source, elem);
|
||||
else
|
||||
tmp_sink = eina_list_append(tmp_sink, elem);
|
||||
}
|
||||
|
||||
device_name = _alsa_cards_name_get(buf);
|
||||
//create the sinks / sources
|
||||
if (tmp_sink)
|
||||
{
|
||||
sink = _alsa_device_sink_create(device_name,
|
||||
buf,
|
||||
tmp_sink);
|
||||
snd_mixer_set_callback(mixer, _alsa_mixer_sink_changed_cb);
|
||||
snd_mixer_set_callback_private(mixer, sink);
|
||||
}
|
||||
if (tmp_source)
|
||||
{
|
||||
source = _alsa_device_source_create(device_name,
|
||||
buf,
|
||||
tmp_source);
|
||||
snd_mixer_set_callback(mixer, _alsa_mixer_source_changed_cb);
|
||||
snd_mixer_set_callback_private(mixer, source);
|
||||
}
|
||||
if (device_name)
|
||||
free(device_name);
|
||||
}
|
||||
}
|
||||
|
||||
static Eina_Bool
|
||||
_alsa_init(Emix_Event_Cb cb, const void *data)
|
||||
{
|
||||
EINA_SAFETY_ON_NULL_RETURN_VAL(cb, EINA_FALSE);
|
||||
if (!ctx)
|
||||
ctx = calloc(1, sizeof(Context));
|
||||
|
||||
EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, EINA_FALSE);
|
||||
|
||||
ctx->cb = cb;
|
||||
ctx->userdata = data;
|
||||
_alsa_cards_refresh();
|
||||
|
||||
//call the event because the backend is now ready to use
|
||||
ctx->cb((void *)ctx->userdata, EMIX_READY_EVENT, NULL);
|
||||
|
||||
return EINA_TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_shutdown(void)
|
||||
{
|
||||
Alsa_Emix_Sink *sink;
|
||||
Alsa_Emix_Source *source;
|
||||
snd_mixer_t *mixer;
|
||||
|
||||
EINA_SAFETY_ON_NULL_RETURN(ctx);
|
||||
|
||||
EINA_LIST_FREE(ctx->sinks, sink)
|
||||
_alsa_device_sink_free(sink);
|
||||
EINA_LIST_FREE(ctx->sources, source)
|
||||
_alsa_device_source_free(source);
|
||||
EINA_LIST_FREE(ctx->cards, mixer)
|
||||
snd_mixer_close(mixer);
|
||||
|
||||
free(ctx);
|
||||
ctx = NULL;
|
||||
}
|
||||
|
||||
static const Eina_List*
|
||||
_alsa_sources_get(void)
|
||||
{
|
||||
EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL);
|
||||
return ctx->sources;
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_sources_mute_set(Emix_Source *source, Eina_Bool mute)
|
||||
{
|
||||
Alsa_Emix_Source *s = (Alsa_Emix_Source*) source;
|
||||
Eina_List *node;
|
||||
snd_mixer_elem_t *elem;
|
||||
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && source));
|
||||
|
||||
EINA_LIST_FOREACH(s->channels, node, elem)
|
||||
{
|
||||
if (!snd_mixer_selem_has_capture_switch(elem))
|
||||
continue;
|
||||
if (snd_mixer_selem_set_capture_switch_all(elem, !mute) < 0)
|
||||
ERR("Failed to mute device\n");
|
||||
}
|
||||
|
||||
source->mute = mute;
|
||||
if (ctx->cb)
|
||||
ctx->cb((void *)ctx->userdata, EMIX_SOURCE_CHANGED_EVENT,
|
||||
(Emix_Source *)source);
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_sources_volume_set(Emix_Source *source, Emix_Volume v)
|
||||
{
|
||||
Alsa_Emix_Source *s = (Alsa_Emix_Source*) source;
|
||||
unsigned int i;
|
||||
snd_mixer_elem_t *elem;
|
||||
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && source));
|
||||
|
||||
if (v.channel_count != eina_list_count(s->channels))
|
||||
{
|
||||
ERR("Volume struct doesnt have the same length than the channels");
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < v.channel_count; i++ )
|
||||
{
|
||||
elem = eina_list_nth(s->channels, i);
|
||||
_alsa_channel_volume_set(elem, v.volumes[i], EINA_FALSE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static const Eina_List*
|
||||
_alsa_sinks_get(void)
|
||||
{
|
||||
EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL);
|
||||
//FIXME fork or just return?
|
||||
/* Eina_List *result = NULL;
|
||||
Eina_List *node;
|
||||
void *data;
|
||||
EINA_LIST_FOREACH(ctx->sinks, node, data)
|
||||
{
|
||||
result = eina_list_append(result, data);
|
||||
}*/
|
||||
return ctx->sinks;
|
||||
}
|
||||
|
||||
static Eina_Bool
|
||||
_alsa_support(void)
|
||||
{
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_sink_mute_set(Emix_Sink *sink, Eina_Bool mute)
|
||||
{
|
||||
Alsa_Emix_Sink *as = (Alsa_Emix_Sink*) sink;
|
||||
Eina_List *node;
|
||||
snd_mixer_elem_t *elem;
|
||||
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && sink));
|
||||
|
||||
EINA_LIST_FOREACH(as->channels, node, elem)
|
||||
{
|
||||
if (!snd_mixer_selem_has_playback_switch(elem))
|
||||
continue;
|
||||
|
||||
if (snd_mixer_selem_set_playback_switch_all(elem, !mute) < 0)
|
||||
ERR("Failed to set mute(%d) device(%p)", mute, elem);
|
||||
}
|
||||
|
||||
sink->mute = mute;
|
||||
if (ctx->cb)
|
||||
ctx->cb((void *)ctx->userdata, EMIX_SINK_CHANGED_EVENT,
|
||||
(Emix_Sink *)sink);
|
||||
}
|
||||
|
||||
static void
|
||||
_alsa_sink_volume_set(Emix_Sink *sink, Emix_Volume v)
|
||||
{
|
||||
Alsa_Emix_Sink *s = (Alsa_Emix_Sink *)sink;
|
||||
unsigned int i;
|
||||
snd_mixer_elem_t *elem;
|
||||
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && sink));
|
||||
|
||||
if (v.channel_count != eina_list_count(s->channels))
|
||||
{
|
||||
ERR("Volume struct doesnt have the same length than the channels");
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < v.channel_count; i++ )
|
||||
{
|
||||
elem = eina_list_nth(s->channels, i);
|
||||
_alsa_channel_volume_set(elem, v.volumes[i], EINA_FALSE);
|
||||
}
|
||||
}
|
||||
|
||||
static Emix_Backend
|
||||
_alsa_backend =
|
||||
{
|
||||
_alsa_init,
|
||||
_alsa_shutdown,
|
||||
_alsa_sinks_get,
|
||||
_alsa_support, /*default support*/
|
||||
NULL, /*get*/
|
||||
NULL, /*set*/
|
||||
_alsa_sink_mute_set, /*mute_set*/
|
||||
_alsa_sink_volume_set, /*volume_set*/
|
||||
NULL, /* port set */
|
||||
_alsa_support, /*change support*/
|
||||
NULL, /*sink input get*/
|
||||
NULL,/*sink input mute set*/
|
||||
NULL,/*sink input volume set*/
|
||||
NULL,/*sink input sink change*/
|
||||
_alsa_sources_get,/*source*/
|
||||
_alsa_sources_mute_set,/* source mute set */
|
||||
_alsa_sources_volume_set, /* source volume set */
|
||||
NULL /* advanced options */
|
||||
};
|
||||
|
||||
E_API Emix_Backend *
|
||||
emix_backend_alsa_get(void)
|
||||
{
|
||||
return &_alsa_backend;
|
||||
}
|
||||
|
||||
E_API const char *emix_backend_alsa_name = "ALSA";
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,319 @@
|
|||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <Eina.h>
|
||||
#include <Ecore.h>
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include <pulse/pulseaudio.h>
|
||||
|
||||
#include <sys/time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
|
||||
#define ERR(...) EINA_LOG_ERR(__VA_ARGS__)
|
||||
#define DBG(...) EINA_LOG_DBG(__VA_ARGS__)
|
||||
#define WRN(...) EINA_LOG_WARN(__VA_ARGS__)
|
||||
|
||||
/* Ecore mainloop integration start */
|
||||
struct pa_io_event
|
||||
{
|
||||
pa_mainloop_api *mainloop;
|
||||
Ecore_Fd_Handler *handler;
|
||||
|
||||
void *userdata;
|
||||
|
||||
pa_io_event_flags_t flags;
|
||||
pa_io_event_cb_t callback;
|
||||
pa_io_event_destroy_cb_t destroy_callback;
|
||||
};
|
||||
|
||||
static Ecore_Fd_Handler_Flags
|
||||
map_flags_to_ecore(pa_io_event_flags_t flags)
|
||||
{
|
||||
return (Ecore_Fd_Handler_Flags)((flags & PA_IO_EVENT_INPUT ? ECORE_FD_READ : 0) |
|
||||
(flags & PA_IO_EVENT_OUTPUT ? ECORE_FD_WRITE : 0) |
|
||||
(flags & PA_IO_EVENT_ERROR ? ECORE_FD_ERROR : 0) |
|
||||
(flags & PA_IO_EVENT_HANGUP ? ECORE_FD_READ : 0));
|
||||
}
|
||||
|
||||
static Eina_Bool
|
||||
_ecore_io_wrapper(void *data, Ecore_Fd_Handler *handler)
|
||||
{
|
||||
char buf[64];
|
||||
pa_io_event_flags_t flags = 0;
|
||||
pa_io_event *event = (pa_io_event *)data;
|
||||
int fd = 0;
|
||||
|
||||
fd = ecore_main_fd_handler_fd_get(handler);
|
||||
if (fd < 0) return ECORE_CALLBACK_RENEW;
|
||||
|
||||
if (ecore_main_fd_handler_active_get(handler, ECORE_FD_READ))
|
||||
{
|
||||
flags |= PA_IO_EVENT_INPUT;
|
||||
|
||||
/* Check for HUP and report */
|
||||
if (recv(fd, buf, 64, MSG_PEEK))
|
||||
{
|
||||
if (errno == ESHUTDOWN || errno == ECONNRESET ||
|
||||
errno == ECONNABORTED || errno == ENETRESET)
|
||||
{
|
||||
DBG("HUP condition detected");
|
||||
flags |= PA_IO_EVENT_HANGUP;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (ecore_main_fd_handler_active_get(handler, ECORE_FD_WRITE))
|
||||
flags |= PA_IO_EVENT_OUTPUT;
|
||||
if (ecore_main_fd_handler_active_get(handler, ECORE_FD_ERROR))
|
||||
flags |= PA_IO_EVENT_ERROR;
|
||||
|
||||
event->callback(event->mainloop, event, fd, flags, event->userdata);
|
||||
|
||||
return ECORE_CALLBACK_RENEW;
|
||||
}
|
||||
|
||||
static pa_io_event *
|
||||
_ecore_pa_io_new(pa_mainloop_api *api, int fd, pa_io_event_flags_t flags,
|
||||
pa_io_event_cb_t cb, void *userdata)
|
||||
{
|
||||
pa_io_event *event;
|
||||
|
||||
event = calloc(1, sizeof(pa_io_event));
|
||||
event->mainloop = api;
|
||||
event->userdata = userdata;
|
||||
event->callback = cb;
|
||||
event->flags = flags;
|
||||
event->handler = ecore_main_fd_handler_add(fd, map_flags_to_ecore(flags),
|
||||
_ecore_io_wrapper, event,
|
||||
NULL, NULL);
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
static void
|
||||
_ecore_pa_io_enable(pa_io_event *event, pa_io_event_flags_t flags)
|
||||
{
|
||||
event->flags = flags;
|
||||
ecore_main_fd_handler_active_set(event->handler, map_flags_to_ecore(flags));
|
||||
}
|
||||
|
||||
static void
|
||||
_ecore_pa_io_free(pa_io_event *event)
|
||||
{
|
||||
ecore_main_fd_handler_del(event->handler);
|
||||
free(event);
|
||||
}
|
||||
|
||||
static void
|
||||
_ecore_pa_io_set_destroy(pa_io_event *event, pa_io_event_destroy_cb_t cb)
|
||||
{
|
||||
event->destroy_callback = cb;
|
||||
}
|
||||
|
||||
/* Timed events */
|
||||
struct pa_time_event
|
||||
{
|
||||
pa_mainloop_api *mainloop;
|
||||
Ecore_Timer *timer;
|
||||
struct timeval tv;
|
||||
|
||||
void *userdata;
|
||||
|
||||
pa_time_event_cb_t callback;
|
||||
pa_time_event_destroy_cb_t destroy_callback;
|
||||
};
|
||||
|
||||
Eina_Bool
|
||||
_ecore_time_wrapper(void *data)
|
||||
{
|
||||
pa_time_event *event = (pa_time_event *)data;
|
||||
|
||||
event->callback(event->mainloop, event, &event->tv, event->userdata);
|
||||
|
||||
return ECORE_CALLBACK_CANCEL;
|
||||
}
|
||||
|
||||
pa_time_event *
|
||||
_ecore_pa_time_new(pa_mainloop_api *api, const struct timeval *tv, pa_time_event_cb_t cb, void *userdata)
|
||||
{
|
||||
pa_time_event *event;
|
||||
struct timeval now;
|
||||
double interval;
|
||||
|
||||
event = calloc(1, sizeof(pa_time_event));
|
||||
event->mainloop = api;
|
||||
event->userdata = userdata;
|
||||
event->callback = cb;
|
||||
event->tv = *tv;
|
||||
|
||||
if (gettimeofday(&now, NULL) == -1)
|
||||
{
|
||||
ERR("Failed to get the current time!");
|
||||
free(event);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
interval = (tv->tv_sec - now.tv_sec) + (tv->tv_usec - now.tv_usec) / 1000;
|
||||
event->timer = ecore_timer_add(interval, _ecore_time_wrapper, event);
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
void
|
||||
_ecore_pa_time_restart(pa_time_event *event, const struct timeval *tv)
|
||||
{
|
||||
struct timeval now;
|
||||
double interval;
|
||||
|
||||
/* If tv is NULL disable timer */
|
||||
if (!tv)
|
||||
{
|
||||
ecore_timer_del(event->timer);
|
||||
event->timer = NULL;
|
||||
return;
|
||||
}
|
||||
|
||||
event->tv = *tv;
|
||||
|
||||
if (gettimeofday(&now, NULL) == -1)
|
||||
{
|
||||
ERR("Failed to get the current time!");
|
||||
return;
|
||||
}
|
||||
|
||||
interval = (tv->tv_sec - now.tv_sec) + (tv->tv_usec - now.tv_usec) / 1000;
|
||||
if (event->timer)
|
||||
{
|
||||
event->timer = ecore_timer_add(interval, _ecore_time_wrapper, event);
|
||||
}
|
||||
else
|
||||
{
|
||||
ecore_timer_interval_set(event->timer, interval);
|
||||
ecore_timer_reset(event->timer);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_ecore_pa_time_free(pa_time_event *event)
|
||||
{
|
||||
if (event->timer)
|
||||
ecore_timer_del(event->timer);
|
||||
|
||||
event->timer = NULL;
|
||||
|
||||
free(event);
|
||||
}
|
||||
|
||||
void
|
||||
_ecore_pa_time_set_destroy(pa_time_event *event, pa_time_event_destroy_cb_t cb)
|
||||
{
|
||||
event->destroy_callback = cb;
|
||||
}
|
||||
|
||||
/* Deferred events */
|
||||
struct pa_defer_event
|
||||
{
|
||||
pa_mainloop_api *mainloop;
|
||||
Ecore_Idler *idler;
|
||||
|
||||
void *userdata;
|
||||
|
||||
pa_defer_event_cb_t callback;
|
||||
pa_defer_event_destroy_cb_t destroy_callback;
|
||||
};
|
||||
|
||||
Eina_Bool
|
||||
_ecore_defer_wrapper(void *data)
|
||||
{
|
||||
pa_defer_event *event = (pa_defer_event *)data;
|
||||
|
||||
event->idler = NULL;
|
||||
event->callback(event->mainloop, event, event->userdata);
|
||||
|
||||
return ECORE_CALLBACK_CANCEL;
|
||||
}
|
||||
|
||||
pa_defer_event *
|
||||
_ecore_pa_defer_new(pa_mainloop_api *api, pa_defer_event_cb_t cb, void *userdata)
|
||||
{
|
||||
pa_defer_event *event;
|
||||
|
||||
event = calloc(1, sizeof(pa_defer_event));
|
||||
event->mainloop = api;
|
||||
event->userdata = userdata;
|
||||
event->callback = cb;
|
||||
|
||||
event->idler = ecore_idler_add(_ecore_defer_wrapper, event);
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
void
|
||||
_ecore_pa_defer_enable(pa_defer_event *event, int b)
|
||||
{
|
||||
if (!b && event->idler)
|
||||
{
|
||||
ecore_idler_del(event->idler);
|
||||
event->idler = NULL;
|
||||
}
|
||||
else if (b && !event->idler)
|
||||
{
|
||||
event->idler = ecore_idler_add(_ecore_defer_wrapper, event);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_ecore_pa_defer_free(pa_defer_event *event)
|
||||
{
|
||||
if (event->idler)
|
||||
ecore_idler_del(event->idler);
|
||||
|
||||
event->idler = NULL;
|
||||
|
||||
free(event);
|
||||
}
|
||||
|
||||
void
|
||||
_ecore_pa_defer_set_destroy(pa_defer_event *event,
|
||||
pa_defer_event_destroy_cb_t cb)
|
||||
{
|
||||
event->destroy_callback = cb;
|
||||
}
|
||||
|
||||
static void
|
||||
_ecore_pa_quit(pa_mainloop_api *api EINA_UNUSED, int retval EINA_UNUSED)
|
||||
{
|
||||
/* FIXME: Need to clean up timers, etc.? */
|
||||
WRN("Not quitting mainloop, although PA requested it");
|
||||
}
|
||||
|
||||
/* Function table for PA mainloop integration */
|
||||
const pa_mainloop_api functable = {
|
||||
.userdata = NULL,
|
||||
|
||||
.io_new = _ecore_pa_io_new,
|
||||
.io_enable = _ecore_pa_io_enable,
|
||||
.io_free = _ecore_pa_io_free,
|
||||
.io_set_destroy = _ecore_pa_io_set_destroy,
|
||||
|
||||
.time_new = _ecore_pa_time_new,
|
||||
.time_restart = _ecore_pa_time_restart,
|
||||
.time_free = _ecore_pa_time_free,
|
||||
.time_set_destroy = _ecore_pa_time_set_destroy,
|
||||
|
||||
.defer_new = _ecore_pa_defer_new,
|
||||
.defer_enable = _ecore_pa_defer_enable,
|
||||
.defer_free = _ecore_pa_defer_free,
|
||||
.defer_set_destroy = _ecore_pa_defer_set_destroy,
|
||||
|
||||
.quit = _ecore_pa_quit,
|
||||
};
|
||||
|
||||
/* *****************************************************
|
||||
* Ecore mainloop integration end
|
||||
*/
|
|
@ -0,0 +1,395 @@
|
|||
#include <Ecore.h>
|
||||
#include <Eina.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "emix.h"
|
||||
|
||||
#ifdef HAVE_PULSE
|
||||
E_API Emix_Backend *emix_backend_pulse_get(void);
|
||||
E_API const char *emix_backend_pulse_name;
|
||||
#endif
|
||||
#ifdef HAVE_ALSA
|
||||
E_API Emix_Backend *emix_backend_alsa_get(void);
|
||||
E_API const char *emix_backend_alsa_name;
|
||||
#endif
|
||||
|
||||
static int _log_domain;
|
||||
|
||||
#define CRIT(...) EINA_LOG_DOM_CRIT(_log_domain, __VA_ARGS__)
|
||||
#define ERR(...) EINA_LOG_DOM_ERR(_log_domain, __VA_ARGS__)
|
||||
#define WRN(...) EINA_LOG_DOM_WARN(_log_domain, __VA_ARGS__)
|
||||
#define INF(...) EINA_LOG_DOM_INFO(_log_domain, __VA_ARGS__)
|
||||
#define DBG(...) EINA_LOG_DOM_DBG(_log_domain, __VA_ARGS__)
|
||||
|
||||
struct Callback_Data
|
||||
{
|
||||
Emix_Event_Cb cb;
|
||||
const void *data;
|
||||
};
|
||||
|
||||
typedef struct Context
|
||||
{
|
||||
/* Valid backends *.so */
|
||||
Eina_Array *backends;
|
||||
Eina_List *backends_names;
|
||||
Eina_List *callbacks;
|
||||
|
||||
Emix_Backend *loaded;
|
||||
} Context;
|
||||
|
||||
typedef struct _Back
|
||||
{
|
||||
Emix_Backend *(*backend_get) (void);
|
||||
const char *backend_name;
|
||||
} Back;
|
||||
|
||||
static int _init_count = 0;
|
||||
static Context *ctx = NULL;
|
||||
|
||||
static void
|
||||
_events_cb(void *data EINA_UNUSED, enum Emix_Event event, void *event_info)
|
||||
{
|
||||
Eina_List *l;
|
||||
struct Callback_Data *callback;
|
||||
|
||||
EINA_LIST_FOREACH(ctx->callbacks, l, callback)
|
||||
callback->cb((void *)callback->data, event, event_info);
|
||||
}
|
||||
|
||||
Eina_Bool
|
||||
emix_init(void)
|
||||
{
|
||||
Back *back;
|
||||
|
||||
if (_init_count > 0)
|
||||
goto end;
|
||||
|
||||
if (!eina_init())
|
||||
{
|
||||
fprintf(stderr, "Could not init eina\n");
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
_log_domain = eina_log_domain_register("emix", NULL);
|
||||
if (_log_domain < 0)
|
||||
{
|
||||
EINA_LOG_CRIT("Could not create log domain 'emix'");
|
||||
goto err_log;
|
||||
}
|
||||
|
||||
if (!ecore_init())
|
||||
{
|
||||
CRIT("Could not init ecore");
|
||||
goto err_ecore;
|
||||
}
|
||||
|
||||
ctx = calloc(1, sizeof(Context));
|
||||
if (!ctx)
|
||||
{
|
||||
ERR("Could not create Epulse Context");
|
||||
goto err_ecore;
|
||||
}
|
||||
ctx->backends = eina_array_new(2);
|
||||
#ifdef HAVE_PULSE
|
||||
back = calloc(1, sizeof(Back));
|
||||
if (back)
|
||||
{
|
||||
back->backend_get = emix_backend_pulse_get;
|
||||
back->backend_name = emix_backend_pulse_name;
|
||||
eina_array_push(ctx->backends, back);
|
||||
ctx->backends_names = eina_list_append(ctx->backends_names,
|
||||
back->backend_name);
|
||||
}
|
||||
#endif
|
||||
#ifdef HAVE_ALSA
|
||||
back = calloc(1, sizeof(Back));
|
||||
if (back)
|
||||
{
|
||||
back->backend_get = emix_backend_alsa_get;
|
||||
back->backend_name = emix_backend_alsa_name;
|
||||
eina_array_push(ctx->backends, back);
|
||||
ctx->backends_names = eina_list_append(ctx->backends_names,
|
||||
back->backend_name);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (ctx->backends == NULL)
|
||||
{
|
||||
ERR("Could not find any valid backend");
|
||||
goto err;
|
||||
}
|
||||
|
||||
end:
|
||||
_init_count++;
|
||||
return EINA_TRUE;
|
||||
err:
|
||||
free(ctx);
|
||||
ctx = NULL;
|
||||
err_ecore:
|
||||
eina_log_domain_unregister(_log_domain);
|
||||
_log_domain = -1;
|
||||
err_log:
|
||||
eina_shutdown();
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
void
|
||||
emix_shutdown()
|
||||
{
|
||||
unsigned int i;
|
||||
Eina_Array_Iterator iterator;
|
||||
Back *back;
|
||||
|
||||
if (_init_count == 0)
|
||||
return;
|
||||
|
||||
_init_count--;
|
||||
if (_init_count > 0)
|
||||
return;
|
||||
|
||||
if (ctx->loaded && ctx->loaded->ebackend_shutdown)
|
||||
ctx->loaded->ebackend_shutdown();
|
||||
|
||||
eina_list_free(ctx->backends_names);
|
||||
EINA_ARRAY_ITER_NEXT(ctx->backends, i, back, iterator)
|
||||
{
|
||||
free(back);
|
||||
}
|
||||
eina_array_free(ctx->backends);
|
||||
free(ctx);
|
||||
ctx = NULL;
|
||||
|
||||
ecore_shutdown();
|
||||
eina_shutdown();
|
||||
}
|
||||
|
||||
const Eina_List*
|
||||
emix_backends_available(void)
|
||||
{
|
||||
EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL);
|
||||
return ctx->backends_names;
|
||||
}
|
||||
|
||||
Eina_Bool
|
||||
emix_backend_set(const char *backend)
|
||||
{
|
||||
Eina_List *l;
|
||||
const char *name;
|
||||
unsigned int i = 0;
|
||||
Back *back;
|
||||
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && backend), EINA_FALSE);
|
||||
if (ctx->loaded && ctx->loaded->ebackend_shutdown)
|
||||
{
|
||||
ctx->loaded->ebackend_shutdown();
|
||||
ctx->loaded = NULL;
|
||||
}
|
||||
|
||||
EINA_LIST_FOREACH(ctx->backends_names, l, name)
|
||||
{
|
||||
if (!strncmp(name, backend, strlen(name)))
|
||||
break;
|
||||
i++;
|
||||
}
|
||||
|
||||
if (i == eina_list_count(ctx->backends_names))
|
||||
{
|
||||
CRIT("Requested backend not found (%s)", backend);
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
back = eina_array_data_get(ctx->backends, i);
|
||||
ctx->loaded = back->backend_get();
|
||||
|
||||
if (!ctx->loaded || !ctx->loaded->ebackend_init)
|
||||
return EINA_FALSE;
|
||||
|
||||
return ctx->loaded->ebackend_init(_events_cb, NULL);
|
||||
}
|
||||
|
||||
const Eina_List*
|
||||
emix_sinks_get(void)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sinks_get),
|
||||
NULL);
|
||||
return ctx->loaded->ebackend_sinks_get();
|
||||
}
|
||||
|
||||
Eina_Bool
|
||||
emix_sink_default_support(void)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_default_support),
|
||||
EINA_FALSE);
|
||||
return ctx->loaded->ebackend_sink_default_support();
|
||||
}
|
||||
|
||||
const Emix_Sink*
|
||||
emix_sink_default_get(void)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_default_get),
|
||||
NULL);
|
||||
return ctx->loaded->ebackend_sink_default_get();
|
||||
}
|
||||
|
||||
void
|
||||
emix_sink_default_set(Emix_Sink *sink)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_default_set &&
|
||||
sink));
|
||||
|
||||
ctx->loaded->ebackend_sink_default_set(sink);
|
||||
}
|
||||
|
||||
Eina_Bool
|
||||
emix_sink_port_set(Emix_Sink *sink, Emix_Port *port)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_port_set &&
|
||||
sink && port), EINA_FALSE);
|
||||
|
||||
return ctx->loaded->ebackend_sink_port_set(sink, port);
|
||||
}
|
||||
|
||||
void
|
||||
emix_sink_mute_set(Emix_Sink *sink, Eina_Bool mute)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_mute_set &&
|
||||
sink));
|
||||
|
||||
ctx->loaded->ebackend_sink_mute_set(sink, mute);
|
||||
}
|
||||
|
||||
void
|
||||
emix_sink_volume_set(Emix_Sink *sink, Emix_Volume volume)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_volume_set &&
|
||||
sink));
|
||||
|
||||
ctx->loaded->ebackend_sink_volume_set(sink, volume);
|
||||
}
|
||||
|
||||
Eina_Bool
|
||||
emix_sink_change_support(void)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_change_support),
|
||||
EINA_FALSE);
|
||||
return ctx->loaded->ebackend_sink_change_support();
|
||||
}
|
||||
|
||||
const Eina_List*
|
||||
emix_sink_inputs_get(void)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_inputs_get),
|
||||
NULL);
|
||||
return ctx->loaded->ebackend_sink_inputs_get();
|
||||
}
|
||||
|
||||
void
|
||||
emix_sink_input_mute_set(Emix_Sink_Input *input, Eina_Bool mute)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_input_mute_set &&
|
||||
input));
|
||||
|
||||
ctx->loaded->ebackend_sink_input_mute_set(input, mute);
|
||||
}
|
||||
|
||||
void
|
||||
emix_sink_input_volume_set(Emix_Sink_Input *input, Emix_Volume volume)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_input_volume_set &&
|
||||
input));
|
||||
|
||||
ctx->loaded->ebackend_sink_input_volume_set(input, volume);
|
||||
}
|
||||
|
||||
void
|
||||
emix_sink_input_sink_change(Emix_Sink_Input *input, Emix_Sink *sink)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sink_input_sink_change &&
|
||||
input && sink));
|
||||
|
||||
ctx->loaded->ebackend_sink_input_sink_change(input, sink);
|
||||
}
|
||||
|
||||
const Eina_List*
|
||||
emix_sources_get(void)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_sources_get), NULL);
|
||||
|
||||
return ctx->loaded->ebackend_sources_get();
|
||||
}
|
||||
|
||||
void
|
||||
emix_source_mute_set(Emix_Source *source, Eina_Bool mute)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_source_mute_set &&
|
||||
source));
|
||||
|
||||
ctx->loaded->ebackend_source_mute_set(source, mute);
|
||||
}
|
||||
|
||||
void
|
||||
emix_source_volume_set(Emix_Source *source, Emix_Volume volume)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN((ctx && ctx->loaded &&
|
||||
ctx->loaded->ebackend_source_volume_set &&
|
||||
source));
|
||||
|
||||
ctx->loaded->ebackend_source_volume_set(source, volume);
|
||||
}
|
||||
|
||||
Evas_Object *
|
||||
emix_advanced_options_add(Evas_Object *parent)
|
||||
{
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && ctx->loaded && parent &&
|
||||
ctx->loaded->ebackend_advanced_options_add), NULL);
|
||||
|
||||
return ctx->loaded->ebackend_advanced_options_add(parent);
|
||||
}
|
||||
|
||||
Eina_Bool
|
||||
emix_event_callback_add(Emix_Event_Cb cb, const void *data)
|
||||
{
|
||||
struct Callback_Data *callback;
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && cb), EINA_FALSE);
|
||||
|
||||
callback = calloc(1, sizeof(*callback));
|
||||
callback->cb = cb;
|
||||
callback->data = data;
|
||||
|
||||
ctx->callbacks = eina_list_append(ctx->callbacks, callback);
|
||||
return EINA_TRUE;
|
||||
}
|
||||
|
||||
Eina_Bool
|
||||
emix_event_callback_del(Emix_Event_Cb cb)
|
||||
{
|
||||
struct Callback_Data *callback;
|
||||
Eina_List *l;
|
||||
EINA_SAFETY_ON_FALSE_RETURN_VAL((ctx && cb), EINA_FALSE);
|
||||
|
||||
EINA_LIST_FOREACH(ctx->callbacks, l, callback)
|
||||
{
|
||||
if (callback->cb == cb)
|
||||
{
|
||||
ctx->callbacks = eina_list_remove_list(ctx->callbacks, l);
|
||||
free(callback);
|
||||
return EINA_TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return EINA_FALSE;
|
||||
}
|
|
@ -0,0 +1,143 @@
|
|||
#ifndef EMIX_H
|
||||
#define EMIX_H
|
||||
|
||||
#include <Eina.h>
|
||||
#include <Evas.h>
|
||||
|
||||
#ifdef E_API
|
||||
#undef E_API
|
||||
#endif
|
||||
|
||||
#ifdef __GNUC__
|
||||
# if __GNUC__ >= 4
|
||||
# define E_API __attribute__ ((visibility("default")))
|
||||
# else
|
||||
# define E_API
|
||||
# endif
|
||||
#else
|
||||
# define E_API
|
||||
#endif
|
||||
|
||||
|
||||
#define EMIX_VOLUME_MAX 100
|
||||
|
||||
enum Emix_Event {
|
||||
EMIX_READY_EVENT = 0,
|
||||
EMIX_DISCONNECTED_EVENT,
|
||||
EMIX_SINK_ADDED_EVENT,
|
||||
EMIX_SINK_REMOVED_EVENT,
|
||||
EMIX_SINK_CHANGED_EVENT,
|
||||
EMIX_SINK_INPUT_ADDED_EVENT,
|
||||
EMIX_SINK_INPUT_REMOVED_EVENT,
|
||||
EMIX_SINK_INPUT_CHANGED_EVENT,
|
||||
EMIX_SOURCE_ADDED_EVENT,
|
||||
EMIX_SOURCE_REMOVED_EVENT,
|
||||
EMIX_SOURCE_CHANGED_EVENT
|
||||
};
|
||||
|
||||
typedef struct _Emix_Volume {
|
||||
unsigned int channel_count;
|
||||
// the index of the field is the id of the channel, the value the volume
|
||||
int *volumes;
|
||||
} Emix_Volume;
|
||||
|
||||
typedef struct _Emix_Port {
|
||||
Eina_Bool active;
|
||||
Eina_Bool available;
|
||||
const char *name;
|
||||
const char *description;
|
||||
} Emix_Port;
|
||||
|
||||
typedef struct _Emix_Sink {
|
||||
const char *name;
|
||||
Emix_Volume volume;
|
||||
Eina_Bool mute;
|
||||
Eina_List *ports;
|
||||
} Emix_Sink;
|
||||
|
||||
typedef struct _Emix_Sink_Input {
|
||||
const char *name;
|
||||
Emix_Volume volume;
|
||||
Eina_Bool mute;
|
||||
Emix_Sink *sink;
|
||||
} Emix_Sink_Input;
|
||||
|
||||
typedef struct _Emix_Source {
|
||||
const char *name;
|
||||
Emix_Volume volume;
|
||||
Eina_Bool mute;
|
||||
} Emix_Source;
|
||||
|
||||
typedef void (*Emix_Event_Cb)(void *data, enum Emix_Event event,
|
||||
void *event_info);
|
||||
|
||||
typedef struct _Emix_Backend {
|
||||
Eina_Bool (*ebackend_init)(Emix_Event_Cb cb, const void *data);
|
||||
void (*ebackend_shutdown)(void);
|
||||
|
||||
const Eina_List* (*ebackend_sinks_get)(void);
|
||||
Eina_Bool (*ebackend_sink_default_support)(void);
|
||||
const Emix_Sink* (*ebackend_sink_default_get)(void);
|
||||
void (*ebackend_sink_default_set)(Emix_Sink *sink);
|
||||
void (*ebackend_sink_mute_set)(Emix_Sink *sink,
|
||||
Eina_Bool mute);
|
||||
void (*ebackend_sink_volume_set)(Emix_Sink *sink,
|
||||
Emix_Volume volume);
|
||||
Eina_Bool (*ebackend_sink_port_set)(Emix_Sink *sink,
|
||||
const Emix_Port *port);
|
||||
Eina_Bool (*ebackend_sink_change_support)(void);
|
||||
|
||||
const Eina_List* (*ebackend_sink_inputs_get)(void);
|
||||
void (*ebackend_sink_input_mute_set)(
|
||||
Emix_Sink_Input *input, Eina_Bool mute);
|
||||
void (*ebackend_sink_input_volume_set)(
|
||||
Emix_Sink_Input *input, Emix_Volume volume);
|
||||
void (*ebackend_sink_input_sink_change)(
|
||||
Emix_Sink_Input *input, Emix_Sink *sink);
|
||||
|
||||
const Eina_List* (*ebackend_sources_get)(void);
|
||||
void (*ebackend_source_mute_set)(Emix_Source *source,
|
||||
Eina_Bool bool);
|
||||
void (*ebackend_source_volume_set)(Emix_Source *source,
|
||||
Emix_Volume volume);
|
||||
|
||||
Evas_Object* (*ebackend_advanced_options_add)(Evas_Object *parent);
|
||||
} Emix_Backend;
|
||||
|
||||
|
||||
E_API Eina_Bool emix_init(void);
|
||||
E_API void emix_shutdown(void);
|
||||
E_API const Eina_List* emix_backends_available(void);
|
||||
E_API Eina_Bool emix_backend_set(const char *backend);
|
||||
|
||||
E_API Eina_Bool emix_event_callback_add(Emix_Event_Cb cb,
|
||||
const void *data);
|
||||
E_API Eina_Bool emix_event_callback_del(Emix_Event_Cb cb);
|
||||
|
||||
E_API const Eina_List* emix_sinks_get(void);
|
||||
E_API Eina_Bool emix_sink_default_support(void);
|
||||
E_API const Emix_Sink* emix_sink_default_get(void);
|
||||
E_API Eina_Bool emix_sink_port_set(Emix_Sink *sink, Emix_Port *port);
|
||||
E_API void emix_sink_default_set(Emix_Sink *sink);
|
||||
E_API void emix_sink_mute_set(Emix_Sink *sink, Eina_Bool mute);
|
||||
E_API void emix_sink_volume_set(Emix_Sink *sink,
|
||||
Emix_Volume volume);
|
||||
E_API Eina_Bool emix_sink_change_support(void);
|
||||
|
||||
E_API const Eina_List* emix_sink_inputs_get(void);
|
||||
E_API void emix_sink_input_mute_set(Emix_Sink_Input *input,
|
||||
Eina_Bool mute);
|
||||
E_API void emix_sink_input_volume_set(Emix_Sink_Input *input,
|
||||
Emix_Volume volume);
|
||||
E_API void emix_sink_input_sink_change(Emix_Sink_Input *input,
|
||||
Emix_Sink *sink);
|
||||
|
||||
E_API const Eina_List* emix_sources_get(void);
|
||||
E_API void emix_source_mute_set(Emix_Source *source,
|
||||
Eina_Bool mute);
|
||||
E_API void emix_source_volume_set(Emix_Source *source,
|
||||
Emix_Volume volume);
|
||||
|
||||
E_API Evas_Object* emix_advanced_options_add(Evas_Object *parent);
|
||||
|
||||
#endif /* EMIX_H */
|
Loading…
Reference in New Issue