/* ALSA mixer implementation.

 * Copyright (C) 2003 Leif Johnson <leif@ambient.2y.net>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:element-alsamixer

 * @short_description: control properties of an audio device

 * @see_also: alsasink, alsasrc

 *

 * <refsect2>

 * <para>

 * This element controls various aspects such as the volume and balance

 * of an audio device using the ALSA api.

 * </para>

 * <para>

 * The application should query and use the interfaces provided by this 

 * element to control the device.

 * </para>

 * </refsect2>

 *

 * Last reviewed on 2006-03-01 (0.10.4)

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gstalsamixer.h"

static void gst_alsa_mixer_update_option (GstAlsaMixer * mixer,

    GstAlsaMixerOptions * alsa_opts);

static void gst_alsa_mixer_update_track (GstAlsaMixer * mixer,

    GstAlsaMixerTrack * alsa_track);

static int gst_alsa_mixer_handle_callback (snd_mixer_t * handle,

    unsigned int mask, snd_mixer_elem_t * elem);

/* First some utils, then the mixer implementation */

static gboolean

gst_alsa_mixer_open (GstAlsaMixer * mixer)

{

  gint err;

  snd_ctl_t *ctl;

  snd_ctl_card_info_t *card_info;

  g_return_val_if_fail (mixer->handle == NULL, FALSE);

  /* open and initialize the mixer device */

  err = snd_mixer_open (&mixer->handle, 0);

  if (err < 0 || mixer->handle == NULL)

    goto open_failed;

  if ((err = snd_mixer_attach (mixer->handle, mixer->device)) < 0) {

    GST_WARNING ("Cannot open mixer for sound device '%s': %s", mixer->device,

        snd_strerror (err));

    goto error;

  }

  if ((err = snd_mixer_selem_register (mixer->handle, NULL, NULL)) < 0) {

    GST_WARNING ("Cannot register mixer elements: %s", snd_strerror (err));

    goto error;

  }

  if ((err = snd_mixer_load (mixer->handle)) < 0) {

    GST_WARNING ("Cannot load mixer settings: %s", snd_strerror (err));

    goto error;

  }

  snd_mixer_set_callback_private (mixer->handle, mixer);

  snd_mixer_set_callback (mixer->handle, gst_alsa_mixer_handle_callback);

  /* now get the device name, any of this is not fatal */

  g_free (mixer->cardname);

  if ((err = snd_ctl_open (&ctl, mixer->device, 0)) < 0) {

    GST_WARNING ("Cannot open CTL: %s", snd_strerror (err));

    goto no_card_name;

  }

  snd_ctl_card_info_malloc (&card_info);

  if ((err = snd_ctl_card_info (ctl, card_info)) < 0) {

    GST_WARNING ("Cannot get card info: %s", snd_strerror (err));

    snd_ctl_close (ctl);

    goto no_card_name;

  }

  mixer->cardname = g_strdup (snd_ctl_card_info_get_name (card_info));

  GST_DEBUG ("Card name = %s", GST_STR_NULL (mixer->cardname));

  snd_ctl_card_info_free (card_info);

  snd_ctl_close (ctl);

no_card_name:

  if (mixer->cardname == NULL) {

    mixer->cardname = g_strdup ("Unknown");

    GST_DEBUG ("Cannot find card name");

  }

  GST_INFO ("Successfully opened mixer for device '%s'.", mixer->device);

  return TRUE;

  /* ERROR */

open_failed:

  {

    GST_WARNING ("Cannot open mixer: %s", snd_strerror (err));

    mixer->handle = NULL;

    return FALSE;

  }

error:

  {

    snd_mixer_close (mixer->handle);

    mixer->handle = NULL;

    return FALSE;

  }

}

static snd_mixer_elem_t *

gst_alsa_mixer_find_master_mixer (GstAlsaMixer * mixer, snd_mixer_t * handle)

