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