mobile/ext/alsa/gstalsamixer.c

   1 /* ALSA mixer implementation.
   2  * Copyright (C) 2003 Leif Johnson <leif@ambient.2y.net>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /**
  21  * SECTION:element-alsamixer
  22  * @see_also: alsasink, alsasrc
  23  *
  24  * This element controls various aspects such as the volume and balance
  25  * of an audio device using the ALSA api.
  26  *
  27  * The application should query and use the interfaces provided by this
  28  * element to control the device.
  29  *
  30  * Last reviewed on 2006-03-01 (0.10.4)
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36
  37 /* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
  38  * with newer GLib versions (>= 2.31.0) */
  39 #define GLIB_DISABLE_DEPRECATION_WARNINGS
  40
  41 #include "gstalsamixer.h"
  42 #include "gst/glib-compat-private.h"
  43 #include <errno.h>
  44
  45 static void gst_alsa_mixer_update_option (GstAlsaMixer * mixer,
  46     GstAlsaMixerOptions * alsa_opts);
  47 static void gst_alsa_mixer_update_track (GstAlsaMixer * mixer,
  48     GstAlsaMixerTrack * alsa_track);
  49 static int gst_alsa_mixer_handle_callback (snd_mixer_t * handle,
  50     unsigned int mask, snd_mixer_elem_t * elem);
  51
  52 /* First some utils, then the mixer implementation */
  53 static gboolean
  54 gst_alsa_mixer_open (GstAlsaMixer * mixer)
  55 {
  56   gint err;
  57   snd_ctl_t *ctl;
  58   snd_ctl_card_info_t *card_info;
  59
  60   g_return_val_if_fail (mixer->handle == NULL, FALSE);
  61
  62   /* open and initialize the mixer device */
  63   err = snd_mixer_open (&mixer->handle, 0);
  64   if (err < 0 || mixer->handle == NULL)
  65     goto open_failed;
  66
  67   if ((err = snd_mixer_attach (mixer->handle, mixer->device)) < 0) {
  68     GST_WARNING ("Cannot open mixer for sound device '%s': %s", mixer->device,
  69         snd_strerror (err));
  70     goto error;
  71   }
  72
  73   if ((err = snd_mixer_selem_register (mixer->handle, NULL, NULL)) < 0) {
  74     GST_WARNING ("Cannot register mixer elements: %s", snd_strerror (err));
  75     goto error;
  76   }
  77
  78   if ((err = snd_mixer_load (mixer->handle)) < 0) {
  79     GST_WARNING ("Cannot load mixer settings: %s", snd_strerror (err));
  80     goto error;
  81   }
  82
  83   snd_mixer_set_callback_private (mixer->handle, mixer);
  84   snd_mixer_set_callback (mixer->handle, gst_alsa_mixer_handle_callback);
  85
  86   /* now get the device name, any of this is not fatal */
  87   g_free (mixer->cardname);
  88   if ((err = snd_ctl_open (&ctl, mixer->device, 0)) < 0) {
  89     GST_WARNING ("Cannot open CTL: %s", snd_strerror (err));
  90     goto no_card_name;
  91   }
  92
  93   snd_ctl_card_info_malloc (&card_info);
  94   if ((err = snd_ctl_card_info (ctl, card_info)) < 0) {
  95     GST_WARNING ("Cannot get card info: %s", snd_strerror (err));
  96     snd_ctl_close (ctl);
  97     goto no_card_name;
  98   }
  99
 100   mixer->cardname = g_strdup (snd_ctl_card_info_get_name (card_info));
 101   GST_DEBUG ("Card name = %s", GST_STR_NULL (mixer->cardname));
 102   snd_ctl_card_info_free (card_info);
 103   snd_ctl_close (ctl);
 104
 105 no_card_name:
 106   if (mixer->cardname == NULL) {
 107     mixer->cardname = g_strdup ("Unknown");
 108     GST_DEBUG ("Cannot find card name");
 109   }
 110
 111   GST_INFO ("Successfully opened mixer for device '%s'.", mixer->device);
 112
 113   return TRUE;
 114
 115   /* ERROR */
 116 open_failed:
 117   {
 118     GST_WARNING ("Cannot open mixer: %s", snd_strerror (err));
 119     mixer->handle = NULL;
 120     return FALSE;
 121   }
 122 error:
 123   {
 124     snd_mixer_close (mixer->handle);
 125     mixer->handle = NULL;
 126     return FALSE;
 127   }
 128 }
 129
 130 static snd_mixer_elem_t *
 131 gst_alsa_mixer_find_master_mixer (GstAlsaMixer * mixer, snd_mixer_t * handle)
 132 {
 133   snd_mixer_elem_t *element;
 134   gint i, count;
 135
 136   count = snd_mixer_get_count (handle);
 137
 138   GST_ALSA_MIXER_LOCK (mixer);
 139
 140   /* Check if we have a playback mixer labelled as 'Master' */
 141   element = snd_mixer_first_elem (handle);
 142   for (i = 0; i < count; i++) {
 143     if (snd_mixer_selem_has_playback_volume (element) &&
 144         strcmp (snd_mixer_selem_get_name (element), "Master") == 0) {
 145       GST_ALSA_MIXER_UNLOCK (mixer);
 146       return element;
 147     }
 148     element = snd_mixer_elem_next (element);
 149   }
 150
 151   /* If not, check if we have a playback mixer labelled as 'Front' */
 152   element = snd_mixer_first_elem (handle);
 153   for (i = 0; i < count; i++) {
 154     if (snd_mixer_selem_has_playback_volume (element) &&
 155         strcmp (snd_mixer_selem_get_name (element), "Front") == 0) {
 156       GST_ALSA_MIXER_UNLOCK (mixer);
 157       return element;
 158     }
 159     element = snd_mixer_elem_next (element);
 160   }
 161
 162   /* If not, check if we have a playback mixer labelled as 'PCM' */
 163   element = snd_mixer_first_elem (handle);
 164   for (i = 0; i < count; i++) {
 165     if (snd_mixer_selem_has_playback_volume (element) &&
 166         strcmp (snd_mixer_selem_get_name (element), "PCM") == 0) {
 167       GST_ALSA_MIXER_UNLOCK (mixer);
 168       return element;
 169     }
 170     element = snd_mixer_elem_next (element);
 171   }
 172
 173   /* If not, check if we have a playback mixer labelled as 'Speaker' */
 174   element = snd_mixer_first_elem (handle);
 175   for (i = 0; i < count; i++) {
 176     if (snd_mixer_selem_has_playback_volume (element) &&
 177         strcmp (snd_mixer_selem_get_name (element), "Speaker") == 0) {
 178       GST_ALSA_MIXER_UNLOCK (mixer);
 179       return element;
 180     }
 181     element = snd_mixer_elem_next (element);
 182   }
 183
 184   /* If not, check if we have a playback mixer with both volume and switch that
 185    * is not mono */
 186   element = snd_mixer_first_elem (handle);
 187   for (i = 0; i < count; i++) {
 188     if (snd_mixer_selem_has_playback_volume (element) &&
 189         snd_mixer_selem_has_playback_switch (element) &&
 190         !snd_mixer_selem_is_playback_mono (element)) {
 191       GST_ALSA_MIXER_UNLOCK (mixer);
 192       return element;
 193     }
 194     element = snd_mixer_elem_next (element);
 195   }
 196
 197   /* If not, check if we have any playback mixer with both volume and switch */
 198   element = snd_mixer_first_elem (handle);
 199   for (i = 0; i < count; i++) {
 200     if (snd_mixer_selem_has_playback_volume (element) &&
 201         snd_mixer_selem_has_playback_switch (element)) {
 202       GST_ALSA_MIXER_UNLOCK (mixer);
 203       return element;
 204     }
 205     element = snd_mixer_elem_next (element);
 206   }
 207
 208   /* If not, take any playback mixer with a volume control */
 209   element = snd_mixer_first_elem (handle);
 210   for (i = 0; i < count; i++) {
 211     if (snd_mixer_selem_has_playback_volume (element)) {
 212       GST_ALSA_MIXER_UNLOCK (mixer);
 213       return element;
 214     }
 215     element = snd_mixer_elem_next (element);
 216   }
 217
 218   GST_ALSA_MIXER_UNLOCK (mixer);
 219   /* Looks like we're out of luck ... */
 220   return NULL;
 221 }
 222
 223 static void
 224 gst_alsa_mixer_update (GstAlsaMixer * mixer, snd_mixer_elem_t * elem)
 225 {
 226   GList *item;
 227
 228   g_return_if_fail (mixer != NULL);
 229
 230   GST_ALSA_MIXER_LOCK (mixer);
 231
 232   for (item = mixer->tracklist; item != NULL; item = item->next) {
 233     if (GST_IS_ALSA_MIXER_TRACK (item->data)) {
 234       if (elem && (GST_ALSA_MIXER_TRACK (item->data)->element != elem))
 235         continue;
 236
 237       gst_alsa_mixer_update_track (mixer, GST_ALSA_MIXER_TRACK (item->data));
 238     } else if (GST_IS_ALSA_MIXER_OPTIONS (item->data)) {
 239       if (elem && (GST_ALSA_MIXER_OPTIONS (item->data)->element != elem))
 240         continue;
 241
 242       gst_alsa_mixer_update_option (mixer, GST_ALSA_MIXER_OPTIONS (item->data));
 243     }
 244   }
 245
 246   GST_ALSA_MIXER_UNLOCK (mixer);
 247 }
 248
 249 static int
 250 gst_alsa_mixer_elem_handle_callback (snd_mixer_elem_t * elem, unsigned int mask)
 251 {
 252   GstAlsaMixer *mixer =
 253       (GstAlsaMixer *) snd_mixer_elem_get_callback_private (elem);
 254
 255   GST_LOG ("ALSA elem cb");
 256
 257   g_return_val_if_fail (mixer != NULL, 1);
 258
 259   gst_alsa_mixer_update (mixer, elem);
 260
 261   return 0;
 262 }
 263
 264 static int
 265 gst_alsa_mixer_handle_callback (snd_mixer_t * handle, unsigned int mask,
 266     snd_mixer_elem_t * elem)
 267 {
 268   GstAlsaMixer *mixer =
 269       (GstAlsaMixer *) snd_mixer_get_callback_private (handle);
 270
 271   GST_LOG ("ALSA cb");
 272
 273   g_return_val_if_fail (mixer != NULL, 1);
 274
 275   /* Hopefully won't be call recursively and will handle pending elem events */
 276   snd_mixer_handle_events (mixer->handle);
 277
 278   gst_alsa_mixer_update (mixer, elem);
 279
 280   return 0;
 281 }
 282
 283 static void
 284 gst_alsa_mixer_ensure_track_list (GstAlsaMixer * mixer)
 285 {
 286   gint i, count;
 287   snd_mixer_elem_t *element, *master;
 288   GList *item;
 289
 290   g_return_if_fail (mixer->handle != NULL);
 291
 292   if (mixer->tracklist)
 293     return;
 294
 295   GST_ALSA_MIXER_LOCK (mixer);
 296
 297   master = gst_alsa_mixer_find_master_mixer (mixer, mixer->handle);
 298
 299   count = snd_mixer_get_count (mixer->handle);
 300   element = snd_mixer_first_elem (mixer->handle);
 301
 302   /* build track list
 303    *
 304    * Some ALSA tracks may have playback and capture capabilities.
 305    * Here we model them as two separate GStreamer tracks.
 306    */
 307
 308   for (i = 0; i < count; i++) {
 309     GstMixerTrack *play_track = NULL;
 310     GstMixerTrack *cap_track = NULL;
 311     const gchar *name;
 312     GList *item;
 313     gint samename = 0;
 314
 315     name = snd_mixer_selem_get_name (element);
 316
 317     /* prevent dup names */
 318     for (item = mixer->tracklist; item != NULL; item = item->next) {
 319       snd_mixer_elem_t *temp;
 320
 321       if (GST_IS_ALSA_MIXER_OPTIONS (item->data))
 322         temp = GST_ALSA_MIXER_OPTIONS (item->data)->element;
 323       else
 324         temp = GST_ALSA_MIXER_TRACK (item->data)->element;
 325
 326       if (strcmp (name, snd_mixer_selem_get_name (temp)) == 0)
 327         samename++;
 328     }
 329
 330     GST_LOG ("[%s] probing element #%u, mixer->dir=%u", name, i, mixer->dir);
 331
 332     if (mixer->dir & GST_ALSA_MIXER_PLAYBACK) {
 333       gboolean has_playback_switch, has_playback_volume;
 334
 335       has_playback_switch = snd_mixer_selem_has_playback_switch (element);
 336       has_playback_volume = snd_mixer_selem_has_playback_volume (element);
 337
 338       GST_LOG ("[%s] PLAYBACK: has_playback_volume=%d, has_playback_switch=%d"
 339           "%s", name, has_playback_volume, has_playback_switch,
 340           (element == master) ? " MASTER" : "");
 341
 342       if (has_playback_volume) {
 343         gint flags = GST_MIXER_TRACK_OUTPUT;
 344
 345         if (element == master)
 346           flags |= GST_MIXER_TRACK_MASTER;
 347
 348         play_track = gst_alsa_mixer_track_new (element, samename, i,
 349             flags, FALSE, NULL, FALSE);
 350
 351       } else if (has_playback_switch) {
 352         /* simple mute switch */
 353         play_track = gst_alsa_mixer_track_new (element, samename, i,
 354             GST_MIXER_TRACK_OUTPUT, TRUE, NULL, FALSE);
 355       }
 356
 357       if (snd_mixer_selem_is_enumerated (element)) {
 358         GstMixerOptions *opts = gst_alsa_mixer_options_new (element, i);
 359
 360         GST_LOG ("[%s] is enumerated (%d)", name, i);
 361         mixer->tracklist = g_list_append (mixer->tracklist, opts);
 362       }
 363     }
 364
 365     if (mixer->dir & GST_ALSA_MIXER_CAPTURE) {
 366       gboolean has_capture_switch, has_common_switch;
 367       gboolean has_capture_volume, has_common_volume;
 368
 369       has_capture_switch = snd_mixer_selem_has_capture_switch (element);
 370       has_common_switch = snd_mixer_selem_has_common_switch (element);
 371       has_capture_volume = snd_mixer_selem_has_capture_volume (element);
 372       has_common_volume = snd_mixer_selem_has_common_volume (element);
 373
 374       GST_LOG ("[%s] CAPTURE: has_capture_volume=%d, has_common_volume=%d, "
 375           "has_capture_switch=%d, has_common_switch=%d, play_track=%p", name,
 376           has_capture_volume, has_common_volume, has_capture_switch,
 377           has_common_switch, play_track);
 378
 379       if (has_capture_volume && !(play_track && has_common_volume)) {
 380         cap_track = gst_alsa_mixer_track_new (element, samename, i,
 381             GST_MIXER_TRACK_INPUT, FALSE, NULL, play_track != NULL);
 382       } else if (has_capture_switch && !(play_track && has_common_switch)) {
 383         cap_track = gst_alsa_mixer_track_new (element, samename, i,
 384             GST_MIXER_TRACK_INPUT, TRUE, NULL, play_track != NULL);
 385       }
 386     }
 387
 388
 389     if (play_track && cap_track) {
 390       GST_ALSA_MIXER_TRACK (play_track)->shared_mute =
 391           GST_ALSA_MIXER_TRACK (cap_track);
 392       GST_ALSA_MIXER_TRACK (cap_track)->shared_mute =
 393           GST_ALSA_MIXER_TRACK (play_track);
 394     }
 395
 396     if (play_track)
 397       mixer->tracklist = g_list_append (mixer->tracklist, play_track);
 398
 399     if (cap_track)
 400       mixer->tracklist = g_list_append (mixer->tracklist, cap_track);
 401
 402     element = snd_mixer_elem_next (element);
 403   }
 404
 405   for (item = mixer->tracklist; item != NULL; item = item->next) {
 406     snd_mixer_elem_t *temp;
 407
 408     if (GST_IS_ALSA_MIXER_OPTIONS (item->data))
 409       temp = GST_ALSA_MIXER_OPTIONS (item->data)->element;
 410     else
 411       temp = GST_ALSA_MIXER_TRACK (item->data)->element;
 412
 413     snd_mixer_elem_set_callback (temp, gst_alsa_mixer_elem_handle_callback);
 414     snd_mixer_elem_set_callback_private (temp, mixer);
 415   }
 416
 417   GST_ALSA_MIXER_UNLOCK (mixer);
 418 }
 419
 420 static void
 421 task_monitor_alsa (gpointer data)
 422 {
 423   struct pollfd *pfds;
 424   int nfds, rnfds;
 425   unsigned short revents;
 426   GstAlsaMixer *mixer = (GstAlsaMixer *) data;
 427   gint ret;
 428
 429   GST_ALSA_MIXER_LOCK (mixer);
 430
 431   nfds = snd_mixer_poll_descriptors_count (mixer->handle);
 432   if (nfds <= 0) {
 433     GST_ERROR ("snd_mixer_poll_descriptors_count <= 0: %d", nfds);
 434     /* FIXME: sleep ? stop monitoring ? */
 435     GST_ALSA_MIXER_UNLOCK (mixer);
 436     return;
 437   }
 438
 439   pfds = g_newa (struct pollfd, nfds + 1);
 440   rnfds = snd_mixer_poll_descriptors (mixer->handle, pfds, nfds);
 441   g_assert (rnfds <= nfds);
 442
 443   if (rnfds < 0) {
 444     GST_ELEMENT_ERROR (mixer, RESOURCE, READ, (NULL), ("alsa error: %s",
 445             snd_strerror (rnfds)));
 446     gst_task_pause (mixer->task);
 447     GST_ALSA_MIXER_UNLOCK (mixer);
 448     return;
 449   }
 450
 451   pfds[rnfds].fd = mixer->pfd[0];
 452   pfds[rnfds].events = POLLIN | POLLPRI | POLLHUP | POLLERR;
 453   pfds[rnfds].revents = 0;
 454
 455   GST_ALSA_MIXER_UNLOCK (mixer);
 456
 457   GST_LOG ("task loop");
 458   ret = poll (pfds, rnfds + 1, -1);
 459
 460   if (ret < 0) {
 461     GST_ELEMENT_ERROR (mixer, RESOURCE, READ, (NULL), GST_ERROR_SYSTEM);
 462     gst_task_pause (mixer->task);
 463     return;
 464   }
 465
 466   GST_ALSA_MIXER_LOCK (mixer);
 467
 468   ret =
 469       snd_mixer_poll_descriptors_revents (mixer->handle, pfds, nfds, &revents);
 470   if (ret < 0) {
 471     GST_ELEMENT_ERROR (mixer, RESOURCE, READ, (NULL), ("alsa error: %s",
 472             snd_strerror (ret)));
 473     gst_task_pause (mixer->task);
 474   } else if (revents & (POLLIN | POLLPRI)) {
 475     GST_DEBUG ("Handling events");
 476     snd_mixer_handle_events (mixer->handle);
 477   } else if (revents & (POLLERR | POLLNVAL | POLLHUP)) {
 478     GST_ELEMENT_ERROR (mixer, RESOURCE, READ, (NULL), (NULL));
 479     gst_task_pause (mixer->task);
 480   }
 481
 482   GST_ALSA_MIXER_UNLOCK (mixer);
 483 }
 484
 485 /* API */
 486
 487 GstAlsaMixer *
 488 gst_alsa_mixer_new (const char *device, GstAlsaMixerDirection dir)
 489 {
 490   GstAlsaMixer *ret = NULL;
 491
 492   g_return_val_if_fail (device != NULL, NULL);
 493
 494   ret = g_new0 (GstAlsaMixer, 1);
 495
 496   if (pipe (ret->pfd) == -1)
 497     goto error;
 498
 499 #if !GLIB_CHECK_VERSION (2, 31, 0)
 500   g_static_rec_mutex_init (&ret->rec_mutex);
 501 #else
 502   g_rec_mutex_init (&ret->rec_mutex);
 503 #endif
 504   g_static_rec_mutex_init (&ret->task_mutex);
 505
 506   ret->task = gst_task_create (task_monitor_alsa, ret);
 507   gst_task_set_lock (ret->task, &ret->task_mutex);
 508
 509   ret->device = g_strdup (device);
 510   ret->dir = dir;
 511
 512   if (!gst_alsa_mixer_open (ret))
 513     goto error;
 514
 515   if (gst_task_start (ret->task) == FALSE) {
 516     GST_WARNING ("Could not start alsamixer task");
 517   }
 518
 519   return ret;
 520
 521   /* ERRORS */
 522 error:
 523   {
 524     gst_alsa_mixer_free (ret);
 525     return NULL;
 526   }
 527 }
 528
 529 void
 530 gst_alsa_mixer_free (GstAlsaMixer * mixer)
 531 {
 532   g_return_if_fail (mixer != NULL);
 533
 534   if (mixer->task) {
 535     if (write (mixer->pfd[1], "stop", 5) <= 0) {
 536       GST_ERROR ("Cannot send " "stop" " to alsamixer task");
 537       close (mixer->pfd[1]);
 538       mixer->pfd[1] = -1;
 539     }
 540
 541     if (gst_task_join (mixer->task) == FALSE) {
 542       GST_ERROR ("Cannot join alsamixer task");
 543     }
 544
 545     gst_object_unref (mixer->task);
 546     mixer->task = NULL;
 547   }
 548
 549   g_static_rec_mutex_free (&mixer->task_mutex);
 550
 551   if (mixer->pfd[0] > 0) {
 552     close (mixer->pfd[0]);
 553     mixer->pfd[0] = -1;
 554   }
 555
 556   if (mixer->pfd[1] > 0) {
 557     close (mixer->pfd[1]);
 558     mixer->pfd[1] = -1;
 559   }
 560
 561   if (mixer->interface) {
 562     g_object_unref (G_OBJECT (mixer->interface));
 563     mixer->interface = NULL;
 564   }
 565
 566   if (mixer->device) {
 567     g_free (mixer->device);
 568     mixer->device = NULL;
 569   }
 570
 571   if (mixer->cardname) {
 572     g_free (mixer->cardname);
 573     mixer->cardname = NULL;
 574   }
 575
 576   if (mixer->tracklist) {
 577     g_list_foreach (mixer->tracklist, (GFunc) g_object_unref, NULL);
 578     g_list_free (mixer->tracklist);
 579     mixer->tracklist = NULL;
 580   }
 581
 582   if (mixer->handle) {
 583     snd_mixer_close (mixer->handle);
 584     mixer->handle = NULL;
 585   }
 586 #if !GLIB_CHECK_VERSION (2, 31, 0)
 587   g_static_rec_mutex_free (&mixer->rec_mutex);
 588 #else
 589   g_rec_mutex_clear (&mixer->rec_mutex);
 590 #endif
 591
 592   g_free (mixer);
 593 }
 594
 595 const GList *
 596 gst_alsa_mixer_list_tracks (GstAlsaMixer * mixer)
 597 {
 598   g_return_val_if_fail (mixer->handle != NULL, NULL);
 599
 600   gst_alsa_mixer_ensure_track_list (mixer);
 601
 602   return (const GList *) mixer->tracklist;
 603 }
 604
 605 void
 606 gst_alsa_mixer_get_volume (GstAlsaMixer * mixer, GstMixerTrack * track,
 607     gint * volumes)
 608 {
 609   gint i;
 610   GstAlsaMixerTrack *alsa_track = GST_ALSA_MIXER_TRACK (track);
 611
 612   g_return_if_fail (mixer->handle != NULL);
 613
 614   GST_ALSA_MIXER_LOCK (mixer);
 615
 616   gst_alsa_mixer_track_update (alsa_track);
 617
 618   if (track->flags & GST_MIXER_TRACK_OUTPUT) {  /* return playback volume */
 619
 620     /* Is emulated mute flag activated? */
 621     if (track->flags & GST_MIXER_TRACK_MUTE &&
 622         !(alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_PSWITCH)) {
 623       for (i = 0; i < track->num_channels; i++)
 624         volumes[i] = alsa_track->volumes[i];
 625     } else {
 626       for (i = 0; i < track->num_channels; i++) {
 627         long tmp = 0;
 628
 629         snd_mixer_selem_get_playback_volume (alsa_track->element, i, &tmp);
 630         alsa_track->volumes[i] = volumes[i] = (gint) tmp;
 631       }
 632     }
 633
 634   } else if (track->flags & GST_MIXER_TRACK_INPUT) {    /* return capture volume */
 635
 636     /* Is emulated record flag activated? */
 637     if (alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_CSWITCH ||
 638         track->flags & GST_MIXER_TRACK_RECORD) {
 639       for (i = 0; i < track->num_channels; i++) {
 640         long tmp = 0;
 641
 642         snd_mixer_selem_get_capture_volume (alsa_track->element, i, &tmp);
 643         alsa_track->volumes[i] = volumes[i] = (gint) tmp;
 644       }
 645     } else {
 646       for (i = 0; i < track->num_channels; i++)
 647         volumes[i] = alsa_track->volumes[i];
 648     }
 649   }
 650   GST_ALSA_MIXER_UNLOCK (mixer);
 651 }
 652
 653 static gboolean
 654 check_if_volumes_are_the_same (guint num_channels, gint * volumes)
 655 {
 656   guint i;
 657
 658   if (num_channels <= 1)
 659     return TRUE;
 660
 661   for (i = 1; i < num_channels; i++) {
 662     if (volumes[i] != volumes[0])
 663       return FALSE;
 664   }
 665
 666   return TRUE;
 667 }
 668
 669 void
 670 gst_alsa_mixer_set_volume (GstAlsaMixer * mixer, GstMixerTrack * track,
 671     gint * volumes)
 672 {
 673   GstAlsaMixerTrack *alsa_track = GST_ALSA_MIXER_TRACK (track);
 674   gint i;
 675
 676   g_return_if_fail (mixer->handle != NULL);
 677
 678   GST_ALSA_MIXER_LOCK (mixer);
 679
 680   gst_alsa_mixer_track_update (alsa_track);
 681
 682   if (track->flags & GST_MIXER_TRACK_OUTPUT) {
 683
 684     /* Is emulated mute flag activated? */
 685     if (track->flags & GST_MIXER_TRACK_MUTE &&
 686         !(alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_PSWITCH)) {
 687       for (i = 0; i < track->num_channels; i++)
 688         alsa_track->volumes[i] = volumes[i];
 689     } else {
 690       if (check_if_volumes_are_the_same (track->num_channels, volumes)) {
 691         snd_mixer_selem_set_playback_volume_all (alsa_track->element,
 692             volumes[0]);
 693         for (i = 0; i < track->num_channels; i++)
 694           alsa_track->volumes[i] = volumes[0];
 695       } else {
 696         for (i = 0; i < track->num_channels; i++) {
 697           alsa_track->volumes[i] = volumes[i];
 698           snd_mixer_selem_set_playback_volume (alsa_track->element, i,
 699               volumes[i]);
 700         }
 701       }
 702     }
 703
 704   } else if (track->flags & GST_MIXER_TRACK_INPUT) {
 705
 706     /* Is emulated record flag activated? */
 707     if (track->flags & GST_MIXER_TRACK_RECORD ||
 708         alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_CSWITCH) {
 709       if (check_if_volumes_are_the_same (track->num_channels, volumes)) {
 710         snd_mixer_selem_set_capture_volume_all (alsa_track->element,
 711             volumes[0]);
 712         for (i = 0; i < track->num_channels; i++)
 713           alsa_track->volumes[i] = volumes[0];
 714       } else {
 715         for (i = 0; i < track->num_channels; i++) {
 716           alsa_track->volumes[i] = volumes[i];
 717           snd_mixer_selem_set_capture_volume (alsa_track->element, i,
 718               volumes[i]);
 719         }
 720       }
 721     } else {
 722       for (i = 0; i < track->num_channels; i++)
 723         alsa_track->volumes[i] = volumes[i];
 724     }
 725   }
 726   GST_ALSA_MIXER_UNLOCK (mixer);
 727 }
 728
 729 void
 730 gst_alsa_mixer_set_mute (GstAlsaMixer * mixer, GstMixerTrack * track,
 731     gboolean mute)
 732 {
 733   GstAlsaMixerTrack *alsa_track = GST_ALSA_MIXER_TRACK (track);
 734
 735   g_return_if_fail (mixer->handle != NULL);
 736
 737   GST_ALSA_MIXER_LOCK (mixer);
 738
 739   gst_alsa_mixer_track_update (alsa_track);
 740
 741   if (! !(mute) == ! !(track->flags & GST_MIXER_TRACK_MUTE)) {
 742     GST_ALSA_MIXER_UNLOCK (mixer);
 743     return;
 744   }
 745   if (mute) {
 746     track->flags |= GST_MIXER_TRACK_MUTE;
 747
 748     if (alsa_track->shared_mute)
 749       ((GstMixerTrack *) (alsa_track->shared_mute))->flags |=
 750           GST_MIXER_TRACK_MUTE;
 751   } else {
 752     track->flags &= ~GST_MIXER_TRACK_MUTE;
 753
 754     if (alsa_track->shared_mute)
 755       ((GstMixerTrack *) (alsa_track->shared_mute))->flags &=
 756           ~GST_MIXER_TRACK_MUTE;
 757   }
 758
 759   if (alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_PSWITCH) {
 760     snd_mixer_selem_set_playback_switch_all (alsa_track->element, mute ? 0 : 1);
 761   } else {
 762     gint i;
 763     GstAlsaMixerTrack *ctrl_track;
 764
 765     if ((track->flags & GST_MIXER_TRACK_INPUT)
 766         && alsa_track->shared_mute != NULL)
 767       ctrl_track = alsa_track->shared_mute;
 768     else
 769       ctrl_track = alsa_track;
 770
 771     for (i = 0; i < ((GstMixerTrack *) ctrl_track)->num_channels; i++) {
 772       long vol =
 773           mute ? ((GstMixerTrack *) ctrl_track)->min_volume : ctrl_track->
 774           volumes[i];
 775       snd_mixer_selem_set_playback_volume (ctrl_track->element, i, vol);
 776     }
 777   }
 778   GST_ALSA_MIXER_UNLOCK (mixer);
 779 }
 780
 781 void
 782 gst_alsa_mixer_set_record (GstAlsaMixer * mixer,
 783     GstMixerTrack * track, gboolean record)
 784 {
 785   GstAlsaMixerTrack *alsa_track = GST_ALSA_MIXER_TRACK (track);
 786
 787   g_return_if_fail (mixer->handle != NULL);
 788
 789   GST_ALSA_MIXER_LOCK (mixer);
 790
 791   gst_alsa_mixer_track_update (alsa_track);
 792
 793   if (! !(record) == ! !(track->flags & GST_MIXER_TRACK_RECORD)) {
 794     GST_ALSA_MIXER_UNLOCK (mixer);
 795     return;
 796   }
 797
 798   if (record) {
 799     track->flags |= GST_MIXER_TRACK_RECORD;
 800   } else {
 801     track->flags &= ~GST_MIXER_TRACK_RECORD;
 802   }
 803
 804   if (alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_CSWITCH) {
 805     snd_mixer_selem_set_capture_switch_all (alsa_track->element,
 806         record ? 1 : 0);
 807
 808     /* update all tracks in same exclusive cswitch group */
 809     if (alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_CSWITCH_EXCL) {
 810       GList *item;
 811
 812       for (item = mixer->tracklist; item != NULL; item = item->next) {
 813
 814         if (GST_IS_ALSA_MIXER_TRACK (item->data)) {
 815           GstAlsaMixerTrack *item_alsa_track =
 816               GST_ALSA_MIXER_TRACK (item->data);
 817
 818           if (item_alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_CSWITCH_EXCL &&
 819               item_alsa_track->capture_group == alsa_track->capture_group) {
 820             gst_alsa_mixer_track_update (item_alsa_track);
 821           }
 822         }
 823       }
 824     }
 825   } else {
 826     gint i;
 827
 828     for (i = 0; i < track->num_channels; i++) {
 829       long vol = record ? alsa_track->volumes[i] : track->min_volume;
 830
 831       snd_mixer_selem_set_capture_volume (alsa_track->element, i, vol);
 832     }
 833   }
 834   GST_ALSA_MIXER_UNLOCK (mixer);
 835 }
 836
 837 void
 838 gst_alsa_mixer_set_option (GstAlsaMixer * mixer,
 839     GstMixerOptions * opts, gchar * value)
 840 {
 841   gint idx = -1, n = 0;
 842   GList *item;
 843   GstAlsaMixerOptions *alsa_opts = GST_ALSA_MIXER_OPTIONS (opts);
 844
 845   g_return_if_fail (mixer->handle != NULL);
 846
 847   for (item = opts->values; item != NULL; item = item->next, n++) {
 848     if (!strcmp (item->data, value)) {
 849       idx = n;
 850       break;
 851     }
 852   }
 853   if (idx == -1)
 854     return;
 855
 856   GST_ALSA_MIXER_LOCK (mixer);
 857   snd_mixer_selem_set_enum_item (alsa_opts->element, 0, idx);
 858   GST_ALSA_MIXER_UNLOCK (mixer);
 859 }
 860
 861 const gchar *
 862 gst_alsa_mixer_get_option (GstAlsaMixer * mixer, GstMixerOptions * opts)
 863 {
 864   gint ret;
 865   guint idx;
 866   GstAlsaMixerOptions *alsa_opts = GST_ALSA_MIXER_OPTIONS (opts);
 867
 868   g_return_val_if_fail (mixer->handle != NULL, NULL);
 869   GST_ALSA_MIXER_LOCK (mixer);
 870   ret = snd_mixer_selem_get_enum_item (alsa_opts->element, 0, &idx);
 871   GST_ALSA_MIXER_UNLOCK (mixer);
 872   if (ret == 0)
 873     return g_list_nth_data (opts->values, idx);
 874   else
 875     return snd_strerror (ret);  /* feeble attempt at error handling */
 876 }
 877
 878 GstMixerFlags
 879 gst_alsa_mixer_get_mixer_flags (GstAlsaMixer * mixer)
 880 {
 881   g_return_val_if_fail (mixer != NULL, GST_MIXER_FLAG_NONE);
 882
 883   return GST_MIXER_FLAG_AUTO_NOTIFICATIONS;
 884 }
 885
 886 static void
 887 gst_alsa_mixer_update_option (GstAlsaMixer * mixer,
 888     GstAlsaMixerOptions * alsa_opts)
 889 {
 890   gint ret;
 891   guint idx;
 892   /* const */ gchar *option;
 893
 894   if (mixer->interface == NULL) {
 895     GST_WARNING ("Cannot send update notifications, no GstMixer * given");
 896     return;
 897   }
 898   GST_ALSA_MIXER_LOCK (mixer);
 899   ret = snd_mixer_selem_get_enum_item (alsa_opts->element, 0, &idx);
 900   GST_ALSA_MIXER_UNLOCK (mixer);
 901   if (ret == 0) {
 902     option = g_list_nth_data (GST_MIXER_OPTIONS (alsa_opts)->values, idx);
 903     gst_mixer_option_changed (mixer->interface, GST_MIXER_OPTIONS (alsa_opts),
 904         option);
 905   }
 906 }
 907
 908 static void
 909 gst_alsa_mixer_update_track (GstAlsaMixer * mixer,
 910     GstAlsaMixerTrack * alsa_track)
 911 {
 912   GstMixerTrack *track = (GstMixerTrack *) alsa_track;
 913   gboolean old_mute;
 914   gboolean old_record;
 915   gint i, n_channels;
 916   gint *old_volumes;
 917
 918   GST_DEBUG ("Updating track %" GST_PTR_FORMAT, alsa_track);
 919
 920   if (mixer->interface == NULL) {
 921     GST_WARNING ("Cannot send update notifications, no GstMixer * given");
 922     return;
 923   }
 924
 925   old_mute = ! !(GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_MUTE));
 926   old_record = ! !(GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_RECORD));
 927   old_volumes = g_new (gint, track->num_channels);
 928   n_channels = track->num_channels;
 929   memcpy (old_volumes, alsa_track->volumes,
 930       sizeof (gint) * track->num_channels);
 931
 932   gst_alsa_mixer_track_update (alsa_track);
 933
 934   if (old_record !=
 935       ! !(GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_RECORD))) {
 936     gst_mixer_record_toggled (mixer->interface, track,
 937         ! !GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_RECORD));
 938   }
 939   if (old_mute != ! !(GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_MUTE))) {
 940     gst_mixer_mute_toggled (mixer->interface, track,
 941         ! !GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_MUTE));
 942   }
 943
 944   n_channels = MIN (n_channels, track->num_channels);
 945   for (i = 0; i < n_channels; i++) {
 946     if (old_volumes[i] != alsa_track->volumes[i]) {
 947       gst_mixer_volume_changed (mixer->interface, track, alsa_track->volumes);
 948       break;
 949     }
 950   }
 951   g_free (old_volumes);
 952 }
 953
 954 /* utility function for gstalsamixerelement to set the interface */
 955 void
 956 _gst_alsa_mixer_set_interface (GstAlsaMixer * mixer, GstMixer * interface)
 957 {
 958   g_return_if_fail (mixer != NULL && mixer->interface == NULL);
 959   g_return_if_fail (interface != NULL);
 960
 961   mixer->interface = g_object_ref (G_OBJECT (interface));
 962 }