{

  snd_mixer_elem_t *element;

  gint i, count;

  count = snd_mixer_get_count (handle);

  /* Check if we have a playback mixer labelled as 'Master' */

  element = snd_mixer_first_elem (handle);

  for (i = 0; i < count; i++) {

    if (snd_mixer_selem_has_playback_volume (element) &&

        strcmp (snd_mixer_selem_get_name (element), "Master") == 0) {

      return element;

    }

    element = snd_mixer_elem_next (element);

  }

  /* If not, check if we have a playback mixer labelled as 'Front' */

  element = snd_mixer_first_elem (handle);

  for (i = 0; i < count; i++) {

    if (snd_mixer_selem_has_playback_volume (element) &&

        strcmp (snd_mixer_selem_get_name (element), "Front") == 0) {

      return element;

    }

    element = snd_mixer_elem_next (element);

  }

  /* If not, check if we have a playback mixer labelled as 'PCM' */

  element = snd_mixer_first_elem (handle);

  for (i = 0; i < count; i++) {

    if (snd_mixer_selem_has_playback_volume (element) &&

        strcmp (snd_mixer_selem_get_name (element), "PCM") == 0) {

      return element;

    }

    element = snd_mixer_elem_next (element);

  }

  /* If not, check if we have a playback mixer with both volume and switch */

  element = snd_mixer_first_elem (handle);

  for (i = 0; i < count; i++) {

    if (snd_mixer_selem_has_playback_volume (element) &&

        snd_mixer_selem_has_playback_switch (element)) {

      return element;

    }

    element = snd_mixer_elem_next (element);

  }

  /* If not, take any playback mixer with a volume control */

  element = snd_mixer_first_elem (handle);

  for (i = 0; i < count; i++) {

    if (snd_mixer_selem_has_playback_volume (element)) {

      return element;

    }

    element = snd_mixer_elem_next (element);

  }

  /* Looks like we're out of luck ... */

  return NULL;

}

static void

gst_alsa_mixer_update (GstAlsaMixer * mixer, snd_mixer_elem_t * elem)

{

  GList *item;

  g_return_if_fail (mixer != NULL);

  g_static_rec_mutex_lock (mixer->rec_mutex);

  for (item = mixer->tracklist; item != NULL; item = item->next) {

    if (GST_IS_ALSA_MIXER_TRACK (item->data)) {

      if (elem && (GST_ALSA_MIXER_TRACK (item->data)->element != elem))

        continue;

      gst_alsa_mixer_update_track (mixer, GST_ALSA_MIXER_TRACK (item->data));

    } else if (GST_IS_ALSA_MIXER_OPTIONS (item->data)) {

      if (elem && (GST_ALSA_MIXER_OPTIONS (item->data)->element != elem))

        continue;

      gst_alsa_mixer_update_option (mixer, GST_ALSA_MIXER_OPTIONS (item->data));

    }

  }

  g_static_rec_mutex_unlock (mixer->rec_mutex);

}

static int

gst_alsa_mixer_elem_handle_callback (snd_mixer_elem_t * elem, unsigned int mask)

{

  GstAlsaMixer *mixer =

      (GstAlsaMixer *) snd_mixer_elem_get_callback_private (elem);

  GST_LOG ("ALSA elem cb");

  g_return_val_if_fail (mixer != NULL, 1);

  gst_alsa_mixer_update (mixer, elem);

  return 0;

}

static int

gst_alsa_mixer_handle_callback (snd_mixer_t * handle, unsigned int mask,

    snd_mixer_elem_t * elem)

{

  GstAlsaMixer *mixer =

      (GstAlsaMixer *) snd_mixer_get_callback_private (handle);

  GST_LOG ("ALSA cb");

  g_return_val_if_fail (mixer != NULL, 1);

  /* Hopefully won't be call recursively and will handle pending elem events */

  snd_mixer_handle_events (mixer->handle);

  gst_alsa_mixer_update (mixer, elem);

  return 0;

}

static void

gst_alsa_mixer_ensure_track_list (GstAlsaMixer * mixer)

