sys/sunaudio/gstsunaudiomixerctrl.c

   1 /*
   2  * GStreamer - SunAudio mixer interface element
   3  * Copyright (C) 2005,2006,2008,2009 Sun Microsystems, Inc.,
   4  *               Brian Cameron <brian.cameron@sun.com>
   5  * Copyright (C) 2008 Sun Microsystems, Inc.,
   6  *               Jan Schmidt <jan.schmidt@sun.com>
   7  * Copyright (C) 2009 Sun Microsystems, Inc.,
   8  *               Garrett D'Amore <garrett.damore@sun.com>
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Library General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Library General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Library General Public
  21  * License along with this library; if not, write to the
  22  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23  * Boston, MA 02111-1307, USA.
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34 #include <string.h>
  35 #include <errno.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/audio.h>
  38 #include <sys/mixer.h>
  39
  40 #include <gst/gst-i18n-plugin.h>
  41
  42 #include "gstsunaudiomixerctrl.h"
  43 #include "gstsunaudiomixertrack.h"
  44 #include "gstsunaudiomixeroptions.h"
  45
  46 GST_DEBUG_CATEGORY_EXTERN (sunaudio_debug);
  47 #define GST_CAT_DEFAULT sunaudio_debug
  48
  49 static gboolean
  50 gst_sunaudiomixer_ctrl_open (GstSunAudioMixerCtrl * mixer)
  51 {
  52   int fd;
  53
  54   /* First try to open non-blocking */
  55   fd = open (mixer->device, O_RDWR | O_NONBLOCK);
  56
  57   if (fd >= 0) {
  58     close (fd);
  59     fd = open (mixer->device, O_WRONLY);
  60   }
  61
  62   if (fd == -1) {
  63     GST_DEBUG_OBJECT (mixer,
  64         "Failed to open mixer device %s, mixing disabled: %s", mixer->device,
  65         strerror (errno));
  66
  67     return FALSE;
  68   }
  69   mixer->mixer_fd = fd;
  70
  71   /* Try to set the multiple open flag if we can, but ignore errors */
  72   ioctl (mixer->mixer_fd, AUDIO_MIXER_MULTIPLE_OPEN);
  73
  74   GST_DEBUG_OBJECT (mixer, "Opened mixer device %s", mixer->device);
  75
  76   return TRUE;
  77 }
  78
  79 void
  80 gst_sunaudiomixer_ctrl_build_list (GstSunAudioMixerCtrl * mixer)
  81 {
  82   GstMixerTrack *track;
  83   GstMixerOptions *options;
  84
  85   struct audio_info audioinfo;
  86
  87   /*
  88    * Do not continue appending the same 3 static tracks onto the list
  89    */
  90   if (mixer->tracklist == NULL) {
  91     g_return_if_fail (mixer->mixer_fd != -1);
  92
  93     /* query available ports */
  94     if (ioctl (mixer->mixer_fd, AUDIO_GETINFO, &audioinfo) < 0) {
  95       g_warning ("Error getting audio device volume");
  96       return;
  97     }
  98
  99     /* Output & should be MASTER when it's the only one. */
 100     track = gst_sunaudiomixer_track_new (GST_SUNAUDIO_TRACK_OUTPUT);
 101     mixer->tracklist = g_list_append (mixer->tracklist, track);
 102
 103     /* Input */
 104     track = gst_sunaudiomixer_track_new (GST_SUNAUDIO_TRACK_RECORD);
 105     mixer->tracklist = g_list_append (mixer->tracklist, track);
 106
 107     /* Monitor */
 108     track = gst_sunaudiomixer_track_new (GST_SUNAUDIO_TRACK_MONITOR);
 109     mixer->tracklist = g_list_append (mixer->tracklist, track);
 110
 111     if (audioinfo.play.avail_ports & AUDIO_SPEAKER) {
 112       track = gst_sunaudiomixer_track_new (GST_SUNAUDIO_TRACK_SPEAKER);
 113       mixer->tracklist = g_list_append (mixer->tracklist, track);
 114     }
 115     if (audioinfo.play.avail_ports & AUDIO_HEADPHONE) {
 116       track = gst_sunaudiomixer_track_new (GST_SUNAUDIO_TRACK_HP);
 117       mixer->tracklist = g_list_append (mixer->tracklist, track);
 118     }
 119     if (audioinfo.play.avail_ports & AUDIO_LINE_OUT) {
 120       track = gst_sunaudiomixer_track_new (GST_SUNAUDIO_TRACK_LINEOUT);
 121       mixer->tracklist = g_list_append (mixer->tracklist, track);
 122     }
 123     if (audioinfo.play.avail_ports & AUDIO_SPDIF_OUT) {
 124       track = gst_sunaudiomixer_track_new (GST_SUNAUDIO_TRACK_SPDIFOUT);
 125       mixer->tracklist = g_list_append (mixer->tracklist, track);
 126     }
 127     if (audioinfo.play.avail_ports & AUDIO_AUX1_OUT) {
 128       track = gst_sunaudiomixer_track_new (GST_SUNAUDIO_TRACK_AUX1OUT);
 129       mixer->tracklist = g_list_append (mixer->tracklist, track);
 130     }
 131     if (audioinfo.play.avail_ports & AUDIO_AUX2_OUT) {
 132       track = gst_sunaudiomixer_track_new (GST_SUNAUDIO_TRACK_AUX2OUT);
 133       mixer->tracklist = g_list_append (mixer->tracklist, track);
 134     }
 135
 136     if (audioinfo.record.avail_ports != AUDIO_NONE) {
 137       options =
 138           gst_sunaudiomixer_options_new (mixer, GST_SUNAUDIO_TRACK_RECSRC);
 139       mixer->tracklist = g_list_append (mixer->tracklist, options);
 140     }
 141   }
 142 }
 143
 144 GstSunAudioMixerCtrl *
 145 gst_sunaudiomixer_ctrl_new (const char *device)
 146 {
 147   GstSunAudioMixerCtrl *ret = NULL;
 148
 149   g_return_val_if_fail (device != NULL, NULL);
 150
 151   ret = g_new0 (GstSunAudioMixerCtrl, 1);
 152
 153   ret->device = g_strdup (device);
 154   ret->mixer_fd = -1;
 155   ret->tracklist = NULL;
 156
 157   if (!gst_sunaudiomixer_ctrl_open (ret))
 158     goto error;
 159
 160   return ret;
 161
 162 error:
 163   if (ret)
 164     gst_sunaudiomixer_ctrl_free (ret);
 165
 166   return NULL;
 167 }
 168
 169 void
 170 gst_sunaudiomixer_ctrl_free (GstSunAudioMixerCtrl * mixer)
 171 {
 172   g_return_if_fail (mixer != NULL);
 173
 174   if (mixer->device) {
 175     g_free (mixer->device);
 176     mixer->device = NULL;
 177   }
 178
 179   if (mixer->tracklist) {
 180     g_list_foreach (mixer->tracklist, (GFunc) g_object_unref, NULL);
 181     g_list_free (mixer->tracklist);
 182     mixer->tracklist = NULL;
 183   }
 184
 185   if (mixer->mixer_fd != -1) {
 186     close (mixer->mixer_fd);
 187     mixer->mixer_fd = -1;
 188   }
 189
 190   g_free (mixer);
 191 }
 192
 193 GstMixerFlags
 194 gst_sunaudiomixer_ctrl_get_mixer_flags (GstSunAudioMixerCtrl * mixer)
 195 {
 196   return GST_MIXER_FLAG_HAS_WHITELIST | GST_MIXER_FLAG_GROUPING;
 197 }
 198
 199 const GList *
 200 gst_sunaudiomixer_ctrl_list_tracks (GstSunAudioMixerCtrl * mixer)
 201 {
 202   gst_sunaudiomixer_ctrl_build_list (mixer);
 203
 204   return (const GList *) mixer->tracklist;
 205 }
 206
 207 void
 208 gst_sunaudiomixer_ctrl_get_volume (GstSunAudioMixerCtrl * mixer,
 209     GstMixerTrack * track, gint * volumes)
 210 {
 211   gint gain, balance;
 212   float ratio;
 213   struct audio_info audioinfo;
 214   GstSunAudioMixerTrack *sunaudiotrack;
 215
 216   g_return_if_fail (GST_IS_SUNAUDIO_MIXER_TRACK (track));
 217   sunaudiotrack = GST_SUNAUDIO_MIXER_TRACK (track);
 218
 219   g_return_if_fail (mixer->mixer_fd != -1);
 220
 221   if (ioctl (mixer->mixer_fd, AUDIO_GETINFO, &audioinfo) < 0) {
 222     g_warning ("Error getting audio device volume");
 223     return;
 224   }
 225
 226   balance = AUDIO_MID_BALANCE;
 227   gain = 0;
 228
 229   switch (sunaudiotrack->track_num) {
 230     case GST_SUNAUDIO_TRACK_OUTPUT:
 231       gain = (int) audioinfo.play.gain;
 232       balance = audioinfo.play.balance;
 233       break;
 234     case GST_SUNAUDIO_TRACK_RECORD:
 235       gain = (int) audioinfo.record.gain;
 236       balance = audioinfo.record.balance;
 237       break;
 238     case GST_SUNAUDIO_TRACK_MONITOR:
 239       gain = (int) audioinfo.monitor_gain;
 240       balance = audioinfo.record.balance;
 241       break;
 242     case GST_SUNAUDIO_TRACK_SPEAKER:
 243       if (audioinfo.play.port & AUDIO_SPEAKER)
 244         gain = AUDIO_MAX_GAIN;
 245       break;
 246     case GST_SUNAUDIO_TRACK_HP:
 247       if (audioinfo.play.port & AUDIO_HEADPHONE)
 248         gain = AUDIO_MAX_GAIN;
 249       break;
 250     case GST_SUNAUDIO_TRACK_LINEOUT:
 251       if (audioinfo.play.port & AUDIO_LINE_OUT)
 252         gain = AUDIO_MAX_GAIN;
 253       break;
 254     case GST_SUNAUDIO_TRACK_SPDIFOUT:
 255       if (audioinfo.play.port & AUDIO_SPDIF_OUT)
 256         gain = AUDIO_MAX_GAIN;
 257       break;
 258     case GST_SUNAUDIO_TRACK_AUX1OUT:
 259       if (audioinfo.play.port & AUDIO_AUX1_OUT)
 260         gain = AUDIO_MAX_GAIN;
 261       break;
 262     case GST_SUNAUDIO_TRACK_AUX2OUT:
 263       if (audioinfo.play.port & AUDIO_AUX2_OUT)
 264         gain = AUDIO_MAX_GAIN;
 265       break;
 266     default:
 267       break;
 268   }
 269
 270   switch (track->num_channels) {
 271     case 2:
 272       if (balance == AUDIO_MID_BALANCE) {
 273         volumes[0] = gain;
 274         volumes[1] = gain;
 275       } else if (balance < AUDIO_MID_BALANCE) {
 276         volumes[0] = gain;
 277         ratio = 1 - (float) (AUDIO_MID_BALANCE - balance) /
 278             (float) AUDIO_MID_BALANCE;
 279         volumes[1] = (int) ((float) gain * ratio + 0.5);
 280       } else {
 281         volumes[1] = gain;
 282         ratio = 1 - (float) (balance - AUDIO_MID_BALANCE) /
 283             (float) AUDIO_MID_BALANCE;
 284         volumes[0] = (int) ((float) gain * ratio + 0.5);
 285       }
 286       break;
 287     case 1:
 288       volumes[0] = gain;
 289       break;
 290   }
 291
 292   /* Likewise reset MUTE */
 293   if ((sunaudiotrack->track_num == GST_SUNAUDIO_TRACK_OUTPUT
 294           && audioinfo.output_muted == 1)
 295       || (sunaudiotrack->track_num != GST_SUNAUDIO_TRACK_OUTPUT && gain == 0)) {
 296     /*
 297      * If MUTE is set, then gain is always 0, so don't bother
 298      * resetting our internal value.
 299      */
 300     track->flags |= GST_MIXER_TRACK_MUTE;
 301   } else {
 302     sunaudiotrack->gain = gain;
 303     sunaudiotrack->balance = balance;
 304     track->flags &= ~GST_MIXER_TRACK_MUTE;
 305   }
 306 }
 307
 308 void
 309 gst_sunaudiomixer_ctrl_set_volume (GstSunAudioMixerCtrl * mixer,
 310     GstMixerTrack * track, gint * volumes)
 311 {
 312   gint gain;
 313   gint balance;
 314   gint l_real_gain;
 315   gint r_real_gain;
 316   float ratio;
 317   struct audio_info audioinfo;
 318   GstSunAudioMixerTrack *sunaudiotrack = GST_SUNAUDIO_MIXER_TRACK (track);
 319
 320   l_real_gain = volumes[0];
 321   r_real_gain = volumes[1];
 322
 323   if (l_real_gain == r_real_gain) {
 324     gain = l_real_gain;
 325     balance = AUDIO_MID_BALANCE;
 326   } else if (l_real_gain < r_real_gain) {
 327     gain = r_real_gain;
 328     ratio = (float) l_real_gain / (float) r_real_gain;
 329     balance =
 330         AUDIO_RIGHT_BALANCE - (int) (ratio * (float) AUDIO_MID_BALANCE + 0.5);
 331   } else {
 332     gain = l_real_gain;
 333     ratio = (float) r_real_gain / (float) l_real_gain;
 334     balance =
 335         AUDIO_LEFT_BALANCE + (int) (ratio * (float) AUDIO_MID_BALANCE + 0.5);
 336   }
 337
 338   sunaudiotrack->gain = gain;
 339   sunaudiotrack->balance = balance;
 340
 341   if (GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_MUTE)) {
 342     if (sunaudiotrack->track_num == GST_SUNAUDIO_TRACK_OUTPUT) {
 343       return;
 344     } else if (gain == 0) {
 345       return;
 346     } else {
 347       /*
 348        * If the volume is set to a non-zero value for LINE_IN
 349        * or MONITOR, then unset MUTE.
 350        */
 351       track->flags &= ~GST_MIXER_TRACK_MUTE;
 352     }
 353   }
 354
 355   /* Set the volume */
 356   AUDIO_INITINFO (&audioinfo);
 357
 358   switch (sunaudiotrack->track_num) {
 359     case GST_SUNAUDIO_TRACK_OUTPUT:
 360       audioinfo.play.gain = gain;
 361       audioinfo.play.balance = balance;
 362       break;
 363     case GST_SUNAUDIO_TRACK_RECORD:
 364       audioinfo.record.gain = gain;
 365       audioinfo.record.balance = balance;
 366       break;
 367     case GST_SUNAUDIO_TRACK_MONITOR:
 368       audioinfo.monitor_gain = gain;
 369       audioinfo.record.balance = balance;
 370       break;
 371     default:
 372       break;
 373   }
 374
 375   g_return_if_fail (mixer->mixer_fd != -1);
 376
 377   if (ioctl (mixer->mixer_fd, AUDIO_SETINFO, &audioinfo) < 0) {
 378     g_warning ("Error setting audio device volume");
 379     return;
 380   }
 381 }
 382
 383 void
 384 gst_sunaudiomixer_ctrl_set_mute (GstSunAudioMixerCtrl * mixer,
 385     GstMixerTrack * track, gboolean mute)
 386 {
 387   struct audio_info audioinfo;
 388   struct audio_info oldinfo;
 389   GstSunAudioMixerTrack *sunaudiotrack = GST_SUNAUDIO_MIXER_TRACK (track);
 390   gint volume, balance;
 391
 392   AUDIO_INITINFO (&audioinfo);
 393
 394   if (ioctl (mixer->mixer_fd, AUDIO_GETINFO, &oldinfo) < 0) {
 395     g_warning ("Error getting audio device volume");
 396     return;
 397   }
 398
 399   if (mute) {
 400     volume = 0;
 401     track->flags |= GST_MIXER_TRACK_MUTE;
 402   } else {
 403     volume = sunaudiotrack->gain;
 404     track->flags &= ~GST_MIXER_TRACK_MUTE;
 405   }
 406
 407   balance = sunaudiotrack->balance;
 408
 409   switch (sunaudiotrack->track_num) {
 410     case GST_SUNAUDIO_TRACK_OUTPUT:
 411       if (mute)
 412         audioinfo.output_muted = 1;
 413       else
 414         audioinfo.output_muted = 0;
 415
 416       audioinfo.play.gain = volume;
 417       audioinfo.play.balance = balance;
 418       break;
 419     case GST_SUNAUDIO_TRACK_RECORD:
 420       audioinfo.record.gain = volume;
 421       audioinfo.record.balance = balance;
 422       break;
 423     case GST_SUNAUDIO_TRACK_MONITOR:
 424       audioinfo.monitor_gain = volume;
 425       audioinfo.record.balance = balance;
 426       break;
 427     case GST_SUNAUDIO_TRACK_SPEAKER:
 428       if (mute) {
 429         audioinfo.play.port = oldinfo.play.port & ~AUDIO_SPEAKER;
 430       } else {
 431         audioinfo.play.port = oldinfo.play.port | AUDIO_SPEAKER;
 432       }
 433       break;
 434     case GST_SUNAUDIO_TRACK_HP:
 435       if (mute) {
 436         audioinfo.play.port = oldinfo.play.port & ~AUDIO_HEADPHONE;
 437       } else {
 438         audioinfo.play.port = oldinfo.play.port | AUDIO_HEADPHONE;
 439       }
 440       break;
 441     case GST_SUNAUDIO_TRACK_LINEOUT:
 442       if (mute) {
 443         audioinfo.play.port = oldinfo.play.port & ~AUDIO_LINE_OUT;
 444       } else {
 445         audioinfo.play.port = oldinfo.play.port | AUDIO_LINE_OUT;
 446       }
 447       break;
 448     case GST_SUNAUDIO_TRACK_SPDIFOUT:
 449       if (mute) {
 450         audioinfo.play.port = oldinfo.play.port & ~AUDIO_SPDIF_OUT;
 451       } else {
 452         audioinfo.play.port = oldinfo.play.port | AUDIO_SPDIF_OUT;
 453       }
 454       break;
 455     case GST_SUNAUDIO_TRACK_AUX1OUT:
 456       if (mute) {
 457         audioinfo.play.port = oldinfo.play.port & ~AUDIO_AUX1_OUT;
 458       } else {
 459         audioinfo.play.port = oldinfo.play.port | AUDIO_AUX1_OUT;
 460       }
 461       break;
 462     case GST_SUNAUDIO_TRACK_AUX2OUT:
 463       if (mute) {
 464         audioinfo.play.port = oldinfo.play.port & ~AUDIO_AUX2_OUT;
 465       } else {
 466         audioinfo.play.port = oldinfo.play.port | AUDIO_AUX2_OUT;
 467       }
 468       break;
 469     default:
 470       break;
 471   }
 472
 473   if (audioinfo.play.port != ((unsigned) ~0)) {
 474     /* mask off ports we can't modify. Hack for broken drivers where mod_ports == 0 */
 475     if (oldinfo.play.mod_ports != 0) {
 476       audioinfo.play.port &= oldinfo.play.mod_ports;
 477       /* and add in any that are forced to be on */
 478       audioinfo.play.port |= (oldinfo.play.port & ~oldinfo.play.mod_ports);
 479     }
 480   }
 481   g_return_if_fail (mixer->mixer_fd != -1);
 482
 483   if (audioinfo.play.port != (guint) (-1) &&
 484       audioinfo.play.port != oldinfo.play.port)
 485     GST_LOG_OBJECT (mixer, "Changing play port mask to 0x%08x",
 486         audioinfo.play.port);
 487
 488   if (ioctl (mixer->mixer_fd, AUDIO_SETINFO, &audioinfo) < 0) {
 489     g_warning ("Error setting audio settings");
 490     return;
 491   }
 492 }
 493
 494 void
 495 gst_sunaudiomixer_ctrl_set_record (GstSunAudioMixerCtrl * mixer,
 496     GstMixerTrack * track, gboolean record)
 497 {
 498 }
 499
 500 void
 501 gst_sunaudiomixer_ctrl_set_option (GstSunAudioMixerCtrl * mixer,
 502     GstMixerOptions * options, gchar * value)
 503 {
 504   struct audio_info audioinfo;
 505   GstMixerTrack *track;
 506   GstSunAudioMixerOptions *opts;
 507   GQuark q;
 508   int i;
 509
 510   g_return_if_fail (mixer != NULL);
 511   g_return_if_fail (mixer->mixer_fd != -1);
 512   g_return_if_fail (value != NULL);
 513   g_return_if_fail (GST_IS_SUNAUDIO_MIXER_OPTIONS (options));
 514
 515   track = GST_MIXER_TRACK (options);
 516   opts = GST_SUNAUDIO_MIXER_OPTIONS (options);
 517
 518   if (opts->track_num != GST_SUNAUDIO_TRACK_RECSRC) {
 519     g_warning ("set_option not supported on track %s", track->label);
 520     return;
 521   }
 522
 523   q = g_quark_try_string (value);
 524   if (q == 0) {
 525     g_warning ("unknown option '%s'", value);
 526     return;
 527   }
 528
 529   for (i = 0; i < 8; i++) {
 530     if (opts->names[i] == q) {
 531       break;
 532     }
 533   }
 534
 535   if (((1 << (i)) & opts->avail) == 0) {
 536     g_warning ("Record port %s not available", g_quark_to_string (q));
 537     return;
 538   }
 539
 540   AUDIO_INITINFO (&audioinfo);
 541   audioinfo.record.port = (1 << (i));
 542
 543   if (ioctl (mixer->mixer_fd, AUDIO_SETINFO, &audioinfo) < 0) {
 544     g_warning ("Error setting audio record port");
 545   }
 546 }
 547
 548 const gchar *
 549 gst_sunaudiomixer_ctrl_get_option (GstSunAudioMixerCtrl * mixer,
 550     GstMixerOptions * options)
 551 {
 552   GstMixerTrack *track;
 553   GstSunAudioMixerOptions *opts;
 554   struct audio_info audioinfo;
 555   int i;
 556
 557   g_return_val_if_fail (mixer != NULL, NULL);
 558   g_return_val_if_fail (mixer->fd != -1, NULL);
 559   g_return_val_if_fail (GST_IS_SUNAUDIO_MIXER_OPTIONS (options), NULL);
 560
 561   track = GST_MIXER_TRACK (options);
 562   opts = GST_SUNAUDIO_MIXER_OPTIONS (options);
 563
 564   g_return_val_if_fail (opts->track_num == GST_SUNAUDIO_TRACK_RECSRC, NULL);
 565
 566   if (ioctl (mixer->mixer_fd, AUDIO_GETINFO, &audioinfo) < 0) {
 567     g_warning ("Error getting audio device settings");
 568     return (NULL);
 569   }
 570
 571   for (i = 0; i < 8; i++) {
 572     if ((1 << i) == audioinfo.record.port) {
 573       const gchar *s = g_quark_to_string (opts->names[i]);
 574       GST_DEBUG_OBJECT (mixer, "Getting value for option %d: %s",
 575           opts->track_num, s);
 576       return (s);
 577     }
 578   }
 579
 580   GST_DEBUG_OBJECT (mixer, "Unable to get value for option %d",
 581       opts->track_num);
 582
 583   g_warning ("Record port value %d seems illegal", audioinfo.record.port);
 584   return (NULL);
 585 }