sys/oss4/oss4-source.c

   1 /* GStreamer OSS4 audio source
   2  * Copyright (C) 2007-2008 Tim-Philipp Müller <tim centricular 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-oss4src
  22  * @short_description: record sound from your sound card using OSS4
  23  *
  24  * <refsect2>
  25  * <para>
  26  * This element lets you record sound using the Open Sound System (OSS)
  27  * version 4.
  28  * </para>
  29  * <title>Example pipelines</title>
  30  * <para>
  31  * <programlisting>
  32  * gst-launch -v oss4src ! queue ! audioconvert ! vorbisenc ! oggmux ! filesink location=mymusic.ogg
  33  * </programlisting>
  34  * will record sound from your sound card using OSS4 and encode it to an
  35  * Ogg/Vorbis file (this will only work if your mixer settings are right
  36  * and the right inputs areenabled etc.)
  37  * </para>
  38  * </refsect2>
  39  *
  40  * Since: 0.10.7
  41  */
  42
  43 /* FIXME: make sure we're not doing ioctls from the app thread (e.g. via the
  44  * mixer interface) while recording */
  45
  46 #ifdef HAVE_CONFIG_H
  47 #include "config.h"
  48 #endif
  49
  50 #include <sys/types.h>
  51 #include <sys/stat.h>
  52 #include <sys/ioctl.h>
  53 #include <fcntl.h>
  54 #include <errno.h>
  55 #include <unistd.h>
  56 #include <string.h>
  57
  58 #include <gst/interfaces/mixer.h>
  59 #include <gst/gst-i18n-plugin.h>
  60
  61 #define NO_LEGACY_MIXER
  62 #include "oss4-audio.h"
  63 #include "oss4-source.h"
  64 #include "oss4-property-probe.h"
  65 #include "oss4-soundcard.h"
  66
  67 #define GST_OSS4_SOURCE_IS_OPEN(src)  (GST_OSS4_SOURCE(src)->fd != -1)
  68
  69 GST_DEBUG_CATEGORY_EXTERN (oss4src_debug);
  70 #define GST_CAT_DEFAULT oss4src_debug
  71
  72 #define DEFAULT_DEVICE       NULL
  73 #define DEFAULT_DEVICE_NAME  NULL
  74
  75 enum
  76 {
  77   PROP_0,
  78   PROP_DEVICE,
  79   PROP_DEVICE_NAME
  80 };
  81
  82 static void gst_oss4_source_init_interfaces (GType type);
  83
  84 GST_BOILERPLATE_FULL (GstOss4Source, gst_oss4_source, GstAudioSrc,
  85     GST_TYPE_AUDIO_SRC, gst_oss4_source_init_interfaces);
  86
  87 static void gst_oss4_source_get_property (GObject * object, guint prop_id,
  88     GValue * value, GParamSpec * pspec);
  89 static void gst_oss4_source_set_property (GObject * object, guint prop_id,
  90     const GValue * value, GParamSpec * pspec);
  91
  92 static void gst_oss4_source_dispose (GObject * object);
  93 static void gst_oss4_source_finalize (GstOss4Source * osssrc);
  94
  95 static GstCaps *gst_oss4_source_getcaps (GstBaseSrc * bsrc);
  96
  97 static gboolean gst_oss4_source_open (GstAudioSrc * asrc,
  98     gboolean silent_errors);
  99 static gboolean gst_oss4_source_open_func (GstAudioSrc * asrc);
 100 static gboolean gst_oss4_source_close (GstAudioSrc * asrc);
 101 static gboolean gst_oss4_source_prepare (GstAudioSrc * asrc,
 102     GstRingBufferSpec * spec);
 103 static gboolean gst_oss4_source_unprepare (GstAudioSrc * asrc);
 104 static guint gst_oss4_source_read (GstAudioSrc * asrc, gpointer data,
 105     guint length);
 106 static guint gst_oss4_source_delay (GstAudioSrc * asrc);
 107 static void gst_oss4_source_reset (GstAudioSrc * asrc);
 108
 109 static void
 110 gst_oss4_source_base_init (gpointer g_class)
 111 {
 112   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 113   GstPadTemplate *templ;
 114
 115   gst_element_class_set_details_simple (element_class,
 116       "OSS v4 Audio Source", "Source/Audio",
 117       "Capture from a sound card via OSS version 4",
 118       "Tim-Philipp Müller <tim centricular net>");
 119
 120   templ = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
 121       gst_oss4_audio_get_template_caps ());
 122   gst_element_class_add_pad_template (element_class, templ);
 123 }
 124 static void
 125 gst_oss4_source_class_init (GstOss4SourceClass * klass)
 126 {
 127   GObjectClass *gobject_class;
 128   GstElementClass *gstelement_class;
 129   GstBaseSrcClass *gstbasesrc_class;
 130   GstBaseAudioSrcClass *gstbaseaudiosrc_class;
 131   GstAudioSrcClass *gstaudiosrc_class;
 132
 133   gobject_class = (GObjectClass *) klass;
 134   gstelement_class = (GstElementClass *) klass;
 135   gstbasesrc_class = (GstBaseSrcClass *) klass;
 136   gstbaseaudiosrc_class = (GstBaseAudioSrcClass *) klass;
 137   gstaudiosrc_class = (GstAudioSrcClass *) klass;
 138
 139   gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_oss4_source_dispose);
 140   gobject_class->finalize =
 141       (GObjectFinalizeFunc) GST_DEBUG_FUNCPTR (gst_oss4_source_finalize);
 142   gobject_class->get_property =
 143       GST_DEBUG_FUNCPTR (gst_oss4_source_get_property);
 144   gobject_class->set_property =
 145       GST_DEBUG_FUNCPTR (gst_oss4_source_set_property);
 146
 147   gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_oss4_source_getcaps);
 148
 149   gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_oss4_source_open_func);
 150   gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_oss4_source_prepare);
 151   gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_oss4_source_unprepare);
 152   gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_oss4_source_close);
 153   gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_oss4_source_read);
 154   gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_oss4_source_delay);
 155   gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_oss4_source_reset);
 156
 157   g_object_class_install_property (gobject_class, PROP_DEVICE,
 158       g_param_spec_string ("device", "Device",
 159           "OSS4 device (e.g. /dev/oss/hdaudio0/pcm0 or /dev/dspN) "
 160           "(NULL = use first available device)",
 161           DEFAULT_DEVICE, G_PARAM_READWRITE));
 162
 163   g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
 164       g_param_spec_string ("device-name", "Device name",
 165           "Human-readable name of the sound device", DEFAULT_DEVICE_NAME,
 166           G_PARAM_READABLE));
 167 }
 168
 169 static void
 170 gst_oss4_source_init (GstOss4Source * osssrc, GstOss4SourceClass * g_class)
 171 {
 172   const gchar *device;
 173
 174   device = g_getenv ("AUDIODEV");
 175   if (device == NULL)
 176     device = DEFAULT_DEVICE;
 177
 178   osssrc->fd = -1;
 179   osssrc->device = g_strdup (device);
 180   osssrc->device_name = g_strdup (DEFAULT_DEVICE_NAME);
 181   osssrc->device_name = NULL;
 182 }
 183
 184 static void
 185 gst_oss4_source_finalize (GstOss4Source * oss)
 186 {
 187   g_free (oss->device);
 188   oss->device = NULL;
 189
 190   g_list_free (oss->property_probe_list);
 191   oss->property_probe_list = NULL;
 192
 193   G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (oss));
 194 }
 195
 196 static void
 197 gst_oss4_source_dispose (GObject * object)
 198 {
 199   GstOss4Source *oss = GST_OSS4_SOURCE (object);
 200
 201   if (oss->probed_caps) {
 202     gst_caps_unref (oss->probed_caps);
 203     oss->probed_caps = NULL;
 204   }
 205
 206   G_OBJECT_CLASS (parent_class)->dispose (object);
 207 }
 208
 209 static void
 210 gst_oss4_source_set_property (GObject * object, guint prop_id,
 211     const GValue * value, GParamSpec * pspec)
 212 {
 213   GstOss4Source *oss;
 214
 215   oss = GST_OSS4_SOURCE (object);
 216
 217   switch (prop_id) {
 218     case PROP_DEVICE:
 219       GST_OBJECT_LOCK (oss);
 220       if (oss->fd == -1) {
 221         g_free (oss->device);
 222         oss->device = g_value_dup_string (value);
 223         g_free (oss->device_name);
 224         oss->device_name = NULL;
 225       } else {
 226         g_warning ("%s: can't change \"device\" property while audio source "
 227             "is open", GST_OBJECT_NAME (oss));
 228       }
 229       GST_OBJECT_UNLOCK (oss);
 230       break;
 231     default:
 232       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 233       break;
 234   }
 235 }
 236
 237 static void
 238 gst_oss4_source_get_property (GObject * object, guint prop_id,
 239     GValue * value, GParamSpec * pspec)
 240 {
 241   GstOss4Source *oss;
 242
 243   oss = GST_OSS4_SOURCE (object);
 244
 245   switch (prop_id) {
 246     case PROP_DEVICE:
 247       GST_OBJECT_LOCK (oss);
 248       g_value_set_string (value, oss->device);
 249       GST_OBJECT_UNLOCK (oss);
 250       break;
 251     case PROP_DEVICE_NAME:
 252       GST_OBJECT_LOCK (oss);
 253       /* If device is set, try to retrieve the name even if we're not open */
 254       if (oss->fd == -1 && oss->device != NULL) {
 255         if (gst_oss4_source_open (GST_AUDIO_SRC (oss), TRUE)) {
 256           g_value_set_string (value, oss->device_name);
 257           gst_oss4_source_close (GST_AUDIO_SRC (oss));
 258         } else {
 259           gchar *name = NULL;
 260
 261           gst_oss4_property_probe_find_device_name_nofd (GST_OBJECT (oss),
 262               oss->device, &name);
 263           g_value_set_string (value, name);
 264           g_free (name);
 265         }
 266       } else {
 267         g_value_set_string (value, oss->device_name);
 268       }
 269
 270       GST_OBJECT_UNLOCK (oss);
 271       break;
 272     default:
 273       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 274       break;
 275   }
 276 }
 277
 278 static GstCaps *
 279 gst_oss4_source_getcaps (GstBaseSrc * bsrc)
 280 {
 281   GstOss4Source *oss;
 282   GstCaps *caps;
 283
 284   oss = GST_OSS4_SOURCE (bsrc);
 285
 286   if (oss->fd == -1) {
 287     caps = gst_caps_copy (gst_oss4_audio_get_template_caps ());
 288   } else if (oss->probed_caps) {
 289     caps = gst_caps_copy (oss->probed_caps);
 290   } else {
 291     caps = gst_oss4_audio_probe_caps (GST_OBJECT (oss), oss->fd);
 292     if (caps != NULL && !gst_caps_is_empty (caps)) {
 293       oss->probed_caps = gst_caps_copy (caps);
 294     }
 295   }
 296
 297   return caps;
 298 }
 299
 300 /* note: we must not take the object lock here unless we fix up get_property */
 301 static gboolean
 302 gst_oss4_source_open (GstAudioSrc * asrc, gboolean silent_errors)
 303 {
 304   GstOss4Source *oss;
 305   gchar *device;
 306   int mode;
 307
 308   oss = GST_OSS4_SOURCE (asrc);
 309
 310   if (oss->device)
 311     device = g_strdup (oss->device);
 312   else
 313     device = gst_oss4_audio_find_device (GST_OBJECT_CAST (oss));
 314
 315   /* desperate times, desperate measures */
 316   if (device == NULL)
 317     device = g_strdup ("/dev/dsp0");
 318
 319   GST_INFO_OBJECT (oss, "Trying to open OSS4 device '%s'", device);
 320
 321   /* we open in non-blocking mode even if we don't really want to do writes
 322    * non-blocking because we can't be sure that this is really a genuine
 323    * OSS4 device with well-behaved drivers etc. We really don't want to
 324    * hang forever under any circumstances. */
 325   oss->fd = open (device, O_RDONLY | O_NONBLOCK, 0);
 326   if (oss->fd == -1) {
 327     switch (errno) {
 328       case EBUSY:
 329         goto busy;
 330       case EACCES:
 331         goto no_permission;
 332       default:
 333         goto open_failed;
 334     }
 335   }
 336
 337   GST_INFO_OBJECT (oss, "Opened device");
 338
 339   /* Make sure it's OSS4. If it's old OSS, let osssink handle it */
 340   if (!gst_oss4_audio_check_version (GST_OBJECT_CAST (oss), oss->fd))
 341     goto legacy_oss;
 342
 343   /* now remove the non-blocking flag. */
 344   mode = fcntl (oss->fd, F_GETFL);
 345   mode &= ~O_NONBLOCK;
 346   if (fcntl (oss->fd, F_SETFL, mode) < 0) {
 347     /* some drivers do no support unsetting the non-blocking flag, try to
 348      * close/open the device then. This is racy but we error out properly. */
 349     GST_WARNING_OBJECT (oss, "failed to unset O_NONBLOCK (buggy driver?), "
 350         "will try to re-open device now");
 351     gst_oss4_source_close (asrc);
 352     if ((oss->fd = open (device, O_RDONLY, 0)) == -1)
 353       goto non_block;
 354   }
 355
 356   oss->open_device = device;
 357
 358   /* not using ENGINEINFO here because it sometimes returns a different and
 359    * less useful name than AUDIOINFO for the same device */
 360   if (!gst_oss4_property_probe_find_device_name (GST_OBJECT (oss), oss->fd,
 361           oss->open_device, &oss->device_name)) {
 362     oss->device_name = NULL;
 363   }
 364
 365   return TRUE;
 366
 367   /* ERRORS */
 368 busy:
 369   {
 370     if (!silent_errors) {
 371       GST_ELEMENT_ERROR (oss, RESOURCE, BUSY,
 372           (_("Could not open audio device for playback. "
 373                   "Device is being used by another application.")), (NULL));
 374     }
 375     g_free (device);
 376     return FALSE;
 377   }
 378 no_permission:
 379   {
 380     if (!silent_errors) {
 381       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
 382           (_("Could not open audio device for playback."
 383                   "You don't have permission to open the device.")),
 384           GST_ERROR_SYSTEM);
 385     }
 386     g_free (device);
 387     return FALSE;
 388   }
 389 open_failed:
 390   {
 391     if (!silent_errors) {
 392       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
 393           (_("Could not open audio device for playback.")), GST_ERROR_SYSTEM);
 394     }
 395     g_free (device);
 396     return FALSE;
 397   }
 398 legacy_oss:
 399   {
 400     gst_oss4_source_close (asrc);
 401     if (!silent_errors) {
 402       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
 403           (_("Could not open audio device for playback."
 404                   "This version of the Open Sound System is not supported by this "
 405                   "element.")), ("Try the 'osssink' element instead"));
 406     }
 407     g_free (device);
 408     return FALSE;
 409   }
 410 non_block:
 411   {
 412     if (!silent_errors) {
 413       GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
 414           ("Unable to set device %s into non-blocking mode: %s",
 415               oss->device, g_strerror (errno)));
 416     }
 417     g_free (device);
 418     return FALSE;
 419   }
 420 }
 421
 422 static gboolean
 423 gst_oss4_source_open_func (GstAudioSrc * asrc)
 424 {
 425   return gst_oss4_source_open (asrc, FALSE);
 426 }
 427
 428 static void
 429 gst_oss4_source_free_mixer_tracks (GstOss4Source * oss)
 430 {
 431   g_list_foreach (oss->tracks, (GFunc) g_object_unref, NULL);
 432   g_list_free (oss->tracks);
 433   oss->tracks = NULL;
 434 }
 435
 436 static gboolean
 437 gst_oss4_source_close (GstAudioSrc * asrc)
 438 {
 439   GstOss4Source *oss;
 440
 441   oss = GST_OSS4_SOURCE (asrc);
 442
 443   if (oss->fd != -1) {
 444     GST_DEBUG_OBJECT (oss, "closing device");
 445     close (oss->fd);
 446     oss->fd = -1;
 447   }
 448
 449   oss->bytes_per_sample = 0;
 450
 451   gst_caps_replace (&oss->probed_caps, NULL);
 452
 453   g_free (oss->open_device);
 454   oss->open_device = NULL;
 455
 456   g_free (oss->device_name);
 457   oss->device_name = NULL;
 458
 459   gst_oss4_source_free_mixer_tracks (oss);
 460
 461   return TRUE;
 462 }
 463
 464 static gboolean
 465 gst_oss4_source_prepare (GstAudioSrc * asrc, GstRingBufferSpec * spec)
 466 {
 467   GstOss4Source *oss;
 468
 469   oss = GST_OSS4_SOURCE (asrc);
 470
 471   if (!gst_oss4_audio_set_format (GST_OBJECT_CAST (oss), oss->fd, spec)) {
 472     GST_WARNING_OBJECT (oss, "Couldn't set requested format %" GST_PTR_FORMAT,
 473         spec->caps);
 474     return FALSE;
 475   }
 476
 477   oss->bytes_per_sample = spec->bytes_per_sample;
 478   return TRUE;
 479 }
 480
 481 static gboolean
 482 gst_oss4_source_unprepare (GstAudioSrc * asrc)
 483 {
 484   /* could do a SNDCTL_DSP_HALT, but the OSS manual recommends a close/open,
 485    * since HALT won't properly reset some devices, apparently */
 486
 487   if (!gst_oss4_source_close (asrc))
 488     goto couldnt_close;
 489
 490   if (!gst_oss4_source_open_func (asrc))
 491     goto couldnt_reopen;
 492
 493   return TRUE;
 494
 495   /* ERRORS */
 496 couldnt_close:
 497   {
 498     GST_DEBUG_OBJECT (asrc, "Couldn't close the audio device");
 499     return FALSE;
 500   }
 501 couldnt_reopen:
 502   {
 503     GST_DEBUG_OBJECT (asrc, "Couldn't reopen the audio device");
 504     return FALSE;
 505   }
 506 }
 507
 508 static guint
 509 gst_oss4_source_read (GstAudioSrc * asrc, gpointer data, guint length)
 510 {
 511   GstOss4Source *oss;
 512   int n;
 513
 514   oss = GST_OSS4_SOURCE_CAST (asrc);
 515
 516   n = read (oss->fd, data, length);
 517   GST_LOG_OBJECT (asrc, "%u bytes, %u samples", n, n / oss->bytes_per_sample);
 518
 519   if (G_UNLIKELY (n < 0)) {
 520     switch (errno) {
 521       case ENOTSUP:
 522       case EACCES:{
 523         /* This is the most likely cause, I think */
 524         GST_ELEMENT_ERROR (asrc, RESOURCE, READ,
 525             (_("Recording is not supported by this audio device.")),
 526             ("read: %s (device: %s) (maybe this is an output-only device?)",
 527                 g_strerror (errno), oss->open_device));
 528         break;
 529       }
 530       default:{
 531         GST_ELEMENT_ERROR (asrc, RESOURCE, READ,
 532             (_("Error recording from audio device.")),
 533             ("read: %s (device: %s)", g_strerror (errno), oss->open_device));
 534         break;
 535       }
 536     }
 537   }
 538
 539   return (guint) n;
 540 }
 541
 542 static guint
 543 gst_oss4_source_delay (GstAudioSrc * asrc)
 544 {
 545   audio_buf_info info = { 0, };
 546   GstOss4Source *oss;
 547   guint delay;
 548
 549   oss = GST_OSS4_SOURCE_CAST (asrc);
 550
 551   if (ioctl (oss->fd, SNDCTL_DSP_GETISPACE, &info) == -1) {
 552     GST_LOG_OBJECT (oss, "GETISPACE failed: %s", g_strerror (errno));
 553     return 0;
 554   }
 555
 556   delay = (info.fragstotal * info.fragsize) - info.bytes;
 557   GST_LOG_OBJECT (oss, "fragstotal:%d, fragsize:%d, bytes:%d, delay:%d",
 558       info.fragstotal, info.fragsize, info.bytes, delay);
 559   return delay;
 560 }
 561
 562 static void
 563 gst_oss4_source_reset (GstAudioSrc * asrc)
 564 {
 565   /* There's nothing we can do here really: OSS can't handle access to the
 566    * same device/fd from multiple threads and might deadlock or blow up in
 567    * other ways if we try an ioctl SNDCTL_DSP_HALT or similar */
 568 }
 569
 570 /* GstMixer interface, which we abuse here for input selection, because we
 571  * don't have a proper interface for that and because that's what
 572  * gnome-sound-recorder does. */
 573
 574 /* GstMixerTrack is a plain GObject, so let's just use the GLib macro here */
 575 G_DEFINE_TYPE (GstOss4SourceInput, gst_oss4_source_input, GST_TYPE_MIXER_TRACK);
 576
 577 static void
 578 gst_oss4_source_input_class_init (GstOss4SourceInputClass * klass)
 579 {
 580   /* nothing to do here */
 581 }
 582
 583 static void
 584 gst_oss4_source_input_init (GstOss4SourceInput * i)
 585 {
 586   /* nothing to do here */
 587 }
 588
 589 #if 0
 590
 591 static void
 592 gst_ossmixer_ensure_track_list (GstOssMixer * mixer)
 593 {
 594   gint i, master = -1;
 595
 596   g_return_if_fail (mixer->fd != -1);
 597
 598   if (mixer->tracklist)
 599     return;
 600
 601   /* find master volume */
 602   if (mixer->devmask & SOUND_MASK_VOLUME)
 603     master = SOUND_MIXER_VOLUME;
 604   else if (mixer->devmask & SOUND_MASK_PCM)
 605     master = SOUND_MIXER_PCM;
 606   else if (mixer->devmask & SOUND_MASK_SPEAKER)
 607     master = SOUND_MIXER_SPEAKER;       /* doubtful... */
 608   /* else: no master, so we won't set any */
 609
 610   /* build track list */
 611   for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 612     if (mixer->devmask & (1 << i)) {
 613       GstMixerTrack *track;
 614       gboolean input = FALSE, stereo = FALSE, record = FALSE;
 615
 616       /* track exists, make up capabilities */
 617       if (MASK_BIT_IS_SET (mixer->stereomask, i))
 618         stereo = TRUE;
 619       if (MASK_BIT_IS_SET (mixer->recmask, i))
 620         input = TRUE;
 621       if (MASK_BIT_IS_SET (mixer->recdevs, i))
 622         record = TRUE;
 623
 624       /* do we want mixer in our list? */
 625       if (!((mixer->dir & GST_OSS_MIXER_CAPTURE && input == TRUE) ||
 626               (mixer->dir & GST_OSS_MIXER_PLAYBACK && i != SOUND_MIXER_PCM)))
 627         /* the PLAYBACK case seems hacky, but that's how 0.8 had it */
 628         continue;
 629
 630       /* add track to list */
 631       track = gst_ossmixer_track_new (mixer->fd, i, stereo ? 2 : 1,
 632           (record ? GST_MIXER_TRACK_RECORD : 0) |
 633           (input ? GST_MIXER_TRACK_INPUT :
 634               GST_MIXER_TRACK_OUTPUT) |
 635           ((master != i) ? 0 : GST_MIXER_TRACK_MASTER));
 636       mixer->tracklist = g_list_append (mixer->tracklist, track);
 637     }
 638   }
 639 }
 640
 641 /* unused with G_DISABLE_* */
 642 static G_GNUC_UNUSED gboolean
 643 gst_ossmixer_contains_track (GstOssMixer * mixer, GstOssMixerTrack * osstrack)
 644 {
 645   const GList *item;
 646
 647   for (item = mixer->tracklist; item != NULL; item = item->next)
 648     if (item->data == osstrack)
 649       return TRUE;
 650
 651   return FALSE;
 652 }
 653
 654 const GList *
 655 gst_ossmixer_list_tracks (GstOssMixer * mixer)
 656 {
 657   gst_ossmixer_ensure_track_list (mixer);
 658
 659   return (const GList *) mixer->tracklist;
 660 }
 661
 662 void
 663 gst_ossmixer_get_volume (GstOssMixer * mixer,
 664     GstMixerTrack * track, gint * volumes)
 665 {
 666   gint volume;
 667   GstOssMixerTrack *osstrack = GST_OSSMIXER_TRACK (track);
 668
 669   g_return_if_fail (mixer->fd != -1);
 670   g_return_if_fail (gst_ossmixer_contains_track (mixer, osstrack));
 671
 672   if (track->flags & GST_MIXER_TRACK_MUTE) {
 673     volumes[0] = osstrack->lvol;
 674     if (track->num_channels == 2) {
 675       volumes[1] = osstrack->rvol;
 676     }
 677   } else {
 678     /* get */
 679     if (ioctl (mixer->fd, MIXER_READ (osstrack->track_num), &volume) < 0) {
 680       g_warning ("Error getting recording device (%d) volume: %s",
 681           osstrack->track_num, g_strerror (errno));
 682       volume = 0;
 683     }
 684
 685     osstrack->lvol = volumes[0] = (volume & 0xff);
 686     if (track->num_channels == 2) {
 687       osstrack->rvol = volumes[1] = ((volume >> 8) & 0xff);
 688     }
 689   }
 690 }
 691
 692 void
 693 gst_ossmixer_set_mute (GstOssMixer * mixer, GstMixerTrack * track,
 694     gboolean mute)
 695 {
 696   int volume;
 697   GstOssMixerTrack *osstrack = GST_OSSMIXER_TRACK (track);
 698
 699   g_return_if_fail (mixer->fd != -1);
 700   g_return_if_fail (gst_ossmixer_contains_track (mixer, osstrack));
 701
 702   if (mute) {
 703     volume = 0;
 704   } else {
 705     volume = (osstrack->lvol & 0xff);
 706     if (MASK_BIT_IS_SET (mixer->stereomask, osstrack->track_num)) {
 707       volume |= ((osstrack->rvol & 0xff) << 8);
 708     }
 709   }
 710
 711   if (ioctl (mixer->fd, MIXER_WRITE (osstrack->track_num), &volume) < 0) {
 712     g_warning ("Error setting mixer recording device volume (0x%x): %s",
 713         volume, g_strerror (errno));
 714     return;
 715   }
 716
 717   if (mute) {
 718     track->flags |= GST_MIXER_TRACK_MUTE;
 719   } else {
 720     track->flags &= ~GST_MIXER_TRACK_MUTE;
 721   }
 722 }
 723 #endif
 724
 725 static gint
 726 gst_oss4_source_mixer_get_current_input (GstOss4Source * oss)
 727 {
 728   int cur = -1;
 729
 730   if (ioctl (oss->fd, SNDCTL_DSP_GET_RECSRC, &cur) == -1 || cur < 0)
 731     return -1;
 732
 733   return cur;
 734 }
 735
 736 static const gchar *
 737 gst_oss4_source_mixer_update_record_flags (GstOss4Source * oss, gint cur_route)
 738 {
 739   const gchar *cur_name = "";
 740   GList *t;
 741
 742   for (t = oss->tracks; t != NULL; t = t->next) {
 743     GstMixerTrack *track = t->data;
 744
 745     if (GST_OSS4_SOURCE_INPUT (track)->route == cur_route) {
 746       if (!GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_RECORD)) {
 747         track->flags |= GST_MIXER_TRACK_RECORD;
 748         /* no point in sending a mixer-record-changes message here */
 749       }
 750       cur_name = track->label;
 751     } else {
 752       if (GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_RECORD)) {
 753         track->flags &= ~GST_MIXER_TRACK_RECORD;
 754         /* no point in sending a mixer-record-changes message here */
 755       }
 756     }
 757   }
 758
 759   return cur_name;
 760 }
 761
 762 static const GList *
 763 gst_oss4_source_mixer_list_tracks (GstMixer * mixer)
 764 {
 765   oss_mixer_enuminfo names = { 0, };
 766   GstOss4Source *oss;
 767   const gchar *cur_name;
 768   GList *tracks = NULL;
 769   gint i, cur;
 770
 771   g_return_val_if_fail (mixer != NULL, NULL);
 772   g_return_val_if_fail (GST_IS_OSS4_SOURCE (mixer), NULL);
 773   g_return_val_if_fail (GST_OSS4_SOURCE_IS_OPEN (mixer), NULL);
 774
 775   oss = GST_OSS4_SOURCE (mixer);
 776
 777   if (oss->tracks != NULL && oss->tracks_static)
 778     goto done;
 779
 780   if (ioctl (oss->fd, SNDCTL_DSP_GET_RECSRC_NAMES, &names) == -1)
 781     goto get_recsrc_names_error;
 782
 783   oss->tracks_static = (names.version == 0);
 784
 785   GST_INFO_OBJECT (oss, "%d inputs (list is static: %s):", names.nvalues,
 786       (oss->tracks_static) ? "yes" : "no");
 787
 788   for (i = 0; i < MIN (names.nvalues, OSS_ENUM_MAXVALUE + 1); ++i) {
 789     GstMixerTrack *track;
 790
 791     track = g_object_new (GST_TYPE_OSS4_SOURCE_INPUT, NULL);
 792     track->label = g_strdup (&names.strings[names.strindex[i]]);
 793     track->flags = GST_MIXER_TRACK_INPUT;
 794     track->num_channels = 2;
 795     track->min_volume = 0;
 796     track->max_volume = 100;
 797     GST_OSS4_SOURCE_INPUT (track)->route = i;
 798
 799     GST_INFO_OBJECT (oss, " [%d] %s", i, track->label);
 800     tracks = g_list_append (tracks, track);
 801   }
 802
 803   gst_oss4_source_free_mixer_tracks (oss);
 804   oss->tracks = tracks;
 805
 806 done:
 807
 808   /* update RECORD flags */
 809   cur = gst_oss4_source_mixer_get_current_input (oss);
 810   cur_name = gst_oss4_source_mixer_update_record_flags (oss, cur);
 811   GST_DEBUG_OBJECT (oss, "current input route: %d (%s)", cur, cur_name);
 812
 813   return (const GList *) oss->tracks;
 814
 815 /* ERRORS */
 816 get_recsrc_names_error:
 817   {
 818     GST_WARNING_OBJECT (oss, "GET_RECSRC_NAMES failed: %s", g_strerror (errno));
 819     return NULL;
 820   }
 821 }
 822
 823 static void
 824 gst_oss4_source_mixer_set_volume (GstMixer * mixer, GstMixerTrack * track,
 825     gint * volumes)
 826 {
 827   GstOss4Source *oss;
 828   int new_vol, cur;
 829
 830   g_return_if_fail (mixer != NULL);
 831   g_return_if_fail (track != NULL);
 832   g_return_if_fail (GST_IS_MIXER_TRACK (track));
 833   g_return_if_fail (GST_IS_OSS4_SOURCE (mixer));
 834   g_return_if_fail (GST_OSS4_SOURCE_IS_OPEN (mixer));
 835
 836   oss = GST_OSS4_SOURCE (mixer);
 837
 838   cur = gst_oss4_source_mixer_get_current_input (oss);
 839   if (cur != GST_OSS4_SOURCE_INPUT (track)->route) {
 840     GST_DEBUG_OBJECT (oss, "track not selected input route, ignoring request");
 841     return;
 842   }
 843
 844   new_vol = (volumes[1] << 8) | volumes[0];
 845   if (ioctl (oss->fd, SNDCTL_DSP_SETRECVOL, &new_vol) == -1) {
 846     GST_WARNING_OBJECT (oss, "SETRECVOL failed: %s", g_strerror (errno));
 847   }
 848 }
 849
 850 static void
 851 gst_oss4_source_mixer_get_volume (GstMixer * mixer, GstMixerTrack * track,
 852     gint * volumes)
 853 {
 854   GstOss4Source *oss;
 855   int cur;
 856
 857   g_return_if_fail (mixer != NULL);
 858   g_return_if_fail (GST_IS_OSS4_SOURCE (mixer));
 859   g_return_if_fail (GST_OSS4_SOURCE_IS_OPEN (mixer));
 860
 861   oss = GST_OSS4_SOURCE (mixer);
 862
 863   cur = gst_oss4_source_mixer_get_current_input (oss);
 864   if (cur != GST_OSS4_SOURCE_INPUT (track)->route) {
 865     volumes[0] = 0;
 866     volumes[1] = 0;
 867   } else {
 868     int vol = -1;
 869
 870     if (ioctl (oss->fd, SNDCTL_DSP_GETRECVOL, &vol) == -1 || vol < 0) {
 871       GST_WARNING_OBJECT (oss, "GETRECVOL failed: %s", g_strerror (errno));
 872       volumes[0] = 100;
 873       volumes[1] = 100;
 874     } else {
 875       volumes[0] = MIN (100, vol & 0xff);
 876       volumes[1] = MIN (100, (vol >> 8) & 0xff);
 877     }
 878   }
 879 }
 880
 881 static void
 882 gst_oss4_source_mixer_set_record (GstMixer * mixer, GstMixerTrack * track,
 883     gboolean record)
 884 {
 885   GstOss4Source *oss;
 886   const gchar *cur_name;
 887   gint cur;
 888
 889   g_return_if_fail (mixer != NULL);
 890   g_return_if_fail (track != NULL);
 891   g_return_if_fail (GST_IS_MIXER_TRACK (track));
 892   g_return_if_fail (GST_IS_OSS4_SOURCE (mixer));
 893   g_return_if_fail (GST_OSS4_SOURCE_IS_OPEN (mixer));
 894
 895   oss = GST_OSS4_SOURCE (mixer);
 896
 897   cur = gst_oss4_source_mixer_get_current_input (oss);
 898
 899   /* stop recording for an input that's not selected anyway => nothing to do */
 900   if (!record && cur != GST_OSS4_SOURCE_INPUT (track)->route)
 901     goto done;
 902
 903   /* select recording for an input that's already selected => nothing to do
 904    * (or should we mess with the recording volume in this case maybe?) */
 905   if (record && cur == GST_OSS4_SOURCE_INPUT (track)->route)
 906     goto done;
 907
 908   /* make current input stop recording: we can't really make an input stop
 909    * recording, we can only select an input FOR recording, so we'll just ignore
 910    * all requests to stop for now */
 911   if (!record) {
 912     GST_WARNING_OBJECT (oss, "Can't un-select an input as such, only switch "
 913         "to a different input source");
 914     /* FIXME: set recording volume to 0 maybe? */
 915   } else {
 916     int new_route = GST_OSS4_SOURCE_INPUT (track)->route;
 917
 918     /* select this input for recording */
 919
 920     if (ioctl (oss->fd, SNDCTL_DSP_SET_RECSRC, &new_route) == -1) {
 921       GST_WARNING_OBJECT (oss, "Could not select input %d for recording: %s",
 922           new_route, g_strerror (errno));
 923     } else {
 924       cur = new_route;
 925     }
 926   }
 927
 928 done:
 929
 930   cur_name = gst_oss4_source_mixer_update_record_flags (oss, cur);
 931   GST_DEBUG_OBJECT (oss, "active input route: %d (%s)", cur, cur_name);
 932 }
 933
 934 static void
 935 gst_oss4_source_mixer_set_mute (GstMixer * mixer, GstMixerTrack * track,
 936     gboolean mute)
 937 {
 938   GstOss4Source *oss;
 939
 940   g_return_if_fail (mixer != NULL);
 941   g_return_if_fail (track != NULL);
 942   g_return_if_fail (GST_IS_MIXER_TRACK (track));
 943   g_return_if_fail (GST_IS_OSS4_SOURCE (mixer));
 944   g_return_if_fail (GST_OSS4_SOURCE_IS_OPEN (mixer));
 945
 946   oss = GST_OSS4_SOURCE (mixer);
 947
 948   /* FIXME: implement gst_oss4_source_mixer_set_mute() - what to do here? */
 949   /* oss4_mixer_set_mute (mixer->mixer, track, mute); */
 950 }
 951
 952 static void
 953 gst_oss4_source_mixer_interface_init (GstMixerClass * klass)
 954 {
 955   GST_MIXER_TYPE (klass) = GST_MIXER_HARDWARE;
 956
 957   klass->list_tracks = gst_oss4_source_mixer_list_tracks;
 958   klass->set_volume = gst_oss4_source_mixer_set_volume;
 959   klass->get_volume = gst_oss4_source_mixer_get_volume;
 960   klass->set_mute = gst_oss4_source_mixer_set_mute;
 961   klass->set_record = gst_oss4_source_mixer_set_record;
 962 }
 963
 964 /* Implement the horror that is GstImplementsInterface */
 965
 966 static gboolean
 967 gst_oss4_source_mixer_supported (GstImplementsInterface * iface,
 968     GType iface_type)
 969 {
 970   GstOss4Source *oss;
 971   gboolean is_open;
 972
 973   g_return_val_if_fail (GST_IS_OSS4_SOURCE (iface), FALSE);
 974   g_return_val_if_fail (iface_type == GST_TYPE_MIXER, FALSE);
 975
 976   oss = GST_OSS4_SOURCE (iface);
 977
 978   GST_OBJECT_LOCK (oss);
 979   is_open = GST_OSS4_SOURCE_IS_OPEN (iface);
 980   GST_OBJECT_UNLOCK (oss);
 981
 982   return is_open;
 983 }
 984
 985 static void
 986 gst_oss4_source_mixer_implements_interface_init (GstImplementsInterfaceClass *
 987     klass)
 988 {
 989   klass->supported = gst_oss4_source_mixer_supported;
 990 }
 991
 992 static void
 993 gst_oss4_source_init_interfaces (GType type)
 994 {
 995   static const GInterfaceInfo implements_iface_info = {
 996     (GInterfaceInitFunc) gst_oss4_source_mixer_implements_interface_init,
 997     NULL,
 998     NULL,
 999   };
1000   static const GInterfaceInfo mixer_iface_info = {
1001     (GInterfaceInitFunc) gst_oss4_source_mixer_interface_init,
1002     NULL,
1003     NULL,
1004   };
1005
1006   g_type_add_interface_static (type, GST_TYPE_IMPLEMENTS_INTERFACE,
1007       &implements_iface_info);
1008   g_type_add_interface_static (type, GST_TYPE_MIXER, &mixer_iface_info);
1009
1010   gst_oss4_add_property_probe_interface (type);
1011 }