{

  gint i, count;

  snd_mixer_elem_t *element, *master;

  GList *item;

  g_return_if_fail (mixer->handle != NULL);

  if (mixer->tracklist)

    return;

  g_static_rec_mutex_lock (mixer->rec_mutex);

  master = gst_alsa_mixer_find_master_mixer (mixer, mixer->handle);

  count = snd_mixer_get_count (mixer->handle);

  element = snd_mixer_first_elem (mixer->handle);

  /* build track list

   *

   * Some ALSA tracks may have playback and capture capabilities.

   * Here we model them as two separate GStreamer tracks.

   */

  for (i = 0; i < count; i++) {

    GstMixerTrack *play_track = NULL;

    GstMixerTrack *cap_track = NULL;

    const gchar *name;

    GList *item;

    gint samename = 0;

    name = snd_mixer_selem_get_name (element);

    /* prevent dup names */

    for (item = mixer->tracklist; item != NULL; item = item->next) {

      snd_mixer_elem_t *temp;

      if (GST_IS_ALSA_MIXER_OPTIONS (item->data))

        temp = GST_ALSA_MIXER_OPTIONS (item->data)->element;

      else

        temp = GST_ALSA_MIXER_TRACK (item->data)->element;

      if (strcmp (name, snd_mixer_selem_get_name (temp)) == 0)

        samename++;

    }

    GST_LOG ("[%s] probing element #%u, mixer->dir=%u", name, i, mixer->dir);

    if (mixer->dir & GST_ALSA_MIXER_PLAYBACK) {

      gboolean has_playback_switch, has_playback_volume;

      has_playback_switch = snd_mixer_selem_has_playback_switch (element);

      has_playback_volume = snd_mixer_selem_has_playback_volume (element);

      GST_LOG ("[%s] PLAYBACK: has_playback_volume=%d, has_playback_switch=%d"

          "%s", name, has_playback_volume, has_playback_switch,

          (element == master) ? " MASTER" : "");

      if (has_playback_volume) {

        gint flags = GST_MIXER_TRACK_OUTPUT;

        if (element == master)

          flags |= GST_MIXER_TRACK_MASTER;

        play_track = gst_alsa_mixer_track_new (element, samename, i,

            flags, FALSE, NULL, FALSE);

      } else if (has_playback_switch) {

        /* simple mute switch */

        play_track = gst_alsa_mixer_track_new (element, samename, i,

            GST_MIXER_TRACK_OUTPUT, TRUE, NULL, FALSE);

      }

      if (snd_mixer_selem_is_enumerated (element)) {

        GstMixerOptions *opts = gst_alsa_mixer_options_new (element, i);

        GST_LOG ("[%s] is enumerated (%d)", name, i);

        mixer->tracklist = g_list_append (mixer->tracklist, opts);

      }

    }

    if (mixer->dir & GST_ALSA_MIXER_CAPTURE) {

      gboolean has_capture_switch, has_common_switch;

      gboolean has_capture_volume, has_common_volume;

      has_capture_switch = snd_mixer_selem_has_capture_switch (element);

      has_common_switch = snd_mixer_selem_has_common_switch (element);

      has_capture_volume = snd_mixer_selem_has_capture_volume (element);

      has_common_volume = snd_mixer_selem_has_common_volume (element);

      GST_LOG ("[%s] CAPTURE: has_capture_volume=%d, has_common_volume=%d, "

          "has_capture_switch=%d, has_common_switch=%d, play_track=%p", name,

          has_capture_volume, has_common_volume, has_capture_switch,

          has_common_switch, play_track);

      if (has_capture_volume && !(play_track && has_common_volume)) {

        cap_track = gst_alsa_mixer_track_new (element, samename, i,

            GST_MIXER_TRACK_INPUT, FALSE, NULL, play_track != NULL);

      } else if (has_capture_switch && !(play_track && has_common_switch)) {

        cap_track = gst_alsa_mixer_track_new (element, samename, i,

            GST_MIXER_TRACK_INPUT, TRUE, NULL, play_track != NULL);

      }

    }

    if (play_track && cap_track) {

      GST_ALSA_MIXER_TRACK (play_track)->shared_mute =

          GST_ALSA_MIXER_TRACK (cap_track);

      GST_ALSA_MIXER_TRACK (cap_track)->shared_mute =

          GST_ALSA_MIXER_TRACK (play_track);

    }

    if (play_track)

      mixer->tracklist = g_list_append (mixer->tracklist, play_track);

    if (cap_track)

      mixer->tracklist = g_list_append (mixer->tracklist, cap_track);

    element = snd_mixer_elem_next (element);

  }

  for (item = mixer->tracklist; item != NULL; item = item->next) {

    snd_mixer_elem_t *temp;

    if (GST_IS_ALSA_MIXER_OPTIONS (item->data))

      temp = GST_ALSA_MIXER_OPTIONS (item->data)->element;

    else

      temp = GST_ALSA_MIXER_TRACK (item->data)->element;

    snd_mixer_elem_set_callback (temp, gst_alsa_mixer_elem_handle_callback);

    snd_mixer_elem_set_callback_private (temp, mixer);

  }

  g_static_rec_mutex_unlock (mixer->rec_mutex);

}

