/*

 * 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 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 {

			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();

}