path: root/alsamixer/mixer_controls.c

/*
 * mixer_controls.c - handles mixer controls and mapping from selems
 * Copyright (c) 1998,1999 Tim Janik
 *                         Jaroslav Kysela <perex@perex.cz>
 * Copyright (c) 2009      Clemens Ladisch <clemens@ladisch.de>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "aconfig.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include CURSESINC
#include <alsa/asoundlib.h>
#include "utils.h"
#include "mem.h"
#include "mixer_display.h"
#include "mixer_widget.h"
#include "mixer_controls.h"

struct control *controls;
unsigned int controls_count;

static const snd_mixer_selem_channel_id_t supported_channels[] = {
	SND_MIXER_SCHN_FRONT_LEFT,
	SND_MIXER_SCHN_FRONT_RIGHT,
	SND_MIXER_SCHN_REAR_LEFT,
	SND_MIXER_SCHN_REAR_RIGHT,
	SND_MIXER_SCHN_FRONT_CENTER,
	SND_MIXER_SCHN_WOOFER,
	SND_MIXER_SCHN_SIDE_LEFT,
	SND_MIXER_SCHN_SIDE_RIGHT,
};
#define LAST_SUPPORTED_CHANNEL SND_MIXER_SCHN_SIDE_RIGHT

static const snd_mixer_selem_channel_id_t control_channels[][2] = {
	{ SND_MIXER_SCHN_FRONT_LEFT, SND_MIXER_SCHN_FRONT_RIGHT },
	{ SND_MIXER_SCHN_REAR_LEFT, SND_MIXER_SCHN_REAR_RIGHT },
	{ SND_MIXER_SCHN_FRONT_CENTER, SND_MIXER_SCHN_UNKNOWN },
	{ SND_MIXER_SCHN_WOOFER, SND_MIXER_SCHN_UNKNOWN },
	{ SND_MIXER_SCHN_SIDE_LEFT, SND_MIXER_SCHN_SIDE_RIGHT },
};

bool are_there_any_controls(void)
{
	snd_mixer_elem_t *elem;
	unsigned int i;

	for (elem = snd_mixer_first_elem(mixer);
	     elem;
	     elem = snd_mixer_elem_next(elem)) {
		if (snd_mixer_elem_get_type(elem) != SND_MIXER_ELEM_SIMPLE)
			continue;
		if (snd_mixer_selem_is_enumerated(elem))
			return TRUE;
		if (snd_mixer_selem_has_playback_volume_joined(elem) ||
		    snd_mixer_selem_has_capture_volume_joined(elem) ||
		    snd_mixer_selem_has_playback_switch_joined(elem) ||
		    snd_mixer_selem_has_capture_switch_joined(elem))
			return TRUE;
		for (i = 0; i < ARRAY_SIZE(supported_channels); ++i)
			if (snd_mixer_selem_has_playback_channel(elem, supported_channels[i]) ||
			    snd_mixer_selem_has_capture_channel(elem, supported_channels[i]))
				return TRUE;
	}
	return FALSE;
}

static bool has_more_than_front_capture_channels(snd_mixer_elem_t *elem)
{
	unsigned int i;

	for (i = 2; i < ARRAY_SIZE(supported_channels); ++i)
		if (snd_mixer_selem_has_capture_channel(elem, supported_channels[i]))
			return TRUE;
	return FALSE;
}

static bool has_any_control_channel(snd_mixer_elem_t *elem,
				    const snd_mixer_selem_channel_id_t channels[2],
				    int (*has_channel)(snd_mixer_elem_t *, snd_mixer_selem_channel_id_t))
{
	return has_channel(elem, channels[0]) ||
	       (channels[1] != SND_MIXER_SCHN_UNKNOWN && has_channel(elem, channels[1]));
}

static bool has_merged_cswitch(snd_mixer_elem_t *elem)
{
	bool pvol, psw;
	unsigned int i;

	pvol = snd_mixer_selem_has_playback_volume(elem);
	psw = snd_mixer_selem_has_playback_switch(elem);
	if ((pvol || psw) &&
	    snd_mixer_selem_has_capture_switch(elem) &&
	    !snd_mixer_selem_has_capture_volume(elem)) {
		if (snd_mixer_selem_has_capture_switch_joined(elem))
			return TRUE;
		else if (((pvol && snd_mixer_selem_has_playback_volume_joined(elem)) ||
			  (psw && snd_mixer_selem_has_playback_switch_joined(elem))) &&
			 has_more_than_front_capture_channels(elem))
			return FALSE;
		for (i = 0; i < ARRAY_SIZE(control_channels); ++i) {
			if (has_any_control_channel(elem, control_channels[i], snd_mixer_selem_has_capture_channel) &&
			    !has_any_control_channel(elem, control_channels[i], snd_mixer_selem_has_playback_channel))
				return FALSE;
		}
		return TRUE;
	}
	return FALSE;
}

static unsigned int get_playback_controls_count(snd_mixer_elem_t *elem)
{
	unsigned int count = 0;
	unsigned int i;
	int has_vol, has_sw;

	has_vol = snd_mixer_selem_has_playback_volume(elem);
	has_sw = snd_mixer_selem_has_playback_switch(elem);
	if (!has_vol && !has_sw)
		return 0;
	if ((!has_vol || snd_mixer_selem_has_playback_volume_joined(elem)) &&
	    (!has_sw || snd_mixer_selem_has_playback_switch_joined(elem)))
		return 1;
	for (i = 0; i < ARRAY_SIZE(control_channels); ++i) {
		if (snd_mixer_selem_has_playback_channel(elem, control_channels[i][0]) ||
		    (control_channels[i][1] != SND_MIXER_SCHN_UNKNOWN &&
		     snd_mixer_selem_has_playback_channel(elem, control_channels[i][1])))
			++count;
	}
	return count;
}

static unsigned int get_capture_controls_count(snd_mixer_elem_t *elem)
{
	unsigned int count = 0;
	unsigned int i;
	int has_vol, has_sw;

	has_vol = snd_mixer_selem_has_capture_volume(elem);
	has_sw = snd_mixer_selem_has_capture_switch(elem);
	if ((!has_vol && !has_sw) ||
	    (view_mode == VIEW_MODE_ALL && has_merged_cswitch(elem)))
		return 0;
	if ((!has_vol || snd_mixer_selem_has_capture_volume_joined(elem)) &&
	    (!has_sw || snd_mixer_selem_has_capture_switch_joined(elem)))
		return 1;
	for (i = 0; i < ARRAY_SIZE(control_channels); ++i) {
		if (snd_mixer_selem_has_capture_channel(elem, control_channels[i][0]) ||
		    (control_channels[i][1] != SND_MIXER_SCHN_UNKNOWN &&
		     snd_mixer_selem_has_capture_channel(elem, control_channels[i][1])))
			++count;
	}
	return count;
}

static unsigned int get_controls_count_for_elem(snd_mixer_elem_t *elem)
{
	unsigned int p, c;

	if (snd_mixer_elem_get_type(elem) != SND_MIXER_ELEM_SIMPLE)
		return 0;
	if (snd_mixer_selem_is_enumerated(elem)) {
		switch (view_mode) {
		case VIEW_MODE_PLAYBACK:
			return snd_mixer_selem_is_enum_capture(elem) ? 0 : 1;
		case VIEW_MODE_CAPTURE:
			return snd_mixer_selem_is_enum_capture(elem) ? 1 : 0;
		case VIEW_MODE_ALL:
		default:
			return 1;
		}
	}
	switch (view_mode) {
	case VIEW_MODE_PLAYBACK:
		return get_playback_controls_count(elem);
	case VIEW_MODE_CAPTURE:
		return get_capture_controls_count(elem);
	case VIEW_MODE_ALL:
	default:
		p = get_playback_controls_count(elem);
		c = get_capture_controls_count(elem);
		return has_merged_cswitch(elem) ? p : p + c;
	}
}

static void create_name(struct control *control)
{
	unsigned int index;
	char *s;

	index = snd_mixer_selem_get_index(control->elem);
	if (index > 0)
		control->name = casprintf("%s %u", snd_mixer_selem_get_name(control->elem), index);
	else
		control->name = cstrdup(snd_mixer_selem_get_name(control->elem));

	while ((s = strstr(control->name, "IEC958")) != NULL)
		memcpy(s, "S/PDIF", 6);
}

static unsigned int create_controls_for_elem(snd_mixer_elem_t *elem, struct control *control)
{
	unsigned int count = 0;
	unsigned int i;
	unsigned int multich_flag;
	unsigned int enum_index;
	struct control *front_control = NULL;
	bool has_pvol, has_psw;
	bool has_cvol, has_csw;
	bool has_channel[LAST_SUPPORTED_CHANNEL + 1];
	bool merged_cswitch;
	bool has_ch0, has_ch1;

	if (snd_mixer_elem_get_type(elem) != SND_MIXER_ELEM_SIMPLE)
		return 0;
	if (snd_mixer_selem_is_enumerated(elem)) {
		if ((view_mode == VIEW_MODE_PLAYBACK && snd_mixer_selem_is_enum_capture(elem)) ||
		    (view_mode == VIEW_MODE_CAPTURE && !snd_mixer_selem_is_enum_capture(elem)))
			return 0;
		control->elem = elem;
		control->flags = TYPE_ENUM;
		control->enum_channel_bits = 0;
		for (i = 0; i <= SND_MIXER_SCHN_LAST; ++i)
			if (snd_mixer_selem_get_enum_item(control->elem, (snd_mixer_selem_channel_id_t)i, &enum_index) >= 0)
				control->enum_channel_bits |= 1 << i;
		if (snd_mixer_selem_is_active(control->elem))
			control->flags |= IS_ACTIVE;
		create_name(control);
		return 1;
	}
	has_pvol = snd_mixer_selem_has_playback_volume(elem);
	has_psw = snd_mixer_selem_has_playback_switch(elem);
	has_cvol = snd_mixer_selem_has_capture_volume(elem);
	has_csw = snd_mixer_selem_has_capture_switch(elem);
	merged_cswitch = view_mode == VIEW_MODE_ALL && has_merged_cswitch(elem);
	if (view_mode != VIEW_MODE_CAPTURE && (has_pvol || has_psw)) {
		if ((!has_pvol || snd_mixer_selem_has_playback_volume_joined(elem)) &&
		    (!has_psw || snd_mixer_selem_has_playback_switch_joined(elem))) {
			control->elem = elem;
			if (has_pvol) {
				control->flags |= TYPE_PVOLUME | HAS_VOLUME_0;
				control->volume_channels[0] = 0;
			}
			if (has_psw) {
				control->flags |= TYPE_PSWITCH | HAS_PSWITCH_0;
				control->pswitch_channels[0] = 0;
			}
			if (merged_cswitch) {
				control->flags |= TYPE_CSWITCH;
				if (snd_mixer_selem_has_capture_switch_joined(elem)) {
					control->flags |= HAS_CSWITCH_0;
					control->cswitch_channels[0] = 0;
				} else {
					if (snd_mixer_selem_has_capture_channel(elem, control_channels[0][0])) {
						control->flags |= HAS_CSWITCH_0;
						control->cswitch_channels[0] = control_channels[0][0];
					}
					if (control_channels[0][1] != SND_MIXER_SCHN_UNKNOWN &&
					    snd_mixer_selem_has_capture_channel(elem, control_channels[0][1])) {
						control->flags |= HAS_CSWITCH_1;
						control->cswitch_channels[1] = control_channels[0][1];
					}
				}
				if ((control->flags & (HAS_CSWITCH_0 | HAS_CSWITCH_1)) == HAS_CSWITCH_1) {
					control->flags ^= HAS_CSWITCH_0 | HAS_CSWITCH_1;
					control->cswitch_channels[0] = control->cswitch_channels[1];
				}
			}
			if (snd_mixer_selem_is_active(control->elem))
				control->flags |= IS_ACTIVE;
			create_name(control);
			++control;
			++count;
		} else {
			multich_flag = 0;
			for (i = 0; i < ARRAY_SIZE(supported_channels); ++i)
				has_channel[supported_channels[i]] =
					snd_mixer_selem_has_playback_channel(elem, supported_channels[i]);
			for (i = 0; i < ARRAY_SIZE(control_channels); ++i) {
				has_ch0 = has_channel[control_channels[i][0]];
				has_ch1 = control_channels[i][1] != SND_MIXER_SCHN_UNKNOWN &&
					has_channel[control_channels[i][1]];
				if (!has_ch0 && !has_ch1)
					continue;
				control->elem = elem;
				if (has_pvol) {
					control->flags |= TYPE_PVOLUME;
					if (snd_mixer_selem_has_playback_volume_joined(elem)) {
						control->flags |= HAS_VOLUME_0;
						control->volume_channels[0] = 0;
					} else {
						if (has_ch0) {
							control->flags |= HAS_VOLUME_0;
							control->volume_channels[0] = control_channels[i][0];
						}
						if (has_ch1) {
							control->flags |= HAS_VOLUME_1;
							control->volume_channels[1] = control_channels[i][1];
						}
					}
				}
				if (has_psw) {
					control->flags |= TYPE_PSWITCH;
					if (snd_mixer_selem_has_playback_switch_joined(elem)) {
						control->flags |= HAS_PSWITCH_0;
						control->pswitch_channels[0] = 0;
					} else {
						if (has_ch0) {
							control->flags |= HAS_PSWITCH_0;
							control->pswitch_channels[0] = control_channels[i][0];
						}
						if (has_ch1) {
							control->flags |= HAS_PSWITCH_1;
							control->pswitch_channels[1] = control_channels[i][1];
						}
					}
				}
				if (merged_cswitch) {
					control->flags |= TYPE_CSWITCH;
					if (snd_mixer_selem_has_capture_switch_joined(elem)) {
						control->flags |= HAS_CSWITCH_0;
						control->cswitch_channels[0] = 0;
					} else {
						if (snd_mixer_selem_has_capture_channel(elem, control_channels[i][0])) {
							control->flags |= HAS_CSWITCH_0;
							control->cswitch_channels[0] = control_channels[i][0];
						}
						if (control_channels[i][1] != SND_MIXER_SCHN_UNKNOWN &&
						    snd_mixer_selem_has_capture_channel(elem, control_channels[i][1])) {
							control->flags |= HAS_CSWITCH_1;
							control->cswitch_channels[1] = control_channels[i][1];
						}
					}
				}
				if ((control->flags & (HAS_VOLUME_0 | HAS_VOLUME_1)) == HAS_VOLUME_1) {
					control->flags ^= HAS_VOLUME_0 | HAS_VOLUME_1;
					control->volume_channels[0] = control->volume_channels[1];
				}
				if ((control->flags & (HAS_PSWITCH_0 | HAS_PSWITCH_1)) == HAS_PSWITCH_1) {
					control->flags ^= HAS_PSWITCH_0 | HAS_PSWITCH_1;
					control->pswitch_channels[0] = control->pswitch_channels[1];
				}
				if ((control->flags & (HAS_CSWITCH_0 | HAS_CSWITCH_1)) == HAS_CSWITCH_1) {
					control->flags ^= HAS_CSWITCH_0 | HAS_CSWITCH_1;
					control->cswitch_channels[0] = control->cswitch_channels[1];
				}
				if (snd_mixer_selem_is_active(control->elem))
					control->flags |= IS_ACTIVE;
				create_name(control);
				if (i == 0)
					front_control = control;
				else {
					front_control->flags |= IS_MULTICH | 0;
					control->flags |= IS_MULTICH | i;
				}
				++control;
				++count;
			}
		}
	}
	if (view_mode != VIEW_MODE_PLAYBACK && (has_cvol || has_csw) && !merged_cswitch) {
		if ((!has_cvol || snd_mixer_selem_has_capture_volume_joined(elem)) &&
		    (!has_csw || snd_mixer_selem_has_capture_switch_joined(elem))) {
			control->elem = elem;
			if (has_cvol) {
				control->flags |= TYPE_CVOLUME | HAS_VOLUME_0;
				control->volume_channels[0] = 0;
			}
			if (has_csw) {
				control->flags |= TYPE_CSWITCH | HAS_CSWITCH_0;
				control->cswitch_channels[0] = 0;
			}
			if (snd_mixer_selem_is_active(control->elem))
				control->flags |= IS_ACTIVE;
			create_name(control);
			++control;
			++count;
		} else {
			for (i = 0; i < ARRAY_SIZE(supported_channels); ++i)
				has_channel[supported_channels[i]] =
					snd_mixer_selem_has_capture_channel(elem, supported_channels[i]);
			for (i = 0; i < ARRAY_SIZE(control_channels); ++i) {
				has_ch0 = has_channel[control_channels[i][0]];
				has_ch1 = control_channels[i][1] != SND_MIXER_SCHN_UNKNOWN &&
					has_channel[control_channels[i][1]];
				if (!has_ch0 && !has_ch1)
					continue;
				control->elem = elem;
				if (has_cvol) {
					control->flags |= TYPE_CVOLUME;
					if (snd_mixer_selem_has_capture_volume_joined(elem)) {
						control->flags |= HAS_VOLUME_0;
						control->volume_channels[0] = 0;
					} else {
						if (has_ch0) {
							control->flags |= HAS_VOLUME_0;
							control->volume_channels[0] = control_channels[i][0];
						}
						if (has_ch1) {
							control->flags |= HAS_VOLUME_1;
							control->volume_channels[1] = control_channels[i][1];
						}
					}
				}
				if (has_csw) {
					control->flags |= TYPE_CSWITCH;
					if (snd_mixer_selem_has_capture_switch_joined(elem)) {
						control->flags |= HAS_CSWITCH_0;
						control->cswitch_channels[0] = 0;
					} else {
						if (has_ch0) {
							control->flags |= HAS_CSWITCH_0;
							control->cswitch_channels[0] = control_channels[i][0];
						}
						if (has_ch1) {
							control->flags |= HAS_CSWITCH_1;
							control->cswitch_channels[1] = control_channels[i][1];
						}
					}
				}
				if ((control->flags & (HAS_VOLUME_0 | HAS_VOLUME_1)) == HAS_VOLUME_1) {
					control->flags ^= HAS_VOLUME_0 | HAS_VOLUME_1;
					control->volume_channels[0] = control->volume_channels[1];
				}
				if ((control->flags & (HAS_CSWITCH_0 | HAS_CSWITCH_1)) == HAS_CSWITCH_1) {
					control->flags ^= HAS_CSWITCH_0 | HAS_CSWITCH_1;
					control->cswitch_channels[0] = control->cswitch_channels[1];
				}
				if (snd_mixer_selem_is_active(control->elem))
					control->flags |= IS_ACTIVE;
				create_name(control);
				if (i == 0)
					front_control = control;
				else {
					front_control->flags |= IS_MULTICH | 0;
					control->flags |= IS_MULTICH | i;
				}
				++control;
				++count;
			}
		}
	}
	return count;
}

static void search_for_focus_control(void)
{
	snd_mixer_elem_t *elem;
	unsigned int i;

	elem = snd_mixer_find_selem(mixer, current_selem_id);
	if (elem)
		for (i = 0; i < controls_count; ++i)
			if (controls[i].elem == elem) {
				focus_control_index = i;
				for (;;) {
					++i;
					if (i >= controls_count || controls[i].elem != elem)
						return;
					if (controls[i].flags == current_control_flags) {
						focus_control_index = i;
						return;
					}
				}
			}
	focus_control_index = 0;
}

void free_controls(void)
{
	unsigned int i;

	for (i = 0; i < controls_count; ++i)
		free(controls[i].name);
	free(controls);
	controls = NULL;
	controls_count = 0;
}

void create_controls(void)
{
	snd_mixer_elem_t *elem;
	struct control *control;

	free_controls();

	for (elem = snd_mixer_first_elem(mixer);
	     elem;
	     elem = snd_mixer_elem_next(elem))
		controls_count += get_controls_count_for_elem(elem);

	if (controls_count > 0) {
		controls = ccalloc(controls_count, sizeof *controls);
		control = controls;
		for (elem = snd_mixer_first_elem(mixer);
		     elem;
		     elem = snd_mixer_elem_next(elem))
			control += create_controls_for_elem(elem, control);
		assert(control == controls + controls_count);
	}

	compute_controls_layout();
	display_view_mode();

	search_for_focus_control();
	refocus_control();
}