static void

task_monitor_alsa (gpointer data)

{

  struct pollfd *pfds;

  unsigned int nfds, rnfds;

  unsigned short revents;

  GstAlsaMixer *mixer = (GstAlsaMixer *) data;

  g_static_rec_mutex_lock (mixer->rec_mutex);

  nfds = snd_mixer_poll_descriptors_count (mixer->handle);

  if (nfds <= 0) {

    GST_ERROR ("snd_mixer_poll_descriptors_count <= 0: %d", nfds);

    /* FIXME: sleep ? stop monitoring ? */

    return;

  }

  pfds = g_newa (struct pollfd, nfds + 1);

  rnfds = snd_mixer_poll_descriptors (mixer->handle, pfds, nfds);

  g_assert (rnfds <= nfds);

  pfds[rnfds].fd = mixer->pfd[0];

  pfds[rnfds].events = POLLIN | POLLPRI | POLLHUP | POLLERR;

  pfds[rnfds].revents = 0;

  g_static_rec_mutex_unlock (mixer->rec_mutex);

  GST_LOG ("task loop");

  poll (pfds, rnfds + 1, -1);

  g_static_rec_mutex_lock (mixer->rec_mutex);

  snd_mixer_poll_descriptors_revents (mixer->handle, pfds, nfds, &revents);

  if (revents & POLLIN || revents & POLLPRI) {

    GST_DEBUG ("Handling events");

    snd_mixer_handle_events (mixer->handle);

  }

  g_static_rec_mutex_unlock (mixer->rec_mutex);

}

/* API */

GstAlsaMixer *

gst_alsa_mixer_new (const char *device, GstAlsaMixerDirection dir)

{

  GstAlsaMixer *ret = NULL;

  g_return_val_if_fail (device != NULL, NULL);

  ret = g_new0 (GstAlsaMixer, 1);

  if (pipe (ret->pfd) == -1)

    goto error;

  ret->rec_mutex = g_new (GStaticRecMutex, 1);

  g_static_rec_mutex_init (ret->rec_mutex);

  ret->task_mutex = g_new (GStaticRecMutex, 1);

  g_static_rec_mutex_init (ret->task_mutex);

  ret->task = gst_task_create (task_monitor_alsa, ret);

  gst_task_set_lock (ret->task, ret->task_mutex);

  ret->device = g_strdup (device);

  ret->dir = dir;

  if (!gst_alsa_mixer_open (ret))

    goto error;

  if (gst_task_start (ret->task) == FALSE) {

    GST_WARNING ("Could not start alsamixer task");

  }

  return ret;

  /* ERRORS */

error:

  {

    gst_alsa_mixer_free (ret);

    return NULL;

  }

}

void

gst_alsa_mixer_free (GstAlsaMixer * mixer)

{

  g_return_if_fail (mixer != NULL);

  if (mixer->task) {

    if (write (mixer->pfd[1], "stop", 5) <= 0) {

      GST_ERROR ("Cannot send " "stop" " to alsamixer task");

      close (mixer->pfd[1]);

      mixer->pfd[1] = -1;

    }

    if (gst_task_join (mixer->task) == FALSE) {

      GST_ERROR ("Cannot join alsamixer task");

    }

    gst_object_unref (mixer->task);

    mixer->task = NULL;

  }

  g_static_rec_mutex_free (mixer->task_mutex);

  g_free (mixer->task_mutex);

  mixer->task_mutex = NULL;

  if (mixer->pfd[0] > 0) {

    close (mixer->pfd[0]);

    mixer->pfd[0] = -1;

  }

  if (mixer->pfd[1] > 0) {

    close (mixer->pfd[1]);

    mixer->pfd[1] = -1;

  }

  if (mixer->interface) {

    g_object_unref (G_OBJECT (mixer->interface));

    mixer->interface = NULL;

  }

  if (mixer->device) {

    g_free (mixer->device);

    mixer->device = NULL;

  }

  if (mixer->cardname) {

    g_free (mixer->cardname);

    mixer->cardname = NULL;

  }

  if (mixer->tracklist) {

    g_list_foreach (mixer->tracklist, (GFunc) g_object_unref, NULL);

    g_list_free (mixer->tracklist);

    mixer->tracklist = NULL;

  }

  if (mixer->handle) {

    snd_mixer_close (mixer->handle);

    mixer->handle = NULL;