void
moko_alsa_volume_control_set_element_from_name (MokoAlsaVolumeControl *control,
const gchar *name)
{
MokoAlsaVolumeControlPrivate *priv =
ALSA_VOLUME_CONTROL_PRIVATE (control);
if (!priv->device) return;
detach_mixer (control);
if (!name) {
moko_alsa_volume_control_set_element (control, NULL);
return;
}
open_mixer (control);
if ((snd_mixer_attach (priv->mixer_handle, priv->device) == 0) &&
(snd_mixer_selem_register (priv->mixer_handle, NULL, NULL) == 0) &&
(snd_mixer_load (priv->mixer_handle) == 0)) {
snd_mixer_elem_t *elem;
elem = snd_mixer_first_elem (priv->mixer_handle);
while (elem) {
const char *elem_name = snd_mixer_selem_get_name (elem);
if (strcmp (elem_name, name) == 0)
break;
elem = snd_mixer_elem_next (elem);
}
if (!elem) {
snd_mixer_detach (priv->mixer_handle, priv->device);
close_mixer (control);
g_warning ("Mixer element '%s' not found", name);
attach_mixer (control);
} else {
snd_mixer_selem_id_t *id;
if (snd_mixer_selem_id_malloc (&id) != 0) {
g_warning ("Unable to allocate element id");
snd_mixer_detach (
priv->mixer_handle, priv->device);
close_mixer (control);
} else {
snd_mixer_selem_get_id (elem, id);
snd_mixer_detach (
priv->mixer_handle, priv->device);
close_mixer (control);
g_debug ("Setting element ID");
moko_alsa_volume_control_set_element (
control, id);
snd_mixer_selem_id_free (id);
}
}
} else
g_warning ("Unable to open mixer on card '%s'", priv->device);
}
int closeMixer()
{
int result = snd_mixer_detach( mixerFd, "default" );
result = snd_mixer_close( mixerFd );
return 0;
}
void VolumeControl::deinit()
{
//deinitialize audio mixer interface
#if defined (__APPLE__)
#warning TODO: Not implemented for MacOS yet!!!
#elif defined(__linux__)
if (mixerHandle != nullptr) {
snd_mixer_detach(mixerHandle, mixerCard);
snd_mixer_free(mixerHandle);
snd_mixer_close(mixerHandle);
mixerHandle = nullptr;
mixerElem = nullptr;
}
#elif defined(WIN32) || defined(_WIN32)
if (mixerHandle != nullptr) {
mixerClose(mixerHandle);
mixerHandle = nullptr;
}
else if (endpointVolume != nullptr) {
endpointVolume->Release();
endpointVolume = nullptr;
CoUninitialize();
}
#endif
}
static void
laudio_alsa_close(void)
{
struct pcm_packet *pkt;
snd_pcm_close(hdl);
hdl = NULL;
if (mixer_hdl)
{
snd_mixer_detach(mixer_hdl, card_name);
snd_mixer_close(mixer_hdl);
mixer_hdl = NULL;
vol_elem = NULL;
}
for (pkt = pcm_pkt_head; pcm_pkt_head; pkt = pcm_pkt_head)
{
pcm_pkt_head = pkt->next;
free(pkt);
}
pcm_pkt_head = NULL;
pcm_pkt_tail = NULL;
update_status(LAUDIO_CLOSED);
}
static void close_hctl(void)
{
free_controls();
if (mixer_device_name) {
snd_mixer_detach(mixer, mixer_device_name);
free(mixer_device_name);
mixer_device_name = NULL;
}
}
void NeoControl::closeAlsaMixer()
{
if (mixerFd) {
snd_mixer_detach(mixerFd, "default");
snd_mixer_close(mixerFd);
mixerFd = NULL;
}
system("alsactl -f /opt/qtmoko/etc/alsa-scenarios/stereoout.state restore");
}
void lamixer_mixer_destroy()
{
g_free(alsa_chans);
snd_mixer_detach(mixer_handle, card_id);
snd_mixer_close(mixer_handle);
lamixer_widgets_destroy(mixerbox);
lamixer_widgets_destroy(capturebox);
g_list_free (VolumeBoxes);
VolumeBoxes = NULL;
}
static void
detach_mixer (MokoAlsaVolumeControl *self)
{
MokoAlsaVolumeControlPrivate *priv = ALSA_VOLUME_CONTROL_PRIVATE (self);
if (priv->mixer_handle && priv->device &&
priv->element && priv->mixer_elem) {
snd_mixer_detach (priv->mixer_handle, priv->device);
priv->mixer_elem = NULL;
g_debug ("Detached from mixer");
close_mixer (self);
}
}
int get_vol_mute(long* vol, int* mute) {
snd_mixer_t* handle;
int open_code = snd_mixer_open(&handle, 0);
if (open_code != 0) return open_code;
int attach_code = snd_mixer_attach(handle, "default");
if (attach_code != 0) {
snd_mixer_close(handle);
return attach_code;
}
int register_code = snd_mixer_selem_register(handle, NULL, NULL);
if (register_code != 0) {
cleanup_handle(handle);
return register_code;
}
int load_code = snd_mixer_load(handle);
if (load_code != 0) {
cleanup_handle(handle);
return load_code;
}
snd_mixer_selem_id_t *sid;
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, "Master");
snd_mixer_elem_t* elem = snd_mixer_find_selem(handle, sid);
if (elem == 0) {
cleanup_handle(handle);
return 1;
}
int vol_code = snd_mixer_selem_get_playback_dB(elem, SND_MIXER_SCHN_UNKNOWN, vol);
if (vol_code != 0) {
cleanup_handle(handle);
return vol_code;
}
int switch_code = snd_mixer_selem_get_playback_switch(elem, SND_MIXER_SCHN_UNKNOWN, mute);
if (switch_code != 0) {
cleanup_handle(handle);
return switch_code;
}
/* snd_mixer_selem_id_free(sid); */
snd_mixer_detach(handle, "default");
snd_mixer_close(handle);
return 0;
}
static void
attach_mixer (MokoAlsaVolumeControl *self)
{
MokoAlsaVolumeControlPrivate *priv = ALSA_VOLUME_CONTROL_PRIVATE (self);
g_debug ("Trying to attach... %p, %s, %p", priv->mixer_handle,
priv->device, priv->element);
open_mixer (self);
if (priv->mixer_handle && priv->device && priv->element &&
(snd_mixer_attach (priv->mixer_handle, priv->device) == 0) &&
(snd_mixer_selem_register (priv->mixer_handle, NULL, NULL) == 0) &&
(snd_mixer_load (priv->mixer_handle) == 0)) {
priv->mixer_elem = snd_mixer_find_selem (
priv->mixer_handle, priv->element);
if (!priv->mixer_elem) {
g_warning ("Unable to find mixer element");
snd_mixer_detach (priv->mixer_handle, priv->device);
close_mixer (self);
} else {
g_debug ("Attached to mixer");
if (snd_mixer_selem_has_playback_volume (
priv->mixer_elem)) {
priv->control_type = PLAYBACK;
snd_mixer_selem_get_playback_volume_range (
priv->mixer_elem,
&priv->min, &priv->max);
} else if (snd_mixer_selem_has_capture_volume (
priv->mixer_elem)) {
priv->control_type = CAPTURE;
snd_mixer_selem_get_capture_volume_range (
priv->mixer_elem,
&priv->min, &priv->max);
} else
priv->control_type = CONTROL;
snd_mixer_elem_set_callback (
priv->mixer_elem, mixer_elem_event_cb);
snd_mixer_elem_set_callback_private (
priv->mixer_elem, self);
start_polling (self);
update_volume (self);
}
} else {
close_mixer (self);
}
}
/**
* Detaches a mixer from the specified card and closes the
* mixer.
*
* @param mixer mixer handle
* @param card HCTL name of the alsa card
* @return 0 on success otherwise negative error code
*/
static int
close_mixer(snd_mixer_t *mixer, const char *card)
{
int err;
DEBUG_PRINT("Card %s: closing mixer", card);
if ((err = snd_mixer_detach(mixer, card)) < 0)
report_error("Card %s: mixer detach error: %s", card,
snd_strerror(err));
snd_mixer_free(mixer);
if ((err = snd_mixer_close(mixer)) < 0)
report_error("Card %s: mixer close error: %s", card,
snd_strerror(err));
return err;
}
static int
mixer_open(void)
{
snd_mixer_elem_t *elem;
snd_mixer_elem_t *master;
snd_mixer_elem_t *pcm;
snd_mixer_elem_t *custom;
snd_mixer_selem_id_t *sid;
int ret;
ret = snd_mixer_open(&mixer_hdl, 0);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Failed to open mixer: %s\n", snd_strerror(ret));
mixer_hdl = NULL;
return -1;
}
ret = snd_mixer_attach(mixer_hdl, card_name);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Failed to attach mixer: %s\n", snd_strerror(ret));
goto out_close;
}
ret = snd_mixer_selem_register(mixer_hdl, NULL, NULL);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Failed to register mixer: %s\n", snd_strerror(ret));
goto out_detach;
}
ret = snd_mixer_load(mixer_hdl);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Failed to load mixer: %s\n", snd_strerror(ret));
goto out_detach;
}
/* Grab interesting elements */
snd_mixer_selem_id_alloca(&sid);
pcm = NULL;
master = NULL;
custom = NULL;
for (elem = snd_mixer_first_elem(mixer_hdl); elem; elem = snd_mixer_elem_next(elem))
{
snd_mixer_selem_get_id(elem, sid);
if (mixer_name && (strcmp(snd_mixer_selem_id_get_name(sid), mixer_name) == 0))
{
custom = elem;
break;
}
else if (strcmp(snd_mixer_selem_id_get_name(sid), "PCM") == 0)
pcm = elem;
else if (strcmp(snd_mixer_selem_id_get_name(sid), "Master") == 0)
master = elem;
}
if (mixer_name)
{
if (custom)
vol_elem = custom;
else
{
DPRINTF(E_LOG, L_LAUDIO, "Failed to open configured mixer element '%s'\n", mixer_name);
goto out_detach;
}
}
else if (pcm)
vol_elem = pcm;
else if (master)
vol_elem = master;
else
{
DPRINTF(E_LOG, L_LAUDIO, "Failed to open PCM or Master mixer element\n");
goto out_detach;
}
/* Get min & max volume */
snd_mixer_selem_get_playback_volume_range(vol_elem, &vol_min, &vol_max);
return 0;
out_detach:
snd_mixer_detach(mixer_hdl, card_name);
out_close:
snd_mixer_close(mixer_hdl);
mixer_hdl = NULL;
vol_elem = NULL;
return -1;
}
void cleanup_handle(snd_mixer_t* handle) {
snd_mixer_detach(handle, "default");
snd_mixer_close(handle);
}
