swagtoy
/
enlightenment
forked from enlightenment/enlightenment
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

mixer: use E_Mixer_Channel_Info as subsystem fct param 

E_Mixer_Channel is only used within audio subsystems
e_mod_mixer_channel_info_get_by_name returns a E_Mixer_Channel_Info
use e_mod_mixer_channel_info_free to free a single channel_info
This commit is contained in:
Jérémy Zurcher 2013-02-27 15:24:30 +01:00
parent ab7edf7ff6
commit d75622c33c
8 changed files with 143 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/modules/mixer/app_mixer.c
View File

@ -65,7 +65,7 @@ _cb_changed_left(void *data, Evas_Object *obj __UNUSED__)
state->right); state->right);
} }
e_mod_mixer_volume_set(app->sys, app->channel_info->id, e_mod_mixer_volume_set(app->sys, app->channel_info,
state->left, state->right); state->left, state->right);
} }
@ -83,7 +83,7 @@ _cb_changed_right(void *data, Evas_Object *obj __UNUSED__)
state->left); state->left);
} }
e_mod_mixer_volume_set(app->sys, app->channel_info->id, e_mod_mixer_volume_set(app->sys, app->channel_info,
state->left, state->right); state->left, state->right);
} }
@ -92,7 +92,7 @@ _cb_changed_mute(void *data, Evas_Object *obj __UNUSED__)
{ {
E_Mixer_App_Dialog_Data *app = data; E_Mixer_App_Dialog_Data *app = data;
e_mod_mixer_mute_set(app->sys, app->channel_info->id, app->state.mute); e_mod_mixer_mute_set(app->sys, app->channel_info, app->state.mute);
} }
static void static void
@ -112,7 +112,7 @@ _cb_changed_lock_sliders(void *data, Evas_Object *obj __UNUSED__)
e_widget_slider_value_int_set(app->ui.channel_editor.left, state->left); e_widget_slider_value_int_set(app->ui.channel_editor.left, state->left);
e_widget_slider_value_int_set(app->ui.channel_editor.right, state->right); e_widget_slider_value_int_set(app->ui.channel_editor.right, state->right);
e_mod_mixer_volume_set(app->sys, app->channel_info->id, e_mod_mixer_volume_set(app->sys, app->channel_info,
state->left, state->right); state->left, state->right);
} }
@ -148,7 +148,7 @@ _update_channel_editor_state(E_Mixer_App_Dialog_Data *app, const E_Mixer_Channel
e_widget_slider_value_int_set(ui->left, state.left); e_widget_slider_value_int_set(ui->left, state.left);
e_widget_slider_value_int_set(ui->right, state.right); e_widget_slider_value_int_set(ui->right, state.right);
if (e_mod_mixer_mutable_get(app->sys, app->channel_info->id)) if (e_mod_mixer_mutable_get(app->sys, app->channel_info))
{ {
e_widget_disabled_set(ui->mute, 0); e_widget_disabled_set(ui->mute, 0);
e_widget_check_checked_set(ui->mute, state.mute); e_widget_check_checked_set(ui->mute, state.mute);
@ -180,12 +180,12 @@ _populate_channel_editor(E_Mixer_App_Dialog_Data *app)
e_widget_entry_text_set(ui->channel, app->channel_name); e_widget_entry_text_set(ui->channel, app->channel_name);
if (e_mod_mixer_capture_get(app->sys, app->channel_info->id)) if (e_mod_mixer_capture_get(app->sys, app->channel_info))
e_widget_entry_text_set(ui->type, _("Capture")); e_widget_entry_text_set(ui->type, _("Capture"));
else else
e_widget_entry_text_set(ui->type, _("Playback")); e_widget_entry_text_set(ui->type, _("Playback"));
e_mod_mixer_state_get(app->sys, app->channel_info->id, &state); e_mod_mixer_state_get(app->sys, app->channel_info, &state);
_update_channel_editor_state(app, state); _update_channel_editor_state(app, state);
app->lock_sliders = (state.left == state.right); app->lock_sliders = (state.left == state.right);
@ -212,7 +212,7 @@ _cb_system_update(void *data, E_Mixer_System *sys __UNUSED__)
if ((!app->sys) || (!app->channel_info)) if ((!app->sys) || (!app->channel_info))
return 1; return 1;
e_mod_mixer_state_get(app->sys, app->channel_info->id, &state); e_mod_mixer_state_get(app->sys, app->channel_info, &state);
_update_channel_editor_state(app, state); _update_channel_editor_state(app, state);
return 1; return 1;

8
src/modules/mixer/e_mod_main.c
View File

@ -783,7 +783,7 @@ _mixer_sys_setup(E_Mixer_Instance *inst)
return 0; return 0;
} }
inst->channel = e_mod_mixer_channel_get_by_name(inst->sys, conf->channel_name); inst->channel = e_mod_mixer_channel_info_get_by_name(inst->sys, conf->channel_name);
return !!inst->channel; return !!inst->channel;
} }
@ -855,7 +855,7 @@ _mixer_sys_setup_default_channel(E_Mixer_Instance *inst)
if (!channel_name) if (!channel_name)
goto error; goto error;
inst->channel = e_mod_mixer_channel_get_by_name(inst->sys, channel_name); inst->channel = e_mod_mixer_channel_info_get_by_name(inst->sys, channel_name);
if (!inst->channel) if (!inst->channel)
goto system_error; goto system_error;
@ -915,7 +915,7 @@ e_mod_mixer_pulse_ready(Eina_Bool ready)
{ {
EINA_LIST_FOREACH(ctxt->instances, l, inst) EINA_LIST_FOREACH(ctxt->instances, l, inst)
{ {
e_mod_mixer_channel_del(inst->channel); e_mod_mixer_channel_info_free(inst->channel);
e_mod_mixer_del(inst->sys); e_mod_mixer_del(inst->sys);
inst->channel = NULL; inst->channel = NULL;
inst->sys = NULL; inst->sys = NULL;
@ -1074,7 +1074,7 @@ _gc_shutdown(E_Gadcon_Client *gcc)
inst->conf->state.left = inst->mixer_state.left; inst->conf->state.left = inst->mixer_state.left;
inst->conf->state.right = inst->mixer_state.right; inst->conf->state.right = inst->mixer_state.right;
evas_object_del(inst->ui.gadget); evas_object_del(inst->ui.gadget);
e_mod_mixer_channel_del(inst->channel); e_mod_mixer_channel_info_free(inst->channel);
e_mod_mixer_del(inst->sys); e_mod_mixer_del(inst->sys);
inst->conf->instance = NULL; inst->conf->instance = NULL;

2
src/modules/mixer/e_mod_main.h
View File

@ -50,7 +50,7 @@ typedef struct E_Mixer_Instance
} ui; } ui;
E_Mixer_System *sys; E_Mixer_System *sys;
E_Mixer_Channel *channel; E_Mixer_Channel_Info *channel;
E_Mixer_Channel_State mixer_state; E_Mixer_Channel_State mixer_state;
E_Mixer_Gadget_Config *conf; E_Mixer_Gadget_Config *conf;

17
src/modules/mixer/e_mod_mixer.c
View File

@ -11,10 +11,8 @@ E_Mixer_Capture_Cb e_mod_mixer_capture_get;
E_Mixer_Cb e_mod_mixer_new; E_Mixer_Cb e_mod_mixer_new;
E_Mixer_Cb e_mod_mixer_del; E_Mixer_Cb e_mod_mixer_del;
E_Mixer_Cb e_mod_mixer_channel_default_name_get; E_Mixer_Cb e_mod_mixer_channel_default_name_get;
E_Mixer_Cb e_mod_mixer_channel_get_by_name; E_Mixer_Cb e_mod_mixer_channel_info_get_by_name;
E_Mixer_Cb e_mod_mixer_channel_name_get; E_Mixer_Cb e_mod_mixer_channel_name_get;
E_Mixer_Cb e_mod_mixer_channel_del;
E_Mixer_Cb e_mod_mixer_channel_free;
E_Mixer_Cb e_mod_mixer_channels_get; E_Mixer_Cb e_mod_mixer_channels_get;
E_Mixer_Cb e_mod_mixer_channel_names_get; E_Mixer_Cb e_mod_mixer_channel_names_get;
E_Mixer_Cb e_mod_mixer_card_name_get; E_Mixer_Cb e_mod_mixer_card_name_get;
@ -34,9 +32,8 @@ e_mixer_default_setup(void)
e_mod_mixer_new = (void *)e_mixer_system_new; e_mod_mixer_new = (void *)e_mixer_system_new;
e_mod_mixer_del = (void *)e_mixer_system_del; e_mod_mixer_del = (void *)e_mixer_system_del;
e_mod_mixer_channel_default_name_get = (void *)e_mixer_system_get_default_channel_name; e_mod_mixer_channel_default_name_get = (void *)e_mixer_system_get_default_channel_name;
e_mod_mixer_channel_get_by_name = (void *)e_mixer_system_get_channel_by_name; e_mod_mixer_channel_info_get_by_name = (void *)e_mixer_system_get_channel_by_name;
e_mod_mixer_channel_name_get = (void *)e_mixer_system_get_channel_name; e_mod_mixer_channel_name_get = (void *)e_mixer_system_get_channel_name;
e_mod_mixer_channel_del = (void *)e_mixer_system_channel_del;
e_mod_mixer_channels_get = (void *)e_mixer_system_get_channels; e_mod_mixer_channels_get = (void *)e_mixer_system_get_channels;
e_mod_mixer_channel_names_get = (void *)e_mixer_system_get_channel_names; e_mod_mixer_channel_names_get = (void *)e_mixer_system_get_channel_names;
e_mod_mixer_card_name_get = (void *)e_mixer_system_get_card_name; e_mod_mixer_card_name_get = (void *)e_mixer_system_get_card_name;
@ -58,9 +55,8 @@ e_mixer_pulse_setup()
e_mod_mixer_new = (void *)e_mixer_pulse_new; e_mod_mixer_new = (void *)e_mixer_pulse_new;
e_mod_mixer_del = (void *)e_mixer_pulse_del; e_mod_mixer_del = (void *)e_mixer_pulse_del;
e_mod_mixer_channel_default_name_get = (void *)e_mixer_pulse_get_default_channel_name; e_mod_mixer_channel_default_name_get = (void *)e_mixer_pulse_get_default_channel_name;
e_mod_mixer_channel_get_by_name = (void *)e_mixer_pulse_get_channel_by_name; e_mod_mixer_channel_info_get_by_name = (void *)e_mixer_pulse_get_channel_by_name;
e_mod_mixer_channel_name_get = (void *)e_mixer_pulse_get_channel_name; e_mod_mixer_channel_name_get = (void *)e_mixer_pulse_get_channel_name;
e_mod_mixer_channel_del = (void *)e_mixer_pulse_channel_del;
e_mod_mixer_channels_get = (void *)e_mixer_pulse_get_channels; e_mod_mixer_channels_get = (void *)e_mixer_pulse_get_channels;
e_mod_mixer_channel_names_get = (void *)e_mixer_pulse_get_channel_names; e_mod_mixer_channel_names_get = (void *)e_mixer_pulse_get_channel_names;
e_mod_mixer_card_name_get = (void *)e_mixer_pulse_get_card_name; e_mod_mixer_card_name_get = (void *)e_mixer_pulse_get_card_name;
@ -82,6 +78,13 @@ _channel_info_cmp(const void *data_a, const void *data_b)
return strcmp(a->name, b->name); return strcmp(a->name, b->name);
} }
void e_mod_mixer_channel_info_free(E_Mixer_Channel_Info* info)
{
if (!info) return;
eina_stringshare_del(info->name);
free(info);
}
Eina_List * Eina_List *
e_mod_mixer_channel_infos_get(E_Mixer_System *sys) e_mod_mixer_channel_infos_get(E_Mixer_System *sys)
{ {

59
src/modules/mixer/e_mod_mixer.h
View File

@ -22,12 +22,12 @@ typedef struct _E_Mixer_Channel_Info
E_Mixer_App *app; E_Mixer_App *app;
} E_Mixer_Channel_Info; } E_Mixer_Channel_Info;
typedef int (*E_Mixer_Volume_Set_Cb)(E_Mixer_System *, E_Mixer_Channel *, int, int); typedef int (*E_Mixer_Volume_Set_Cb)(E_Mixer_System *, E_Mixer_Channel_Info *, int, int);
typedef int (*E_Mixer_Volume_Get_Cb)(E_Mixer_System *, E_Mixer_Channel *, int *, int *); typedef int (*E_Mixer_Volume_Get_Cb)(E_Mixer_System *, E_Mixer_Channel_Info *, int *, int *);
typedef int (*E_Mixer_Mute_Get_Cb)(E_Mixer_System *, E_Mixer_Channel *, int *); typedef int (*E_Mixer_Mute_Get_Cb)(E_Mixer_System *, E_Mixer_Channel_Info *, int *);
typedef int (*E_Mixer_Mute_Set_Cb)(E_Mixer_System *, E_Mixer_Channel *, int); typedef int (*E_Mixer_Mute_Set_Cb)(E_Mixer_System *, E_Mixer_Channel_Info *, int);
typedef int (*E_Mixer_State_Get_Cb)(E_Mixer_System *, E_Mixer_Channel *, E_Mixer_Channel_State *); typedef int (*E_Mixer_State_Get_Cb)(E_Mixer_System *, E_Mixer_Channel_Info *, E_Mixer_Channel_State *);
typedef int (*E_Mixer_Capture_Cb)(E_Mixer_System *, E_Mixer_Channel *); typedef int (*E_Mixer_Capture_Cb)(E_Mixer_System *, E_Mixer_Channel_Info *);
typedef void *(*E_Mixer_Cb)(); typedef void *(*E_Mixer_Cb)();
extern Eina_Bool _mixer_using_default; extern Eina_Bool _mixer_using_default;
@ -41,15 +41,14 @@ extern E_Mixer_Capture_Cb e_mod_mixer_capture_get;
extern E_Mixer_Cb e_mod_mixer_new; extern E_Mixer_Cb e_mod_mixer_new;
extern E_Mixer_Cb e_mod_mixer_del; extern E_Mixer_Cb e_mod_mixer_del;
extern E_Mixer_Cb e_mod_mixer_channel_default_name_get; extern E_Mixer_Cb e_mod_mixer_channel_default_name_get;
extern E_Mixer_Cb e_mod_mixer_channel_get_by_name; extern E_Mixer_Cb e_mod_mixer_channel_info_get_by_name;
extern E_Mixer_Cb e_mod_mixer_channel_name_get; extern E_Mixer_Cb e_mod_mixer_channel_name_get;
extern E_Mixer_Cb e_mod_mixer_channel_del;
extern E_Mixer_Cb e_mod_mixer_channel_free;
extern E_Mixer_Cb e_mod_mixer_channel_names_get; extern E_Mixer_Cb e_mod_mixer_channel_names_get;
extern E_Mixer_Cb e_mod_mixer_card_name_get; extern E_Mixer_Cb e_mod_mixer_card_name_get;
extern E_Mixer_Cb e_mod_mixer_card_names_get; extern E_Mixer_Cb e_mod_mixer_card_names_get;
extern E_Mixer_Cb e_mod_mixer_card_default_get; extern E_Mixer_Cb e_mod_mixer_card_default_get;
void e_mod_mixer_channel_info_free(E_Mixer_Channel_Info*);
Eina_List *e_mod_mixer_channel_infos_get(E_Mixer_System *sys); Eina_List *e_mod_mixer_channel_infos_get(E_Mixer_System *sys);
void e_mod_mixer_channel_infos_free(Eina_List*); void e_mod_mixer_channel_infos_free(Eina_List*);
void e_mod_mixer_channel_names_free(Eina_List*); void e_mod_mixer_channel_names_free(Eina_List*);
@ -67,23 +66,22 @@ void e_mixer_system_del(E_Mixer_System *self);
Eina_List *e_mixer_system_get_cards(void); Eina_List *e_mixer_system_get_cards(void);
const char *e_mixer_system_get_default_card(void); const char *e_mixer_system_get_default_card(void);
const char *e_mixer_system_get_card_name(const char *card); const char *e_mixer_system_get_card_name(const char *card);
const char *e_mixer_system_get_channel_name(E_Mixer_System *self, E_Mixer_Channel *channel); const char *e_mixer_system_get_channel_name(E_Mixer_System *self, E_Mixer_Channel_Info *channel);
Eina_List *e_mixer_system_get_channels(E_Mixer_System *self); Eina_List *e_mixer_system_get_channels(E_Mixer_System *self);
Eina_List *e_mixer_system_get_channel_names(E_Mixer_System *self); Eina_List *e_mixer_system_get_channel_names(E_Mixer_System *self);
const char *e_mixer_system_get_default_channel_name(E_Mixer_System *self); const char *e_mixer_system_get_default_channel_name(E_Mixer_System *self);
E_Mixer_Channel *e_mixer_system_get_channel_by_name(E_Mixer_System *self, const char *name); E_Mixer_Channel_Info *e_mixer_system_get_channel_by_name(E_Mixer_System *self, const char *name);
void e_mixer_system_channel_del(E_Mixer_Channel *channel);
int e_mixer_system_has_capture(E_Mixer_System *self, E_Mixer_Channel *channel); int e_mixer_system_has_capture(E_Mixer_System *self, E_Mixer_Channel_Info *channel);
int e_mixer_system_get_volume(E_Mixer_System *self, E_Mixer_Channel *channel, int *left, int *right); int e_mixer_system_get_volume(E_Mixer_System *self, E_Mixer_Channel_Info *channel, int *left, int *right);
int e_mixer_system_set_volume(E_Mixer_System *self, E_Mixer_Channel *channel, int left, int right); int e_mixer_system_set_volume(E_Mixer_System *self, E_Mixer_Channel_Info *channel, int left, int right);
int e_mixer_system_can_mute(E_Mixer_System *self, E_Mixer_Channel *channel); int e_mixer_system_can_mute(E_Mixer_System *self, E_Mixer_Channel_Info *channel);
int e_mixer_system_get_mute(E_Mixer_System *self, E_Mixer_Channel *channel, int *mute); int e_mixer_system_get_mute(E_Mixer_System *self, E_Mixer_Channel_Info *channel, int *mute);
int e_mixer_system_set_mute(E_Mixer_System *self, E_Mixer_Channel *channel, int mute); int e_mixer_system_set_mute(E_Mixer_System *self, E_Mixer_Channel_Info *channel, int mute);
int e_mixer_system_get_state(E_Mixer_System *self, E_Mixer_Channel *channel, E_Mixer_Channel_State *state); int e_mixer_system_get_state(E_Mixer_System *self, E_Mixer_Channel_Info *channel, E_Mixer_Channel_State *state);
int e_mixer_system_set_state(E_Mixer_System *self, E_Mixer_Channel *channel, const E_Mixer_Channel_State *state); int e_mixer_system_set_state(E_Mixer_System *self, E_Mixer_Channel_Info *channel, const E_Mixer_Channel_State *state);
/* PULSE */ /* PULSE */
int pulse_init(void); int pulse_init(void);
@ -97,23 +95,22 @@ void e_mixer_pulse_del(E_Mixer_System *self);
Eina_List *e_mixer_pulse_get_cards(void); Eina_List *e_mixer_pulse_get_cards(void);
const char *e_mixer_pulse_get_default_card(void); const char *e_mixer_pulse_get_default_card(void);
const char *e_mixer_pulse_get_card_name(const char *card); const char *e_mixer_pulse_get_card_name(const char *card);
const char *e_mixer_pulse_get_channel_name(E_Mixer_System *self, E_Mixer_Channel *channel); const char *e_mixer_pulse_get_channel_name(E_Mixer_System *self, E_Mixer_Channel_Info *channel);
Eina_List *e_mixer_pulse_get_channels(E_Mixer_System *self); Eina_List *e_mixer_pulse_get_channels(E_Mixer_System *self);
Eina_List *e_mixer_pulse_get_channel_names(E_Mixer_System *self); Eina_List *e_mixer_pulse_get_channel_names(E_Mixer_System *self);
const char *e_mixer_pulse_get_default_channel_name(E_Mixer_System *self); const char *e_mixer_pulse_get_default_channel_name(E_Mixer_System *self);
E_Mixer_Channel *e_mixer_pulse_get_channel_by_name(E_Mixer_System *self, const char *name); E_Mixer_Channel_Info *e_mixer_pulse_get_channel_by_name(E_Mixer_System *self, const char *name);
void e_mixer_pulse_channel_del(E_Mixer_Channel *channel);
int e_mixer_pulse_has_capture(E_Mixer_System *self, E_Mixer_Channel *channel); int e_mixer_pulse_has_capture(E_Mixer_System *self, E_Mixer_Channel_Info *channel);
int e_mixer_pulse_get_volume(E_Mixer_System *self, E_Mixer_Channel *channel, int *left, int *right); int e_mixer_pulse_get_volume(E_Mixer_System *self, E_Mixer_Channel_Info *channel, int *left, int *right);
int e_mixer_pulse_set_volume(E_Mixer_System *self, E_Mixer_Channel *channel, int left, int right); int e_mixer_pulse_set_volume(E_Mixer_System *self, E_Mixer_Channel_Info *channel, int left, int right);
int e_mixer_pulse_can_mute(E_Mixer_System *self, E_Mixer_Channel *channel); int e_mixer_pulse_can_mute(E_Mixer_System *self, E_Mixer_Channel_Info *channel);
int e_mixer_pulse_get_mute(E_Mixer_System *self, E_Mixer_Channel *channel, int *mute); int e_mixer_pulse_get_mute(E_Mixer_System *self, E_Mixer_Channel_Info *channel, int *mute);
int e_mixer_pulse_set_mute(E_Mixer_System *self, E_Mixer_Channel *channel, int mute); int e_mixer_pulse_set_mute(E_Mixer_System *self, E_Mixer_Channel_Info *channel, int mute);
int e_mixer_pulse_get_state(E_Mixer_System *self, E_Mixer_Channel *channel, E_Mixer_Channel_State *state); int e_mixer_pulse_get_state(E_Mixer_System *self, E_Mixer_Channel_Info *channel, E_Mixer_Channel_State *state);
int e_mixer_pulse_set_state(E_Mixer_System *self, E_Mixer_Channel *channel, const E_Mixer_Channel_State *state); int e_mixer_pulse_set_state(E_Mixer_System *self, E_Mixer_Channel_Info *channel, const E_Mixer_Channel_State *state);
/** /**
* @addtogroup Optional_Devices * @addtogroup Optional_Devices

95
src/modules/mixer/sys_alsa.c
View File

@ -383,12 +383,13 @@ e_mixer_system_get_default_channel_name(E_Mixer_System *self)
return NULL; return NULL;
} }
E_Mixer_Channel * E_Mixer_Channel_Info *
e_mixer_system_get_channel_by_name(E_Mixer_System *self, e_mixer_system_get_channel_by_name(E_Mixer_System *self,
const char *name) const char *name)
{ {
snd_mixer_elem_t *elem; snd_mixer_elem_t *elem;
snd_mixer_selem_id_t *sid; snd_mixer_selem_id_t *sid;
E_Mixer_Channel_Info *ch_info;
if ((!self) || (!name)) if ((!self) || (!name))
return NULL; return NULL;
@ -406,29 +407,31 @@ e_mixer_system_get_channel_by_name(E_Mixer_System *self,
snd_mixer_selem_get_id(elem, sid); snd_mixer_selem_get_id(elem, sid);
n = snd_mixer_selem_id_get_name(sid); n = snd_mixer_selem_id_get_name(sid);
if (n && (strcmp(n, name) == 0)) if (n && (strcmp(n, name) == 0))
return elem; {
ch_info = malloc(sizeof(*ch_info));
ch_info->id = elem;
ch_info->name = eina_stringshare_add(n);
ch_info->has_capture = snd_mixer_selem_has_capture_switch(elem) || snd_mixer_selem_has_capture_volume(elem);
return ch_info;
}
} }
return NULL; return NULL;
} }
void
e_mixer_system_channel_del(E_Mixer_Channel *channel __UNUSED__)
{
}
const char * const char *
e_mixer_system_get_channel_name(E_Mixer_System *self, e_mixer_system_get_channel_name(E_Mixer_System *self,
E_Mixer_Channel *channel) E_Mixer_Channel_Info *channel)
{ {
snd_mixer_selem_id_t *sid; snd_mixer_selem_id_t *sid;
const char *name; const char *name;
if ((!self) || (!channel)) if ((!self) || (!channel) || (!channel->id) )
return NULL; return NULL;
snd_mixer_selem_id_alloca(&sid); snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_get_id(channel, sid); snd_mixer_selem_get_id(channel->id, sid);
name = eina_stringshare_add(snd_mixer_selem_id_get_name(sid)); name = eina_stringshare_add(snd_mixer_selem_id_get_name(sid));
return name; return name;
@ -436,33 +439,33 @@ e_mixer_system_get_channel_name(E_Mixer_System *self,
int int
e_mixer_system_get_volume(E_Mixer_System *self, e_mixer_system_get_volume(E_Mixer_System *self,
E_Mixer_Channel *channel, E_Mixer_Channel_Info *channel,
int *left, int *left,
int *right) int *right)
{ {
long lvol, rvol, range, min, max; long lvol, rvol, range, min, max;
if ((!self) || (!channel) || (!left) || (!right)) if ((!self) || (!channel) || (!channel->id) || (!left) || (!right))
return 0; return 0;
snd_mixer_handle_events(self); snd_mixer_handle_events(self);
snd_mixer_selem_get_playback_volume_range(channel, &min, &max); snd_mixer_selem_get_playback_volume_range(channel->id, &min, &max);
range = max - min; range = max - min;
if (range < 1) if (range < 1)
return 0; return 0;
if (snd_mixer_selem_has_playback_channel(channel, 0)) if (snd_mixer_selem_has_playback_channel(channel->id, 0))
snd_mixer_selem_get_playback_volume(channel, 0, &lvol); snd_mixer_selem_get_playback_volume(channel->id, 0, &lvol);
else else
lvol = min; lvol = min;
if (snd_mixer_selem_has_playback_channel(channel, 1)) if (snd_mixer_selem_has_playback_channel(channel->id, 1))
snd_mixer_selem_get_playback_volume(channel, 1, &rvol); snd_mixer_selem_get_playback_volume(channel->id, 1, &rvol);
else else
rvol = min; rvol = min;
if (snd_mixer_selem_is_playback_mono(channel) || if (snd_mixer_selem_is_playback_mono(channel->id) ||
snd_mixer_selem_has_playback_volume_joined(channel)) snd_mixer_selem_has_playback_volume_joined(channel->id))
rvol = lvol; rvol = lvol;
*left = rint((double)(lvol - min) * 100 / (double)range); *left = rint((double)(lvol - min) * 100 / (double)range);
@ -473,18 +476,18 @@ e_mixer_system_get_volume(E_Mixer_System *self,
int int
e_mixer_system_set_volume(E_Mixer_System *self, e_mixer_system_set_volume(E_Mixer_System *self,
E_Mixer_Channel *channel, E_Mixer_Channel_Info *channel,
int left, int left,
int right) int right)
{ {
long range, min, max, divide; long range, min, max, divide;
int mode; int mode;
if ((!self) || (!channel)) if ((!self) || (!channel) || (!channel->id))
return 0; return 0;
snd_mixer_handle_events(self); snd_mixer_handle_events(self);
snd_mixer_selem_get_playback_volume_range(channel, &min, &max); snd_mixer_selem_get_playback_volume_range(channel->id, &min, &max);
divide = 100 + min; divide = 100 + min;
if (divide == 0) if (divide == 0)
{ {
@ -510,14 +513,14 @@ e_mixer_system_set_volume(E_Mixer_System *self,
} }
if (mode & 1) if (mode & 1)
snd_mixer_selem_set_playback_volume(channel, 0, left); snd_mixer_selem_set_playback_volume(channel->id, 0, left);
if ((!snd_mixer_selem_is_playback_mono(channel)) && if ((!snd_mixer_selem_is_playback_mono(channel->id)) &&
(!snd_mixer_selem_has_playback_volume_joined(channel)) && (!snd_mixer_selem_has_playback_volume_joined(channel->id)) &&
(mode & 2)) (mode & 2))
{ {
if (snd_mixer_selem_has_playback_channel(channel, 1)) if (snd_mixer_selem_has_playback_channel(channel->id, 1))
snd_mixer_selem_set_playback_volume(channel, 1, right); snd_mixer_selem_set_playback_volume(channel->id, 1, right);
} }
return 1; return 1;
@ -525,34 +528,34 @@ e_mixer_system_set_volume(E_Mixer_System *self,
int int
e_mixer_system_can_mute(E_Mixer_System *self, e_mixer_system_can_mute(E_Mixer_System *self,
E_Mixer_Channel *channel) E_Mixer_Channel_Info *channel)
{ {
if ((!self) || (!channel)) if ((!self) || (!channel) || (!channel->id))
return 0; return 0;
snd_mixer_handle_events(self); snd_mixer_handle_events(self);
return snd_mixer_selem_has_playback_switch(channel) || return snd_mixer_selem_has_playback_switch(channel->id) ||
snd_mixer_selem_has_playback_switch_joined(channel); snd_mixer_selem_has_playback_switch_joined(channel->id);
} }
int int
e_mixer_system_get_mute(E_Mixer_System *self, e_mixer_system_get_mute(E_Mixer_System *self,
E_Mixer_Channel *channel, E_Mixer_Channel_Info *channel,
int *mute) int *mute)
{ {
if ((!self) || (!channel) || (!mute)) if ((!self) || (!channel) || (!channel->id) || (!mute))
return 0; return 0;
snd_mixer_handle_events(self); snd_mixer_handle_events(self);
if (snd_mixer_selem_has_playback_switch(channel) || if (snd_mixer_selem_has_playback_switch(channel->id) ||
snd_mixer_selem_has_playback_switch_joined(channel)) snd_mixer_selem_has_playback_switch_joined(channel->id))
{ {
int m; int m;
/* XXX: not checking for return, always returns 0 even if it worked. /* XXX: not checking for return, always returns 0 even if it worked.
* alsamixer also don't check it. Bug? * alsamixer also don't check it. Bug?
*/ */
snd_mixer_selem_get_playback_switch(channel, 0, &m); snd_mixer_selem_get_playback_switch(channel->id, 0, &m);
*mute = !m; *mute = !m;
} }
else else
@ -563,23 +566,23 @@ e_mixer_system_get_mute(E_Mixer_System *self,
int int
e_mixer_system_set_mute(E_Mixer_System *self, e_mixer_system_set_mute(E_Mixer_System *self,
E_Mixer_Channel *channel, E_Mixer_Channel_Info *channel,
int mute) int mute)
{ {
if ((!self) || (!channel)) if ((!self) || (!channel) || (!channel->id))
return 0; return 0;
snd_mixer_handle_events(self); snd_mixer_handle_events(self);
if (snd_mixer_selem_has_playback_switch(channel) || if (snd_mixer_selem_has_playback_switch(channel->id) ||
snd_mixer_selem_has_playback_switch_joined(channel)) snd_mixer_selem_has_playback_switch_joined(channel->id))
return snd_mixer_selem_set_playback_switch_all(channel, !mute); return snd_mixer_selem_set_playback_switch_all(channel->id, !mute);
else else
return 0; return 0;
} }
int int
e_mixer_system_get_state(E_Mixer_System *self, e_mixer_system_get_state(E_Mixer_System *self,
E_Mixer_Channel *channel, E_Mixer_Channel_Info *channel,
E_Mixer_Channel_State *state) E_Mixer_Channel_State *state)
{ {
int r; int r;
@ -594,7 +597,7 @@ e_mixer_system_get_state(E_Mixer_System *self,
int int
e_mixer_system_set_state(E_Mixer_System *self, e_mixer_system_set_state(E_Mixer_System *self,
E_Mixer_Channel *channel, E_Mixer_Channel_Info *channel,
const E_Mixer_Channel_State *state) const E_Mixer_Channel_State *state)
{ {
int r; int r;
@ -609,11 +612,11 @@ e_mixer_system_set_state(E_Mixer_System *self,
int int
e_mixer_system_has_capture(E_Mixer_System *self, e_mixer_system_has_capture(E_Mixer_System *self,
E_Mixer_Channel *channel) E_Mixer_Channel_Info *channel)
{ {
if ((!self) || (!channel)) if ((!self) || (!channel) || (!channel->id))
return 0; return 0;
return snd_mixer_selem_has_capture_switch(channel) || snd_mixer_selem_has_capture_volume(channel); return snd_mixer_selem_has_capture_switch(channel->id) || snd_mixer_selem_has_capture_volume(channel->id);
} }

40
src/modules/mixer/sys_dummy.c
View File

@ -90,35 +90,41 @@ e_mixer_system_get_default_channel_name(E_Mixer_System *self __UNUSED__)
return eina_stringshare_ref(_name); return eina_stringshare_ref(_name);
} }
E_Mixer_Channel * E_Mixer_Channel_Info *
e_mixer_system_get_channel_by_name(E_Mixer_System *self __UNUSED__, const char *name) e_mixer_system_get_channel_by_name(E_Mixer_System *self __UNUSED__, const char *name)
{ {
E_Mixer_Channel_Info *ch_info;
_e_mixer_dummy_set(); _e_mixer_dummy_set();
if (name == _name || strcmp(name, _name) == 0) if (name == _name || strcmp(name, _name) == 0)
return (E_Mixer_Channel *)-2; {
ch_info = malloc(sizeof(*ch_info));
ch_info->id = (void*)-2;
ch_info->name = eina_stringshare_ref(_name);
ch_info->has_capture = 0;
return ch_info;
}
else else
return NULL; return NULL;
} }
void
e_mixer_system_channel_del(E_Mixer_Channel *channel __UNUSED__)
{
}
const char * const char *
e_mixer_system_get_channel_name(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel) e_mixer_system_get_channel_name(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel)
{ {
_e_mixer_dummy_set(); _e_mixer_dummy_set();
if (channel == (E_Mixer_Channel *)-2) if (!channel)
return NULL;
if (channel->id == (E_Mixer_Channel *)-2)
return eina_stringshare_ref(_name); return eina_stringshare_ref(_name);
else else
return NULL; return NULL;
} }
int int
e_mixer_system_get_volume(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel __UNUSED__, int *left, int *right) e_mixer_system_get_volume(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel __UNUSED__, int *left, int *right)
{ {
if (left) if (left)
*left = 0; *left = 0;
@ -129,19 +135,19 @@ e_mixer_system_get_volume(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *chan
} }
int int
e_mixer_system_set_volume(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel __UNUSED__, int left __UNUSED__, int right __UNUSED__) e_mixer_system_set_volume(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel __UNUSED__, int left __UNUSED__, int right __UNUSED__)
{ {
return 0; return 0;
} }
int int
e_mixer_system_can_mute(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel __UNUSED__) e_mixer_system_can_mute(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel __UNUSED__)
{ {
return 1; return 1;
} }
int int
e_mixer_system_get_mute(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel __UNUSED__, int *mute) e_mixer_system_get_mute(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel __UNUSED__, int *mute)
{ {
if (mute) if (mute)
*mute = 1; *mute = 1;
@ -150,13 +156,13 @@ e_mixer_system_get_mute(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channe
} }
int int
e_mixer_system_set_mute(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel __UNUSED__, int mute __UNUSED__) e_mixer_system_set_mute(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel __UNUSED__, int mute __UNUSED__)
{ {
return 0; return 0;
} }
int int
e_mixer_system_get_state(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel __UNUSED__, E_Mixer_Channel_State *state) e_mixer_system_get_state(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel __UNUSED__, E_Mixer_Channel_State *state)
{ {
const E_Mixer_Channel_State def = {1, 0, 0}; const E_Mixer_Channel_State def = {1, 0, 0};
@ -167,13 +173,13 @@ e_mixer_system_get_state(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *chann
} }
int int
e_mixer_system_set_state(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel __UNUSED__, const E_Mixer_Channel_State *state __UNUSED__) e_mixer_system_set_state(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel __UNUSED__, const E_Mixer_Channel_State *state __UNUSED__)
{ {
return 0; return 0;
} }
int int
e_mixer_system_has_capture(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel __UNUSED__) e_mixer_system_has_capture(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel __UNUSED__)
{ {
return 0; return 0;
} }

37
src/modules/mixer/sys_pulse.c
View File

@ -297,11 +297,12 @@ static Eina_Bool
_pulse_queue_process(const Eina_Hash *h EINA_UNUSED, const char *key, E_Mixer_Channel_State *state, void *d EINA_UNUSED) _pulse_queue_process(const Eina_Hash *h EINA_UNUSED, const char *key, E_Mixer_Channel_State *state, void *d EINA_UNUSED)
{ {
Eina_List *l, *list[2] = {sinks, sources}; Eina_List *l, *list[2] = {sinks, sources};
void *s, *ch; E_Mixer_Channel_Info ch;
void *s;
int x; int x;
if ((state->mute == -1) && (state->left == -1) && (state->right == -1)) return EINA_TRUE; if ((state->mute == -1) && (state->left == -1) && (state->right == -1)) return EINA_TRUE;
ch = (void*)1; ch.id = (void*)1;
for (x = 0; x < 2; x++) for (x = 0; x < 2; x++)
EINA_LIST_FOREACH(list[x], l, s) EINA_LIST_FOREACH(list[x], l, s)
{ {
@ -493,26 +494,28 @@ e_mixer_pulse_get_default_channel_name(E_Mixer_System *self EINA_UNUSED)
return eina_stringshare_ref(_name); return eina_stringshare_ref(_name);
} }
E_Mixer_Channel * E_Mixer_Channel_Info *
e_mixer_pulse_get_channel_by_name(E_Mixer_System *self EINA_UNUSED, const char *name EINA_UNUSED) e_mixer_pulse_get_channel_by_name(E_Mixer_System *self EINA_UNUSED, const char *name EINA_UNUSED)
{ {
return (E_Mixer_Channel *)1; E_Mixer_Channel_Info *ch_info;
}
void ch_info = malloc(sizeof(*ch_info));
e_mixer_pulse_channel_del(E_Mixer_Channel *channel __UNUSED__) ch_info->id = (void*)1;
{ ch_info->name = eina_stringshare_ref(_name);
ch_info->has_capture = 0;
return ch_info;
} }
const char * const char *
e_mixer_pulse_get_channel_name(E_Mixer_System *self EINA_UNUSED, E_Mixer_Channel *channel) e_mixer_pulse_get_channel_name(E_Mixer_System *self EINA_UNUSED, E_Mixer_Channel_Info *channel)
{ {
if (!channel) return NULL; if (!channel) return NULL;
return eina_stringshare_ref(_name); return eina_stringshare_ref(_name);
} }
int int
e_mixer_pulse_get_volume(E_Mixer_System *self, E_Mixer_Channel *channel, int *left, int *right) e_mixer_pulse_get_volume(E_Mixer_System *self, E_Mixer_Channel_Info *channel, int *left, int *right)
{ {
double volume; double volume;
int x, n; int x, n;
@ -536,7 +539,7 @@ e_mixer_pulse_get_volume(E_Mixer_System *self, E_Mixer_Channel *channel, int *le
} }
int int
e_mixer_pulse_set_volume(E_Mixer_System *self, E_Mixer_Channel *channel, int left, int right) e_mixer_pulse_set_volume(E_Mixer_System *self, E_Mixer_Channel_Info *channel, int left, int right)
{ {
uint32_t id = 0; uint32_t id = 0;
int x, n; int x, n;
@ -573,20 +576,20 @@ e_mixer_pulse_set_volume(E_Mixer_System *self, E_Mixer_Channel *channel, int lef
} }
int int
e_mixer_pulse_can_mute(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel __UNUSED__) e_mixer_pulse_can_mute(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel __UNUSED__)
{ {
return 1; return 1;
} }
int int
e_mixer_pulse_get_mute(E_Mixer_System *self, E_Mixer_Channel *channel __UNUSED__, int *mute) e_mixer_pulse_get_mute(E_Mixer_System *self, E_Mixer_Channel_Info *channel __UNUSED__, int *mute)
{ {
if (mute) *mute = pulse_sink_muted_get((void *)self); if (mute) *mute = pulse_sink_muted_get((void *)self);
return 1; return 1;
} }
int int
e_mixer_pulse_set_mute(E_Mixer_System *self, E_Mixer_Channel *channel __UNUSED__, int mute) e_mixer_pulse_set_mute(E_Mixer_System *self, E_Mixer_Channel_Info *channel __UNUSED__, int mute)
{ {
uint32_t id; uint32_t id;
Eina_Bool source = EINA_FALSE; Eina_Bool source = EINA_FALSE;
@ -605,7 +608,7 @@ e_mixer_pulse_set_mute(E_Mixer_System *self, E_Mixer_Channel *channel __UNUSED__
} }
int int
e_mixer_pulse_get_state(E_Mixer_System *self, E_Mixer_Channel *channel, E_Mixer_Channel_State *state) e_mixer_pulse_get_state(E_Mixer_System *self, E_Mixer_Channel_Info *channel, E_Mixer_Channel_State *state)
{ {
if (!state) return 0; if (!state) return 0;
if (!channel) return 0; if (!channel) return 0;
@ -615,7 +618,7 @@ e_mixer_pulse_get_state(E_Mixer_System *self, E_Mixer_Channel *channel, E_Mixer_
} }
int int
e_mixer_pulse_set_state(E_Mixer_System *self, E_Mixer_Channel *channel, const E_Mixer_Channel_State *state) e_mixer_pulse_set_state(E_Mixer_System *self, E_Mixer_Channel_Info *channel, const E_Mixer_Channel_State *state)
{ {
e_mixer_pulse_set_volume(self, channel, state->left, state->right); e_mixer_pulse_set_volume(self, channel, state->left, state->right);
e_mixer_pulse_set_mute(self, channel, state->mute); e_mixer_pulse_set_mute(self, channel, state->mute);
@ -623,7 +626,7 @@ e_mixer_pulse_set_state(E_Mixer_System *self, E_Mixer_Channel *channel, const E_
} }
int int
e_mixer_pulse_has_capture(E_Mixer_System *self __UNUSED__, E_Mixer_Channel *channel __UNUSED__) e_mixer_pulse_has_capture(E_Mixer_System *self __UNUSED__, E_Mixer_Channel_Info *channel __UNUSED__)
{ {
return 0; return 0;
} }